硬盘支持（FAT32）

clks/include/clks/disk.h

@@ -0,0 +1,38 @@
+#ifndef CLKS_DISK_H
+#define CLKS_DISK_H
+
+#include <clks/types.h>
+
+#define CLKS_DISK_SECTOR_SIZE 512ULL
+#define CLKS_DISK_PATH_MAX 192U
+#define CLKS_DISK_NODE_FILE 1ULL
+#define CLKS_DISK_NODE_DIR 2ULL
+
+void clks_disk_init(void);
+
+clks_bool clks_disk_present(void);
+u64 clks_disk_size_bytes(void);
+u64 clks_disk_sector_count(void);
+
+clks_bool clks_disk_read_sector(u64 lba, void *out_sector);
+clks_bool clks_disk_write_sector(u64 lba, const void *sector_data);
+
+clks_bool clks_disk_is_formatted_fat32(void);
+clks_bool clks_disk_format_fat32(const char *label);
+
+clks_bool clks_disk_mount(const char *mount_path);
+clks_bool clks_disk_is_mounted(void);
+const char *clks_disk_mount_path(void);
+clks_bool clks_disk_path_in_mount(const char *path);
+
+clks_bool clks_disk_stat(const char *path, u64 *out_type, u64 *out_size);
+const void *clks_disk_read_all(const char *path, u64 *out_size);
+u64 clks_disk_count_children(const char *dir_path);
+clks_bool clks_disk_get_child_name(const char *dir_path, u64 index, char *out_name, usize out_name_size);
+clks_bool clks_disk_mkdir(const char *path);
+clks_bool clks_disk_write_all(const char *path, const void *data, u64 size);
+clks_bool clks_disk_append(const char *path, const void *data, u64 size);
+clks_bool clks_disk_remove(const char *path);
+u64 clks_disk_node_count(void);
+
+#endif

clks/include/clks/syscall.h

@@ -88,6 +88,14 @@
 #define CLKS_SYSCALL_FB_BLIT 82ULL
 #define CLKS_SYSCALL_FB_CLEAR 83ULL
 #define CLKS_SYSCALL_KERNEL_VERSION 84ULL
+#define CLKS_SYSCALL_DISK_PRESENT 85ULL
+#define CLKS_SYSCALL_DISK_SIZE_BYTES 86ULL
+#define CLKS_SYSCALL_DISK_SECTOR_COUNT 87ULL
+#define CLKS_SYSCALL_DISK_FORMATTED 88ULL
+#define CLKS_SYSCALL_DISK_FORMAT_FAT32 89ULL
+#define CLKS_SYSCALL_DISK_MOUNT 90ULL
+#define CLKS_SYSCALL_DISK_MOUNTED 91ULL
+#define CLKS_SYSCALL_DISK_MOUNT_PATH 92ULL
 
 void clks_syscall_init(void);
 u64 clks_syscall_dispatch(void *frame_ptr);

clks/kernel/runtime/syscall.c

@@ -1,5 +1,6 @@
 #include <clks/cpu.h>
 #include <clks/audio.h>
+#include <clks/disk.h>
 #include <clks/exec.h>
 #include <clks/framebuffer.h>
 #include <clks/fs.h>
@@ -36,7 +37,7 @@
 #define CLKS_SYSCALL_KDBG_STACK_WINDOW_BYTES (128ULL * 1024ULL)
 #define CLKS_SYSCALL_KERNEL_SYMBOL_FILE "/system/kernel.sym"
 #define CLKS_SYSCALL_KERNEL_ADDR_BASE 0xFFFF800000000000ULL
-#define CLKS_SYSCALL_STATS_MAX_ID CLKS_SYSCALL_KERNEL_VERSION
+#define CLKS_SYSCALL_STATS_MAX_ID CLKS_SYSCALL_DISK_MOUNT_PATH
 #define CLKS_SYSCALL_STATS_RING_SIZE 256U
 #define CLKS_SYSCALL_USC_MAX_ALLOWED_APPS 64U
 
@@ -479,6 +480,56 @@ static u64 clks_syscall_kernel_version(u64 arg0, u64 arg1) {
     return clks_syscall_copy_text_to_user(arg0, arg1, CLKS_VERSION_STRING, len);
 }
 
