refactor: remove legacy per-node function pointers from fs_node_t

Phase B3b complete — all VFS dispatch now goes exclusively through
the f_ops pointer. Changes:

- fs.h: removed 16 legacy function pointer fields from fs_node_t
  (read, write, open, close, finddir, readdir, ioctl, mmap, poll,
  create, mkdir, unlink, rmdir, rename, truncate, link)
  fs_node_t shrinks by 64 bytes (16 pointers × 4 bytes)

- fs.c: removed all legacy fallback paths from VFS wrappers
- syscall.c: removed legacy fallbacks for poll, readdir, ioctl,
  mmap, truncate, finddir, and read/write capability checks
- overlayfs.c: removed legacy fallbacks in finddir/readdir dispatch
- kconsole.c: switched to f_ops-based readdir dispatch

- Removed all dual-assignment lines from:
  ext2.c, fat.c, diskfs.c, tmpfs.c, devfs.c, overlayfs.c,
  procfs.c, persistfs.c, pty.c, tty.c, keyboard.c, vbe.c,
  initrd.c, syscall.c (pipe + socket nodes)

- Removed ext2_set_dir_ops, fat_set_dir_ops, diskfs_set_dir_ops
  helper functions (no longer needed)

20/20 smoke tests pass.

diff --git a/include/fs.h b/include/fs.h
index 3c3dbce41d0a206068cf1d385380e82b1c16ee49..a185040c1d9c60651511b31ac8b699ddf4d75eee 100644 (file)
--- a/include/fs.h
+++ b/include/fs.h
@@ -63,25 +63,6 @@ typedef struct fs_node {
     char symlink_target[128];
 
     const struct file_operations* f_ops;
-
-    // Legacy per-node function pointers (will be removed after migration)
-    uint32_t (*read)(struct fs_node* node, uint32_t offset, uint32_t size, uint8_t* buffer);
-    uint32_t (*write)(struct fs_node* node, uint32_t offset, uint32_t size, const uint8_t* buffer);
-    void (*open)(struct fs_node* node);
-    void (*close)(struct fs_node* node);
-    struct fs_node* (*finddir)(struct fs_node* node, const char* name);
-    int (*readdir)(struct fs_node* node, uint32_t* inout_index, void* buf, uint32_t buf_len);
-    int (*ioctl)(struct fs_node* node, uint32_t cmd, void* arg);
-    uintptr_t (*mmap)(struct fs_node* node, uintptr_t addr, uint32_t length, uint32_t prot, uint32_t offset);
-    int (*poll)(struct fs_node* node, int events);
-    int (*create)(struct fs_node* dir, const char* name, uint32_t flags, struct fs_node** out);
-    int (*mkdir)(struct fs_node* dir, const char* name);
-    int (*unlink)(struct fs_node* dir, const char* name);
-    int (*rmdir)(struct fs_node* dir, const char* name);
-    int (*rename)(struct fs_node* old_dir, const char* old_name,
-                  struct fs_node* new_dir, const char* new_name);
-    int (*truncate)(struct fs_node* node, uint32_t length);
-    int (*link)(struct fs_node* dir, const char* name, struct fs_node* target);
 } fs_node_t;
 
 struct vfs_dirent {

diff --git a/src/drivers/initrd.c b/src/drivers/initrd.c
index 86095a072650741188d66e57a65b10d8af19f127..00563e8e66633fd322f150152dd0dda71dbe11d2 100644 (file)
--- a/src/drivers/initrd.c
+++ b/src/drivers/initrd.c
@@ -222,10 +222,8 @@ static void initrd_finalize_nodes(void) {
 
         if (e->flags & FS_FILE) {
             n->f_ops = &initrd_file_ops;
-            n->read = &initrd_read_impl;
         } else if (e->flags & FS_DIRECTORY) {
             n->f_ops = &initrd_dir_ops;
-            n->finddir = &initrd_finddir;
         }
     }
 }

diff --git a/src/drivers/keyboard.c b/src/drivers/keyboard.c
index 38b5c2743f1cadbc24b6e65e0af04774c5eb5485..d2dba13228ee606f6a716855617415059991f97b 100644 (file)
--- a/src/drivers/keyboard.c
+++ b/src/drivers/keyboard.c
@@ -132,8 +132,6 @@ void keyboard_register_devfs(void) {
     g_dev_kbd_node.flags = FS_CHARDEVICE;
     g_dev_kbd_node.inode = 21;
     g_dev_kbd_node.f_ops = &kbd_fops;
-    g_dev_kbd_node.read = &kbd_dev_read;
-    g_dev_kbd_node.poll = &kbd_dev_poll;
     devfs_register_device(&g_dev_kbd_node);
 }
 

