修复 general_map 异常返回行为的问题, 内核堆增加扩容机制.

xiaoyi1212 · xiaoyi1212 · commit e94281ee30b2 · 2026-03-22T11:09:15.000+08:00
- 增加 memfd 与 memfd_create 系统调用
- initramfs 修复与 rootfs 新增 xorg
diff --git a/assets/cp_rootfs.sfs b/assets/cp_rootfs.sfs
diff --git a/assets/initramfs.img b/assets/initramfs.img
diff --git a/libs/liballoc-x86_64.a b/libs/liballoc-x86_64.a
diff --git a/src/arch/x86_64/include/nr.h b/src/arch/x86_64/include/nr.h
@@ -153,6 +153,7 @@
 #define SYSCALL_PIPE2         293
 #define SYSCALL_PRLIMIT64     302
 #define SYSCALL_GETRANDOM     318
+#define SYSCALL_MEMFD_CREATE  319
 #define SYSCALL_CP_F_RANGE    326
 #define SYSCALL_STATX         332
 #define SYSCALL_FSOPEN        430
diff --git a/src/arch/x86_64/main.c b/src/arch/x86_64/main.c
@@ -29,6 +29,7 @@
 #include "fs/sysfs.h"
 #include "fs/tmpfs.h"
 #include "fs/vfs.h"
+#include "fs/memfd.h"
 #include "fsgsbase.h"
 #include "hpet.h"
 #include "intctl.h"
