feat: implement readlink(2) readlinkat(2)

[lunaix-os.git] / lunaix-os / kernel / fs / vfs.c

diff --git a/lunaix-os/kernel/fs/vfs.c b/lunaix-os/kernel/fs/vfs.c
index 09668f501d09c09bec83b1a8492b6379760ed615..4c0324088d0a60eaddd486e90a7cc7676cbd5cfc 100644 (file)
--- a/lunaix-os/kernel/fs/vfs.c
+++ b/lunaix-os/kernel/fs/vfs.c
@@ -37,6 +37,10 @@ static struct hbucket* dnode_cache;
 
 static int fs_id = 0;
 
 
 static int fs_id = 0;
 

+struct hstr vfs_ddot = HSTR("..", 2);
+struct hstr vfs_dot = HSTR(".", 1);
+struct hstr vfs_empty = HSTR("", 0);
+

 struct v_dnode*
 vfs_d_alloc();
 
 struct v_dnode*
 vfs_d_alloc();
 


@@ -62,6 +66,9 @@ vfs_init()
 
     dnode_cache = vzalloc(DNODE_HASHTABLE_SIZE * sizeof(struct hbucket));
 
 
     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();
     // 创建一个根superblock，用来蕴含我们的根目录。
     root_sb = vfs_sb_alloc();
     root_sb->root = vfs_d_alloc();


@@ -80,9 +87,13 @@ __dcache_get_bucket(struct v_dnode* parent, unsigned int hash)
 struct v_dnode*
 vfs_dcache_lookup(struct v_dnode* parent, struct hstr* str)
 {
 struct v_dnode*
 vfs_dcache_lookup(struct v_dnode* parent, struct hstr* str)
 {

-    if (!str->len)
+    if (!str->len || HSTR_EQ(str, &vfs_dot))

         return parent;
 
         return parent;
 

+    if (HSTR_EQ(str, &vfs_ddot)) {
+        return parent->parent ? parent->parent : parent;
+    }
+

     struct hbucket* slot = __dcache_get_bucket(parent, str->hash);
 
     struct v_dnode *pos, *n;
     struct hbucket* slot = __dcache_get_bucket(parent, str->hash);
 
     struct v_dnode *pos, *n;


@@ -282,6 +293,9 @@ vfs_open(struct v_dnode* dnode, struct v_file** file)
     struct v_file* vfile = cake_grab(file_pile);
     memset(vfile, 0, sizeof(*vfile));
 
     struct v_file* vfile = cake_grab(file_pile);
     memset(vfile, 0, sizeof(*vfile));
 

+    vfile->dnode = dnode;
+    vfile->inode = dnode->inode;
+

     int errno = dnode->inode->ops.open(dnode->inode, vfile);
     if (errno) {
         cake_release(file_pile, vfile);
     int errno = dnode->inode->ops.open(dnode->inode, vfile);
     if (errno) {
         cake_release(file_pile, vfile);


@@ -349,7 +363,10 @@ struct v_dnode*
 vfs_d_alloc()
 {
     struct v_dnode* dnode = cake_grab(dnode_pile);
 vfs_d_alloc()
 {
     struct v_dnode* dnode = cake_grab(dnode_pile);

+    memset(dnode, 0, sizeof(*dnode));

     llist_init_head(&dnode->children);
     llist_init_head(&dnode->children);

+    dnode->name = vfs_empty;
+    return dnode;

 }
 
 void
 }
 
 void


@@ -376,14 +393,15 @@ vfs_i_free(struct v_inode* inode)
     cake_release(inode_pile, 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;
 {
     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))) {
     if ((errno = vfs_walk(NULL, path, &dentry, &name, VFS_WALK_PARENT))) {

-        return -1;
+        return ENOENT;

     }
 
     vfs_walk(dentry, name.value, &file, NULL, 0);
     }
 
     vfs_walk(dentry, name.value, &file, NULL, 0);


@@ -399,15 +417,24 @@ __DEFINE_LXSYSCALL2(int, open, const char*, path, int, options)
         errno = vfs_open(file, &opened_file);
     }
 
         errno = vfs_open(file, &opened_file);
     }
 

-    __current->k_status = errno;
+    *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;

 
     if (!errno && !(errno = vfs_alloc_fdslot(&fd))) {
         struct v_fd* fd_s = vzalloc(sizeof(*fd_s));
         fd_s->file = opened_file;
 
     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;
         __current->fdtable->fds[fd] = fd_s;

+        return fd;

     }
 
     }
 

