From 2687264120b44704961375849a51d69b17ce585a Mon Sep 17 00:00:00 2001 From: Minep Date: Sun, 14 Aug 2022 16:55:14 +0100 Subject: [PATCH] refactor: synchronize the vfs objects chore: minor tweaks, fixes, and annotations --- lunaix-os/includes/lunaix/ds/semaphore.h | 14 +- lunaix-os/includes/lunaix/fs.h | 10 +- lunaix-os/kernel/ds/semaphore.c | 1 + lunaix-os/kernel/fs/twifs/twifs.c | 14 +- lunaix-os/kernel/fs/vfs.c | 237 +++++++++++++++++------ 5 files changed, 203 insertions(+), 73 deletions(-) diff --git a/lunaix-os/includes/lunaix/ds/semaphore.h b/lunaix-os/includes/lunaix/ds/semaphore.h index e202d14..aa7045f 100644 --- a/lunaix-os/includes/lunaix/ds/semaphore.h +++ b/lunaix-os/includes/lunaix/ds/semaphore.h @@ -3,15 +3,19 @@ #include -struct sem_t { - _Atomic unsigned int counter; +struct sem_t +{ + atomic_ulong counter; // FUTURE: might need a waiting list }; -void sem_init(struct sem_t *sem, unsigned int initial); +void +sem_init(struct sem_t* sem, unsigned int initial); -void sem_wait(struct sem_t *sem); +void +sem_wait(struct sem_t* sem); -void sem_post(struct sem_t *sem); +void +sem_post(struct sem_t* sem); #endif /* __LUNAIX_SEMAPHORE_H */ diff --git a/lunaix-os/includes/lunaix/fs.h b/lunaix-os/includes/lunaix/fs.h index d0d59d1..37c8228 100644 --- a/lunaix-os/includes/lunaix/fs.h +++ b/lunaix-os/includes/lunaix/fs.h @@ -9,7 +9,9 @@ #include #include #include +#include #include +#include #define VFS_NAME_MAXLEN 128 #define VFS_MAX_FD 32 @@ -93,7 +95,7 @@ struct v_file struct v_dnode* dnode; struct llist_header* f_list; uint32_t f_pos; - uint32_t ref_count; + atomic_ulong ref_count; struct v_file_ops ops; }; @@ -105,6 +107,7 @@ struct v_fd struct v_inode { + mutex_t lock; uint32_t itype; time_t ctime; time_t mtime; @@ -118,7 +121,7 @@ struct v_inode void* data; // 允许底层FS绑定他的一些专有数据 struct { - int (*create)(struct v_inode* this); + int (*create)(struct v_inode* this, struct v_dnode* dnode); int (*open)(struct v_inode* this, struct v_file* file); int (*sync)(struct v_inode* this); int (*mkdir)(struct v_inode* this, struct v_dnode* dnode); @@ -134,6 +137,7 @@ struct v_inode struct v_dnode { + mutex_t lock; // sync the path walking struct hstr name; struct v_inode* inode; struct v_dnode* parent; @@ -141,7 +145,7 @@ struct v_dnode struct llist_header children; struct llist_header siblings; struct v_superblock* super_block; - uint32_t ref_count; + atomic_ulong ref_count; struct { void (*destruct)(struct v_dnode* dnode); diff --git a/lunaix-os/kernel/ds/semaphore.c b/lunaix-os/kernel/ds/semaphore.c index 84c0100..c3b1082 100644 --- a/lunaix-os/kernel/ds/semaphore.c +++ b/lunaix-os/kernel/ds/semaphore.c @@ -12,6 +12,7 @@ sem_wait(struct sem_t* sem) { while (!atomic_load(&sem->counter)) { // FIXME: better thing like wait queue + sched_yieldk(); } atomic_fetch_sub(&sem->counter, 1); } diff --git a/lunaix-os/kernel/fs/twifs/twifs.c b/lunaix-os/kernel/fs/twifs/twifs.c index ec2707f..506d604 100644 --- a/lunaix-os/kernel/fs/twifs/twifs.c +++ b/lunaix-os/kernel/fs/twifs/twifs.c @@ -165,13 +165,13 @@ struct v_inode* __twifs_create_inode(struct twifs_node* twi_node) { struct v_inode* inode = vfs_i_alloc(); - *inode = (struct v_inode){ .ctime = 0, - .itype = twi_node->itype, - .lb_addr = 0, - .lb_usage = 0, - .data = twi_node, - .mtime = 0, - .open_count = 0 }; + inode->itype = twi_node->itype; + inode->data = twi_node; + + inode->ctime = clock_unixtime(); + inode->atime = inode->ctime; + inode->mtime = inode->ctime; + inode->ops.dir_lookup = __twifs_dirlookup; inode->ops.mkdir = __twifs_mkdir; inode->ops.unlink = __twifs_rmstuff; diff --git a/lunaix-os/kernel/fs/vfs.c b/lunaix-os/kernel/fs/vfs.c index 68a8d5f..82f409a 100644 --- a/lunaix-os/kernel/fs/vfs.c +++ b/lunaix-os/kernel/fs/vfs.c @@ -26,6 +26,12 @@ #define DNODE_HASH_MASK (DNODE_HASHTABLE_SIZE - 1) #define DNODE_HASHBITS (32 - DNODE_HASHTABLE_BITS) +#define lock_inode(inode) mutex_lock(&inode->lock) +#define unlock_inode(inode) mutex_unlock(&inode->lock) + +#define lock_dnode(dnode) mutex_lock(&dnode->lock) +#define unlock_dnode(dnode) mutex_unlock(&dnode->lock) + static struct cake_pile* dnode_pile; static struct cake_pile* inode_pile; static struct cake_pile* file_pile; @@ -160,6 +166,8 @@ __vfs_walk(struct v_dnode* start, goto cont; } + lock_dnode(current_level); + name_content[j] = 0; name.len = j; hstr_rehash(&name, HSTR_FULL_HASH); @@ -170,6 +178,7 @@ __vfs_walk(struct v_dnode* start, component->len = j; strcpy(component->value, name_content); } + unlock_dnode(current_level); break; } @@ -181,6 +190,8 @@ __vfs_walk(struct v_dnode* start, strcpy(dnode->name.value, name_content); + lock_inode(current_level->inode); + errno = current_level->inode->ops.dir_lookup(current_level->inode, dnode); @@ -193,7 +204,11 @@ __vfs_walk(struct v_dnode* start, } } + unlock_inode(current_level->inode); + if (errno) { + unlock_dnode(current_level); + vfree(dnode->name.value); goto error; } @@ -203,6 +218,8 @@ __vfs_walk(struct v_dnode* start, llist_append(¤t_level->children, &dnode->siblings); } + unlock_dnode(current_level); + j = 0; current_level = dnode; cont: @@ -334,7 +351,7 @@ vfs_open(struct v_dnode* dnode, struct v_file** file) vfile->dnode = dnode; vfile->inode = inode; - vfile->ref_count = 1; + vfile->ref_count = ATOMIC_VAR_INIT(1); vfile->ops = inode->default_fops; if ((inode->itype & VFS_IFFILE) && !inode->pg_cache) { @@ -348,8 +365,9 @@ vfs_open(struct v_dnode* dnode, struct v_file** file) if (errno) { cake_release(file_pile, vfile); } else { - dnode->ref_count++; + atomic_fetch_add(&dnode->ref_count, 1); inode->open_count++; + *file = vfile; } @@ -360,14 +378,17 @@ int vfs_link(struct v_dnode* to_link, struct v_dnode* name) { int errno; + + lock_inode(to_link->inode); if (to_link->super_block->root != name->super_block->root) { errno = EXDEV; } else if (!to_link->inode->ops.link) { errno = ENOTSUP; } else if (!(errno = to_link->inode->ops.link(to_link->inode, name))) { name->inode = to_link->inode; - to_link->inode->link_count++; + atomic_fetch_add(&to_link->inode->link_count, 1); } + unlock_inode(to_link->inode); return errno; } @@ -377,8 +398,9 @@ vfs_close(struct v_file* file) { int errno = 0; if (!file->ops.close || !(errno = file->ops.close(file))) { - file->dnode->ref_count--; + atomic_fetch_sub(&file->dnode->ref_count, 1); file->inode->open_count--; + pcache_commit_all(file->inode); cake_release(file_pile, file); } @@ -388,11 +410,16 @@ vfs_close(struct v_file* file) int vfs_fsync(struct v_file* file) { + lock_inode(file->inode); + int errno = ENOTSUP; pcache_commit_all(file->inode); if (file->ops.sync) { errno = file->ops.sync(file->inode); } + + unlock_inode(file->inode); + return errno; } @@ -429,6 +456,10 @@ vfs_d_alloc() struct v_dnode* dnode = cake_grab(dnode_pile); memset(dnode, 0, sizeof(*dnode)); llist_init_head(&dnode->children); + mutex_init(&dnode->lock); + + dnode->ref_count = ATOMIC_VAR_INIT(0); + dnode->name = vfs_empty; return dnode; } @@ -447,6 +478,8 @@ vfs_i_alloc() { struct v_inode* inode = cake_grab(inode_pile); memset(inode, 0, sizeof(*inode)); + mutex_init(&inode->lock); + return inode; } @@ -493,14 +526,19 @@ __vfs_try_locate_file(const char* path, return errno; } - if (!(errno = (*fdir)->inode->ops.create((*fdir)->inode))) { - struct v_dnode* file_new; - file_new = vfs_d_alloc(); - file_new->name = HHSTR(valloc(VFS_NAME_MAXLEN), name.len, name.hash); - strcpy(file_new->name.value, name_str); + struct v_dnode* parent = *fdir; + struct v_dnode* file_new = vfs_d_alloc(); + file_new->name = HHSTR(valloc(VFS_NAME_MAXLEN), name.len, name.hash); + strcpy(file_new->name.value, name_str); + + if (!(errno = parent->inode->ops.create(parent->inode, file_new))) { *file = file_new; - llist_append(&(*fdir)->children, &file_new->siblings); + vfs_dcache_add(parent, file_new); + llist_append(&parent->children, &file_new->siblings); + } else { + vfree(file_new->name.value); + vfs_d_free(file_new); } return errno; @@ -513,13 +551,10 @@ vfs_do_open(const char* path, int options) struct v_dnode *dentry, *file; struct v_file* ofile = 0; - errno = __vfs_try_locate_file(path, &dentry, &file, 0); - - if (errno != ENOENT && (options & FO_CREATE)) { - errno = dentry->inode->ops.create(dentry->inode); - } + errno = __vfs_try_locate_file( + path, &dentry, &file, (options & FO_CREATE) ? FLOCATE_CREATE_EMPTY : 0); - if (!errno && (errno = vfs_open(file, &ofile))) { + if (errno || (errno = vfs_open(file, &ofile))) { return errno; } @@ -590,6 +625,10 @@ __DEFINE_LXSYSCALL2(int, readdir, int, fd, struct dirent*, dent) goto done; } + struct v_inode* inode = fd_s->file->inode; + + lock_inode(inode); + if (!(fd_s->file->inode->itype & VFS_IFDIR)) { errno = ENOTDIR; } else { @@ -604,7 +643,8 @@ __DEFINE_LXSYSCALL2(int, readdir, int, fd, struct dirent*, dent) __vfs_readdir_callback(&dctx, vfs_ddot.value, vfs_ddot.len, 0); } else { dctx.index -= 2; - if ((errno = fd_s->file->ops.readdir(fd_s->file->inode, &dctx))) { + if ((errno = fd_s->file->ops.readdir(inode, &dctx))) { + unlock_inode(inode); goto done; } } @@ -612,36 +652,7 @@ __DEFINE_LXSYSCALL2(int, readdir, int, fd, struct dirent*, dent) dent->d_offset++; } -done: - return DO_STATUS(errno); -} - -__DEFINE_LXSYSCALL1(int, mkdir, const char*, path) -{ - struct v_dnode *parent, *dir; - struct hstr component = HSTR(valloc(VFS_NAME_MAXLEN), 0); - int errno = - vfs_walk(__current->cwd, path, &parent, &component, VFS_WALK_PARENT); - if (errno) { - goto done; - } - - if ((parent->super_block->fs->types & FSTYPE_ROFS)) { - errno = ENOTSUP; - } else if (!parent->inode->ops.mkdir) { - errno = ENOTSUP; - } else if (!(parent->inode->itype & VFS_IFDIR)) { - errno = ENOTDIR; - } else { - dir = vfs_d_alloc(); - dir->name = component; - if (!(errno = parent->inode->ops.mkdir(parent->inode, dir))) { - llist_append(&parent->children, &dir->siblings); - } else { - vfs_d_free(dir); - vfree(component.value); - } - } + unlock_inode(inode); done: return DO_STATUS(errno); @@ -661,9 +672,15 @@ __DEFINE_LXSYSCALL3(int, read, int, fd, void*, buf, size_t, count) goto done; } + lock_inode(file->inode); + + file->inode->atime = clock_unixtime(); + __SYSCALL_INTERRUPTIBLE( { errno = file->ops.read(file->inode, buf, count, file->f_pos); }) + unlock_inode(file->inode); + if (errno > 0) { file->f_pos += errno; return errno; @@ -687,9 +704,15 @@ __DEFINE_LXSYSCALL3(int, write, int, fd, void*, buf, size_t, count) goto done; } + lock_inode(file->inode); + + file->inode->mtime = clock_unixtime(); + __SYSCALL_INTERRUPTIBLE( { errno = file->ops.write(file->inode, buf, count, file->f_pos); }) + unlock_inode(file->inode); + if (errno > 0) { file->f_pos += errno; return errno; @@ -708,6 +731,9 @@ __DEFINE_LXSYSCALL3(int, lseek, int, fd, int, offset, int, options) } struct v_file* file = fd_s->file; + + lock_inode(file->inode); + size_t fpos = file->f_pos; switch (options) { case FSEEK_CUR: @@ -724,6 +750,8 @@ __DEFINE_LXSYSCALL3(int, lseek, int, fd, int, offset, int, options) file->f_pos = fpos; } + unlock_inode(file->inode); + done: return DO_STATUS(errno); } @@ -760,9 +788,14 @@ int vfs_readlink(struct v_dnode* dnode, char* buf, size_t size) { const char* link; - if (dnode->inode->ops.read_symlink) { - int errno = dnode->inode->ops.read_symlink(dnode->inode, &link); + struct v_inode* inode = dnode->inode; + if (inode->ops.read_symlink) { + lock_inode(inode); + + int errno = inode->ops.read_symlink(inode, &link); strncpy(buf, link, size); + + unlock_inode(inode); return errno; } return 0; @@ -834,49 +867,125 @@ done: return DO_STATUS(errno); } +/* + NOTE + When we perform operation that could affect the layout of + directory (i.e., rename, mkdir, rmdir). We must lock the parent dir + whenever possible. This will blocking any ongoing path walking to reach + it hence avoid any partial state. +*/ + __DEFINE_LXSYSCALL1(int, rmdir, const char*, pathname) { int errno; struct v_dnode* dnode; if ((errno = vfs_walk(__current->cwd, pathname, &dnode, NULL, 0))) { - goto done; + return DO_STATUS(errno); } + + lock_dnode(dnode); + + if (dnode->parent) + lock_dnode(dnode->parent); + if ((dnode->super_block->fs->types & FSTYPE_ROFS)) { errno = EROFS; goto done; } - if (dnode->inode->open_count) { + if (dnode->ref_count || dnode->inode->open_count) { errno = EBUSY; goto done; } + if (!llist_empty(&dnode->children)) { + errno = ENOTEMPTY; + goto done; + } + + lock_inode(dnode->inode); + if ((dnode->inode->itype & VFS_IFDIR)) { errno = dnode->inode->ops.rmdir(dnode->inode); + // FIXME remove the dnode from cache & parent. } else { errno = ENOTDIR; } + unlock_inode(dnode->inode); + +done: + unlock_dnode(dnode); + if (dnode->parent) + unlock_dnode(dnode->parent); + return DO_STATUS(errno); +} + +__DEFINE_LXSYSCALL1(int, mkdir, const char*, path) +{ + struct v_dnode *parent, *dir; + struct hstr component = HSTR(valloc(VFS_NAME_MAXLEN), 0); + int errno = + vfs_walk(__current->cwd, path, &parent, &component, VFS_WALK_PARENT); + if (errno) { + goto done; + } + + lock_dnode(parent); + lock_inode(parent->inode); + + if ((parent->super_block->fs->types & FSTYPE_ROFS)) { + errno = ENOTSUP; + } else if (!parent->inode->ops.mkdir) { + errno = ENOTSUP; + } else if (!(parent->inode->itype & VFS_IFDIR)) { + errno = ENOTDIR; + } else { + dir = vfs_d_alloc(); + dir->name = component; + if (!(errno = parent->inode->ops.mkdir(parent->inode, dir))) { + llist_append(&parent->children, &dir->siblings); + } else { + vfs_d_free(dir); + vfree(component.value); + } + } + + unlock_inode(parent->inode); + unlock_dnode(parent); + done: return DO_STATUS(errno); } int -__vfs_do_unlink(struct v_inode* inode) +__vfs_do_unlink(struct v_dnode* dnode) { + struct v_inode* inode = dnode->inode; + + if (dnode->ref_count) { + return EBUSY; + } + + lock_inode(inode); + int errno; if (inode->open_count) { errno = EBUSY; } else if (!(inode->itype & VFS_IFDIR)) { - // TODO handle symbolic link and type other than regular file + // The underlying unlink implementation should handle + // symlink case errno = inode->ops.unlink(inode); if (!errno) { inode->link_count--; + // FIXME remove the dnode from cache & parent } } else { errno = EISDIR; } + unlock_inode(inode); + return errno; } @@ -892,7 +1001,7 @@ __DEFINE_LXSYSCALL1(int, unlink, const char*, pathname) goto done; } - errno = __vfs_do_unlink(dnode->inode); + errno = __vfs_do_unlink(dnode); done: return DO_STATUS(errno); @@ -908,7 +1017,7 @@ __DEFINE_LXSYSCALL2(int, unlinkat, int, fd, const char*, pathname) struct v_dnode* dnode; if (!(errno = vfs_walk(fd_s->file->dnode, pathname, &dnode, NULL, 0))) { - errno = __vfs_do_unlink(dnode->inode); + errno = __vfs_do_unlink(dnode); } done: @@ -951,7 +1060,8 @@ vfs_dup_fd(struct v_fd* old, struct v_fd** new) struct v_fd* copied = cake_grab(fd_pile); memcpy(copied, old, sizeof(struct v_fd)); - old->file->ref_count++; + + atomic_fetch_add(&old->file->ref_count, 1); *new = copied; @@ -1034,8 +1144,12 @@ __DEFINE_LXSYSCALL2(int, goto done; } + lock_inode(dnode->inode); + errno = dnode->inode->ops.symlink(dnode->inode, link_target); + unlock_inode(dnode->inode); + done: return DO_STATUS(errno); } @@ -1044,6 +1158,9 @@ int __vfs_do_chdir(struct v_dnode* dnode) { int errno = 0; + + lock_dnode(dnode); + if (!(dnode->inode->itype & VFS_IFDIR)) { errno = ENOTDIR; goto done; @@ -1053,9 +1170,11 @@ __vfs_do_chdir(struct v_dnode* dnode) __current->cwd->ref_count--; } - dnode->ref_count++; + dnode->ref_count--; __current->cwd = dnode; + unlock_dnode(dnode); + done: return errno; } @@ -1119,4 +1238,6 @@ __DEFINE_LXSYSCALL2(char*, getcwd, char*, buf, size_t, size) done: __current->k_status = errno; return ret_ptr; -} \ No newline at end of file +} + +// TODO rename syscall \ No newline at end of file -- 2.27.0