修复 modfs 因为文件属性问题导致无法挂载 rootfs

xiaoyi1212 · xiaoyi1212 · commit 22216c234fff · 2026-03-11T18:12:12.000+08:00
diff --git a/module/squashfs/squashfs.c b/module/squashfs/squashfs.c
@@ -390,7 +390,6 @@ int squashfs_lookup_child(
 int squashfs_create_mount(
     const char *src, squashfs_mount_t **out, sqfs_inode_generic_t **root_inode, sqfs_u64 *root_ref
 ) {
-
     *out = NULL;
     if (root_inode != NULL) {
         *root_inode = NULL;
diff --git a/src/arch/x86_64/acpi/apic.c b/src/arch/x86_64/acpi/apic.c
@@ -8,18 +8,18 @@
 #include "term/klog.h"
 #include "timer.h"
 
-bool x2apic_mode = false;
-uint64_t lapic_address;
+static bool x2apic_mode = false;
+static uint64_t lapic_address;
 
-uint64_t calibrated_timer_initial = 0;
+static uint64_t calibrated_timer_initial = 0;
 
 static struct ioapic_info found_ioapics[MAX_IOAPICS];
 static struct iso_info found_isos[MAX_ISO];
 
 static size_t found_iso_count    = 0;
 static size_t found_ioapic_count = 0;
 
-void disable_pic() {
+static void disable_pic() {
     io_out8(0x21, 0xff);
     io_out8(0xa1, 0xff);
 
@@ -35,19 +35,19 @@ void lapic_write(uint32_t reg, uint32_t value) {
         wrmsr(0x800 + (reg >> 4), value);
         return;
     }
-    *(volatile uint32_t *)((uint64_t)lapic_address + reg) = value;
+    *(volatile uint32_t *)(lapic_address + reg) = value;
 }
 
 uint32_t lapic_read(uint32_t reg) {
     if (x2apic_mode) {
         return rdmsr(0x800 + (reg >> 4));
     }
-    return *(volatile uint32_t *)((uint64_t)lapic_address + reg);
+    return *(volatile uint32_t *)(lapic_address + reg);
 }
 
 uint64_t lapic_id() {
     uint32_t phy_id = lapic_read(LAPIC_REG_ID);
-    return x2apic_mode ? phy_id : (phy_id >> 24);
+    return x2apic_mode ? phy_id : phy_id >> 24;
 }
 
 static void ioapic_mmio_write(uintptr_t base, uint32_t reg, uint32_t value) {
@@ -82,12 +82,13 @@ static struct ioapic_info *find_ioapic(uint32_t gsi) {
 
 void ioapic_add(uint8_t vector, uint32_t irq) {
     struct ioapic_info *io = find_ioapic(isa_irq_to_gsi(vector));
-    if (!io)
+    if (!io) {
         return;
+    }
 
-    uint32_t irq0     = irq - io->gsi_base;
-    uint32_t ioredtbl = 0x10 + irq0 * 2;
-    uint64_t redirect = vector | ((uint64_t)lapic_id() << 56);
+    const uint32_t irq0     = irq - io->gsi_base;
+    const uint32_t ioredtbl = 0x10 + irq0 * 2;
+    const uint64_t redirect = vector | lapic_id() << 56;
 
     ioapic_mmio_write(io->mmio_base, ioredtbl, (uint32_t)redirect);
     ioapic_mmio_write(io->mmio_base, ioredtbl + 1, (uint32_t)(redirect >> 32));
@@ -99,10 +100,10 @@ void ioapic_enable(uint8_t vector) {
         printk("Cannot found ioapic for vector %d gsi:%d ENABLE\n", vector, isa_irq_to_gsi(vector));
         return;
     }
-    uint64_t index = 0x10 + ((isa_irq_to_gsi(vector) - ioapic->gsi_base) * 2);
+    const uint64_t index = 0x10 + (isa_irq_to_gsi(vector) - ioapic->gsi_base) * 2;
     uint64_t value = (uint64_t)ioapic_mmio_read(ioapic->mmio_base, index + 1) << 32
                      | (uint64_t)ioapic_mmio_read(ioapic->mmio_base, index);
-    value &= (~0x10000UL);
+    value &= ~0x10000UL;
     ioapic_mmio_write(ioapic->mmio_base, index, (uint32_t)(value & 0xFFFFFFFF));
     ioapic_mmio_write(ioapic->mmio_base, index + 1, (uint32_t)(value >> 32));
 }
diff --git a/src/arch/x86_64/main.c b/src/arch/x86_64/main.c
@@ -138,7 +138,6 @@ USED _Noreturn void kmain() {
     extern void mount_modfs();
     extern errno_t mount_boot_rootfs();
     mount_modfs();
-    mount_boot_rootfs();
 
     init_console_symlink();
 
diff --git a/src/fs/fssys.c b/src/fs/fssys.c
@@ -548,20 +548,23 @@ syscall_(chdir, char *s) {
 }
 
 syscall_(fcntl, int fd, int cmd, uint64_t arg) {
-    if (fd < 0 || cmd < 0)
+    if (fd < 0 || cmd < 0) {
         return SYSCALL_FAULT_(EINVAL);
+    }
     fd_t *handle = get_fd(get_current_task()->process->fdts, fd);
-    if (handle == NULL)
+    if (handle == NULL) {
         return SYSCALL_FAULT_(EBADF);
+    }
 
     switch (cmd) {
     case F_GETFD:
-        return (handle->flags & O_CLOEXEC) ? 1 : 0;
+        return handle->flags & O_CLOEXEC ? 1 : 0;
     case F_SETFD:
-        if (arg & 1)
+        if (arg & 1) {
             handle->flags |= O_CLOEXEC;
-        else
+        } else {
             handle->flags &= ~O_CLOEXEC;
+        }
         return EOK;
     case F_DUPFD_CLOEXEC:
         return dup_with_minfd(handle, (int)arg, true);
@@ -570,7 +573,7 @@ syscall_(fcntl, int fd, int cmd, uint64_t arg) {
     case F_GETFL:
         return handle->flags;
     case F_SETFL:;
-        uint32_t valid_flags = O_APPEND | O_DIRECT | O_NOATIME | O_NONBLOCK;
+        const uint32_t valid_flags = O_APPEND | O_DIRECT | O_NOATIME | O_NONBLOCK;
         handle->flags &= ~valid_flags;
         handle->flags |= arg & valid_flags;
         handle->node->flags &= ~valid_flags;
@@ -587,8 +590,8 @@ syscall_(mount, char *dev_name, char *dir_name, char *type, uint64_t flags, void
         return SYSCALL_FAULT_(EINVAL);
     }
 
-    char *ndir_name = vfs_cwd_path_build(dir_name);
-    vfs_node_t dir  = vfs_open(ndir_name);
+    char *ndir_name      = vfs_cwd_path_build(dir_name);
+    const vfs_node_t dir = vfs_open(ndir_name);
     if (!dir) {
         free(ndir_name);
         return SYSCALL_FAULT_(ENOENT);
@@ -599,35 +602,39 @@ syscall_(mount, char *dev_name, char *dir_name, char *type, uint64_t flags, void
             free(ndir_name);
             return SYSCALL_FAULT_(EINVAL);
         }
-        char *old_root_p    = vfs_cwd_path_build(dev_name);
-        vfs_node_t old_root = vfs_open(old_root_p);
+        char *old_root_p          = vfs_cwd_path_build(dev_name);
+        const vfs_node_t old_root = vfs_open(old_root_p);
         free(old_root_p);
-        if (old_root == NULL || !old_root->is_mount)
+        if (old_root == NULL || !old_root->is_mount) {
             return SYSCALL_FAULT_(EINVAL);
-        if (dir != rootdir)
+        }
+        if (dir != rootdir) {
             list_append(dir->parent->child, old_root);
+        }
         char *nb       = old_root->name;
         old_root->name = dir->name;
         dir->name      = nb;
         list_append(old_root->parent->child, dir);
 
         list_delete(old_root->parent->child, old_root);
-        if (dir != rootdir)
+        if (dir != rootdir) {
             list_delete(dir->parent->child, dir);
-        else
+        } else {
             rootdir = old_root;
+        }
 
-        vfs_node_t parent = dir->parent;
-        dir->parent       = old_root->parent;
-        old_root->parent  = parent;
+        const vfs_node_t parent = dir->parent;
+        dir->parent             = old_root->parent;
+        old_root->parent        = parent;
 
         vfs_close(old_root);
         vfs_close(dir);
         return EOK;
     }
 
-    if (type == NULL)
+    if (type == NULL) {
         return SYSCALL_FAULT_(EINVAL);
+}
 
     char *ndev_name = vfs_cwd_path_build(dev_name);
     errno_t mret    = EOK;
@@ -636,8 +643,9 @@ syscall_(mount, char *dev_name, char *dir_name, char *type, uint64_t flags, void
     if (mret != EOK) {
         free(ndir_name);
         free(ndev_name);
-        if (mret < 0)
+        if (mret < 0) {
             return (uint64_t)mret;
+}
         return SYSCALL_FAULT_(EIO);
     }
     free(ndir_name);
@@ -647,12 +655,10 @@ syscall_(mount, char *dev_name, char *dir_name, char *type, uint64_t flags, void
 
 syscall_(poll, struct pollfd *fds_user, size_t nfds, size_t timeout) {
     int ready           = 0;
-    uint64_t start_time = nano_time();
+    const uint64_t start_time = nano_time();
     bool sigexit        = false;
-    tcb_t current       = get_current_task();
-    fdt_t *fdt          = current->process->fdts;
-
-    extern vfs_callback_t fs_callbacks[256];
+    const tcb_t current       = get_current_task();
+    const fdt_t *fdt          = current->process->fdts;
 
     do {
         ready = 0;
@@ -663,7 +669,8 @@ syscall_(poll, struct pollfd *fds_user, size_t nfds, size_t timeout) {
 
         // 检查每个文件描述符
         for (size_t i = 0; i < nfds; i++) {
-            fd_t *handle = get_fd(fdt, fds_user[i].fd);
+            extern vfs_callback_t fs_callbacks[256];
+            const fd_t *handle = get_fd(fdt, fds_user[i].fd);
             if (handle == NULL) {
                 fds_user[i].revents = POLLNVAL;
                 ready++;
diff --git a/src/fs/procfs/proc_dpatch.c b/src/fs/procfs/proc_dpatch.c
@@ -65,7 +65,7 @@ void load_procfs_root() {
 }
 
 size_t procfs_read_dispatch(proc_handle_t *handle, void *addr, size_t offset, size_t size) {
-    uint64_t hash = hash_dp(handle->name);
+    const uint64_t hash = hash_dp(handle->name);
     for (size_t i = 0; i < dp_index; i++) {
         if (hash == dispatch_array[i]->hash) {
             return dispatch_array[i]->read_entry(handle, addr, offset, size);
@@ -75,7 +75,7 @@ size_t procfs_read_dispatch(proc_handle_t *handle, void *addr, size_t offset, si
 }
 
 void procfs_stat_dispatch(proc_handle_t *handle, vfs_node_t node) {
-    uint64_t hash = hash_dp(handle->name);
+    const uint64_t hash = hash_dp(handle->name);
     for (size_t i = 0; i < dp_index; i++) {
         if (hash == dispatch_array[i]->hash) {
             node->size = dispatch_array[i]->stat_entry(handle);
diff --git a/src/fs/tmpfs.c b/src/fs/tmpfs.c
@@ -103,6 +103,8 @@ errno_t tmpfs_stat(void *file, vfs_node_t node) {
         return -ENOENT;
     node->type = file0->type == tp_file_symlink ? file_symlink
                  : file0->type == tp_file_dir   ? file_dir
+                 : file0->type == tp_file_blk   ? file_block
+                 : file0->type == tp_file_char  ? file_stream
                                                 : file_none;
     node->size = file0->type == file_dir ? 0 : file0->size;
     return EOK;
@@ -233,7 +235,7 @@ errno_t tmpfs_mknod(void *parent, const char *name, vfs_node_t node, uint16_t mo
         node->type   = file_block;
         handle->type = tp_file_blk;
     }
-    if ((mode & S_IFMT) == S_IFCHR) {
+    else if ((mode & S_IFMT) == S_IFCHR) {
         node->type   = file_stream;
         handle->type = tp_file_char;
     } else {
diff --git a/src/mod/module.c b/src/mod/module.c
@@ -1,6 +1,7 @@
 #include "mod/module.h"
 #include "boot.h"
 #include "errno.h"
+#include "fs/tmpfs.h"
 #include "fs/vfs.h"
 #include "krlibc.h"
 #include "mem/heap.h"
@@ -23,6 +24,10 @@ static const char *find_boot_rootfs_name(void) {
     return NULL;
 }
 
+static bool is_boot_rootfs_module(const char *name) {
+    return strcmp(name, "cp_rootfs") == 0 || strcmp(name, "rootfs") == 0;
+}
+
 void extract_name(const char *input, char *output, size_t output_size) {
     const char *name = strrchr(input, '/');
     if (!name) {
@@ -100,35 +105,11 @@ void mount_modfs() {
             continue;
         }
         vfs_write(mod_node, module0.data, 0, module0.size);
+        if (is_boot_rootfs_module(module0.name) && mod_node->handle != NULL) {
+            tmpfs_file_t *tmpfile = mod_node->handle;
+            tmpfile->type         = tp_file_blk;
+            mod_node->type        = file_block;
+            mod_node->mode        = 0644;
+        }
     }
 }
-
-errno_t mount_boot_rootfs() {
-    const char *rootfs_name = find_boot_rootfs_name();
-    if (rootfs_name == NULL) {
-        logkf("rootfs: boot module not found\n\r");
-        return -ENOENT;
-    }
-
-    char rootfs_path[64];
-    sprintf(rootfs_path, "/mod/%s", rootfs_name);
-
-    vfs_mkdir("/new_root");
-
-    vfs_node_t new_root = vfs_open("/new_root");
-    if (new_root == NULL) {
-        logkf("rootfs: cannot open /new_root\n\r");
-        return -ENOENT;
-    }
-
-    errno_t ret = vfs_mount(rootfs_path, "squashfs", new_root, NULL);
-    if (ret != EOK) {
-        logkf("rootfs: squashfs mount from %s failed: %d\n\r", rootfs_path, ret);
-        vfs_close(new_root);
-        return ret;
-    }
-
-    logkf("rootfs: mounted %s on /new_root\n\r", rootfs_path);
-    vfs_close(new_root);
-    return EOK;
-}
diff --git a/src/task/poll.c b/src/task/poll.c
@@ -314,6 +314,8 @@ syscall_(
     const uint64_t start_time = nano_time();
     int ready                 = 0;
 
+    arch_open_interrupt();
+    scheduler_enable();
     do {
         ready = 0;
         spin_lock(ep->lock);
@@ -356,7 +358,8 @@ syscall_(
         }
 
         scheduler_yield();
-    } while (timeout < 0 || (nano_time() - start_time) < (uint64_t)timeout * 1000000ULL);
+    } while (timeout < 0 || nano_time() - start_time < (uint64_t)timeout * 1000000ULL);
+    arch_close_interrupt();
 
     return 0;
 }
