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 5af07b2fdbe23a11daf41249016bc332467903c7..7f5b646227193385a5c8b71cefd619e68c80b472 100644 (file)
--- a/src/kernel/devfs.c
+++ b/src/kernel/devfs.c
@@ -27,8 +27,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,
 };
 
@@ -224,6 +226,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 9abde00252519f9db6b025b3aea78191c96f11e5..baee9f5c0761d9c9f41ed63bd23611432e7f4451 100644 (file)
--- a/src/kernel/overlayfs.c
+++ b/src/kernel/overlayfs.c
@@ -94,7 +94,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,
 };
 
@@ -123,6 +126,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;
     }
@@ -164,6 +168,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;
@@ -178,10 +184,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);
@@ -211,6 +225,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 d4320ad18b2cc6b63d71abccf2aa8cc6291f8fd5..94b5be647b2a02bf4670f2a684cc343c91fc3d60 100644 (file)
--- a/src/kernel/persistfs.c
+++ b/src/kernel/persistfs.c
@@ -71,8 +71,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 = {
@@ -113,6 +115,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 ce21f63aea03131ab3a3241a0c017279dc238a8e..de6b0ecc6fa96d034f3fd11aa3d9de433386639d 100644 (file)
--- a/src/kernel/procfs.c
+++ b/src/kernel/procfs.c
@@ -233,8 +233,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;
 
@@ -297,6 +298,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];
 }
 
@@ -403,13 +405,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,
 };
 
@@ -429,8 +435,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,
 };
 
@@ -447,11 +455,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 5557e1dae738eb1daa7654429fec2cad05419d80..124c27799ae2d700f33359865f22511ab7f9078f 100644 (file)
--- a/src/kernel/tmpfs.c
+++ b/src/kernel/tmpfs.c
@@ -26,8 +26,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,
 };
 
@@ -76,6 +78,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;
 }
@@ -204,6 +207,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;
 }