From: Tulio A M Mendes <tadryanom@hotmail.com>
Date: Fri, 13 Feb 2026 22:27:06 +0000 (-0300)
Subject: refactor: remove legacy per-node function pointers from fs_node_t
X-Git-Url: https://projects.tadryanom.me/sitemap.xml?a=commitdiff_plain;h=2b756030a3675cf75a47a514e8b589e8db840bab;p=AdrOS.git

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 8b6456b..a3ecf4b 100644
--- a/include/fs.h
+++ b/include/fs.h
@@ -54,25 +54,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 7ae0fff..b3a7fd7 100644
--- a/src/drivers/initrd.c
+++ b/src/drivers/initrd.c
@@ -213,10 +213,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 f3fd89b..b36fac6 100644
--- a/src/drivers/keyboard.c
+++ b/src/drivers/keyboard.c
@@ -123,8 +123,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 dbbb81d..4c4ebf7 100644
--- a/src/drivers/vbe.c
+++ b/src/drivers/vbe.c
@@ -193,10 +193,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 38d51e5..5af07b2 100644
--- a/src/kernel/devfs.c
+++ b/src/kernel/devfs.c
@@ -224,44 +224,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 fede86b..f0a5ea0 100644
--- a/src/kernel/diskfs.c
+++ b/src/kernel/diskfs.c
@@ -459,7 +459,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);
@@ -512,24 +511,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;
@@ -584,9 +575,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;
@@ -871,9 +859,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;
@@ -894,9 +880,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;
@@ -1069,16 +1053,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;
@@ -1094,9 +1068,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 dea111a..abb406e 100644
--- a/src/kernel/ext2.c
+++ b/src/kernel/ext2.c
@@ -557,18 +557,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;
@@ -584,13 +572,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;
@@ -603,9 +589,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;
@@ -1427,7 +1410,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 e7fa6b3..7864128 100644
--- a/src/kernel/fat.c
+++ b/src/kernel/fat.c
@@ -507,17 +507,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;
@@ -533,17 +522,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;
 }
@@ -1179,7 +1163,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 aa2f15e..c42cd24 100644
--- a/src/kernel/fs.c
+++ b/src/kernel/fs.c
@@ -72,31 +72,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);
@@ -152,7 +144,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;
@@ -206,8 +197,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) {
@@ -218,8 +208,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) {
@@ -230,8 +219,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) {
@@ -242,8 +230,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) {
@@ -254,8 +241,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) {
@@ -265,8 +251,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) {
@@ -281,6 +266,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 16c3104..5104389 100644
--- a/src/kernel/kconsole.c
+++ b/src/kernel/kconsole.c
@@ -267,7 +267,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;
     }
@@ -275,7 +277,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 d10f037..9abde00 100644
--- a/src/kernel/overlayfs.c
+++ b/src/kernel/overlayfs.c
@@ -126,10 +126,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] = '/';
@@ -170,8 +166,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;
 }
 
@@ -184,18 +178,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);
@@ -225,8 +211,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 788c3b3..d4320ad 100644
--- a/src/kernel/persistfs.c
+++ b/src/kernel/persistfs.c
@@ -113,11 +113,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");
@@ -125,11 +120,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 ed2f1f3..ce21f63 100644
--- a/src/kernel/procfs.c
+++ b/src/kernel/procfs.c
@@ -249,7 +249,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) {
@@ -259,7 +258,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;
@@ -299,8 +297,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];
 }
 
@@ -451,39 +447,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 c1a56c4..24f2ff5 100644
--- a/src/kernel/pty.c
+++ b/src/kernel/pty.c
@@ -142,9 +142,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;
@@ -153,10 +150,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 --- */
@@ -248,9 +241,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 */
@@ -259,8 +249,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 60a3c22..efca96b 100644
--- a/src/kernel/syscall.c
+++ b/src/kernel/syscall.c
@@ -264,7 +264,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;
@@ -421,17 +420,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++;
     }
 
@@ -917,11 +912,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;
         }
     }
@@ -1155,7 +1147,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];
@@ -1228,7 +1219,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)))
@@ -1257,7 +1247,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;
@@ -1299,14 +1289,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)) {
@@ -1338,7 +1327,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;
 }
 
@@ -1520,7 +1508,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;
     }
 
@@ -1546,7 +1534,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;
@@ -1700,7 +1688,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);
@@ -2382,7 +2369,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;
@@ -2408,7 +2395,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;
@@ -2656,9 +2643,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 d62c3c7..5557e1d 100644
--- a/src/kernel/tmpfs.c
+++ b/src/kernel/tmpfs.c
@@ -76,8 +76,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;
 }
@@ -206,8 +204,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;
 }
@@ -223,8 +219,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);
@@ -297,8 +291,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 fb8b0e4..1118a9d 100644
--- a/src/kernel/tty.c
+++ b/src/kernel/tty.c
@@ -474,10 +474,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 */
@@ -486,10 +482,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);
 }