feat: refine symbolic link support.

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

diff --git a/lunaix-os/kernel/fs/ramfs/ramfs.c b/lunaix-os/kernel/fs/ramfs/ramfs.c
index 11ec8463aa4f8db47097bc8eb3e936e6d45aa7c4..37f8869ac6ca3ec322d3f87e4dc4a610adcaa4a3 100644 (file)
--- a/lunaix-os/kernel/fs/ramfs/ramfs.c
+++ b/lunaix-os/kernel/fs/ramfs/ramfs.c
@@ -8,9 +8,11 @@
  * @copyright Copyright (c) 2022
  *
  */
+#include <klibc/string.h>
 #include <lunaix/fs.h>
 #include <lunaix/fs/ramfs.h>
 #include <lunaix/mm/valloc.h>
+#include <lunaix/spike.h>
 
 /*
     A RAM FS will play a role of being a root.
@@ -22,7 +24,7 @@
     case, our rootfs will be something like ext2.
 
     RamFS vs. TwiFS: Indeed, they are both fs that lives in RAM so
-    there is no foundmentally differences. However, TwiFS is designed
+    there is no foundmental differences. However, TwiFS is designed
     to be a 'virtual FIlesystem for KERnel space' (FIKER), so other
     kernel sub-modules can just create node and attach their own
     implementation of read/write, without brothering to create a
@@ -44,6 +46,45 @@ volatile static inode_t ino = 0;
 extern const struct v_inode_ops ramfs_inode_ops;
 extern const struct v_file_ops ramfs_file_ops;
 
+static int
+__ramfs_mknod(struct v_dnode* dnode, struct v_inode** nod_out, u32_t flags)
+{
+    struct v_inode* inode = vfs_i_alloc(dnode->super_block);
+
+    if (!inode) {
+        return ENOMEM;
+    }
+
+    struct ram_inode* rinode = valloc(sizeof(struct ram_inode));
+
+    if (!rinode) {
+        vfs_i_free(inode);
+        return ENOMEM;
+    }
+
+    rinode->flags = flags;
+    inode->data = rinode;
+
+    if ((flags & RAMF_DIR)) {
+        inode->itype = VFS_IFDIR;
+    } else {
+        inode->itype = VFS_IFFILE;
+    }
+
+    if ((flags & RAMF_SYMLINK)) {
+        inode->itype |= VFS_IFSYMLINK;
+    }
+
+    if (nod_out) {
+        *nod_out = inode;
+    }
+
+    vfs_i_addhash(inode);
+    vfs_assign_inode(dnode, inode);
+
+    return 0;
+}
+
 int
 ramfs_readdir(struct v_file* file, struct dir_context* dctx)
 {
@@ -52,8 +93,10 @@ ramfs_readdir(struct v_file* file, struct dir_context* dctx)
     llist_for_each(pos, n, &file->dnode->children, siblings)
     {
         if (i++ >= dctx->index) {
-            dctx->read_complete_callback(
-              dctx, pos->name.value, pos->name.len, 0);
+            dctx->read_complete_callback(dctx,
+                                         pos->name.value,
+                                         pos->name.len,
+                                         vfs_get_dtype(pos->inode->itype));
             return 1;
         }
     }
@@ -63,25 +106,13 @@ ramfs_readdir(struct v_file* file, struct dir_context* dctx)
 int
 ramfs_mkdir(struct v_inode* this, struct v_dnode* dnode)
 {
-    struct v_inode* inode = vfs_i_alloc(dnode->super_block);
-    inode->itype = VFS_IFDIR;
-
-    vfs_i_addhash(inode);
-    vfs_assign_inode(dnode, inode);
-
-    return 0;
+    return __ramfs_mknod(dnode, NULL, RAMF_DIR);
 }
 
 int
 ramfs_create(struct v_inode* this, struct v_dnode* dnode)
 {
-    struct v_inode* inode = vfs_i_alloc(dnode->super_block);
-    inode->itype = VFS_IFFILE;
-
-    vfs_i_addhash(inode);
-    vfs_assign_inode(dnode, inode);
-
-    return 0;
+    return __ramfs_mknod(dnode, NULL, RAMF_FILE);
 }
 
 void
@@ -97,13 +128,7 @@ ramfs_mount(struct v_superblock* vsb, struct v_dnode* mount_point)
 {
     vsb->ops.init_inode = ramfs_inode_init;
 
-    struct v_inode* inode = vfs_i_alloc(vsb);
-    inode->itype = VFS_IFDIR;
-
-    vfs_i_addhash(inode);
-    vfs_assign_inode(mount_point, inode);
-
-    return 0;
+    return __ramfs_mknod(mount_point, NULL, RAMF_DIR);
 }
 
 int
@@ -115,23 +140,82 @@ ramfs_unmount(struct v_superblock* vsb)
 void
 ramfs_init()
 {
-    struct filesystem* ramfs = fsm_new_fs("ramfs", 5);
+    struct filesystem* ramfs = fsm_new_fs("ramfs", -1);
     ramfs->mount = ramfs_mount;
     ramfs->unmount = ramfs_unmount;
 
     fsm_register(ramfs);
 }
 
+int
+ramfs_mksymlink(struct v_inode* this, const char* target)
+{
+    struct ram_inode* rinode = RAM_INODE(this->data);
+
+    assert(!(rinode->flags & RAMF_SYMLINK));
+
+    size_t len = strlen(target);
+    char* symlink = valloc(len);
+
+    if (!symlink) {
+        return ENOMEM;
+    }
+
+    memcpy(symlink, target, len);
+
+    this->itype |= VFS_IFSYMLINK;
+    rinode->flags |= RAMF_SYMLINK;
+    rinode->symlink = symlink;
+
+    return 0;
+}
+
+int
+ramfs_read_symlink(struct v_inode* this, const char** path_out)
+{
+    struct ram_inode* rinode = RAM_INODE(this->data);
+
+    if (!(rinode->flags & RAMF_SYMLINK)) {
+        return EINVAL;
+    }
+
+    *path_out = rinode->symlink;
+
+    return 0;
+}
+
+int
+ramfs_unlink(struct v_inode* this)
+{
+    struct ram_inode* rinode = RAM_INODE(this->data);
+
+    if ((rinode->flags & RAMF_SYMLINK)) {
+        rinode->flags &= ~RAMF_SYMLINK;
+        this->itype &= ~VFS_IFSYMLINK;
+        vfree(rinode->symlink);
+        return;
+    }
+
+    // TODO
+
+    return 0;
+}
+
 const struct v_inode_ops ramfs_inode_ops = { .mkdir = ramfs_mkdir,
                                              .rmdir = default_inode_rmdir,
                                              .dir_lookup =
                                                default_inode_dirlookup,
                                              .create = ramfs_create,
                                              .open = default_inode_open,
+                                             .unlink = ramfs_unlink,
+                                             .set_symlink = ramfs_mksymlink,
+                                             .read_symlink = ramfs_read_symlink,
                                              .rename = default_inode_rename };
 
 const struct v_file_ops ramfs_file_ops = { .readdir = ramfs_readdir,
                                            .close = default_file_close,
                                            .read = default_file_read,
+                                           .read_page = default_file_read,
                                            .write = default_file_write,
+                                           .write_page = default_file_write,
                                            .seek = default_file_seek };
\ No newline at end of file