修复 VMA 无法在 fork 同步分配数据的问题, 修复 EEVDF 中 yield 无效问题.

修复 iso9660_readfile 错误的返回长度问题.
修复 VMA 在 execve 函数中发生泄露的问题.

Co-authored-by: suhuajun-github <115517663+suhuajun-github@users.noreply.github.com>

Author: xiaoyi1212

assets/initramfs.img

@@ -7,18 +7,6 @@ vfs_node_t pipefs_root = NULL;
 int        pipefs_id   = 0;
 int        pipefd_id   = 0;
 
-void wake_blocked_tasks(task_block_list_t *head) {
-    task_block_list_t *current = head->next;
-    head->next                 = NULL;
-
-    while (current) {
-        task_block_list_t *next = current->next;
-        if (current->thread) { current->thread->status = START; }
-        free(current);
-        current = next;
-    }
-}
-
 void pipefs_open(void *parent, const char *name, vfs_node_t node) {
     (void)parent;
     (void)name;
@@ -33,124 +21,53 @@ size_t pipefs_read(void *file, void *addr, size_t offset, size_t size) {
     pipe_info_t *pipe = spec->info;
     if (!pipe) return -EINVAL;
 
-    spin_lock(pipe->lock);
-
-    uint32_t available = (pipe->write_ptr - pipe->read_ptr) % PIPE_BUFF;
-    if (available == 0) {
-        fd_file_handle *fd = container_of(spec->node, fd_file_handle, node);
-        if (fd->flags & O_NONBLOCK) {
-            spin_unlock(pipe->lock);
-            return -EWOULDBLOCK;
-        }
-
-        if (pipe->write_fds == 0) {
-            spin_unlock(pipe->lock);
-            return 0;
-        }
-        close_interrupt;
-        task_block_list_t *new_block = malloc(sizeof(task_block_list_t));
-        new_block->thread            = get_current_task();
-        new_block->next              = NULL;
-
-        task_block_list_t *browse = &pipe->blocking_read;
-        while (browse->next)
-            browse = browse->next;
-        browse->next = new_block;
+    while (pipe->ptr == 0) {
+        if (pipe->write_fds == 0) { return 0; }
 
-        spin_unlock(pipe->lock);
-
-        task_block(get_current_task(), WAIT, -1);
+        scheduler_yield();
     }
-    spin_unlock(pipe->lock);
-
-    available = (pipe->write_ptr - pipe->read_ptr) % PIPE_BUFF;
 
     // 实际读取量
-    uint32_t to_read = MIN(size, available);
+    uint32_t to_read = MIN(size, pipe->ptr);
 
-    if (available == 0) {
-        spin_unlock(pipe->lock);
-        return 0;
-    }
+    if (to_read == 0) { return 0; }
 
-    // 分两种情况拷贝数据
-    if (pipe->read_ptr + to_read <= PIPE_BUFF) {
-        memcpy(addr, &pipe->buf[pipe->read_ptr], to_read);
-    } else {
-        uint32_t first_chunk = PIPE_BUFF - pipe->read_ptr;
-        memcpy(addr, &pipe->buf[pipe->read_ptr], first_chunk);
-        memcpy(addr + first_chunk, pipe->buf, to_read - first_chunk);
-    }
+    spin_lock(pipe->lock);
 
-    // 更新读指针
-    pipe->read_ptr = (pipe->read_ptr + to_read) % PIPE_BUFF;
+    memcpy(addr, pipe->buf, to_read);
+    memmove(pipe->buf, &pipe->buf[pipe->ptr], pipe->ptr - to_read);
 
-    wake_blocked_tasks(&pipe->blocking_write);
+    pipe->ptr -= to_read;
 
     spin_unlock(pipe->lock);
 
     return to_read;
 }
 
 size_t pipe_write_inner(void *file, const void *addr, size_t size) {
-    if (size > PIPE_BUFF) size = PIPE_BUFF;
-
     pipe_specific_t *spec = (pipe_specific_t *)file;
     pipe_info_t     *pipe = spec->info;
 
-    spin_lock(pipe->lock);
-
-    uint32_t free_space = PIPE_BUFF - ((pipe->write_ptr - pipe->read_ptr) % PIPE_BUFF);
-    if (free_space < size) {
-        if (pipe->read_fds == 0) {
-            spin_unlock(pipe->lock);
-            return -EPIPE;
-        }
-        task_block_list_t *new_block = malloc(sizeof(task_block_list_t));
-        new_block->thread            = get_current_task();
-        new_block->next              = NULL;
-
-        task_block_list_t *browse = &pipe->blocking_write;
-
-        while (browse->next)
-            browse = browse->next;
-        browse->next = new_block;
-
-        spin_unlock(pipe->lock);
-
-        task_block(get_current_task(), WAIT, -1);
-
-        while (get_current_task()->status == WAIT) {
-            open_interrupt;
-            __asm__("pause");
-        }
-        close_interrupt;
+    while ((PIPE_BUFF - pipe->ptr) < size) {
+        if (pipe->read_fds == 0) { return -EPIPE; }
+        scheduler_yield();
     }
 
-    if (pipe->write_ptr + size <= PIPE_BUFF) {
-        memcpy(&pipe->buf[pipe->write_ptr], addr, size);
-    } else {
-        uint32_t first_chunk = PIPE_BUFF - pipe->write_ptr;
-        memcpy(&pipe->buf[pipe->write_ptr], addr, first_chunk);
-        memcpy(pipe->buf, addr + first_chunk, size - first_chunk);
-    }
-
-    pipe->write_ptr = (pipe->write_ptr + size) % PIPE_BUFF;
-
-    wake_blocked_tasks(&pipe->blocking_read);
-
+    spin_lock(pipe->lock);
+    memcpy(&pipe->buf[pipe->ptr], addr, size);
+    pipe->ptr += size;
     spin_unlock(pipe->lock);
 
     return size;
 }
 
 size_t pipefs_write(void *file, const void *addr, size_t offset, size_t size) {
-    int    ret       = 0;
+    size_t ret       = 0;
     size_t chunks    = size / PIPE_BUFF;
     size_t remainder = size % PIPE_BUFF;
     if (chunks)
         for (size_t i = 0; i < chunks; i++) {
-            int cycle = 0;
+            size_t cycle = 0;
             while (cycle != PIPE_BUFF)
                 cycle += pipe_write_inner(file, addr + i * PIPE_BUFF + cycle, PIPE_BUFF - cycle);
             ret += cycle;
@@ -183,15 +100,17 @@ bool pipefs_close(void *current) {
         pipe->read_fds--;
     }
 
-    if (!pipe->write_fds) wake_blocked_tasks(&pipe->blocking_read);
-    if (!pipe->read_fds) wake_blocked_tasks(&pipe->blocking_write);
-
-    if (pipe->write_fds == 0 && pipe->read_fds == 0) { free(pipe); }
-    spin_unlock(pipe->lock);
+    list_delete(pipefs_root->child, spec->node);
+    if ((spec->write && pipe->write_fds == 0) || pipe->read_fds == 0) free(spec);
 
-    free(spec);
+    if (pipe->write_fds == 0 && pipe->read_fds == 0) {
+        spin_unlock(pipe->lock);
+        free(pipe->buf);
+        free(pipe);
+        return true;
+    }
 
-    list_delete(pipefs_root->child, spec->node);
+    spin_unlock(pipe->lock);
 
     return true;
 }
@@ -204,17 +123,13 @@ int pipefs_poll(void *file, size_t events) {
 
     spin_lock(pipe->lock);
     if (events & EPOLLIN) {
-        if (!pipe->write_fds)
-            out |= EPOLLHUP;
-        else if (pipe->write_ptr != pipe->read_ptr)
-            out |= EPOLLIN;
+        if (!pipe->write_fds) out |= EPOLLHUP;
+        if (pipe->assigned > 0) out |= EPOLLIN;
     }
 
     if (events & EPOLLOUT) {
-        if (!pipe->read_fds)
-            out |= EPOLLERR;
-        else if (pipe->assigned < PIPE_BUFF)
-            out |= EPOLLOUT;
+        if (!pipe->read_fds) out |= EPOLLHUP;
+        if (pipe->assigned < PIPE_BUFF) out |= EPOLLOUT;
     }
     spin_unlock(pipe->lock);
     return out;
@@ -231,6 +146,13 @@ static int dummy() {
     return -ENOSYS;
 }
 
+errno_t pipefs_stat(void *file, vfs_node_t node) {
+    pipe_specific_t *spec = (pipe_specific_t *)file;
+    pipe_info_t     *pipe = spec->info;
+    node->size = pipe->ptr;
+    return EOK;
+}
+
 static struct vfs_callback pipefs_callbacks = {
     .mount    = pipefs_mount,
     .unmount  = (vfs_unmount_t)empty,
@@ -246,7 +168,7 @@ static struct vfs_callback pipefs_callbacks = {
     .delete   = (vfs_del_t)empty,
     .rename   = (vfs_rename_t)empty,
     .map      = (vfs_mapfile_t)empty,
-    .stat     = (vfs_stat_t)empty,
+    .stat     = pipefs_stat,
     .ioctl    = (vfs_ioctl_t)pipefs_ioctl,
     .poll     = pipefs_poll,
     .dup      = (vfs_dup_t)empty,

src/arch/x86_64/fs/pipefs.c

@@ -12,9 +12,8 @@ typedef struct task_block_list {
 } task_block_list_t;
 
 typedef struct pipe_info {
-    uint32_t read_ptr;
-    uint32_t write_ptr;
-    char     buf[PIPE_BUFF];
+    uint32_t ptr;
+    char    *buf;
     int      assigned;
 
     int write_fds;

src/arch/x86_64/include/pipefs.h

@@ -48,3 +48,4 @@ int    vma_split(vma_t *vma, unsigned long addr);
 int    vma_merge(vma_t *vma1, vma_t *vma2);
 int    vma_unmap_range(vma_manager_t *mgr, uintptr_t start, uintptr_t end);
 void   vma_manager_exit_cleanup(vma_manager_t *mgr);
+bool vma_manager_clone(vma_manager_t *src_mgr,vma_manager_t *dst_mgr);

src/arch/x86_64/include/vma.h

@@ -209,3 +209,71 @@ void vma_manager_exit_cleanup(vma_manager_t *mgr) {
     mgr->vm_total = 0;
     mgr->vm_used  = 0;
 }
+
+bool vma_manager_clone(vma_manager_t *src_mgr,vma_manager_t *dst_mgr) {
+    if (!src_mgr) {
+        return false;
+    }
+    if (!dst_mgr) {
+        return false;
+    }
+
+    // 2. 复制管理器的基本信息
+    dst_mgr->vma_list = NULL; // 链表头先设为 NULL
+    dst_mgr->vm_total = src_mgr->vm_total;
+    dst_mgr->vm_used  = 0; // vm_used 将在插入 VMA 时更新
+
+    vma_t *src_vma = src_mgr->vma_list;
+    vma_t *new_vma = NULL;
+
+    // 3. 遍历源 VMA 链表并深拷贝
+    while (src_vma) {
+        // 3.1. 分配新的 VMA 节点
+        new_vma = vma_alloc();
+        if (!new_vma) {
+            // 如果分配失败，必须清理已复制的部分
+            // vma_manager_exit_cleanup 适合清理，但需要保证它能正确处理部分构建的链表
+            // 这里我们使用一个更轻量级的清理，因为 vma_insert 并没有完全依赖 mgr->vm_used
+            // 但是 vma_manager_exit_cleanup 更健壮
+            vma_manager_exit_cleanup(dst_mgr);
+            return false;
+        }
+
+        // 3.2. 复制 VMA 的基本属性
+        // 复制除了指针以外的所有字段
+        new_vma->vm_start  = src_vma->vm_start;
+        new_vma->vm_end    = src_vma->vm_end;
+        new_vma->vm_flags  = src_vma->vm_flags;
+        new_vma->vm_type   = src_vma->vm_type;
+        new_vma->vm_fd     = src_vma->vm_fd;
+        new_vma->vm_offset = src_vma->vm_offset;
+        new_vma->shm_id    = src_vma->shm_id;
+
+        // 链表指针在 vma_alloc 中初始化为 NULL，在 vma_insert 中设置
+
+        // 3.3. 深拷贝 vm_name
+        if (src_vma->vm_name) {
+            size_t name_len = strlen(src_vma->vm_name) + 1;
+            new_vma->vm_name = (char *)malloc(name_len);
+            if (!new_vma->vm_name) {
+                // 如果名称分配失败，清理并退出
+                vma_free(new_vma);
+                vma_manager_exit_cleanup(dst_mgr);
+                return false;
+            }
+            memcpy(new_vma->vm_name, src_vma->vm_name, name_len);
+        } else {
+            new_vma->vm_name = NULL;
+        }
+
+        if (vma_insert(dst_mgr, new_vma) != 0) {
+            // 这不应该发生，除非 vm_start/vm_end 出错
+            vma_free(new_vma);
+            vma_manager_exit_cleanup(dst_mgr);
+            return false;
+        }
+
+        src_vma = src_vma->vm_next;
+    }
+    return true;
+}