+    __current->k_status = errno;

     return SYSCALL_ESTATUS(errno);
 }
 
     return SYSCALL_ESTATUS(errno);
 }
 


@@ -456,11 +483,21 @@ __DEFINE_LXSYSCALL2(int, readdir, int, fd, struct dirent*, dent)
                                 .index = dent->d_offset,
                                 .read_complete_callback =
                                   __vfs_readdir_callback };
                                 .index = dent->d_offset,
                                 .read_complete_callback =
                                   __vfs_readdir_callback };

-        if (!(errno = fd_s->file->ops.readdir(fd_s->file, &dctx))) {
-            dent->d_offset++;
+        if (dent->d_offset == 0) {
+            __vfs_readdir_callback(&dctx, vfs_dot.value, vfs_dot.len, 0);
+        } else if (dent->d_offset == 1) {
+            __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, &dctx))) {
+                goto done;
+            }

         }
         }

+        errno = 0;
+        dent->d_offset++;

     }
 
     }
 

+done:

     __current->k_status = errno;
     return SYSCALL_ESTATUS(errno);
 }
     __current->k_status = errno;
     return SYSCALL_ESTATUS(errno);
 }


@@ -474,7 +511,9 @@ __DEFINE_LXSYSCALL1(int, mkdir, const char*, path)
         goto done;
     }
 
         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;
         errno = ENOTSUP;
     } else if (!(parent->inode->itype & VFS_INODE_TYPE_DIR)) {
         errno = ENOTDIR;


@@ -555,6 +594,80 @@ __DEFINE_LXSYSCALL3(int, lseek, int, fd, int, offset, int, options)
         fd_s->pos = fpos;
     }
 
         fd_s->pos = fpos;
     }
 

+    __current->k_status = errno;
+    return SYSCALL_ESTATUS(errno);
+}
+
+int
+vfs_readlink(struct v_dnode* dnode, char* buf, size_t size, int depth)
+{
+    if (!dnode) {
+        return 0;
+    }
+
+    if (depth > 64) {
+        return ELOOP;
+    }
+
+    size_t len = vfs_readlink(dnode->parent, buf, size, depth + 1);
+
+    if (len >= size) {
+        return len;
+    }
+
+    size_t cpy_size = MIN(dnode->name.len, size - len);
+    strncpy(buf + len, dnode->name.value, cpy_size);
+    len += cpy_size;
+
+    if (len < size) {
+        buf[len++] = PATH_DELIM;
+    }
+
+    return len;
+}
+
+__DEFINE_LXSYSCALL3(int, readlink, const char*, path, char*, buf, size_t, size)
+{
+    int errno;
+    struct v_dnode* dnode;
+    if (!(errno = vfs_walk(NULL, path, &dnode, NULL, 0))) {
+        errno = vfs_readlink(dnode, buf, size, 0);
+    }
+
+    if (errno >= 0) {
+        return errno;
+    }
+
+    __current->k_status = errno;
+    return SYSCALL_ESTATUS(errno);
+}
+
+__DEFINE_LXSYSCALL4(int,
+                    readlinkat,
+                    int,
+                    dirfd,
+                    const char*,
+                    pathname,
+                    char*,
+                    buf,
+                    size_t,
+                    size)
+{
+    int errno;
+    struct v_fd* fd_s;
+    if (!GET_FD(dirfd, fd_s)) {
+        errno = EBADF;
+    } else {
+        struct v_dnode* dnode;
+        if (!(errno = vfs_walk(fd_s->file->dnode, pathname, &dnode, NULL, 0))) {
+            errno = vfs_readlink(fd_s->file->dnode, buf, size, 0);
+        }
+    }
+
+    if (errno >= 0) {
+        return errno;
+    }
+

     __current->k_status = errno;
     return SYSCALL_ESTATUS(errno);
 }
\ No newline at end of file
     __current->k_status = errno;
     return SYSCALL_ESTATUS(errno);
 }
\ No newline at end of file