refactor: migrate devfs, procfs, tmpfs, overlayfs, persistfs to inode_operations

- devfs: devfs_dir_iops with lookup/readdir; devfs_dir_ops now empty
- procfs: procfs_root_iops, procfs_self_iops, procfs_pid_dir_iops
  with lookup/readdir; corresponding fops now empty
- tmpfs: tmpfs_dir_iops with lookup/readdir; tmpfs_dir_ops now empty;
  all dir creation sites (tmpfs_child_ensure_dir, tmpfs_create_root)
  wire i_ops
- overlayfs: overlay_dir_iops with lookup/readdir; finddir_impl and
  readdir_impl updated to check i_ops->lookup/readdir on child layers
  before falling back to f_ops (needed since child FSes now use i_ops)
- persistfs: persistfs_root_iops with lookup

All file-type nodes (read/write/poll/ioctl) remain in f_ops only —
correct separation of concerns.

20/20 smoke tests pass.

diff --git a/src/kernel/devfs.c b/src/kernel/devfs.c
index d447c199a2d869922906d5ff884840fca510067c..3266dd3259c12290cef7d6be30e14fb7e50425f9 100644 (file)
--- a/src/kernel/devfs.c
+++ b/src/kernel/devfs.c
@@ -36,8 +36,10 @@ static uint32_t dev_random_write(fs_node_t* node, uint32_t offset, uint32_t size
 static int dev_null_poll(fs_node_t* node, int events);
 static int dev_always_ready_poll(fs_node_t* node, int events);
 
-static const struct file_operations devfs_dir_ops = {
-    .finddir = devfs_finddir_impl,
+static const struct file_operations devfs_dir_ops = {0};
+
+static const struct inode_operations devfs_dir_iops = {
+    .lookup  = devfs_finddir_impl,
     .readdir = devfs_readdir_impl,
 };
 
@@ -233,6 +235,7 @@ static void devfs_init_once(void) {
     g_dev_root.vfs.inode = 1;
     g_dev_root.vfs.length = 0;
     g_dev_root.vfs.f_ops = &devfs_dir_ops;
+    g_dev_root.vfs.i_ops = &devfs_dir_iops;
 
     memset(&g_dev_null, 0, sizeof(g_dev_null));
     strcpy(g_dev_null.name, "null");

diff --git a/src/kernel/overlayfs.c b/src/kernel/overlayfs.c
index 85b650b270b91c757666dd446c2f55b351847b19..f1abef41c61779027b0317bfcb7e755ad487a23a 100644 (file)
--- a/src/kernel/overlayfs.c
+++ b/src/kernel/overlayfs.c
@@ -103,7 +103,10 @@ static const struct file_operations overlay_file_ops = {
 
 static const struct file_operations overlay_dir_ops = {
     .read    = overlay_read_impl,
-    .finddir = overlay_finddir_impl,
+};
+
+static const struct inode_operations overlay_dir_iops = {
+    .lookup  = overlay_finddir_impl,
     .readdir = overlay_readdir_impl,
 };
 
@@ -132,6 +135,7 @@ static fs_node_t* overlay_wrap_child(struct overlay_node* parent, const char* na
 
     if (c->vfs.flags == FS_DIRECTORY) {
         c->vfs.f_ops = &overlay_dir_ops;
+        c->vfs.i_ops = &overlay_dir_iops;
     } else {
         c->vfs.f_ops = &overlay_file_ops;
     }
@@ -173,6 +177,8 @@ static int overlay_readdir_impl(struct fs_node* node, uint32_t* inout_index, voi
     // Prefer upper layer readdir; fall back to lower.
     fs_node_t* src = dir->upper ? dir->upper : dir->lower;
     if (!src) return 0;
+    if (src->i_ops && src->i_ops->readdir)
+        return src->i_ops->readdir(src, inout_index, buf, buf_len);
     if (src->f_ops && src->f_ops->readdir)
         return src->f_ops->readdir(src, inout_index, buf, buf_len);
     return 0;
@@ -187,10 +193,18 @@ static struct fs_node* overlay_finddir_impl(struct fs_node* node, const char* na
     fs_node_t* upper_child = NULL;
     fs_node_t* lower_child = NULL;
 
-    if (dir->upper && dir->upper->f_ops && dir->upper->f_ops->finddir)
-        upper_child = dir->upper->f_ops->finddir(dir->upper, name);
-    if (dir->lower && dir->lower->f_ops && dir->lower->f_ops->finddir)
-        lower_child = dir->lower->f_ops->finddir(dir->lower, name);
+    if (dir->upper) {
+        if (dir->upper->i_ops && dir->upper->i_ops->lookup)
+            upper_child = dir->upper->i_ops->lookup(dir->upper, name);
+        else if (dir->upper->f_ops && dir->upper->f_ops->finddir)
+            upper_child = dir->upper->f_ops->finddir(dir->upper, name);
+    }
+    if (dir->lower) {
+        if (dir->lower->i_ops && dir->lower->i_ops->lookup)
+            lower_child = dir->lower->i_ops->lookup(dir->lower, name);
+        else if (dir->lower->f_ops && dir->lower->f_ops->finddir)
+            lower_child = dir->lower->f_ops->finddir(dir->lower, name);
+    }
 
     if (!upper_child && !lower_child) return 0;
     return overlay_wrap_child(dir, name, lower_child, upper_child);
@@ -220,6 +234,7 @@ fs_node_t* overlayfs_create_root(fs_node_t* lower_root, fs_node_t* upper_root) {
     root->vfs.inode = upper_root->inode;
     root->vfs.length = 0;
     root->vfs.f_ops = &overlay_dir_ops;
+    root->vfs.i_ops = &overlay_dir_iops;
 
     root->path[0] = 0;
 

diff --git a/src/kernel/persistfs.c b/src/kernel/persistfs.c
index a62cc73765579c74efc4c575fe6265769b29e0bb..c2e42b782d6dbc4e8ebb4ac634d78d271f92793c 100644 (file)
--- a/src/kernel/persistfs.c
+++ b/src/kernel/persistfs.c
@@ -80,8 +80,10 @@ static struct fs_node* persist_root_finddir(struct fs_node* node, const char* na
     return 0;
 }
 
-static const struct file_operations persistfs_root_fops = {
-    .finddir = persist_root_finddir,
+static const struct file_operations persistfs_root_fops = {0};
+
+static const struct inode_operations persistfs_root_iops = {
+    .lookup = persist_root_finddir,
 };
 
 static const struct file_operations persistfs_counter_fops = {
@@ -122,6 +124,7 @@ fs_node_t* persistfs_create_root(int drive) {
         g_root.inode = 1;
         g_root.length = 0;
         g_root.f_ops = &persistfs_root_fops;
+        g_root.i_ops = &persistfs_root_iops;
 
         memset(&g_counter, 0, sizeof(g_counter));
         strcpy(g_counter.name, "counter");

diff --git a/src/kernel/procfs.c b/src/kernel/procfs.c
index e99a9b6decc478eeafccdb6b5f45f4abeedaf39e..6422ba0a26bb9bf10c7543d11495e192d13cc0fd 100644 (file)
--- a/src/kernel/procfs.c
+++ b/src/kernel/procfs.c
@@ -242,8 +242,9 @@ static uint32_t proc_pid_maps_read(fs_node_t* node, uint32_t offset, uint32_t si
 
 /* --- per-PID directory --- */
 
-/* Forward declarations for file_operations tables used in dynamic node creation */
+/* Forward declarations for file_operations / inode_operations tables */
 static const struct file_operations procfs_pid_dir_fops;
+static const struct inode_operations procfs_pid_dir_iops;
 static const struct file_operations procfs_pid_status_fops;
 static const struct file_operations procfs_pid_maps_fops;
 
@@ -306,6 +307,7 @@ static fs_node_t* proc_get_pid_dir(uint32_t pid) {
     g_pid_dir[slot].flags = FS_DIRECTORY;
     g_pid_dir[slot].inode = pid;
     g_pid_dir[slot].f_ops = &procfs_pid_dir_fops;
+    g_pid_dir[slot].i_ops = &procfs_pid_dir_iops;
     return &g_pid_dir[slot];
 }
 
@@ -412,13 +414,17 @@ static int proc_root_readdir(fs_node_t* node, uint32_t* inout_index, void* buf,
 
 /* --- file_operations tables --- */
 
-static const struct file_operations procfs_root_fops = {
-    .finddir = proc_root_finddir,
+static const struct file_operations procfs_root_fops = {0};
+
+static const struct inode_operations procfs_root_iops = {
+    .lookup  = proc_root_finddir,
     .readdir = proc_root_readdir,
 };
 
-static const struct file_operations procfs_self_fops = {
-    .finddir = proc_self_finddir,
+static const struct file_operations procfs_self_fops = {0};
+
+static const struct inode_operations procfs_self_iops = {
+    .lookup  = proc_self_finddir,
     .readdir = proc_self_readdir,
 };
 
@@ -438,8 +444,10 @@ static const struct file_operations procfs_cmdline_fops = {
     .read = proc_cmdline_read,
 };
 
-static const struct file_operations procfs_pid_dir_fops = {
-    .finddir = proc_pid_finddir,
+static const struct file_operations procfs_pid_dir_fops = {0};
+
+static const struct inode_operations procfs_pid_dir_iops = {
+    .lookup  = proc_pid_finddir,
     .readdir = proc_pid_readdir,
 };
 
@@ -456,11 +464,13 @@ fs_node_t* procfs_create_root(void) {
     strcpy(g_proc_root.name, "proc");
     g_proc_root.flags = FS_DIRECTORY;
     g_proc_root.f_ops = &procfs_root_fops;
+    g_proc_root.i_ops = &procfs_root_iops;
 
     memset(&g_proc_self, 0, sizeof(g_proc_self));
     strcpy(g_proc_self.name, "self");
     g_proc_self.flags = FS_DIRECTORY;
     g_proc_self.f_ops = &procfs_self_fops;
+    g_proc_self.i_ops = &procfs_self_iops;
 
     memset(&g_proc_self_status, 0, sizeof(g_proc_self_status));
     strcpy(g_proc_self_status.name, "status");

diff --git a/src/kernel/tmpfs.c b/src/kernel/tmpfs.c
index 5f1cc321ce852c82897271d5aa29e13d00d62687..52e5b1cf598192d5839529f280b601a9a3a23ec8 100644 (file)
--- a/src/kernel/tmpfs.c
+++ b/src/kernel/tmpfs.c
@@ -35,8 +35,10 @@ static const struct file_operations tmpfs_file_ops = {
     .write   = tmpfs_write_impl,
 };
 
-static const struct file_operations tmpfs_dir_ops = {
-    .finddir = tmpfs_finddir_impl,
+static const struct file_operations tmpfs_dir_ops = {0};
+
+static const struct inode_operations tmpfs_dir_iops = {
+    .lookup  = tmpfs_finddir_impl,
     .readdir = tmpfs_readdir_impl,
 };
 
@@ -85,6 +87,7 @@ static struct tmpfs_node* tmpfs_child_ensure_dir(struct tmpfs_node* dir, const c
     struct tmpfs_node* nd = tmpfs_node_alloc(name, FS_DIRECTORY);
     if (!nd) return NULL;
     nd->vfs.f_ops = &tmpfs_dir_ops;
+    nd->vfs.i_ops = &tmpfs_dir_iops;
     tmpfs_child_add(dir, nd);
     return nd;
 }
@@ -213,6 +216,7 @@ fs_node_t* tmpfs_create_root(void) {
     if (!root) return NULL;
 
     root->vfs.f_ops = &tmpfs_dir_ops;
+    root->vfs.i_ops = &tmpfs_dir_iops;
 
     return &root->vfs;
 }