feat: implement rmdir(2), unlink(2), unlinkat(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 48ec27dc18d06155be990d6926f20b1da413f993..0fbf6529df93295f851e13b690f827479daa5d69 100644 (file)
--- a/lunaix-os/kernel/fs/vfs.c
+++ b/lunaix-os/kernel/fs/vfs.c
@@ -39,6 +39,7 @@ 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();
@@ -86,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)
 {
-    if (!str->len)
+    if (!str->len || HSTR_EQ(str, &vfs_dot))
         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;
@@ -288,6 +293,10 @@ vfs_open(struct v_dnode* dnode, struct v_file** file)
     struct v_file* vfile = cake_grab(file_pile);
     memset(vfile, 0, sizeof(*vfile));
 
+    vfile->dnode = dnode;
+    vfile->inode = dnode->inode;
+    dnode->inode->open_count++;
+
     int errno = dnode->inode->ops.open(dnode->inode, vfile);
     if (errno) {
         cake_release(file_pile, vfile);
@@ -306,6 +315,9 @@ vfs_close(struct v_file* file)
 
     int errno = file->ops.close(file);
     if (!errno) {
+        if (file->inode->open_count) {
+            file->inode->open_count--;
+        }
         cake_release(file_pile, file);
     }
     return errno;
@@ -357,6 +369,7 @@ vfs_d_alloc()
     struct v_dnode* dnode = cake_grab(dnode_pile);
     memset(dnode, 0, sizeof(*dnode));
     llist_init_head(&dnode->children);
+    dnode->name = vfs_empty;
     return dnode;
 }
 
@@ -384,6 +397,8 @@ vfs_i_free(struct v_inode* inode)
     cake_release(inode_pile, inode);
 }
 
+/* ---- System call definition and support ---- */
+
 int
 __vfs_do_open(struct v_file** file_out, const char* path, int options)
 {
@@ -417,8 +432,6 @@ __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;
@@ -427,6 +440,7 @@ __DEFINE_LXSYSCALL2(int, open, const char*, path, int, options)
         return fd;
     }
 
+    __current->k_status = errno;
     return SYSCALL_ESTATUS(errno);
 }
 
@@ -475,11 +489,21 @@ __DEFINE_LXSYSCALL2(int, readdir, int, fd, struct dirent*, dent)
                                 .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);
 }
@@ -576,6 +600,161 @@ __DEFINE_LXSYSCALL3(int, lseek, int, fd, int, offset, int, options)
         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);
+}
+
+__DEFINE_LXSYSCALL1(int, rmdir, const char*, pathname)
+{
+    int errno;
+    struct v_dnode* dnode;
+    if ((errno = vfs_walk(NULL, pathname, &dnode, NULL, 0))) {
+        goto done;
+    }
+    if ((dnode->super_block->fs->types & FSTYPE_ROFS)) {
+        errno = EROFS;
+        goto done;
+    }
+
+    if (dnode->inode->open_count) {
+        errno = EBUSY;
+        goto done;
+    }
+
+    if (dnode->inode->itype == VFS_INODE_TYPE_DIR) {
+        errno = dnode->inode->ops.rmdir(dnode->inode);
+    } else {
+        errno = ENOTDIR;
+    }
+
+done:
+    __current->k_status = errno;
+    return SYSCALL_ESTATUS(errno);
+}
+
+int
+__vfs_do_unlink(struct v_inode* inode)
+{
+    int errno;
+    if (inode->open_count) {
+        errno = EBUSY;
+    } else if (inode->itype != VFS_INODE_TYPE_DIR) {
+        // TODO handle symbolic link and type other than regular file
+        errno = inode->ops.unlink(inode);
+    } else {
+        errno = EISDIR;
+    }
+
+    return errno;
+}
+
+__DEFINE_LXSYSCALL1(int, unlink, const char*, pathname)
+{
+    int errno;
+    struct v_dnode* dnode;
+    if ((errno = vfs_walk(NULL, pathname, &dnode, NULL, 0))) {
+        goto done;
+    }
+    if ((dnode->super_block->fs->types & FSTYPE_ROFS)) {
+        errno = EROFS;
+        goto done;
+    }
+
+    errno = __vfs_do_unlink(dnode->inode);
+
+done:
+    __current->k_status = errno;
+    return SYSCALL_ESTATUS(errno);
+}
+
+__DEFINE_LXSYSCALL2(int, unlinkat, int, fd, const char*, pathname)
+{
+    int errno;
+    struct v_fd* fd_s;
+    if (!GET_FD(fd, fd_s)) {
+        errno = EBADF;
+    } else {
+        struct v_dnode* dnode;
+        if (!(errno = vfs_walk(fd_s->file->dnode, pathname, &dnode, NULL, 0))) {
+            errno = __vfs_do_unlink(dnode->inode);
+        }
+    }
+
+done:
     __current->k_status = errno;
     return SYSCALL_ESTATUS(errno);
 }
\ No newline at end of file