+static u64 clks_syscall_disk_present(void) {
+    return (clks_disk_present() == CLKS_TRUE) ? 1ULL : 0ULL;
+}
+
+static u64 clks_syscall_disk_size_bytes(void) {
+    return clks_disk_size_bytes();
+}
+
+static u64 clks_syscall_disk_sector_count(void) {
+    return clks_disk_sector_count();
+}
+
+static u64 clks_syscall_disk_formatted(void) {
+    return (clks_disk_is_formatted_fat32() == CLKS_TRUE) ? 1ULL : 0ULL;
+}
+
+static u64 clks_syscall_disk_format_fat32(u64 arg0) {
+    char label[16];
+
+    if (clks_syscall_copy_user_optional_string(arg0, label, sizeof(label)) == CLKS_FALSE) {
+        return 0ULL;
+    }
+
+    return (clks_disk_format_fat32((label[0] != '\0') ? label : CLKS_NULL) == CLKS_TRUE) ? 1ULL : 0ULL;
+}
+
+static u64 clks_syscall_disk_mount(u64 arg0) {
+    char path[CLKS_SYSCALL_PATH_MAX];
+
+    if (clks_syscall_copy_user_string(arg0, path, sizeof(path)) == CLKS_FALSE) {
+        return 0ULL;
+    }
+
+    return (clks_disk_mount(path) == CLKS_TRUE) ? 1ULL : 0ULL;
+}
+
+static u64 clks_syscall_disk_mounted(void) {
+    return (clks_disk_is_mounted() == CLKS_TRUE) ? 1ULL : 0ULL;
+}
+
+static u64 clks_syscall_disk_mount_path(u64 arg0, u64 arg1) {
+    const char *mount_path = clks_disk_mount_path();
+
+    if (mount_path == CLKS_NULL || mount_path[0] == '\0') {
+        return 0ULL;
+    }
+
+    return clks_syscall_copy_text_to_user(arg0, arg1, mount_path, clks_strlen(mount_path));
+}
+
 static u64 clks_syscall_fd_open(u64 arg0, u64 arg1, u64 arg2) {
     char path[CLKS_SYSCALL_PATH_MAX];
 
@@ -1994,6 +2045,22 @@ static const char *clks_syscall_usc_syscall_name(u64 id) {
         return "SHUTDOWN";
     case CLKS_SYSCALL_RESTART:
         return "RESTART";
+    case CLKS_SYSCALL_DISK_PRESENT:
+        return "DISK_PRESENT";
+    case CLKS_SYSCALL_DISK_SIZE_BYTES:
+        return "DISK_SIZE_BYTES";
+    case CLKS_SYSCALL_DISK_SECTOR_COUNT:
+        return "DISK_SECTOR_COUNT";
+    case CLKS_SYSCALL_DISK_FORMATTED:
+        return "DISK_FORMATTED";
+    case CLKS_SYSCALL_DISK_FORMAT_FAT32:
+        return "DISK_FORMAT_FAT32";
+    case CLKS_SYSCALL_DISK_MOUNT:
+        return "DISK_MOUNT";
+    case CLKS_SYSCALL_DISK_MOUNTED:
+        return "DISK_MOUNTED";
+    case CLKS_SYSCALL_DISK_MOUNT_PATH:
+        return "DISK_MOUNT_PATH";
     default:
         return "UNKNOWN";
     }
@@ -2025,6 +2092,8 @@ static clks_bool clks_syscall_usc_is_dangerous(u64 id) {
         return (CLKS_CFG_USC_SC_SHUTDOWN != 0) ? CLKS_TRUE : CLKS_FALSE;
     case CLKS_SYSCALL_RESTART:
         return (CLKS_CFG_USC_SC_RESTART != 0) ? CLKS_TRUE : CLKS_FALSE;
+    case CLKS_SYSCALL_DISK_FORMAT_FAT32:
+        return CLKS_TRUE;
     default:
         return CLKS_FALSE;
     }
@@ -2528,6 +2597,22 @@ u64 clks_syscall_dispatch(void *frame_ptr) {
         return clks_syscall_fb_clear(frame->rbx);
     case CLKS_SYSCALL_KERNEL_VERSION:
         return clks_syscall_kernel_version(frame->rbx, frame->rcx);
+    case CLKS_SYSCALL_DISK_PRESENT:
+        return clks_syscall_disk_present();
+    case CLKS_SYSCALL_DISK_SIZE_BYTES:
+        return clks_syscall_disk_size_bytes();
+    case CLKS_SYSCALL_DISK_SECTOR_COUNT:
+        return clks_syscall_disk_sector_count();
+    case CLKS_SYSCALL_DISK_FORMATTED:
+        return clks_syscall_disk_formatted();
+    case CLKS_SYSCALL_DISK_FORMAT_FAT32:
+        return clks_syscall_disk_format_fat32(frame->rbx);
+    case CLKS_SYSCALL_DISK_MOUNT:
+        return clks_syscall_disk_mount(frame->rbx);
+    case CLKS_SYSCALL_DISK_MOUNTED:
+        return clks_syscall_disk_mounted();
+    case CLKS_SYSCALL_DISK_MOUNT_PATH:
+        return clks_syscall_disk_mount_path(frame->rbx, frame->rcx);
     default:
         return (u64)-1;
     }

clks/kernel/storage/fs.c

@@ -1,4 +1,5 @@
 #include <clks/boot.h>
+#include <clks/disk.h>
 #include <clks/fs.h>
 #include <clks/heap.h>
 #include <clks/log.h>
@@ -515,6 +516,14 @@ void clks_fs_init(void) {
     clks_log_hex(CLKS_LOG_INFO, "FS", "NODE_COUNT", (u64)clks_fs_nodes_used);
     clks_log_hex(CLKS_LOG_INFO, "FS", "FILE_COUNT", stats.file_count);
 
+    clks_disk_init();
+    if (clks_disk_present() == CLKS_TRUE) {
+        clks_log_hex(CLKS_LOG_INFO, "FS", "DISK_BYTES", clks_disk_size_bytes());
+        clks_log_hex(CLKS_LOG_INFO, "FS", "DISK_FAT32", (clks_disk_is_formatted_fat32() == CLKS_TRUE) ? 1ULL : 0ULL);
+    } else {
+        clks_log(CLKS_LOG_WARN, "FS", "DISK BACKEND NOT PRESENT");
+    }
+
     if (clks_fs_require_directory("/system") == CLKS_FALSE) {
         return;
     }
@@ -545,11 +554,23 @@ clks_bool clks_fs_is_ready(void) {
 
 clks_bool clks_fs_stat(const char *path, struct clks_fs_node_info *out_info) {
     i32 node_index;
+    u64 disk_type = 0ULL;
+    u64 disk_size = 0ULL;
 
     if (clks_fs_ready == CLKS_FALSE || out_info == CLKS_NULL) {
         return CLKS_FALSE;
     }
 
+    if (clks_disk_path_in_mount(path) == CLKS_TRUE) {
+        if (clks_disk_stat(path, &disk_type, &disk_size) == CLKS_FALSE) {
+            return CLKS_FALSE;
+        }
+
+        out_info->type = (disk_type == CLKS_DISK_NODE_DIR) ? CLKS_FS_NODE_DIR : CLKS_FS_NODE_FILE;
+        out_info->size = disk_size;
+        return CLKS_TRUE;
+    }
+
     node_index = clks_fs_find_node_by_external(path);
 
     if (node_index < 0) {
@@ -563,11 +584,17 @@ clks_bool clks_fs_stat(const char *path, struct clks_fs_node_info *out_info) {
 
 const void *clks_fs_read_all(const char *path, u64 *out_size) {
     i32 node_index;
+    const void *disk_data;
 
     if (clks_fs_ready == CLKS_FALSE) {
         return CLKS_NULL;
     }
 
+    if (clks_disk_path_in_mount(path) == CLKS_TRUE) {
+        disk_data = clks_disk_read_all(path, out_size);
+        return disk_data;
+    }
+
     node_index = clks_fs_find_node_by_external(path);
 
     if (node_index < 0) {
@@ -598,6 +625,10 @@ u64 clks_fs_count_children(const char *dir_path) {
         return 0ULL;
     }
 
+    if (clks_disk_path_in_mount(dir_path) == CLKS_TRUE) {
+        return clks_disk_count_children(dir_path);
+    }
+
     dir_index = clks_fs_find_node_by_external(dir_path);
 
     if (dir_index < 0) {
@@ -634,6 +665,10 @@ clks_bool clks_fs_get_child_name(const char *dir_path, u64 index, char *out_name
         return CLKS_FALSE;
     }
 
+    if (clks_disk_path_in_mount(dir_path) == CLKS_TRUE) {
+        return clks_disk_get_child_name(dir_path, index, out_name, out_name_size);
+    }
+
     dir_index = clks_fs_find_node_by_external(dir_path);
 
     if (dir_index < 0 || clks_fs_nodes[(u16)dir_index].type != CLKS_FS_NODE_DIR) {
@@ -683,6 +718,10 @@ clks_bool clks_fs_mkdir(const char *path) {
         return CLKS_FALSE;
     }
 
+    if (clks_disk_path_in_mount(path) == CLKS_TRUE) {
+        return clks_disk_mkdir(path);
+    }
+
     if (clks_fs_normalize_external_path(path, internal, sizeof(internal)) == CLKS_FALSE) {
         return CLKS_FALSE;
     }
@@ -720,6 +759,10 @@ clks_bool clks_fs_write_all(const char *path, const void *data, u64 size) {
         return CLKS_FALSE;
     }
 
+    if (clks_disk_path_in_mount(path) == CLKS_TRUE) {
+        return clks_disk_write_all(path, data, size);
+    }
+
     if (clks_fs_normalize_external_path(path, internal, sizeof(internal)) == CLKS_FALSE) {
         return CLKS_FALSE;
     }
@@ -785,6 +828,10 @@ clks_bool clks_fs_append(const char *path, const void *data, u64 size) {
         return CLKS_FALSE;
     }
 
+    if (clks_disk_path_in_mount(path) == CLKS_TRUE) {
+        return clks_disk_append(path, data, size);
+    }
+
     if (size > 0ULL && data == CLKS_NULL) {
         return CLKS_FALSE;
     }
@@ -851,6 +898,10 @@ clks_bool clks_fs_remove(const char *path) {
         return CLKS_FALSE;
     }
 
+    if (clks_disk_path_in_mount(path) == CLKS_TRUE) {
+        return clks_disk_remove(path);
+    }
+
     if (clks_fs_normalize_external_path(path, internal, sizeof(internal)) == CLKS_FALSE) {
         return CLKS_FALSE;
     }
@@ -908,5 +959,9 @@ u64 clks_fs_node_count(void) {
         }
     }
 
+    if (clks_disk_is_mounted() == CLKS_TRUE) {
+        used += clks_disk_node_count();
+    }
+
     return used;
 }