X-Git-Url: https://scm.lunaixsky.com/lunaix-os.git/blobdiff_plain/003db17f7a36a8098827f40df8fedc087b5a26f6..7515e526342f6ee07cbe92f5a458f1c2c4a1fcaf:/lunaix-os/kernel/fs/vfs.c

diff --git a/lunaix-os/kernel/fs/vfs.c b/lunaix-os/kernel/fs/vfs.c
index 902f21e..48ec27d 100644
--- a/lunaix-os/kernel/fs/vfs.c
+++ b/lunaix-os/kernel/fs/vfs.c
@@ -37,6 +37,9 @@ static struct hbucket* dnode_cache;
 
 static int fs_id = 0;
 
+struct hstr vfs_ddot = HSTR("..", 2);
+struct hstr vfs_dot = HSTR(".", 1);
+
 struct v_dnode*
 vfs_d_alloc();
 
@@ -62,6 +65,9 @@ vfs_init()
 
     dnode_cache = vzalloc(DNODE_HASHTABLE_SIZE * sizeof(struct hbucket));
 
+    hstr_rehash(&vfs_ddot, HSTR_FULL_HASH);
+    hstr_rehash(&vfs_dot, HSTR_FULL_HASH);
+
     // 创建一个根superblock，用来蕴含我们的根目录。
     root_sb = vfs_sb_alloc();
     root_sb->root = vfs_d_alloc();
