Volume-centric VFS implementation

kernel/fs/vfs.c

@@ -10,216 +10,182 @@
 #include <mm/liballoc.h>
 #include <proc/proc.h>
 #include <proc/procgroup.h>
+#include <proc/reschedule.h>
+#include <proc/suspension_q.h>
 #include <status.h>
 #include <sync/spin_lock.h>
 #include <sys/debug.h>
 
-static struct vfs_mount_table mount_table;
+static struct vfs_volume_table volume_table;
 
-static struct vfs_mountpoint* vfs_find_mountpoint (const char* mountpoint) {
+static struct vfs_volume* vfs_find_volume (const char* volume) {
   struct hash_node_link* found_link = NULL;
-  size_t mountpoint_len = strlen (mountpoint);
-  uint32_t hash = hash_fnv32 (mountpoint, strlen (mountpoint));
+  size_t volume_len = strlen (volume);
+  uint32_t hash = hash_fnv32 (volume, strlen (volume));
 
-  spin_lock (&mount_table.lock);
-  hash_find (&mount_table, mountpoint, mountpoint_len, hash,
-             lengthof (mount_table.mountpoint_buckets), mountpoint_buckets, struct vfs_mountpoint,
-             mount_table_link, key, found_link);
-  spin_unlock (&mount_table.lock);
+  spin_lock (&volume_table.lock);
+  hash_find (&volume_table, volume, volume_len, hash, lengthof (volume_table.volume_buckets),
+             volume_buckets, struct vfs_volume, volume_table_link, key, found_link);
+  spin_unlock (&volume_table.lock);
 
   if (found_link == NULL)
     return NULL;
 
-  return hash_entry (found_link, struct vfs_mountpoint, mount_table_link);
+  return hash_entry (found_link, struct vfs_volume, volume_table_link);
 }
 
-int vfs_create_mountpoint (const char* key, int fs_type, struct device* back_device,
-                           struct proc* proc, struct reschedule_ctx* rctx) {
-  if (strlen_null (key) > fieldsizeof (struct vfs_mountpoint, key))
+int vfs_create_volume (const char* key, int fs_type, struct device* back_device, struct proc* proc,
+                       struct reschedule_ctx* rctx) {
+  if (strlen_null (key) > VOLUME_MAX)
     return -ST_OOB_ERROR;
 
-  struct vfs_mountpoint* mountpoint = malloc (sizeof (*mountpoint));
+  struct vfs_volume* volume = malloc (sizeof (*volume));
 
-  if (mountpoint == NULL)
+  if (volume == NULL)
     return -ST_OOM_ERROR;
 
-  memset (mountpoint, 0, sizeof (*mountpoint));
+  memset (volume, 0, sizeof (*volume));
 
-  memcpy (mountpoint->key, key, strlen_null (key));
-  mountpoint->fs_type = fs_type;
-  mountpoint->back_device = back_device;
+  memcpy (volume->key, key, strlen_null (key));
+  volume->fs_type = fs_type;
+  volume->back_device = back_device;
+  volume->lock = SPIN_LOCK_INIT;
 
-  switch (mountpoint->fs_type) {
+  switch (volume->fs_type) {
   case VFS_TARFS: {
-    mountpoint->driver_ops.mount = &tarfs_mount;
-    mountpoint->driver_ops.describe = &tarfs_describe;
-    mountpoint->driver_ops.read = &tarfs_read;
+    volume->driver_ops.mount = &tarfs_mount;
+    volume->driver_ops.describe = &tarfs_describe;
+    volume->driver_ops.read = &tarfs_read;
   } break;
   default: {
-    free (mountpoint);
+    free (volume);
     return -ST_MOUNT_ERROR;
   } break;
   }
 
-  int ret = mountpoint->driver_ops.mount (mountpoint, proc, rctx);
+  int ret = volume->driver_ops.mount (volume, proc, rctx);
 
   if (ret < 0) {
-    free (mountpoint);
+    free (volume);
     return ret;
   }
 
-  uint32_t mp_hash = hash_fnv32 (mountpoint->key, strlen (mountpoint->key));
+  uint32_t mp_hash = hash_fnv32 (volume->key, strlen (volume->key));
 
-  spin_lock (&mount_table.lock);
+  spin_lock (&volume_table.lock);
 
-  hash_insert (&mount_table, &mountpoint->mount_table_link, mp_hash,
-               lengthof (mount_table.mountpoint_buckets), mountpoint_buckets);
+  hash_insert (&volume_table, &volume->volume_table_link, mp_hash,
+               lengthof (volume_table.volume_buckets), volume_buckets);
 
-  spin_unlock (&mount_table.lock);
+  spin_unlock (&volume_table.lock);
 
   return ST_OK;
 }
 
-int vfs_open (struct procgroup* procgroup, const char* mountpoint, const char* path) {
-  struct vfs_mountpoint* vmp = vfs_find_mountpoint (mountpoint);
+int vfs_volume_open (struct proc* proc, const char* volume_name, struct reschedule_ctx* rctx) {
+  struct vfs_volume* volume = vfs_find_volume (volume_name);
 
-  if (vmp == NULL)
+  if (volume == NULL)
     return -ST_NOT_FOUND;
 
-  struct vfs_handle* handle = malloc (sizeof (*handle));
+  spin_lock (&volume->lock);
 
-  if (handle == NULL)
-    return -ST_OOM_ERROR;
-
-  memset (handle, 0, sizeof (*handle));
-  handle->mountpoint = vmp;
-  handle->ownerpg = procgroup;
-  strncpy (handle->path, path, sizeof (handle->path));
-
-  spin_lock (&procgroup->lock);
-
-  int id = handle->id = id_alloc (&procgroup->vfs_handle_id_alloc);
-
-  if (id < 0) {
-    free (handle);
-    spin_unlock (&procgroup->lock);
-    return -ST_OOM_ERROR;
+  if (!volume->locked) {
+    volume->locked = true;
+    volume->owner = proc;
+    spin_unlock (&volume->lock);
+    return ST_OK;
+  } else {
+    if (proc == VFS_KERNEL) {
+      spin_unlock (&volume->lock);
+      return -ST_TRY_AGAIN;
+    } else {
+      proc_sq_suspend (proc, &volume->sq, &volume->lock, rctx);
+      return ST_OK;
+    }
   }
-
-  rbtree_insert (struct vfs_handle, &procgroup->vfs_handle_tree, &handle->handle_tree_link,
-                 handle_tree_link, id);
-
-  spin_unlock (&procgroup->lock);
-
-  return id;
 }
 
-int vfs_close (struct procgroup* procgroup, int id) {
-  struct vfs_handle* handle = NULL;
+int vfs_volume_close (struct proc* proc, const char* volume_name, struct reschedule_ctx* rctx) {
+  struct vfs_volume* volume = vfs_find_volume (volume_name);
 
-  spin_lock (&procgroup->lock);
-
-  rbtree_find (struct vfs_handle, &procgroup->vfs_handle_tree, id, handle, handle_tree_link, id);
-
-  if (handle == NULL) {
-    spin_unlock (&procgroup->lock);
+  if (volume == NULL)
     return -ST_NOT_FOUND;
+
+  spin_lock (&volume->lock);
+
+  if (volume->locked && volume->owner != proc) {
+    spin_unlock (&volume->lock);
+    return -ST_PERMISSION_ERROR;
   }
 
-  spin_lock (&handle->lock);
+  spin_lock (&volume->sq.lock);
 
-  rbtree_delete (&procgroup->vfs_handle_tree, &handle->handle_tree_link);
+  struct list_node_link* node = volume->sq.proc_list;
 
-  id_free (&procgroup->vfs_handle_id_alloc, handle->id);
+  if (node) {
+    struct proc_sq_entry* sq_entry = list_entry (node, struct proc_sq_entry, sq_link);
+    struct proc* resumed_proc = sq_entry->proc;
 
-  spin_unlock (&handle->lock);
-  spin_unlock (&procgroup->lock);
+    volume->owner = proc;
+    volume->locked = true;
 
-  free (handle);
+    spin_unlock (&volume->sq.lock);
+    spin_unlock (&volume->lock);
+
+    proc_sq_resume (resumed_proc, sq_entry, rctx);
+    return ST_OK;
+  }
+
+  volume->locked = false;
+  volume->owner = NULL;
+
+  spin_unlock (&volume->sq.lock);
+  spin_unlock (&volume->lock);
 
   return ST_OK;
 }
 
-int vfs_describe (struct procgroup* procgroup, int id, struct desc* desc) {
-  struct vfs_handle* handle = NULL;
+int vfs_read (struct proc* proc, const char* volume_name, const char* path, uint8_t* buffer,
+              size_t off, size_t size, struct reschedule_ctx* rctx) {
+  struct vfs_volume* volume = vfs_find_volume (volume_name);
 
-  spin_lock (&procgroup->lock);
-
-  rbtree_find (struct vfs_handle, &procgroup->vfs_handle_tree, id, handle, handle_tree_link, id);
-
-  if (handle == NULL) {
-    spin_unlock (&procgroup->lock);
+  if (volume == NULL)
     return -ST_NOT_FOUND;
+
+  spin_lock (&volume->lock);
+
+  if (volume->locked && volume->owner != proc) {
+    spin_unlock (&volume->lock);
+    return -ST_PERMISSION_ERROR;
   }
 
-  spin_unlock (&procgroup->lock);
+  spin_unlock (&volume->lock);
 
-  spin_lock (&handle->lock);
-  int ret = handle->mountpoint->driver_ops.describe (handle->mountpoint, handle->path, desc);
-  spin_unlock (&handle->lock);
-
-  return ret;
+  return volume->driver_ops.read (volume, path, buffer, off, size);
 }
 
-int vfs_read (struct procgroup* procgroup, int id, uint8_t* buffer, size_t off, size_t size) {
-  struct vfs_handle* handle = NULL;
+int vfs_describe (struct proc* proc, const char* volume_name, const char* path, struct desc* desc,
+                  struct reschedule_ctx* rctx) {
+  struct vfs_volume* volume = vfs_find_volume (volume_name);
 
-  spin_lock (&procgroup->lock);
-
-  rbtree_find (struct vfs_handle, &procgroup->vfs_handle_tree, id, handle, handle_tree_link, id);
-
-  if (handle == NULL) {
-    spin_unlock (&procgroup->lock);
+  if (volume == NULL)
     return -ST_NOT_FOUND;
+
+  spin_lock (&volume->lock);
+
+  if (volume->locked && volume->owner != proc) {
+    spin_unlock (&volume->lock);
+    return -ST_PERMISSION_ERROR;
   }
 
-  spin_unlock (&procgroup->lock);
+  spin_unlock (&volume->lock);
 
-  spin_lock (&handle->lock);
-  int ret =
-      handle->mountpoint->driver_ops.read (handle->mountpoint, handle->path, buffer, off, size);
-  spin_unlock (&handle->lock);
-
-  return ret;
-}
-
-int vfs_kernel_read (const char* mountpoint, const char* path, uint8_t* buffer, size_t off,
-                     size_t size) {
-  struct vfs_mountpoint* vmp = vfs_find_mountpoint (mountpoint);
-
-  if (vmp == NULL)
-    return -ST_NOT_FOUND;
-
-  return vmp->driver_ops.read (vmp, path, buffer, off, size);
-}
-
-int vfs_kernel_describe (const char* mountpoint, const char* path, struct desc* desc) {
-  struct vfs_mountpoint* vmp = vfs_find_mountpoint (mountpoint);
-
-  if (vmp == NULL)
-    return -ST_NOT_FOUND;
-
-  return vmp->driver_ops.describe (vmp, path, desc);
-}
-
-void vfs_procgroup_cleanup (struct procgroup* procgroup) {
-  struct vfs_handle* handle;
-
-  struct rb_node_link* node;
-  rbtree_first (&procgroup->vfs_handle_tree, node);
-
-  while (node != NULL) {
-    struct rb_node_link* next;
-    rbtree_next (node, next);
-    handle = rbtree_entry (node, struct vfs_handle, handle_tree_link);
-    node = next;
-
-    vfs_close (procgroup, handle->id);
-  }
+  return volume->driver_ops.describe (volume, path, desc);
 }
 
 void vfs_init (void) {
-  memset (&mount_table, 0, sizeof (mount_table));
+  memset (&volume_table, 0, sizeof (volume_table));
 
-  mount_table.lock = SPIN_LOCK_INIT;
+  volume_table.lock = SPIN_LOCK_INIT;
 }