diff --git a/src/drivers/vbe.c b/src/drivers/vbe.c
index ac306bcc3ba4ce6f2b3276710cfeb125c0c0f8ab..c2d2d8b8896557d3acfb727b13cb5086b5e1a3dc 100644 (file)
--- a/src/drivers/vbe.c
+++ b/src/drivers/vbe.c
@@ -202,10 +202,6 @@ void vbe_register_devfs(void) {
     g_dev_fb0_node.inode = 20;
     g_dev_fb0_node.length = g_vbe.size;
     g_dev_fb0_node.f_ops = &fb0_fops;
-    g_dev_fb0_node.read = &fb0_read;
-    g_dev_fb0_node.write = &fb0_write;
-    g_dev_fb0_node.ioctl = &fb0_ioctl;
-    g_dev_fb0_node.mmap = &fb0_mmap;
     devfs_register_device(&g_dev_fb0_node);
 
     kprintf("[VBE] Registered /dev/fb0\n");

diff --git a/src/kernel/devfs.c b/src/kernel/devfs.c
index cb3640c3c433856496ce2654c3ecbee0f0ee89e4..d447c199a2d869922906d5ff884840fca510067c 100644 (file)
--- a/src/kernel/devfs.c
+++ b/src/kernel/devfs.c
@@ -233,44 +233,30 @@ 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.finddir = devfs_finddir_impl;
-    g_dev_root.vfs.readdir = devfs_readdir_impl;
 
     memset(&g_dev_null, 0, sizeof(g_dev_null));
     strcpy(g_dev_null.name, "null");
     g_dev_null.flags = FS_CHARDEVICE;
     g_dev_null.inode = 2;
     g_dev_null.f_ops = &dev_null_ops;
-    g_dev_null.read = dev_null_read;
-    g_dev_null.write = dev_null_write;
-    g_dev_null.poll = dev_null_poll;
 
     memset(&g_dev_zero, 0, sizeof(g_dev_zero));
     strcpy(g_dev_zero.name, "zero");
     g_dev_zero.flags = FS_CHARDEVICE;
     g_dev_zero.inode = 7;
     g_dev_zero.f_ops = &dev_zero_ops;
-    g_dev_zero.read = dev_zero_read;
-    g_dev_zero.write = dev_zero_write;
-    g_dev_zero.poll = dev_always_ready_poll;
 
     memset(&g_dev_random, 0, sizeof(g_dev_random));
     strcpy(g_dev_random.name, "random");
     g_dev_random.flags = FS_CHARDEVICE;
     g_dev_random.inode = 8;
     g_dev_random.f_ops = &dev_random_ops;
-    g_dev_random.read = dev_random_read;
-    g_dev_random.write = dev_random_write;
-    g_dev_random.poll = dev_always_ready_poll;
 
     memset(&g_dev_urandom, 0, sizeof(g_dev_urandom));
     strcpy(g_dev_urandom.name, "urandom");
     g_dev_urandom.flags = FS_CHARDEVICE;
     g_dev_urandom.inode = 9;
     g_dev_urandom.f_ops = &dev_random_ops;
-    g_dev_urandom.read = dev_random_read;
-    g_dev_urandom.write = dev_random_write;
-    g_dev_urandom.poll = dev_always_ready_poll;
 }
 
 fs_node_t* devfs_create_root(void) {

diff --git a/src/kernel/diskfs.c b/src/kernel/diskfs.c
index 87f8ad0bda9eba716c40ee90a16ba9d0d5d6d00c..776a2fa51c315ad4c7a133b65d90ae89cbabbf38 100644 (file)
--- a/src/kernel/diskfs.c
+++ b/src/kernel/diskfs.c
@@ -468,7 +468,6 @@ static int diskfs_readdir_impl(struct fs_node* node, uint32_t* inout_index, void
     return (int)(nents * (uint32_t)sizeof(struct vfs_dirent));
 }
 
-static void diskfs_set_dir_ops(fs_node_t* vfs);
 static int diskfs_vfs_truncate(struct fs_node* node, uint32_t length);
 static struct fs_node* diskfs_root_finddir(struct fs_node* node, const char* name);
 static int diskfs_vfs_create(struct fs_node* dir, const char* name, uint32_t flags, struct fs_node** out);
@@ -521,24 +520,16 @@ static struct fs_node* diskfs_root_finddir(struct fs_node* node, const char* nam
 
     strcpy(dn->vfs.name, name);
     dn->vfs.inode = 100 + (uint32_t)cino;
-    dn->vfs.open = 0;
-    dn->vfs.close = &diskfs_close_impl;
     dn->ino = cino;
 
     if (sb.inodes[cino].type == DISKFS_INODE_DIR) {
         dn->vfs.flags = FS_DIRECTORY;
         dn->vfs.length = 0;
         dn->vfs.f_ops = &diskfs_dir_fops;
-        dn->vfs.finddir = &diskfs_root_finddir;
-        dn->vfs.readdir = &diskfs_readdir_impl;
-        diskfs_set_dir_ops(&dn->vfs);
     } else {
         dn->vfs.flags = FS_FILE;
         dn->vfs.length = sb.inodes[cino].size_bytes;
         dn->vfs.f_ops = &diskfs_file_fops;
-        dn->vfs.read = &diskfs_read_impl;
-        dn->vfs.write = &diskfs_write_impl;
-        dn->vfs.truncate = &diskfs_vfs_truncate;
     }
 
     return &dn->vfs;
@@ -593,9 +584,6 @@ int diskfs_open_file(const char* rel_path, uint32_t flags, fs_node_t** out_node)
     dn->vfs.inode = 100 + (uint32_t)ino;
     dn->vfs.length = sb.inodes[ino].size_bytes;
     dn->vfs.f_ops = &diskfs_file_fops;
-    dn->vfs.read = &diskfs_read_impl;
-    dn->vfs.write = &diskfs_write_impl;
-    dn->vfs.close = &diskfs_close_impl;
     dn->ino = ino;
 
     *out_node = &dn->vfs;
@@ -880,9 +868,7 @@ static int diskfs_vfs_create(struct fs_node* dir, const char* name, uint32_t fla
         dn->vfs.flags = FS_FILE;
         dn->vfs.inode = 100 + (uint32_t)ino;
         dn->vfs.length = sb.inodes[ino].size_bytes;
-        dn->vfs.read = &diskfs_read_impl;
-        dn->vfs.write = &diskfs_write_impl;
-        dn->vfs.close = &diskfs_close_impl;
+        dn->vfs.f_ops = &diskfs_file_fops;
         dn->ino = ino;
         *out = &dn->vfs;
         return 0;
@@ -903,9 +889,7 @@ static int diskfs_vfs_create(struct fs_node* dir, const char* name, uint32_t fla
     dn->vfs.flags = FS_FILE;
     dn->vfs.inode = 100 + (uint32_t)new_ino;
     dn->vfs.length = 0;
-    dn->vfs.read = &diskfs_read_impl;
-    dn->vfs.write = &diskfs_write_impl;
-    dn->vfs.close = &diskfs_close_impl;
+    dn->vfs.f_ops = &diskfs_file_fops;
     dn->ino = new_ino;
     *out = &dn->vfs;
     return 0;
@@ -1078,16 +1062,6 @@ static int diskfs_vfs_link(struct fs_node* dir, const char* name, struct fs_node
     return diskfs_super_store(&sb);
 }
 
-static void diskfs_set_dir_ops(fs_node_t* vfs) {
-    if (!vfs) return;
-    vfs->create = &diskfs_vfs_create;
-    vfs->mkdir = &diskfs_vfs_mkdir;
-    vfs->unlink = &diskfs_vfs_unlink;
-    vfs->rmdir = &diskfs_vfs_rmdir;
-    vfs->rename = &diskfs_vfs_rename;
-    vfs->link = &diskfs_vfs_link;
-}
-
 fs_node_t* diskfs_create_root(int drive) {
     if (!g_ready) {
         g_diskfs_drive = drive;
@@ -1103,9 +1077,6 @@ fs_node_t* diskfs_create_root(int drive) {
         g_root.vfs.inode = 100;
         g_root.vfs.length = 0;
         g_root.vfs.f_ops = &diskfs_dir_fops;
-        g_root.vfs.finddir = &diskfs_root_finddir;
-        g_root.vfs.readdir = &diskfs_readdir_impl;
-        diskfs_set_dir_ops(&g_root.vfs);
         g_root.ino = 0;
 
         if (g_ready) {

diff --git a/src/kernel/ext2.c b/src/kernel/ext2.c
index ae0618f1d5718271e8ff67d563343582e98b4fe5..41f122a9ed4d4582a8553546e72e911fde7acb80 100644 (file)
--- a/src/kernel/ext2.c
+++ b/src/kernel/ext2.c
@@ -566,18 +566,6 @@ static void ext2_close_impl(fs_node_t* node) {
     kfree(en);
 }
 
-static void ext2_set_dir_ops(fs_node_t* vfs) {
-    if (!vfs) return;
-    vfs->finddir = &ext2_finddir;
-    vfs->readdir = &ext2_readdir_impl;
-    vfs->create = &ext2_create_impl;
-    vfs->mkdir = &ext2_mkdir_impl;
-    vfs->unlink = &ext2_unlink_impl;
-    vfs->rmdir = &ext2_rmdir_impl;
-    vfs->rename = &ext2_rename_impl;
-    vfs->link = &ext2_link_impl;
-}
-
 static struct ext2_node* ext2_make_node(uint32_t ino, const struct ext2_inode* inode, const char* name) {
     struct ext2_node* en = (struct ext2_node*)kmalloc(sizeof(struct ext2_node));
     if (!en) return NULL;
@@ -593,13 +581,11 @@ static struct ext2_node* ext2_make_node(uint32_t ino, const struct ext2_inode* i
     en->vfs.uid = inode->i_uid;
     en->vfs.gid = inode->i_gid;
     en->vfs.mode = inode->i_mode;
-    en->vfs.close = &ext2_close_impl;
 
     if ((inode->i_mode & 0xF000) == EXT2_S_IFDIR) {
         en->vfs.flags = FS_DIRECTORY;
         en->vfs.length = inode->i_size;
         en->vfs.f_ops = &ext2_dir_fops;
-        ext2_set_dir_ops(&en->vfs);
     } else if ((inode->i_mode & 0xF000) == EXT2_S_IFLNK) {
         en->vfs.flags = FS_SYMLINK;
         en->vfs.length = inode->i_size;
@@ -612,9 +598,6 @@ static struct ext2_node* ext2_make_node(uint32_t ino, const struct ext2_inode* i
         en->vfs.flags = FS_FILE;
         en->vfs.length = inode->i_size;
         en->vfs.f_ops = &ext2_file_fops;
-        en->vfs.read = &ext2_file_read;
-        en->vfs.write = &ext2_file_write;
-        en->vfs.truncate = &ext2_truncate_impl;
     }
 
     return en;
@@ -1436,7 +1419,7 @@ fs_node_t* ext2_mount(int drive, uint32_t partition_lba) {
     g_ext2_root.vfs.gid = root_inode.i_gid;
     g_ext2_root.vfs.mode = root_inode.i_mode;
     g_ext2_root.ino = EXT2_ROOT_INO;
-    ext2_set_dir_ops(&g_ext2_root.vfs);
+    g_ext2_root.vfs.f_ops = &ext2_dir_fops;
 
     g_ext2_ready = 1;
 

diff --git a/src/kernel/fat.c b/src/kernel/fat.c
index 2b1a0d636efd4e694316854641db744c3de830c5..d89ae56f7a4a5acf6e97af14d3fbb1e4c5ad23f6 100644 (file)
--- a/src/kernel/fat.c
+++ b/src/kernel/fat.c
@@ -516,17 +516,6 @@ static void fat_close_impl(fs_node_t* node) {
     kfree(fn);
 }
 
-static void fat_set_dir_ops(fs_node_t* vfs) {
-    if (!vfs) return;
-    vfs->finddir = &fat_finddir;
-    vfs->readdir = &fat_readdir_impl;
-    vfs->create = &fat_create_impl;
-    vfs->mkdir = &fat_mkdir_impl;
-    vfs->unlink = &fat_unlink_impl;
-    vfs->rmdir = &fat_rmdir_impl;
-    vfs->rename = &fat_rename_impl;
-}
-
 static struct fat_node* fat_make_node(const struct fat_dirent* de, uint32_t parent_cluster, uint32_t dirent_offset) {
     struct fat_node* fn = (struct fat_node*)kmalloc(sizeof(struct fat_node));
     if (!fn) return NULL;
@@ -542,17 +531,12 @@ static struct fat_node* fat_make_node(const struct fat_dirent* de, uint32_t pare
         fn->vfs.length = 0;
         fn->vfs.inode = fn->first_cluster;
         fn->vfs.f_ops = &fat_dir_fops;
-        fat_set_dir_ops(&fn->vfs);
     } else {
         fn->vfs.flags = FS_FILE;
         fn->vfs.length = de->file_size;
         fn->vfs.inode = fn->first_cluster;
         fn->vfs.f_ops = &fat_file_fops;
-        fn->vfs.read = &fat_file_read;
-        fn->vfs.write = &fat_file_write;
-        fn->vfs.truncate = &fat_truncate_impl;
     }
-    fn->vfs.close = &fat_close_impl;
 
     return fn;
 }
@@ -1188,7 +1172,7 @@ fs_node_t* fat_mount(int drive, uint32_t partition_lba) {
     g_fat_root.first_cluster = (g_fat.type == FAT_TYPE_32) ? g_fat.root_cluster : 0;
     g_fat_root.parent_cluster = 0;
     g_fat_root.dir_entry_offset = 0;
-    fat_set_dir_ops(&g_fat_root.vfs);
+    g_fat_root.vfs.f_ops = &fat_dir_fops;
 
     g_fat_ready = 1;
 

diff --git a/src/kernel/fs.c b/src/kernel/fs.c
index 37ba13ac15b3aedc5b285f90819a9186bab85458..e4156d758bbf2ca0358a62964d82a11a18dbd64b 100644 (file)
--- a/src/kernel/fs.c
+++ b/src/kernel/fs.c
@@ -81,31 +81,23 @@ int vfs_mount(const char* mountpoint, fs_node_t* root) {
 uint32_t vfs_read(fs_node_t* node, uint32_t offset, uint32_t size, uint8_t* buffer) {
     if (node->f_ops && node->f_ops->read)
         return node->f_ops->read(node, offset, size, buffer);
-    if (node->read)
-        return node->read(node, offset, size, buffer);
     return 0;
 }
 
 uint32_t vfs_write(fs_node_t* node, uint32_t offset, uint32_t size, const uint8_t* buffer) {
     if (node->f_ops && node->f_ops->write)
         return node->f_ops->write(node, offset, size, buffer);
-    if (node->write)
-        return node->write(node, offset, size, buffer);
     return 0;
 }
 
 void vfs_open(fs_node_t* node) {
     if (node->f_ops && node->f_ops->open)
         node->f_ops->open(node);
-    else if (node->open)
-        node->open(node);
 }
 
 void vfs_close(fs_node_t* node) {
     if (node->f_ops && node->f_ops->close)
         node->f_ops->close(node);
-    else if (node->close)
-        node->close(node);
 }
 
 static fs_node_t* vfs_lookup_depth(const char* path, int depth);
@@ -161,7 +153,6 @@ static fs_node_t* vfs_lookup_depth(const char* path, int depth) {
         if (!cur) return NULL;
         fs_node_t* (*fn_finddir)(fs_node_t*, const char*) = NULL;
         if (cur->f_ops && cur->f_ops->finddir) fn_finddir = cur->f_ops->finddir;
-        else if (cur->finddir) fn_finddir = cur->finddir;
         if (!fn_finddir) return NULL;
         cur = fn_finddir(cur, part);
         if (!cur) return NULL;
@@ -215,8 +206,7 @@ int vfs_create(const char* path, uint32_t flags, fs_node_t** out) {
     if (parent->flags != FS_DIRECTORY) return -ENOTDIR;
     if (parent->f_ops && parent->f_ops->create)
         return parent->f_ops->create(parent, name, flags, out);
-    if (!parent->create) return -ENOSYS;
-    return parent->create(parent, name, flags, out);
+    return -ENOSYS;
 }
 
 int vfs_mkdir(const char* path) {
@@ -227,8 +217,7 @@ int vfs_mkdir(const char* path) {
     if (parent->flags != FS_DIRECTORY) return -ENOTDIR;
     if (parent->f_ops && parent->f_ops->mkdir)
         return parent->f_ops->mkdir(parent, name);
-    if (!parent->mkdir) return -ENOSYS;
-    return parent->mkdir(parent, name);
+    return -ENOSYS;
 }
 
 int vfs_unlink(const char* path) {
@@ -239,8 +228,7 @@ int vfs_unlink(const char* path) {
     if (parent->flags != FS_DIRECTORY) return -ENOTDIR;
     if (parent->f_ops && parent->f_ops->unlink)
         return parent->f_ops->unlink(parent, name);
-    if (!parent->unlink) return -ENOSYS;
-    return parent->unlink(parent, name);
+    return -ENOSYS;
 }
 
 int vfs_rmdir(const char* path) {
@@ -251,8 +239,7 @@ int vfs_rmdir(const char* path) {
     if (parent->flags != FS_DIRECTORY) return -ENOTDIR;
     if (parent->f_ops && parent->f_ops->rmdir)
         return parent->f_ops->rmdir(parent, name);
-    if (!parent->rmdir) return -ENOSYS;
-    return parent->rmdir(parent, name);
+    return -ENOSYS;
 }
 
 int vfs_rename(const char* old_path, const char* new_path) {
@@ -263,8 +250,7 @@ int vfs_rename(const char* old_path, const char* new_path) {
     if (!old_parent || !new_parent) return -ENOENT;
     if (old_parent->f_ops && old_parent->f_ops->rename)
         return old_parent->f_ops->rename(old_parent, old_name, new_parent, new_name);
-    if (!old_parent->rename) return -ENOSYS;
-    return old_parent->rename(old_parent, old_name, new_parent, new_name);
+    return -ENOSYS;
 }
 
 int vfs_truncate(const char* path, uint32_t length) {
@@ -274,8 +260,7 @@ int vfs_truncate(const char* path, uint32_t length) {
     if (node->flags != FS_FILE) return -EISDIR;
     if (node->f_ops && node->f_ops->truncate)
         return node->f_ops->truncate(node, length);
-    if (!node->truncate) return -ENOSYS;
-    return node->truncate(node, length);
+    return -ENOSYS;
 }
 
 int vfs_link(const char* old_path, const char* new_path) {
@@ -290,6 +275,5 @@ int vfs_link(const char* old_path, const char* new_path) {
     if (parent->flags != FS_DIRECTORY) return -ENOTDIR;
     if (parent->f_ops && parent->f_ops->link)
         return parent->f_ops->link(parent, name, target);
-    if (!parent->link) return -ENOSYS;
-    return parent->link(parent, name, target);
+    return -ENOSYS;
 }

diff --git a/src/kernel/kconsole.c b/src/kernel/kconsole.c
index 18268e049977564dcc8988ac19d3dd8518d33469..eb8349a839f14afd4724f6a75707f63892352519 100644 (file)
--- a/src/kernel/kconsole.c
+++ b/src/kernel/kconsole.c
@@ -276,7 +276,9 @@ static void kconsole_ls(const char* path) {
         return;
     }
 
-    if (!dir->readdir) {
+    int (*fn_readdir)(struct fs_node*, uint32_t*, void*, uint32_t) = NULL;
+    if (dir->f_ops && dir->f_ops->readdir) fn_readdir = dir->f_ops->readdir;
+    if (!fn_readdir) {
         kprintf("ls: not a directory\n");
         return;
     }
@@ -284,7 +286,7 @@ static void kconsole_ls(const char* path) {
     uint32_t idx = 0;
     struct vfs_dirent ent;
     while (1) {
-        int rc = dir->readdir(dir, &idx, &ent, sizeof(ent));
+        int rc = fn_readdir(dir, &idx, &ent, sizeof(ent));
         if (rc != 0) break;
         kprintf("  %s\n", ent.d_name);
     }

diff --git a/src/kernel/overlayfs.c b/src/kernel/overlayfs.c
index c59da3810cc542aeaa117fc4919dfdd0ae5fca9f..85b650b270b91c757666dd446c2f55b351847b19 100644 (file)
--- a/src/kernel/overlayfs.c
+++ b/src/kernel/overlayfs.c
@@ -135,10 +135,6 @@ static fs_node_t* overlay_wrap_child(struct overlay_node* parent, const char* na
     } else {
         c->vfs.f_ops = &overlay_file_ops;
     }
-    c->vfs.read = &overlay_read_impl;
-    c->vfs.write = (c->vfs.flags == FS_FILE) ? &overlay_write_impl : 0;
-    c->vfs.finddir = (c->vfs.flags == FS_DIRECTORY) ? &overlay_finddir_impl : 0;
-    c->vfs.readdir = (c->vfs.flags == FS_DIRECTORY) ? &overlay_readdir_impl : 0;
 
     if (parent->path[0] == 0) {
         c->path[0] = '/';
@@ -179,8 +175,6 @@ static int overlay_readdir_impl(struct fs_node* node, uint32_t* inout_index, voi
     if (!src) return 0;
     if (src->f_ops && src->f_ops->readdir)
         return src->f_ops->readdir(src, inout_index, buf, buf_len);
-    if (src->readdir)
-        return src->readdir(src, inout_index, buf, buf_len);
     return 0;
 }
 
@@ -193,18 +187,10 @@ 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) {
-        if (dir->upper->f_ops && dir->upper->f_ops->finddir)
-            upper_child = dir->upper->f_ops->finddir(dir->upper, name);
-        else if (dir->upper->finddir)
-            upper_child = dir->upper->finddir(dir->upper, name);
-    }
-    if (dir->lower) {
-        if (dir->lower->f_ops && dir->lower->f_ops->finddir)
-            lower_child = dir->lower->f_ops->finddir(dir->lower, name);
-        else if (dir->lower->finddir)
-            lower_child = dir->lower->finddir(dir->lower, name);
-    }
+    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 (!upper_child && !lower_child) return 0;
     return overlay_wrap_child(dir, name, lower_child, upper_child);
@@ -234,8 +220,6 @@ 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.finddir = &overlay_finddir_impl;
-    root->vfs.readdir = &overlay_readdir_impl;
 
     root->path[0] = 0;
 

diff --git a/src/kernel/persistfs.c b/src/kernel/persistfs.c
index 62429f251ae6aa8315061a0e126434eee3c6ac9a..a62cc73765579c74efc4c575fe6265769b29e0bb 100644 (file)
--- a/src/kernel/persistfs.c
+++ b/src/kernel/persistfs.c
@@ -122,11 +122,6 @@ 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.read = 0;
-        g_root.write = 0;
-        g_root.open = 0;
-        g_root.close = 0;
-        g_root.finddir = &persist_root_finddir;
 
         memset(&g_counter, 0, sizeof(g_counter));
         strcpy(g_counter.name, "counter");
@@ -134,11 +129,6 @@ fs_node_t* persistfs_create_root(int drive) {
         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;
-        g_counter.close = 0;
-        g_counter.finddir = 0;
     }
 
     return g_ready ? &g_root : 0;

diff --git a/src/kernel/procfs.c b/src/kernel/procfs.c
index 2edd0723ee1d7d05c59b8596b975e9c7cfac0ce9..e99a9b6decc478eeafccdb6b5f45f4abeedaf39e 100644 (file)
--- a/src/kernel/procfs.c
+++ b/src/kernel/procfs.c
@@ -258,7 +258,6 @@ static fs_node_t* proc_pid_finddir(fs_node_t* node, const char* name) {
         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];
     }
     if (strcmp(name, "maps") == 0) {
@@ -268,7 +267,6 @@ static fs_node_t* proc_pid_finddir(fs_node_t* node, const char* name) {
         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];
     }
     return NULL;
@@ -308,8 +306,6 @@ 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].finddir = proc_pid_finddir;
-    g_pid_dir[slot].readdir = proc_pid_readdir;
     return &g_pid_dir[slot];
 }
 
@@ -460,39 +456,31 @@ 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.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 1002122004492640e8a571e83c92f69b2fa16385..b245f3f2cc9583ebbe1cb66cb61f844f2febf156 100644 (file)
--- a/src/kernel/pty.c
+++ b/src/kernel/pty.c
@@ -151,9 +151,6 @@ static void pty_init_pair(int idx) {
     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;
 
     memset(&p->slave_node, 0, sizeof(p->slave_node));
     name[0] = '0' + (char)idx;
@@ -162,10 +159,6 @@ static void pty_init_pair(int idx) {
     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;
-    p->slave_node.poll = &pty_slave_poll_fn;
 }
 
 /* --- DevFS pts directory callbacks --- */
@@ -257,9 +250,6 @@ void pty_init(void) {
     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;
     devfs_register_device(&g_dev_ptmx_node);
 
     /* Register /dev/pts directory */
@@ -268,8 +258,6 @@ void pty_init(void) {
     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);
 }
 

diff --git a/src/kernel/syscall.c b/src/kernel/syscall.c
index 88870dd8789e1e98cd2a0c57c44d6047e6d667f7..e20e90e054a91461ec1aee9884c9465bd4dc9b35 100644 (file)
--- a/src/kernel/syscall.c
+++ b/src/kernel/syscall.c
@@ -273,7 +273,6 @@ static int poll_wait_kfds(struct pollfd* kfds, uint32_t nfds, int32_t timeout) {
 
             int (*fn_poll)(fs_node_t*, int) = NULL;
             if (n->f_ops && n->f_ops->poll) fn_poll = n->f_ops->poll;
-            else if (n->poll) fn_poll = n->poll;
             if (fn_poll) {
                 int vfs_events = 0;
                 if (kfds[i].events & POLLIN)  vfs_events |= VFS_POLL_IN;
@@ -430,17 +429,13 @@ static int pipe_node_create(struct pipe_state* ps, int is_read_end, fs_node_t**
     pn->is_read_end = is_read_end ? 1U : 0U;
     pn->node.flags = FS_FILE;
     pn->node.length = 0;
-    pn->node.close = pipe_close;
-    pn->node.poll = pipe_poll;
     if (pn->is_read_end) {
         strcpy(pn->node.name, "pipe:r");
         pn->node.f_ops = &pipe_read_fops;
-        pn->node.read = pipe_read;
         ps->readers++;
     } else {
         strcpy(pn->node.name, "pipe:w");
         pn->node.f_ops = &pipe_write_fops;
-        pn->node.write = pipe_write;
         ps->writers++;
     }
 
@@ -926,11 +921,8 @@ static int syscall_open_impl(const char* user_path, uint32_t flags) {
         return -ENOENT;
     } else if ((flags & 0x200U) != 0U && node->flags == FS_FILE) {
         /* O_TRUNC on existing file */
-        if ((node->f_ops && node->f_ops->truncate) || node->truncate) {
-            if (node->f_ops && node->f_ops->truncate)
-                node->f_ops->truncate(node, 0);
-            else
-                node->truncate(node, 0);
+        if (node->f_ops && node->f_ops->truncate) {
+            node->f_ops->truncate(node, 0);
             node->length = 0;
         }
     }
@@ -1164,7 +1156,6 @@ static int syscall_getdents_impl(int fd, void* user_buf, uint32_t len) {
     if (f->node->flags != FS_DIRECTORY) return -ENOTDIR;
     int (*fn_readdir)(struct fs_node*, uint32_t*, void*, uint32_t) = NULL;
     if (f->node->f_ops && f->node->f_ops->readdir) fn_readdir = f->node->f_ops->readdir;
-    else if (f->node->readdir) fn_readdir = f->node->readdir;
     if (!fn_readdir) return -ENOSYS;
 
     uint8_t kbuf[256];
@@ -1237,7 +1228,6 @@ static int syscall_read_impl(int fd, void* user_buf, uint32_t len) {
     {
         int (*fn_poll)(fs_node_t*, int) = NULL;
         if (f->node->f_ops && f->node->f_ops->poll) fn_poll = f->node->f_ops->poll;
-        else if (f->node->poll) fn_poll = f->node->poll;
         if (nonblock && fn_poll) {
             int rev = fn_poll(f->node, VFS_POLL_IN);
             if (!(rev & (VFS_POLL_IN | VFS_POLL_ERR | VFS_POLL_HUP)))
@@ -1266,7 +1256,7 @@ static int syscall_read_impl(int fd, void* user_buf, uint32_t len) {
         return (int)total;
     }
 
-    if (!(f->node->f_ops && f->node->f_ops->read) && !f->node->read) return -ESPIPE;
+    if (!(f->node->f_ops && f->node->f_ops->read)) return -ESPIPE;
 
     uint8_t kbuf[256];
     uint32_t total = 0;
@@ -1308,14 +1298,13 @@ static int syscall_write_impl(int fd, const void* user_buf, uint32_t len) {
     {
         int (*fn_poll)(fs_node_t*, int) = NULL;
         if (f->node->f_ops && f->node->f_ops->poll) fn_poll = f->node->f_ops->poll;
-        else if (f->node->poll) fn_poll = f->node->poll;
         if (nonblock && fn_poll) {
             int rev = fn_poll(f->node, VFS_POLL_OUT);
             if (!(rev & (VFS_POLL_OUT | VFS_POLL_ERR)))
                 return -EAGAIN;
         }
     }
-    if (!(f->node->f_ops && f->node->f_ops->write) && !f->node->write) return -ESPIPE;
+    if (!(f->node->f_ops && f->node->f_ops->write)) return -ESPIPE;
     if (f->node->flags != FS_FILE && f->node->flags != FS_CHARDEVICE && f->node->flags != FS_SOCKET) return -ESPIPE;
 
     if ((f->flags & O_APPEND) && (f->node->flags & FS_FILE)) {
@@ -1347,7 +1336,6 @@ static int syscall_ioctl_impl(int fd, uint32_t cmd, void* user_arg) {
 
     fs_node_t* n = f->node;
     if (n->f_ops && n->f_ops->ioctl) return n->f_ops->ioctl(n, cmd, user_arg);
-    if (n->ioctl) return n->ioctl(n, cmd, user_arg);
     return -ENOTTY;
 }
 
@@ -1529,7 +1517,7 @@ static uintptr_t syscall_mmap_impl(uintptr_t addr, uint32_t length, uint32_t pro
         if (fd < 0) return (uintptr_t)-EBADF;
         struct file* f = fd_get(fd);
         if (!f || !f->node) return (uintptr_t)-EBADF;
-        if (!(f->node->f_ops && f->node->f_ops->mmap) && !f->node->mmap) return (uintptr_t)-ENOSYS;
+        if (!(f->node->f_ops && f->node->f_ops->mmap)) return (uintptr_t)-ENOSYS;
         mmap_node = f->node;
     }
 
@@ -1555,7 +1543,7 @@ static uintptr_t syscall_mmap_impl(uintptr_t addr, uint32_t length, uint32_t pro
         /* Device-backed mmap: delegate to the node's mmap callback */
         uintptr_t (*fn_mmap)(fs_node_t*, uintptr_t, uint32_t, uint32_t, uint32_t) = NULL;
         if (mmap_node->f_ops && mmap_node->f_ops->mmap) fn_mmap = mmap_node->f_ops->mmap;
-        else fn_mmap = mmap_node->mmap;
+        if (!fn_mmap) return (uintptr_t)-ENOSYS;
         uintptr_t result = fn_mmap(mmap_node, base, aligned_len, prot, offset);
         if (!result) return (uintptr_t)-ENOMEM;
         base = result;
@@ -1709,7 +1697,6 @@ static int syscall_readlink_impl(const char* user_path, char* user_buf, uint32_t
     if (!dir) return -ENOENT;
     fs_node_t* (*fn_finddir)(fs_node_t*, const char*) = NULL;
     if (dir->f_ops && dir->f_ops->finddir) fn_finddir = dir->f_ops->finddir;
-    else if (dir->finddir) fn_finddir = dir->finddir;
     if (!fn_finddir) return -ENOENT;
 
     fs_node_t* node = fn_finddir(dir, leaf);
@@ -2391,7 +2378,7 @@ static void posix_ext_syscall_dispatch(struct registers* regs, uint32_t syscall_
         uint32_t offset = sc_arg3(regs);
         struct file* f = fd_get(fd);
         if (!f || !f->node) { sc_ret(regs) = (uint32_t)-EBADF; return; }
-        if (!(f->node->f_ops && f->node->f_ops->read) && !f->node->read) { sc_ret(regs) = (uint32_t)-ESPIPE; return; }
+        if (!(f->node->f_ops && f->node->f_ops->read)) { sc_ret(regs) = (uint32_t)-ESPIPE; return; }
         if (count > 1024 * 1024) { sc_ret(regs) = (uint32_t)-EINVAL; return; }
         uint8_t kbuf[256];
         uint32_t total = 0;
@@ -2417,7 +2404,7 @@ static void posix_ext_syscall_dispatch(struct registers* regs, uint32_t syscall_
         uint32_t offset = sc_arg3(regs);
         struct file* f = fd_get(fd);
         if (!f || !f->node) { sc_ret(regs) = (uint32_t)-EBADF; return; }
-        if (!(f->node->f_ops && f->node->f_ops->write) && !f->node->write) { sc_ret(regs) = (uint32_t)-ESPIPE; return; }
+        if (!(f->node->f_ops && f->node->f_ops->write)) { sc_ret(regs) = (uint32_t)-ESPIPE; return; }
         if (count > 1024 * 1024) { sc_ret(regs) = (uint32_t)-EINVAL; return; }
         uint8_t kbuf[256];
         uint32_t total = 0;
@@ -2665,9 +2652,6 @@ static fs_node_t* sock_node_create(int sid) {
     n->flags = FS_SOCKET;
     n->inode = (uint32_t)sid;
     n->f_ops = &sock_fops;
-    n->read = sock_node_read;
-    n->write = sock_node_write;
-    n->close = sock_node_close;
     return n;
 }
 

diff --git a/src/kernel/tmpfs.c b/src/kernel/tmpfs.c
index 6cf2ee54af4a70272e3fa07c72b7ebca3eaaad47..5f1cc321ce852c82897271d5aa29e13d00d62687 100644 (file)
--- a/src/kernel/tmpfs.c
+++ b/src/kernel/tmpfs.c
@@ -85,8 +85,6 @@ 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.finddir = tmpfs_finddir_impl;
-    nd->vfs.readdir = tmpfs_readdir_impl;
     tmpfs_child_add(dir, nd);
     return nd;
 }
@@ -215,8 +213,6 @@ fs_node_t* tmpfs_create_root(void) {
     if (!root) return NULL;
 
     root->vfs.f_ops = &tmpfs_dir_ops;
-    root->vfs.finddir = tmpfs_finddir_impl;
-    root->vfs.readdir = tmpfs_readdir_impl;
 
     return &root->vfs;
 }
@@ -232,8 +228,6 @@ int tmpfs_add_file(fs_node_t* root_dir, const char* name, const uint8_t* data, u
     if (!f) return -ENOMEM;
 
     f->vfs.f_ops = &tmpfs_file_ops;
-    f->vfs.read = tmpfs_read_impl;
-    f->vfs.write = tmpfs_write_impl;
 
     if (len) {
         f->data = (uint8_t*)kmalloc(len);
@@ -306,8 +300,6 @@ fs_node_t* tmpfs_create_file(fs_node_t* root_dir, const char* path, const uint8_
     if (!f) return NULL;
 
     f->vfs.f_ops = &tmpfs_file_ops;
-    f->vfs.read = tmpfs_read_impl;
-    f->vfs.write = tmpfs_write_impl;
 
     if (len && data) {
         f->data = (uint8_t*)kmalloc(len);

diff --git a/src/kernel/tty.c b/src/kernel/tty.c
index 233021899db0241924b11167d2671cfa86ce378d..f0484a6c8921ba2365184ed5d4278289b543fac2 100644 (file)
--- a/src/kernel/tty.c
+++ b/src/kernel/tty.c
@@ -483,10 +483,6 @@ void tty_init(void) {
     g_dev_console_node.flags = FS_CHARDEVICE;
     g_dev_console_node.inode = 10;
     g_dev_console_node.f_ops = &tty_fops;
-    g_dev_console_node.read = &tty_devfs_read;
-    g_dev_console_node.write = &tty_devfs_write;
-    g_dev_console_node.ioctl = &tty_devfs_ioctl;
-    g_dev_console_node.poll = &tty_devfs_poll;
     devfs_register_device(&g_dev_console_node);
 
     /* Register /dev/tty */
@@ -495,10 +491,6 @@ void tty_init(void) {
     g_dev_tty_node.flags = FS_CHARDEVICE;
     g_dev_tty_node.inode = 3;
     g_dev_tty_node.f_ops = &tty_fops;
-    g_dev_tty_node.read = &tty_devfs_read;
-    g_dev_tty_node.write = &tty_devfs_write;
-    g_dev_tty_node.ioctl = &tty_devfs_ioctl;
-    g_dev_tty_node.poll = &tty_devfs_poll;
     devfs_register_device(&g_dev_tty_node);
 }