@@ -80,6 +86,9 @@ __dcache_get_bucket(struct v_dnode* parent, unsigned int hash)
 struct v_dnode*
 vfs_dcache_lookup(struct v_dnode* parent, struct hstr* str)
 {
+    if (!str->len)
+        return parent;
+
     struct hbucket* slot = __dcache_get_bucket(parent, str->hash);
 
     struct v_dnode *pos, *n;
@@ -109,7 +118,7 @@ vfs_walk(struct v_dnode* start,
     int errno = 0;
     int i = 0, j = 0;
 
-    if (path[0] == PATH_DELIM) {
+    if (path[0] == PATH_DELIM || !start) {
         if ((walk_options & VFS_WALK_FSRELATIVE) && start) {
             start = start->super_block->root;
         } else {
@@ -146,6 +155,7 @@ vfs_walk(struct v_dnode* start,
         }
 
         name_content[j] = 0;
+        name.len = j;
         hstr_rehash(&name, HSTR_FULL_HASH);
 
         if (!lookahead && (walk_options & VFS_WALK_PARENT)) {
@@ -200,6 +210,7 @@ vfs_walk(struct v_dnode* start,
 error:
     vfree(dnode->name.value);
     vfs_d_free(dnode);
+    *dentry = NULL;
     return errno;
 }
 
@@ -344,7 +355,9 @@ struct v_dnode*
 vfs_d_alloc()
 {
     struct v_dnode* dnode = cake_grab(dnode_pile);
+    memset(dnode, 0, sizeof(*dnode));
     llist_init_head(&dnode->children);
+    return dnode;
 }
 
 void
@@ -371,45 +384,64 @@ vfs_i_free(struct v_inode* inode)
     cake_release(inode_pile, inode);
 }
 
-__DEFINE_LXSYSCALL2(int, open, const char*, path, int, options)
+int
+__vfs_do_open(struct v_file** file_out, const char* path, int options)
 {
     char name_str[VFS_NAME_MAXLEN];
     struct hstr name = HSTR(name_str, 0);
     struct v_dnode *dentry, *file;
-    int errno, fd;
+    int errno;
     if ((errno = vfs_walk(NULL, path, &dentry, &name, VFS_WALK_PARENT))) {
-        return -1;
+        return ENOENT;
     }
 
+    vfs_walk(dentry, name.value, &file, NULL, 0);
+
     struct v_file* opened_file = 0;
-    if (!(file = vfs_dcache_lookup(dentry, &name)) && (options & FO_CREATE)) {
-        errno = dentry->inode->ops.create(dentry->inode, opened_file);
-    } else if (!file) {
-        errno = EEXIST;
+    if (!file) {
+        if ((options & FO_CREATE)) {
+            errno = dentry->inode->ops.create(dentry->inode, opened_file);
+        } else {
+            errno = ENOENT;
+        }
     } else {
         errno = vfs_open(file, &opened_file);
     }
 
+    *file_out = opened_file;
+    return errno;
+}
+
+__DEFINE_LXSYSCALL2(int, open, const char*, path, int, options)
+{
+    struct v_file* opened_file;
+    int errno = __vfs_do_open(&opened_file, path, options), fd;
+
     __current->k_status = errno;
 
     if (!errno && !(errno = vfs_alloc_fdslot(&fd))) {
         struct v_fd* fd_s = vzalloc(sizeof(*fd_s));
         fd_s->file = opened_file;
-        fd_s->pos = file->inode->fsize & -((options & FO_APPEND) == 0);
+        fd_s->pos = opened_file->inode->fsize & -((options & FO_APPEND) != 0);
         __current->fdtable->fds[fd] = fd_s;
+        return fd;
     }
 
     return SYSCALL_ESTATUS(errno);
 }
 
+#define GET_FD(fd, fd_s)                                                       \
+    (fd >= 0 && fd < VFS_MAX_FD && (fd_s = __current->fdtable->fds[fd]))
+
 __DEFINE_LXSYSCALL1(int, close, int, fd)
 {
     struct v_fd* fd_s;
     int errno;
-    if (fd < 0 || fd >= VFS_MAX_FD || !(fd_s = __current->fdtable->fds[fd])) {
+    if (!GET_FD(fd, fd_s)) {
         errno = EBADF;
     } else if (!(errno = vfs_close(fd_s->file))) {
         vfree(fd_s);
+        __current->fdtable->fds[fd] = 0;
     }
 
     __current->k_status = errno;
@@ -424,7 +456,7 @@ __vfs_readdir_callback(struct dir_context* dctx,
                        const int dtype)
 {
     struct dirent* dent = (struct dirent*)dctx->cb_data;
-    strcpy(dent->d_name, name);
+    strncpy(dent->d_name, name, DIRENT_NAME_MAX_LEN);
     dent->d_nlen = len;
     dent->d_type = dtype;
 }
@@ -433,7 +465,7 @@ __DEFINE_LXSYSCALL2(int, readdir, int, fd, struct dirent*, dent)
 {
     struct v_fd* fd_s;
     int errno;
-    if (fd < 0 || fd >= VFS_MAX_FD || !(fd_s = __current->fdtable->fds[fd])) {
+    if (!GET_FD(fd, fd_s)) {
         errno = EBADF;
     } else if (!(fd_s->file->inode->itype & VFS_INODE_TYPE_DIR)) {
         errno = ENOTDIR;
@@ -456,13 +488,14 @@ __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(root_sb->root, path, &parent, &component, VFS_WALK_PARENT);
+    int errno = vfs_walk(NULL, path, &parent, &component, VFS_WALK_PARENT);
     if (errno) {
         goto done;
     }
 
-    if (!parent->inode->ops.mkdir) {
+    if ((parent->super_block->fs->types & FSTYPE_ROFS)) {
+        errno = ENOTSUP;
+    } else if (!parent->inode->ops.mkdir) {
         errno = ENOTSUP;
     } else if (!(parent->inode->itype & VFS_INODE_TYPE_DIR)) {
         errno = ENOTDIR;
@@ -478,6 +511,71 @@ __DEFINE_LXSYSCALL1(int, mkdir, const char*, path)
     }
 
 done:
+    __current->k_status = errno;
+    return SYSCALL_ESTATUS(errno);
+}
+
+__DEFINE_LXSYSCALL3(int, read, int, fd, void*, buf, size_t, count)
+{
+    int errno = 0;
+    struct v_fd* fd_s;
+    if (!GET_FD(fd, fd_s)) {
+        errno = EBADF;
+    } else {
+        struct v_file* file = fd_s->file;
+        file->f_pos = fd_s->pos;
+        if ((errno = file->ops.read(file, buf, count)) >= 0) {
+            fd_s->pos += errno;
+        }
+    }
+
+    __current->k_status = errno;
+    return SYSCALL_ESTATUS(errno);
+}
+
+__DEFINE_LXSYSCALL3(int, write, int, fd, void*, buf, size_t, count)
+{
+    int errno = 0;
+    struct v_fd* fd_s;
+    if (!GET_FD(fd, fd_s)) {
+        errno = EBADF;
+    } else {
+        struct v_file* file = fd_s->file;
+        file->f_pos = fd_s->pos;
+        if ((errno = file->ops.write(file, buf, count)) >= 0) {
+            fd_s->pos += errno;
+        }
+    }
+
+    __current->k_status = errno;
+    return SYSCALL_ESTATUS(errno);
+}
+
+__DEFINE_LXSYSCALL3(int, lseek, int, fd, int, offset, int, options)
+{
+    int errno = 0;
+    struct v_fd* fd_s;
+    if (!GET_FD(fd, fd_s)) {
+        errno = EBADF;
+    } else {
+        size_t fpos = fd_s->file->f_pos;
+        switch (options) {
+            case FSEEK_CUR:
+                fpos = (size_t)((int)fd_s->file->f_pos + offset);
+                break;
+            case FSEEK_END:
+                fpos = (size_t)((int)fd_s->file->inode->fsize + offset);
+                break;
+            case FSEEK_SET:
+                fpos = offset;
+                break;
+
+            default:
+                break;
+        }
+        fd_s->pos = fpos;
+    }
+
     __current->k_status = errno;
     return SYSCALL_ESTATUS(errno);
 }
\ No newline at end of file