procfs self节点更改为软链接, vfs_node 增加挂载点标记

Author: xiaoyi1212

module/all_include/fs_subsystem.h

@@ -100,6 +100,7 @@ struct vfs_node {           // vfs节点
     list_t     child;       // 子节点
     vfs_node_t root;        // 根目录
     bool       visited;     // 是否与具体文件系统同步
+    bool       is_mount;    // 是否是挂载点
 };
 
 errno_t    vfs_mkdir(const char *name);

src/x86_64/fs/procfs.c

@@ -9,6 +9,7 @@
 #include "vfs.h"
 
 static int procfs_id     = 0;
+static int proc_self_id  = 0;
 vfs_node_t procfs_root   = NULL;
 spin_t     procfs_oplock = SPIN_INIT;
 
@@ -24,6 +25,10 @@ static int dummy() {
     return 0;
 }
 
+static int udummy() {
+    return VFS_STATUS_FAILED;
+}
+
 const char *get_vma_permissions(vma_t *vma) {
     static char perms[5];
 
@@ -86,39 +91,19 @@ char *proc_gen_maps_file(pcb_t task, size_t *content_len) {
     return buf;
 }
 
+extern lock_queue *pgb_queue;
+
 errno_t procfs_mount(const char *src, vfs_node_t node) {
     if (src != (void *)PROC_REGISTER_ID) return VFS_STATUS_FAILED;
     procfs_root = node;
 
     procfs_root->fsid = procfs_id;
 
     vfs_node_t procfs_self = vfs_node_alloc(procfs_root, "self");
-    procfs_self->type      = file_dir;
+    procfs_self->type      = file_symlink;
     procfs_self->mode      = 0644;
-
-    vfs_node_t self_environ            = vfs_node_alloc(procfs_self, "environ");
-    self_environ->type                 = file_none;
-    self_environ->mode                 = 0700;
-    proc_handle_t *self_environ_handle = malloc(sizeof(proc_handle_t));
-    self_environ->handle               = self_environ_handle;
-    self_environ_handle->task          = NULL;
-    sprintf(self_environ_handle->name, "self/environ");
-
-    vfs_node_t self_maps            = vfs_node_alloc(procfs_self, "maps");
-    self_maps->type                 = file_none;
-    self_maps->mode                 = 0700;
-    proc_handle_t *self_maps_handle = malloc(sizeof(proc_handle_t));
-    self_maps->handle               = self_maps_handle;
-    self_maps_handle->task          = NULL;
-    sprintf(self_maps_handle->name, "self/maps");
-
-    vfs_node_t self_cmdline            = vfs_node_alloc(procfs_self, "cmdline");
-    self_cmdline->type                 = file_none;
-    self_cmdline->mode                 = 0700;
-    proc_handle_t *self_cmdline_handle = malloc(sizeof(proc_handle_t));
-    self_cmdline->handle               = self_cmdline_handle;
-    self_cmdline_handle->task          = NULL;
-    sprintf(self_cmdline_handle->name, "self/cmdline");
+    procfs_self->linkto    = NULL;
+    procfs_self->fsid      = proc_self_id;
 
     vfs_node_t cmdline    = vfs_node_alloc(procfs_root, "cmdline");
     cmdline->type         = file_none;
@@ -136,6 +121,10 @@ errno_t procfs_mount(const char *src, vfs_node_t node) {
     filesystems_handle->task          = NULL;
     sprintf(filesystems_handle->name, "filesystems");
 
+    queue_foreach(pgb_queue, node) {
+        procfs_on_new_task(node->data);
+    }
+
     return VFS_STATUS_SUCCESS;
 }
 
@@ -177,30 +166,12 @@ size_t procfs_read(void *file, void *addr, size_t offset, size_t size) {
         len = (len + 1) > size ? size : len + 1;
         memcpy(addr, get_kernel_cmdline(), len);
         return len;
-    } else if (!strcmp(handle->name, "self/maps")) {
-        size_t content_len = 0;
-        char  *content     = proc_gen_maps_file(get_current_task()->parent_group, &content_len);
-        if (offset >= content_len) {
-            free(content);
-            return 0;
-        }
-        content_len    = MIN(content_len, offset + size);
-        size_t to_copy = MIN(content_len, size);
-        memcpy(addr, content + offset, to_copy);
-        free(content);
-        ((char *)addr)[to_copy] = '\0';
-        return to_copy;
-    } else if (!strcmp(handle->name, "self/cmdline")) {
-        ssize_t len = strlen(get_current_task()->parent_group->cmdline);
-        if (len == 0) return 0;
-        len = (len + 1) > size ? size : len + 1;
-        memcpy(addr, get_current_task()->parent_group->cmdline, len);
-        return len;
     } else if (!strcmp(handle->name, "proc_cmdline")) {
-        ssize_t len = strlen(task->cmdline);
+        char   *cmdline = task->cmdline ? task->cmdline : "no_cmdline";
+        ssize_t len     = strlen(cmdline);
         if (len == 0) return 0;
         len = (len + 1) > size ? size : len + 1;
-        memcpy(addr, task->cmdline, len);
+        memcpy(addr, cmdline, len);
         return len;
     } else if (!strcmp(handle->name, "proc_maps")) {
         size_t content_len = 0;
@@ -234,15 +205,8 @@ errno_t procfs_stat(void *file, vfs_node_t node) {
         node->size = strlen(filesystems_content);
     else if (!strcmp(handle->name, "cmdline"))
         node->size = strlen(get_kernel_cmdline());
-    else if (!strcmp(handle->name, "self/maps")) {
-        size_t content_len = 0;
-        char  *content     = proc_gen_maps_file(get_current_task()->parent_group, &content_len);
-        free(content);
-        node->size = content_len;
-    } else if (!strcmp(handle->name, "proc_cmdline"))
-        node->size = strlen(handle->task->cmdline);
-    else if (!strcmp(handle->name, "self/cmdline"))
-        node->size = strlen(get_current_task()->parent_group->cmdline);
+    else if (!strcmp(handle->name, "proc_cmdline"))
+        node->size = strlen(handle->task->cmdline ? handle->task->cmdline : "null");
     else if (!strcmp(handle->name, "proc_maps")) {
         size_t content_len = 0;
         char  *content     = proc_gen_maps_file(handle->task, &content_len);
@@ -252,6 +216,77 @@ errno_t procfs_stat(void *file, vfs_node_t node) {
         node->size = strlen("cpkernel_drm");
 }
 
+void procfs_self_open(void *parent, const char *name, vfs_node_t node) {
+    logkf("procfs: self open node: %p\n", get_current_task()->parent_group->procfs_node);
+    procfs_self_handle_t *handle = malloc(sizeof(procfs_self_handle_t));
+    handle->self                 = node;
+    node->linkto                 = get_current_task()->parent_group->procfs_node;
+    node->handle                 = handle;
+    vfs_node_t new_self_node     = vfs_node_alloc(node->parent, "self");
+    new_self_node->type          = file_symlink;
+    new_self_node->mode          = 0644;
+    new_self_node->fsid          = proc_self_id;
+    list_delete(node->parent->child, node);
+}
+
+void procfs_self_close(void *current) {
+    procfs_self_handle_t *handle  = current;
+    handle->self->type           |= file_delete;
+    free(handle);
+}
+
+size_t procfs_self_read(void *fd, void *addr, size_t offset, size_t size) {
+    procfs_self_handle_t *handle = fd;
+    return procfs_read(handle->self->linkto->handle, addr, offset, size);
+}
+
+size_t procfs_self_write(void *fd, const void *addr, size_t offset, size_t size) {
+    procfs_self_handle_t *handle = fd;
+    return procfs_write(handle->self->linkto->handle, addr, offset, size);
+}
+
+size_t procfs_self_readlink(vfs_node_t file, void *addr, size_t offset, size_t size) {
+    procfs_self_handle_t *handle = file->handle;
+    if (offset >= strlen(handle->self->linkto->name)) return 0;
+    logkf("procfs: readlink offset:%llu size:%llu", offset, size);
+    char   *ptr = handle->self->linkto->name + offset;
+    ssize_t len = strlen(ptr);
+    len         = MIN(len, (ssize_t)size);
+    memcpy(addr, ptr, len);
+    return len;
+}
+
+errno_t procfs_self_stat(void *file, vfs_node_t node) {
+    procfs_self_handle_t *handle  = file;
+    node->type                   |= file_symlink;
+    node->size                    = strlen(handle->self->linkto->name);
+}
+
+void procfs_self_free_handle(procfs_self_handle_t *handle) {
+    free(handle);
+}
+
+static struct vfs_callback procfs_self_callbacks = {
+    .open     = procfs_self_open,
+    .close    = procfs_self_close,
+    .read     = procfs_self_read,
+    .write    = procfs_self_write,
+    .readlink = procfs_self_readlink,
+    .mkdir    = (vfs_mk_t)dummy,
+    .mkfile   = (vfs_mk_t)dummy,
+    .link     = (vfs_mk_t)dummy,
+    .symlink  = (vfs_mk_t)dummy,
+    .delete   = (vfs_del_t)dummy,
+    .rename   = (vfs_rename_t)dummy,
+    .stat     = procfs_self_stat,
+    .ioctl    = (vfs_ioctl_t)dummy,
+    .map      = (vfs_mapfile_t)dummy,
+    .poll     = (vfs_poll_t)dummy,
+    .mount    = (vfs_mount_t)udummy,
+    .unmount  = (vfs_unmount_t)dummy,
+    .dup      = (vfs_dup_t)dummy,
+};
+
 static struct vfs_callback procfs_callbacks = {
     .mount    = procfs_mount,
     .unmount  = (vfs_unmount_t)dummy,
@@ -274,30 +309,34 @@ static struct vfs_callback procfs_callbacks = {
 };
 
 void procfs_setup() {
-    procfs_id = vfs_regist("proc", &procfs_callbacks, PROC_REGISTER_ID);
-    if (procfs_id == VFS_STATUS_FAILED) { kerror("procfs register error"); }
+    procfs_id    = vfs_regist("proc", &procfs_callbacks, PROC_REGISTER_ID);
+    proc_self_id = vfs_regist("proc_self", &procfs_self_callbacks, PROC_REGISTER_ID);
+    if (procfs_id == VFS_STATUS_FAILED || proc_self_id == VFS_STATUS_FAILED) {
+        kerror("procfs register error");
+    }
 }
 
 void procfs_on_new_task(pcb_t task) {
     if (procfs_root == NULL) return;
-    spin_lock(procfs_oplock);
 
     char name[MAX_PID_NAME_LEN];
     sprintf(name, "%d", task->pid);
 
-    char fname[6 + MAX_PID_NAME_LEN];
-    sprintf(fname, "/proc/%d", task->pid);
+    char *root_path = vfs_get_fullpath(procfs_root);
+    char  fname[strlen(root_path) + 1 + MAX_PID_NAME_LEN];
+    sprintf(fname, "%s/%d", root_path, task->pid);
     vfs_node_t pro = vfs_open(fname);
+    free(root_path);
     if (pro != NULL) {
         vfs_close(pro);
-        spin_unlock(procfs_oplock);
         return;
     }
 
-    vfs_node_t node = vfs_child_append(procfs_root, name, NULL);
-    node->type      = file_dir;
-    node->mode      = 0644;
-    node->fsid      = procfs_id;
+    vfs_node_t node   = vfs_child_append(procfs_root, name, NULL);
+    node->type        = file_dir;
+    node->mode        = 0644;
+    node->fsid        = procfs_id;
+    task->procfs_node = node;
 
     vfs_node_t cmdline    = vfs_child_append(node, "cmdline", NULL);
     cmdline->type         = file_none;
@@ -316,16 +355,16 @@ void procfs_on_new_task(pcb_t task) {
     mmaps->handle           = handle_m;
     handle_m->task          = task;
     sprintf(handle_m->name, "proc_maps");
-
-    spin_unlock(procfs_oplock);
 }
 
 void procfs_on_exit_task(pcb_t task) {
     if (procfs_root == NULL) return;
     spin_lock(procfs_oplock);
 
-    char name[6 + MAX_PID_NAME_LEN];
-    sprintf(name, "/proc/%d", task->pid);
+    char *root_path = vfs_get_fullpath(procfs_root);
+    char  name[strlen(root_path) + 1 + MAX_PID_NAME_LEN];
+    sprintf(name, "%s/%d", root_path, task->pid);
+    free(root_path);
 
     vfs_node_t node = vfs_open(name);
     if (node && node->parent) {
@@ -335,33 +374,3 @@ void procfs_on_exit_task(pcb_t task) {
 
     spin_unlock(procfs_oplock);
 }
-
-extern lock_queue *pgb_queue;
-
-void procfs_update_task_list() {
-    if (procfs_root == NULL) return;
-    do {
-        vfs_node_t proc_node = NULL;
-        list_foreach(procfs_root->child, node) {
-            vfs_node_t pnode = node->data;
-            if (pnode->handle != NULL) {
-                proc_handle_t *handle = pnode->handle;
-                if (handle->task == NULL) continue;
-                proc_node = pnode;
-                break;
-            }
-        }
-        if (proc_node == NULL) break;
-        proc_handle_t *handle = proc_node->handle;
-        if (handle->task->status == DEATH) {
-            if (proc_node && proc_node->parent) {
-                list_delete(proc_node->parent->child, proc_node);
-                vfs_free(proc_node);
-            }
-        }
-    } while (true);
-    queue_foreach(pgb_queue, node) {
-        pcb_t process = node->data;
-        procfs_on_new_task(process);
-    }
-}

src/x86_64/fs/vfs.c

@@ -388,6 +388,11 @@ vfs_node_t get_rootdir() {
     return rootdir;
 }
 
+void set_rootdir(vfs_node_t node) {
+    rootdir         = node;
+    rootdir->parent = NULL;
+}
+
 void *vfs_map(vfs_node_t node, uint64_t addr, uint64_t len, uint64_t prot, uint64_t flags,
               uint64_t offset) {
     if (unlikely(node == NULL)) return NULL;
@@ -461,8 +466,9 @@ errno_t vfs_mount(const char *src, vfs_node_t node) {
     if (node->type != file_dir) return VFS_STATUS_FAILED;
     for (int i = 1; i < fs_nextid; i++) {
         if (fs_callbacks[i]->mount(src, node) == 0) {
-            node->fsid = i;
-            node->root = node;
+            node->fsid     = i;
+            node->root     = node;
+            node->is_mount = true;
             return VFS_STATUS_SUCCESS;
         }
     }
@@ -509,11 +515,11 @@ errno_t vfs_unmount(const char *path) {
         if (cur->root == cur) {
             vfs_free_child(cur);
             callbackof(cur, unmount)(cur->handle);
-            cur->fsid   = node->fsid; // 交给上级
-            cur->root   = node->root;
-            cur->handle = NULL;
-            cur->child  = NULL;
-            // cur->type   = file_none;
+            cur->fsid     = node->fsid; // 交给上级
+            cur->root     = node->root;
+            cur->handle   = NULL;
+            cur->child    = NULL;
+            cur->is_mount = false;
             if (cur->fsid) do_update(cur);
             return VFS_STATUS_SUCCESS;
         }

src/x86_64/include/pcb.h

@@ -113,6 +113,7 @@ struct process_control_block {
     lock_queue       *child_pcb;   // 子进程列表
     page_directory_t *page_dir;    // 进程页表
     vma_manager_t     vma_manager; // VMA 分配管理器
+    vfs_node_t        procfs_node; // 进程私有 procfs 文件句柄
     char            **envp;        // 环境变量指针
     size_t            envc;        // 环境变量数量
     ucb_t             user;        // 用户会话

src/x86_64/include/procfs.h

@@ -12,6 +12,10 @@ typedef struct proc_handle {
     pcb_t      task;
 } proc_handle_t;
 
+typedef struct procfs_self_handle {
+    vfs_node_t self;
+} procfs_self_handle_t;
+
 void procfs_update_task_list();
 void procfs_on_new_task(pcb_t task);
 void procfs_on_exit_task(pcb_t task);

src/x86_64/include/syscall.h

@@ -171,6 +171,7 @@
 #define SYSCALL_ARCH_PRCTL  158
 #define SYSCALL_PIVOT_ROOT  155
 #define SYSCALL_G_AFFINITY  160
+#define SYSCALL_CHROOT      161
 #define SYSCALL_MOUNT       165
 #define SYSCALL_UMOUNT2     166
 #define SYSCALL_REBOOT      169

src/x86_64/include/vfs.h

@@ -164,6 +164,7 @@ struct vfs_node {           // vfs节点
     list_t     child;       // 子节点
     vfs_node_t root;        // 根目录
     bool       visited;     // 是否与具体文件系统同步
+    bool       is_mount;    // 是否是挂载点
 };
 
 struct fd {
@@ -317,6 +318,7 @@ errno_t vfs_unmount(const char *path);
  * @return 根目录节点
  */
 vfs_node_t get_rootdir();
+void       set_rootdir(vfs_node_t node);
 
 char *vfs_get_fullpath(vfs_node_t node);
 char *at_resolve_pathname(int dirfd, char *pathname);