@@ -124,6 +125,7 @@ USED _Noreturn void kmain() {
     sockfs_regist();
     epollfs_regist();
     eventfdfs_regist();
+    memfd_setup();
     sysfs_regist();
 
     // 率先将调度器 IRQ 注册进去, 防止驱动程序IRQ分配占用
diff --git a/src/arch/x86_64/syscall.c b/src/arch/x86_64/syscall.c
@@ -254,6 +254,8 @@ syscall_t syscall_handlers[MAX_SYSCALLS] = {
     [SYSCALL_EPOLL_PWAIT]   = (syscall_t)syscall_epoll_pwait,
     [SYSCALL_ACCEPT4]       = (syscall_t)syscall_accept4,
     [SYSCALL_EVENTFD2]      = (syscall_t)syscall_eventfd2,
+    [SYSCALL_FTRUNCATE]     = (syscall_t)syscall_ftruncate,
+    [SYSCALL_MEMFD_CREATE]  = (syscall_t)syscall_memfd_create,
 };
 
 USED void syscall_handler(struct syscall_regs *regs, uint64_t user_regs) { // syscall 指令处理
diff --git a/src/fs/memfd.c b/src/fs/memfd.c
@@ -0,0 +1,168 @@
+#include "fs/memfd.h"
+#include "errno.h"
+#include "mem/frame.h"
+#include "mem/page.h"
+#include "task/task.h"
+#include "term/klog.h"
+#include "syscall.h"
+
+static int memfd_fsid = 0;
+
+static size_t memfd_read(void *data, void *buf, size_t offset, size_t len) {
+    const struct memfd_ctx *ctx = data;
+    const size_t avail          = ctx->len - offset;
+    if (avail <= 0) {
+        return 0;
+    }
+    const size_t copy_len = len < avail ? len : avail;
+    memcpy(buf, ctx->data + offset, copy_len);
+    return copy_len;
+}
+
+static size_t memfd_write(void *data, const void *buf, size_t offset, size_t len) {
+    struct memfd_ctx *ctx = data;
+    spin_lock(ctx->lock);
+    if (offset + len > ctx->len) {
+        const size_t new_size    = ctx->len * 2;
+        const uint64_t phys_addr = alloc_frames(new_size / PAGE_SIZE);
+        uint8_t *new_data        = phys_to_virt(phys_addr);
+        if (!new_data) {
+            spin_unlock(ctx->lock);
+            return -ENOMEM;
+        }
+        page_map_range(
+            get_kernel_pagedir(), (uint64_t)new_data, phys_addr, ctx->len, KERNEL_PTE_FLAGS
+        );
+        memcpy(new_data, ctx->data, ctx->len);
+        unmap_page_range(get_kernel_pagedir(), (uint64_t)ctx->data, ctx->len);
+        ctx->data = new_data;
+        ctx->len  = new_size;
+    }
+    memcpy(ctx->data + offset, buf, len);
+    ctx->node->size = ctx->len;
+    spin_unlock(ctx->lock);
+    return len;
+}
+
+static void *
+memfd_map(void *file, void *addr, size_t offset, size_t size, size_t prot, size_t flags) {
+    if ((flags & MAP_TYPE) == MAP_PRIVATE) {
+        return general_map(memfd_read, file, (uint64_t)addr, size, prot, flags, offset);
+    }
+    const struct memfd_ctx *ctx = file;
+    page_map_range(
+        get_current_task()->process->directory,
+        (uint64_t)addr,
+        virt_to_phys((void *)ctx->data + offset),
+        size,
+        KERNEL_PTE_FLAGS
+    );
+    return addr;
+}
+
+bool memfd_close(void *handle) {
+    struct memfd_ctx *ctx = handle;
+    if (!ctx) {
+        return true;
+    }
+
+    spin_lock(ctx->lock);
+
+    unmap_page_range(get_kernel_pagedir(), (uint64_t)ctx->data, ctx->len);
+
+    spin_unlock(ctx->lock);
+    ctx->node->handle = NULL;
+    free(ctx);
+    return true;
+}
+
+errno_t memfd_stat(void *file, vfs_node_t node) {
+    struct memfd_ctx *ctx = file;
+    if (!ctx) {
+        return -EINVAL;
+    }
+    node->size = ctx->len;
+    return EOK;
+}
+
+errno_t memfd_free(void *handle) {
+    if (!handle) {
+        return EOK;
+    }
+    free(handle);
+    return EOK;
+}
+
+syscall_(memfd_create, const char *name, const unsigned int flags) {
+    if (flags & MFD_HUGETLB) {
+        return -EINVAL;
+    }
+
+    if (flags & MFD_NOEXEC_SEAL || flags & MFD_EXEC) {
+        return -EINVAL;
+    }
+
+    struct memfd_ctx *ctx = malloc(sizeof(struct memfd_ctx));
+    if (!ctx) {
+        return SYSCALL_FAULT_(ENOMEM);
+    }
+    strncpy(ctx->name, name, 63);
+    ctx->name[63] = '\0';
+    ctx->len      = PAGE_SIZE;
+
+    const uint64_t phys_addr = alloc_frames(1);
+    ctx->data          = phys_to_virt(phys_addr);
+    page_map_range(
+        get_kernel_pagedir(), (uint64_t)ctx->data, phys_addr, ctx->len, KERNEL_PTE_FLAGS
+    );
+    memset(ctx->data, 0, ctx->len);
+    ctx->flags = flags;
+    ctx->lock  = SPIN_INIT;
+
+    const vfs_node_t node = vfs_node_alloc(NULL, NULL);
+    node->type            = file_none;
+    node->fsid            = memfd_fsid;
+    node->handle          = ctx;
+    node->refcount++;
+    node->size = 0;
+    ctx->node  = node;
+    fd_t *fd   = calloc(1, sizeof(fd_t));
+    if (!fd) {
+        free(ctx);
+        return SYSCALL_FAULT_(ENOMEM);
+    }
+    fd->flags = flags;
+    fd->node  = node;
+    return add_fd(get_current_task()->process->fdts, fd);
+}
+
+static struct vfs_callback memfd_callbacks = {
+    .mount    = (vfs_mount_t)dummy,
+    .unmount  = (vfs_unmount_t)dummy,
+    .mkdir    = (vfs_mk_t)dummy,
+    .close    = memfd_close,
+    .stat     = memfd_stat,
+    .open     = (vfs_open_t)dummy,
+    .read     = memfd_read,
+    .write    = memfd_write,
+    .readlink = (vfs_readlink_t)dummy,
+    .mkfile   = (vfs_mk_t)dummy,
+    .link     = (vfs_mk_t)dummy,
+    .symlink  = (vfs_mk_t)dummy,
+    .ioctl    = (vfs_ioctl_t)dummy,
+    .dup      = (vfs_dup_t)dummy,
+    .delete   = (vfs_del_t)dummy,
+    .rename   = (vfs_rename_t)dummy,
+    .poll     = (vfs_poll_t)dummy,
+    .map      = memfd_map,
+    .free     = memfd_free,
+    .chmod    = (vfs_chmod_t)dummy,
+    .mknod    = (vfs_mknod_t)dummy,
+};
+
+void memfd_setup() {
+    memfd_fsid = vfs_regist("memfdfs", &memfd_callbacks, 0x45564644, FS_VIRTUAL_FLAGS);
+    if (memfd_fsid == -EINVAL) {
+        kerror("eventfdfs regist error.");
+    }
+}
diff --git a/src/fs/procfs/procfs.c b/src/fs/procfs/procfs.c
@@ -108,7 +108,6 @@ size_t procfs_self_readlink(vfs_node_t file, void *addr, size_t offset, size_t s
         return 0;
     if (offset >= strlen(file->linkto->name))
         return 0;
-    logkf("procfs: readlink offset:%llu size:%llu", offset, size);
     char *ptr   = file->linkto->name + offset;
     ssize_t len = strlen(ptr);
     len         = MIN(len, (ssize_t)size);
diff --git a/src/fs/vfs.c b/src/fs/vfs.c
@@ -614,7 +614,7 @@ void vfs_deinit() {
 static _Atomic size_t inode_now = 0;
 
 vfs_node_t vfs_node_alloc(vfs_node_t parent, const char *name) {
-    vfs_node_t node = malloc(sizeof(struct vfs_node));
+    const vfs_node_t node = malloc(sizeof(struct vfs_node));
     not_null_assert(node, "vfs alloc null");
     if (unlikely(node == NULL))
         return NULL;
@@ -1098,7 +1098,7 @@ void *general_map(
 
     ssize_t ret = read_callback(file, (void *)addr, offset, len);
     if (ret < 0)
-        return (void *)-ENOMEM;
+        return (void*)ret;
 
     if ((uint64_t)ret < len) {
         memset((void *)(addr + (uint64_t)ret), 0, len - (uint64_t)ret);
diff --git a/src/include/fs/memfd.h b/src/include/fs/memfd.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#define MFD_CLOEXEC       0x0001U
+#define MFD_ALLOW_SEALING 0x0002U
+#define MFD_HUGETLB       0x0004U
+#define MFD_NOEXEC_SEAL   0x0008U
+#define MFD_EXEC          0x0010U
+
+#include "fs/vfs.h"
+#include "lock.h"
+
+struct memfd_ctx {
+    vfs_node_t node;
+    char name[64];
+    uint8_t *data;
+    size_t len;
+    int flags;
+    spin_t lock;
+};
+
+void memfd_setup();
diff --git a/src/include/mem/alloc.h b/src/include/mem/alloc.h
@@ -3,15 +3,30 @@
 #include "types.h"
 
 typedef enum HeapError {
-    InvalidFree,
-    LayoutError,
+  InvalidFree,
+  LayoutError,
 } HeapError;
 
 /**
  * Type alias for the error handler function pointer.
  */
 typedef void (*ErrorHandler)(enum HeapError error, void *ptr);
 
+typedef struct MemorySpan {
+  /**
+   * Pointer to the start of the new memory block.
+   * Must be non-null and properly aligned if the system requires it.
+   */
+  uint8_t *ptr;
+  /**
+   * The size of the memory block in bytes.
+   * If `size` is 0, the allocator considers the OOM handling failed.
+   */
+  size_t size;
+} MemorySpan;
+
+typedef struct MemorySpan (*OomCallback)(size_t);
+
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
@@ -24,6 +39,13 @@ extern "C" {
  * Any pointers allocated before the reset will become "leaked" (safe to use,
  * but calling free() on them later is Undefined Behavior/Double Free because
  * the new allocator doesn't know about them).
+ *
+ * # Safety
+ * - `address` must be a valid pointer to the start of a contiguous, writable memory block.
+ * - `size` must be the correct size of that memory block in bytes.
+ * - The memory range `[address, address + size)` must be exclusively available to the allocator
+ *   (it must not be accessed or modified by other code while managed by the allocator).
+ * - Thread safety is handled internally by the allocator lock.
  */
 bool heap_init(uint8_t *address, size_t size);
 
@@ -47,10 +69,29 @@ bool heap_extend(uint8_t *address, size_t size);
  */
 void heap_onerror(ErrorHandler handler);
 
+/**
+ * Registers a custom Out-Of-Memory (OOM) handler.
+ *
+ * # Purpose
+ * This handler acts as a hook that is triggered when the allocator **runs out of memory**.
+ * It provides a mechanism to **automatically extend the heap** on demand.
+ *
+ * Instead of immediately returning `NULL` when the heap is full, the allocator will:
+ * 1. Call this function.
+ * 2. If this function returns a valid new memory span, the allocator adds it to the heap.
+ * 3. The allocator retries the original allocation request.
+ *
+ * # Safety
+ * - The `callback` function pointer must be valid and callable.
+ * - The callback implementation must ensure the returned memory is valid and not already in use.
+ * - The callback itself must be thread-safe if the allocator is accessed concurrently.
+ */
+void heap_set_oom_handler(OomCallback callback);
+
 /**
  * Returns the usable size of the memory block pointed to by `ptr`.
- * This corresponds to the size originally requested during allocation (`malloc`, `aligned_alloc`,
- * `realloc`). Returns 0 if `ptr` is null.
+ * This corresponds to the size originally requested during allocation (`malloc`, `aligned_alloc`, `realloc`).
+ * Returns 0 if `ptr` is null.
  *
  * # Safety
  * - `ptr` must be null or a pointer previously returned by `malloc`, `realloc`,
@@ -117,5 +158,5 @@ void free(void *ptr);
 void *realloc(void *ptr, size_t size);
 
 #ifdef __cplusplus
-} // extern "C"
-#endif // __cplusplus
+}  // extern "C"
+#endif  // __cplusplus
diff --git a/src/include/syscall.h b/src/include/syscall.h
@@ -459,6 +459,7 @@ syscall_(utimensat, int dfd, const char *pathname, struct timespec *ntimes, int
 syscall_(futimensat, int dfd, const char *pathname, struct timeval *utimes);
 syscall_(umask, uint64_t mask);
 syscall_(sync);
+syscall_(memfd_create, const char *name, unsigned int flags);
 
 // socket syscall
 syscall_(socket, int domain, int type, int protocol);
diff --git a/src/mem/heap/heap.c b/src/mem/heap/heap.c
@@ -6,6 +6,8 @@
 #include "task/scheduler.h"
 #include "term/klog.h"
 
+static uint64_t base_addr = KERNEL_HEAP_START;
+
 #if !(defined(__x86_64__) || defined(__amd64__))
 
 static void *heap_alloc(void *ptr, size_t size);
@@ -281,6 +283,15 @@ void *pvalloc(size_t size) {
 
 #else
 
+static MemorySpan heap_oom_alloc(size_t size) {
+    const size_t allocate_size = MAX(PADDING_UP(size, PAGE_SIZE), KERNEL_HEAP_SIZE);
+    const uint64_t ptr         = base_addr;
+    base_addr += allocate_size;
+    page_map_range_to_random(get_kernel_pagedir(), ptr, allocate_size, KERNEL_PTE_FLAGS);
+    logkf("oom alloc: size=%llu %#p\n\r", allocate_size, ptr);
+    return (MemorySpan){ .ptr = (uint8_t *)ptr, .size = allocate_size };
+}
+
 static void heap_error_handler(const HeapError error, void *ptr) {
     switch (error) {
     case InvalidFree:
@@ -297,12 +308,13 @@ static void heap_error_handler(const HeapError error, void *ptr) {
 #endif
 
 void init_heap() {
-    uint64_t base_addr = KERNEL_HEAP_START;
     logkf("kernel_heap: init heap at %p - size: %llu\n", base_addr, KERNEL_HEAP_SIZE);
     page_map_range_to_random(get_kernel_pagedir(), base_addr, KERNEL_HEAP_SIZE, KERNEL_PTE_FLAGS);
 #if defined(__x86_64__) || defined(__amd64__)
     heap_init((void *)base_addr, KERNEL_HEAP_SIZE);
     heap_onerror(heap_error_handler);
+    heap_set_oom_handler(heap_oom_alloc);
+    base_addr += KERNEL_HEAP_SIZE;
 #else
     mpool_init(&pool, (void *)base_addr, KERNEL_HEAP_SIZE);
 #endif
