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 {
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;
}
}
}
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);
}
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");
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) {
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);
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;
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;
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;
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;
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;
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) {
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;
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;
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;
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;
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;
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;
}
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;
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);
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;
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) {
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) {
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) {
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) {
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) {
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) {
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;
}
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;
}
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);
}
} 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] = '/';
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;
}
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);
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;
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");
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;
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) {
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;
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];
}
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;
}
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;
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 --- */
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 */
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);
}
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;
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++;
}
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;
}
}
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];
{
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)))
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;
{
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)) {
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;
}
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;
}
/* 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;
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);
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;
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;
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;
}
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;
}
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;
}
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);
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);
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 */
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);
}
projects / AdrOS.git / commitdiff