refactor: migrate procfs, persistfs, pty to f_ops (dual-assignment)

- procfs: 9 static file_operations tables for root, self, self/status,
  uptime, meminfo, cmdline, pid dirs, pid/status, pid/maps
- persistfs: 2 tables for root dir and counter file
- pty: 4 tables for master, slave, ptmx, pts directory

All fs_node_t nodes in the codebase now have f_ops assigned.
Legacy per-node function pointers retained for backward compat.

20/20 smoke tests pass.

diff --git a/src/kernel/persistfs.c b/src/kernel/persistfs.c
index bffa5d76940e6f8778c289a01471806795dd0e88..788c3b38b3d37906bc454ea1abf0d157e26933ef 100644 (file)
--- a/src/kernel/persistfs.c
+++ b/src/kernel/persistfs.c
@@ -71,6 +71,15 @@ 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_counter_fops = {
+    .read  = persist_counter_read,
+    .write = persist_counter_write,
+};
+
 fs_node_t* persistfs_create_root(int drive) {
     if (!g_ready) {
         if (ata_pio_drive_present(drive)) {
@@ -103,6 +112,7 @@ fs_node_t* persistfs_create_root(int drive) {
         g_root.flags = FS_DIRECTORY;
         g_root.inode = 1;
         g_root.length = 0;
+        g_root.f_ops = &persistfs_root_fops;
         g_root.read = 0;
         g_root.write = 0;
         g_root.open = 0;
@@ -114,6 +124,7 @@ fs_node_t* persistfs_create_root(int drive) {
         g_counter.flags = FS_FILE;
         g_counter.inode = 2;
         g_counter.length = 512;
+        g_counter.f_ops = &persistfs_counter_fops;
         g_counter.read = &persist_counter_read;
         g_counter.write = &persist_counter_write;
         g_counter.open = 0;

diff --git a/src/kernel/procfs.c b/src/kernel/procfs.c
index a775c79d99f498228d775f65223537e095f76e21..ed2f1f3b11a97c775ff4c680ec081fb5e1148a8d 100644 (file)
--- a/src/kernel/procfs.c
+++ b/src/kernel/procfs.c
@@ -233,6 +233,11 @@ 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 */
+static const struct file_operations procfs_pid_dir_fops;
+static const struct file_operations procfs_pid_status_fops;
+static const struct file_operations procfs_pid_maps_fops;
+
 static fs_node_t* proc_pid_finddir(fs_node_t* node, const char* name) {
     uint32_t pid = node->inode;
     uint32_t slot = g_pid_pool_idx;
@@ -243,6 +248,7 @@ static fs_node_t* proc_pid_finddir(fs_node_t* node, const char* name) {
         strcpy(g_pid_status[slot].name, "status");
         g_pid_status[slot].flags = FS_FILE;
         g_pid_status[slot].inode = pid;
+        g_pid_status[slot].f_ops = &procfs_pid_status_fops;
         g_pid_status[slot].read = proc_pid_status_read;
         return &g_pid_status[slot];
     }
@@ -252,6 +258,7 @@ static fs_node_t* proc_pid_finddir(fs_node_t* node, const char* name) {
         strcpy(g_pid_maps[slot].name, "maps");
         g_pid_maps[slot].flags = FS_FILE;
         g_pid_maps[slot].inode = pid;
+        g_pid_maps[slot].f_ops = &procfs_pid_maps_fops;
         g_pid_maps[slot].read = proc_pid_maps_read;
         return &g_pid_maps[slot];
     }
@@ -291,6 +298,7 @@ static fs_node_t* proc_get_pid_dir(uint32_t pid) {
     strcpy(g_pid_dir[slot].name, num);
     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].finddir = proc_pid_finddir;
     g_pid_dir[slot].readdir = proc_pid_readdir;
     return &g_pid_dir[slot];
@@ -397,37 +405,84 @@ static int proc_root_readdir(fs_node_t* node, uint32_t* inout_index, void* buf,
     return 0;
 }
 
+/* --- file_operations tables --- */
+
+static const struct file_operations procfs_root_fops = {
+    .finddir = proc_root_finddir,
+    .readdir = proc_root_readdir,
+};
+
+static const struct file_operations procfs_self_fops = {
+    .finddir = proc_self_finddir,
+    .readdir = proc_self_readdir,
+};
+
+static const struct file_operations procfs_self_status_fops = {
+    .read = proc_self_status_read,
+};
+
+static const struct file_operations procfs_uptime_fops = {
+    .read = proc_uptime_read,
+};
+
+static const struct file_operations procfs_meminfo_fops = {
+    .read = proc_meminfo_read,
+};
+
+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,
+    .readdir = proc_pid_readdir,
+};
+
+static const struct file_operations procfs_pid_status_fops = {
+    .read = proc_pid_status_read,
+};
+
+static const struct file_operations procfs_pid_maps_fops = {
+    .read = proc_pid_maps_read,
+};
+
 fs_node_t* procfs_create_root(void) {
     memset(&g_proc_root, 0, sizeof(g_proc_root));
     strcpy(g_proc_root.name, "proc");
     g_proc_root.flags = FS_DIRECTORY;
+    g_proc_root.f_ops = &procfs_root_fops;
     g_proc_root.finddir = proc_root_finddir;
     g_proc_root.readdir = proc_root_readdir;
 
     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.finddir = proc_self_finddir;
     g_proc_self.readdir = proc_self_readdir;
 
     memset(&g_proc_self_status, 0, sizeof(g_proc_self_status));
     strcpy(g_proc_self_status.name, "status");
     g_proc_self_status.flags = FS_FILE;
+    g_proc_self_status.f_ops = &procfs_self_status_fops;
     g_proc_self_status.read = proc_self_status_read;
 
     memset(&g_proc_uptime, 0, sizeof(g_proc_uptime));
     strcpy(g_proc_uptime.name, "uptime");
     g_proc_uptime.flags = FS_FILE;
+    g_proc_uptime.f_ops = &procfs_uptime_fops;
     g_proc_uptime.read = proc_uptime_read;
 
     memset(&g_proc_meminfo, 0, sizeof(g_proc_meminfo));
     strcpy(g_proc_meminfo.name, "meminfo");
     g_proc_meminfo.flags = FS_FILE;
+    g_proc_meminfo.f_ops = &procfs_meminfo_fops;
     g_proc_meminfo.read = proc_meminfo_read;
 
     memset(&g_proc_cmdline, 0, sizeof(g_proc_cmdline));
     strcpy(g_proc_cmdline.name, "cmdline");
     g_proc_cmdline.flags = FS_FILE;
+    g_proc_cmdline.f_ops = &procfs_cmdline_fops;
     g_proc_cmdline.read = proc_cmdline_read;
 
     return &g_proc_root;

diff --git a/src/kernel/pty.c b/src/kernel/pty.c
index c53d8044608109a30b98abe6571fbc97a4d2aae6..c1a56c4cd040d13e4ad3ef0c4ebb4bfbcaa248af 100644 (file)
--- a/src/kernel/pty.c
+++ b/src/kernel/pty.c
@@ -100,6 +100,36 @@ static int pty_slave_poll_fn(fs_node_t* node, int events) {
     return revents;
 }
 
+/* Forward declarations for file_operations tables */
+static uint32_t pty_ptmx_read_fn(fs_node_t* node, uint32_t offset, uint32_t size, uint8_t* buffer);
+static uint32_t pty_ptmx_write_fn(fs_node_t* node, uint32_t offset, uint32_t size, const uint8_t* buffer);
+static struct fs_node* pty_pts_finddir(struct fs_node* node, const char* name);
+static int pty_pts_readdir(struct fs_node* node, uint32_t* inout_index, void* buf, uint32_t buf_len);
+
+static const struct file_operations pty_master_fops = {
+    .read  = pty_master_read_fn,
+    .write = pty_master_write_fn,
+    .poll  = pty_master_poll_fn,
+};
+
+static const struct file_operations pty_slave_fops = {
+    .read  = pty_slave_read_fn,
+    .write = pty_slave_write_fn,
+    .ioctl = pty_slave_ioctl_fn,
+    .poll  = pty_slave_poll_fn,
+};
+
+static const struct file_operations pty_ptmx_fops = {
+    .read  = pty_ptmx_read_fn,
+    .write = pty_ptmx_write_fn,
+    .poll  = pty_master_poll_fn,
+};
+
+static const struct file_operations pty_pts_dir_fops = {
+    .finddir = pty_pts_finddir,
+    .readdir = pty_pts_readdir,
+};
+
 static void pty_init_pair(int idx) {
     struct pty_pair* p = &g_ptys[idx];
     memset(p, 0, sizeof(*p));
@@ -111,6 +141,7 @@ static void pty_init_pair(int idx) {
     strcpy(p->master_node.name, "ptmx");
     p->master_node.flags = FS_CHARDEVICE;
     p->master_node.inode = PTY_MASTER_INO_BASE + (uint32_t)idx;
+    p->master_node.f_ops = &pty_master_fops;
     p->master_node.read = &pty_master_read_fn;
     p->master_node.write = &pty_master_write_fn;
     p->master_node.poll = &pty_master_poll_fn;
@@ -121,6 +152,7 @@ static void pty_init_pair(int idx) {
     strcpy(p->slave_node.name, name);
     p->slave_node.flags = FS_CHARDEVICE;
     p->slave_node.inode = PTY_SLAVE_INO_BASE + (uint32_t)idx;
+    p->slave_node.f_ops = &pty_slave_fops;
     p->slave_node.read = &pty_slave_read_fn;
     p->slave_node.write = &pty_slave_write_fn;
     p->slave_node.ioctl = &pty_slave_ioctl_fn;
@@ -215,6 +247,7 @@ void pty_init(void) {
     strcpy(g_dev_ptmx_node.name, "ptmx");
     g_dev_ptmx_node.flags = FS_CHARDEVICE;
     g_dev_ptmx_node.inode = PTY_MASTER_INO_BASE;
+    g_dev_ptmx_node.f_ops = &pty_ptmx_fops;
     g_dev_ptmx_node.read = &pty_ptmx_read_fn;
     g_dev_ptmx_node.write = &pty_ptmx_write_fn;
     g_dev_ptmx_node.poll = &pty_master_poll_fn;
@@ -225,6 +258,7 @@ void pty_init(void) {
     strcpy(g_dev_pts_dir_node.name, "pts");
     g_dev_pts_dir_node.flags = FS_DIRECTORY;
     g_dev_pts_dir_node.inode = 5;
+    g_dev_pts_dir_node.f_ops = &pty_pts_dir_fops;
     g_dev_pts_dir_node.finddir = &pty_pts_finddir;
     g_dev_pts_dir_node.readdir = &pty_pts_readdir;
     devfs_register_device(&g_dev_pts_dir_node);