Stage 6

clks/kernel/fs.c

@@ -0,0 +1,572 @@
+#include <clks/boot.h>
+#include <clks/fs.h>
+#include <clks/log.h>
+#include <clks/ramdisk.h>
+#include <clks/string.h>
+#include <clks/types.h>
+
+#define CLKS_FS_MAX_NODES 512U
+#define CLKS_FS_PATH_MAX  CLKS_RAMDISK_PATH_MAX
+
+struct clks_fs_node {
+    clks_bool used;
+    enum clks_fs_node_type type;
+    u16 parent;
+    u16 reserved;
+    const void *data;
+    u64 size;
+    char path[CLKS_FS_PATH_MAX];
+};
+
+struct clks_fs_build_stats {
+    u64 file_count;
+    u64 dir_count;
+};
+
+static struct clks_fs_node clks_fs_nodes[CLKS_FS_MAX_NODES];
+static u16 clks_fs_nodes_used = 0U;
+static clks_bool clks_fs_ready = CLKS_FALSE;
+
+static clks_bool clks_fs_normalize_external_path(const char *path, char *out_internal, usize out_size) {
+    usize in_pos = 0;
+    usize out_pos = 0;
+
+    if (path == CLKS_NULL || out_internal == CLKS_NULL || out_size == 0U) {
+        return CLKS_FALSE;
+    }
+
+    if (path[0] != '/') {
+        return CLKS_FALSE;
+    }
+
+    while (path[in_pos] == '/') {
+        in_pos++;
+    }
+
+    while (path[in_pos] != '\0') {
+        usize comp_start = in_pos;
+        usize comp_len;
+
+        while (path[in_pos] != '\0' && path[in_pos] != '/') {
+            in_pos++;
+        }
+
+        comp_len = in_pos - comp_start;
+
+        if (comp_len == 0U) {
+            while (path[in_pos] == '/') {
+                in_pos++;
+            }
+            continue;
+        }
+
+        if (comp_len == 1U && path[comp_start] == '.') {
+            while (path[in_pos] == '/') {
+                in_pos++;
+            }
+            continue;
+        }
+
+        if (comp_len == 2U && path[comp_start] == '.' && path[comp_start + 1U] == '.') {
+            return CLKS_FALSE;
+        }
+
+        if (out_pos != 0U) {
+            if (out_pos + 1U >= out_size) {
+                return CLKS_FALSE;
+            }
+            out_internal[out_pos++] = '/';
+        }
+
+        if (out_pos + comp_len >= out_size) {
+            return CLKS_FALSE;
+        }
+
+        clks_memcpy(out_internal + out_pos, path + comp_start, comp_len);
+        out_pos += comp_len;
+
+        while (path[in_pos] == '/') {
+            in_pos++;
+        }
+    }
+
+    out_internal[out_pos] = '\0';
+    return CLKS_TRUE;
+}
+
+static i32 clks_fs_find_node_by_internal(const char *internal_path) {
+    u16 i;
+
+    for (i = 0U; i < clks_fs_nodes_used; i++) {
+        if (clks_fs_nodes[i].used == CLKS_FALSE) {
+            continue;
+        }
+
+        if (clks_strcmp(clks_fs_nodes[i].path, internal_path) == 0) {
+            return (i32)i;
+        }
+    }
+
+    return -1;
+}
+
+static i32 clks_fs_find_node_by_external(const char *external_path) {
+    char internal[CLKS_FS_PATH_MAX];
+
+    if (clks_fs_normalize_external_path(external_path, internal, sizeof(internal)) == CLKS_FALSE) {
+        return -1;
+    }
+
+    return clks_fs_find_node_by_internal(internal);
+}
+
+static const char *clks_fs_basename(const char *internal_path) {
+    usize len;
+    usize i;
+
+    if (internal_path == CLKS_NULL) {
+        return "";
+    }
+
+    len = clks_strlen(internal_path);
+
+    if (len == 0U) {
+        return "";
+    }
+
+    for (i = len; i != 0U; i--) {
+        if (internal_path[i - 1U] == '/') {
+            return &internal_path[i];
+        }
+    }
+
+    return internal_path;
+}
+
+static clks_bool clks_fs_split_parent(const char *internal_path, char *parent_out, usize parent_out_size) {
+    usize len;
+    usize i;
+
+    if (internal_path == CLKS_NULL || parent_out == CLKS_NULL || parent_out_size == 0U) {
+        return CLKS_FALSE;
+    }
+
+    len = clks_strlen(internal_path);
+
+    if (len == 0U) {
+        parent_out[0] = '\0';
+        return CLKS_TRUE;
+    }
+
+    for (i = len; i != 0U; i--) {
+        if (internal_path[i - 1U] == '/') {
+            usize parent_len = i - 1U;
+
+            if (parent_len >= parent_out_size) {
+                return CLKS_FALSE;
+            }
+
+            clks_memcpy(parent_out, internal_path, parent_len);
+            parent_out[parent_len] = '\0';
+            return CLKS_TRUE;
+        }
+    }
+
+    parent_out[0] = '\0';
+    return CLKS_TRUE;
+}
+
+static i32 clks_fs_create_or_update_node(const char *internal_path,
+                                         enum clks_fs_node_type type,
+                                         u16 parent,
+                                         const void *data,
+                                         u64 size) {
+    i32 existing;
+    usize path_len;
+
+    if (internal_path == CLKS_NULL) {
+        return -1;
+    }
+
+    path_len = clks_strlen(internal_path);
+
+    if (path_len >= CLKS_FS_PATH_MAX) {
+        return -1;
+    }
+
+    existing = clks_fs_find_node_by_internal(internal_path);
+
+    if (existing >= 0) {
+        struct clks_fs_node *node = &clks_fs_nodes[(u16)existing];
+
+        if (node->type != type) {
+            return -1;
+        }
+
+        node->parent = parent;
+
+        if (type == CLKS_FS_NODE_FILE) {
+            node->data = data;
+            node->size = size;
+        }
+
+        return existing;
+    }
+
+    if (clks_fs_nodes_used >= CLKS_FS_MAX_NODES) {
+        return -1;
+    }
+
+    clks_fs_nodes[clks_fs_nodes_used].used = CLKS_TRUE;
+    clks_fs_nodes[clks_fs_nodes_used].type = type;
+    clks_fs_nodes[clks_fs_nodes_used].parent = parent;
+    clks_fs_nodes[clks_fs_nodes_used].reserved = 0U;
+    clks_fs_nodes[clks_fs_nodes_used].data = (type == CLKS_FS_NODE_FILE) ? data : CLKS_NULL;
+    clks_fs_nodes[clks_fs_nodes_used].size = (type == CLKS_FS_NODE_FILE) ? size : 0ULL;
+    clks_memcpy(clks_fs_nodes[clks_fs_nodes_used].path, internal_path, path_len + 1U);
+
+    clks_fs_nodes_used++;
+    return (i32)(clks_fs_nodes_used - 1U);
+}
+
+static clks_bool clks_fs_ensure_root(void) {
+    if (clks_fs_create_or_update_node("", CLKS_FS_NODE_DIR, 0U, CLKS_NULL, 0ULL) != 0) {
+        return CLKS_FALSE;
+    }
+
+    return CLKS_TRUE;
+}
+
+static clks_bool clks_fs_ensure_dir_hierarchy(const char *internal_dir_path) {
+    char prefix[CLKS_FS_PATH_MAX];
+    usize cursor = 0;
+    usize i = 0;
+    u16 current_parent = 0U;
+
+    prefix[0] = '\0';
+
+    if (internal_dir_path == CLKS_NULL) {
+        return CLKS_FALSE;
+    }
+
+    if (internal_dir_path[0] == '\0') {
+        return CLKS_TRUE;
+    }
+
+    while (internal_dir_path[i] != '\0') {
+        usize comp_start = i;
+        usize comp_len;
+        i32 node_index;
+
+        while (internal_dir_path[i] != '\0' && internal_dir_path[i] != '/') {
+            i++;
+        }
+
+        comp_len = i - comp_start;
+
+        if (comp_len == 0U) {
+            return CLKS_FALSE;
+        }
+
+        if (cursor != 0U) {
+            if (cursor + 1U >= sizeof(prefix)) {
+                return CLKS_FALSE;
+            }
+            prefix[cursor++] = '/';
+        }
+
+        if (cursor + comp_len >= sizeof(prefix)) {
+            return CLKS_FALSE;
+        }
+
+        clks_memcpy(prefix + cursor, internal_dir_path + comp_start, comp_len);
+        cursor += comp_len;
+        prefix[cursor] = '\0';
+
+        node_index = clks_fs_find_node_by_internal(prefix);
+
+        if (node_index < 0) {
+            node_index = clks_fs_create_or_update_node(prefix, CLKS_FS_NODE_DIR, current_parent, CLKS_NULL, 0ULL);
+
+            if (node_index < 0) {
+                return CLKS_FALSE;
+            }
+        } else if (clks_fs_nodes[(u16)node_index].type != CLKS_FS_NODE_DIR) {
+            return CLKS_FALSE;
+        }
+
+        current_parent = (u16)node_index;
+
+        if (internal_dir_path[i] == '/') {
+            i++;
+        }
+    }
+
+    return CLKS_TRUE;
+}
+
+static clks_bool clks_fs_require_directory(const char *external_path) {
+    i32 node_index = clks_fs_find_node_by_external(external_path);
+
+    if (node_index < 0) {
+        clks_log(CLKS_LOG_ERROR, "FS", "MISSING REQUIRED DIRECTORY");
+        clks_log(CLKS_LOG_ERROR, "FS", external_path);
+        return CLKS_FALSE;
+    }
+
+    if (clks_fs_nodes[(u16)node_index].type != CLKS_FS_NODE_DIR) {
+        clks_log(CLKS_LOG_ERROR, "FS", "REQUIRED PATH IS NOT DIRECTORY");
+        clks_log(CLKS_LOG_ERROR, "FS", external_path);
+        return CLKS_FALSE;
+    }
+
+    return CLKS_TRUE;
+}
+
+static clks_bool clks_fs_ramdisk_visit(const struct clks_ramdisk_entry *entry, void *ctx) {
+    struct clks_fs_build_stats *stats = (struct clks_fs_build_stats *)ctx;
+
+    if (entry == CLKS_NULL || stats == CLKS_NULL) {
+        return CLKS_FALSE;
+    }
+
+    if (entry->type == CLKS_RAMDISK_ENTRY_DIR) {
+        if (clks_fs_ensure_dir_hierarchy(entry->path) == CLKS_FALSE) {
+            return CLKS_FALSE;
+        }
+
+        stats->dir_count++;
+        return CLKS_TRUE;
+    }
+
+    if (entry->type == CLKS_RAMDISK_ENTRY_FILE) {
+        char parent[CLKS_FS_PATH_MAX];
+        i32 parent_index;
+
+        if (clks_fs_split_parent(entry->path, parent, sizeof(parent)) == CLKS_FALSE) {
+            return CLKS_FALSE;
+        }
+
+        if (clks_fs_ensure_dir_hierarchy(parent) == CLKS_FALSE) {
+            return CLKS_FALSE;
+        }
+
+        parent_index = clks_fs_find_node_by_internal(parent);
+
+        if (parent_index < 0) {
+            return CLKS_FALSE;
+        }
+
+        if (clks_fs_create_or_update_node(entry->path,
+                                          CLKS_FS_NODE_FILE,
+                                          (u16)parent_index,
+                                          entry->data,
+                                          entry->size) < 0) {
+            return CLKS_FALSE;
+        }
+
+        stats->file_count++;
+        return CLKS_TRUE;
+    }
+
+    return CLKS_TRUE;
+}
+
+void clks_fs_init(void) {
+    const struct limine_file *module;
+    struct clks_fs_build_stats stats;
+    u64 module_count;
+
+    clks_fs_ready = CLKS_FALSE;
+    clks_fs_nodes_used = 0U;
+    clks_memset(clks_fs_nodes, 0, sizeof(clks_fs_nodes));
+    clks_memset(&stats, 0, sizeof(stats));
+
+    if (clks_fs_ensure_root() == CLKS_FALSE) {
+        clks_log(CLKS_LOG_ERROR, "FS", "FAILED TO CREATE ROOT NODE");
+        return;
+    }
+
+    module_count = clks_boot_get_module_count();
+
+    if (module_count == 0ULL) {
+        clks_log(CLKS_LOG_ERROR, "FS", "NO RAMDISK MODULE FROM LIMINE");
+        return;
+    }
+
+    module = clks_boot_get_module(0ULL);
+
+    if (module == CLKS_NULL || module->address == CLKS_NULL || module->size == 0ULL) {
+        clks_log(CLKS_LOG_ERROR, "FS", "INVALID RAMDISK MODULE");
+        return;
+    }
+
+    if (clks_ramdisk_iterate(module->address, module->size, clks_fs_ramdisk_visit, &stats) == CLKS_FALSE) {
+        clks_log(CLKS_LOG_ERROR, "FS", "RAMDISK TAR PARSE FAILED");
+        return;
+    }
+
+    clks_log(CLKS_LOG_INFO, "FS", "RAMDISK VFS ONLINE");
+    clks_log_hex(CLKS_LOG_INFO, "FS", "MODULE_SIZE", module->size);
+    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);
+
+    if (clks_fs_require_directory("/system") == CLKS_FALSE) {
+        return;
+    }
+
+    if (clks_fs_require_directory("/shell") == CLKS_FALSE) {
+        return;
+    }
+
+    if (clks_fs_require_directory("/temp") == CLKS_FALSE) {
+        return;
+    }
+
+    if (clks_fs_require_directory("/driver") == CLKS_FALSE) {
+        return;
+    }
+
+    clks_fs_ready = CLKS_TRUE;
+    clks_log(CLKS_LOG_INFO, "FS", "LAYOUT /SYSTEM /SHELL /TEMP /DRIVER OK");
+}
+
+clks_bool clks_fs_is_ready(void) {
+    return clks_fs_ready;
+}
+
+clks_bool clks_fs_stat(const char *path, struct clks_fs_node_info *out_info) {
+    i32 node_index;
+
+    if (clks_fs_ready == CLKS_FALSE || out_info == CLKS_NULL) {
+        return CLKS_FALSE;
+    }
+
+    node_index = clks_fs_find_node_by_external(path);
+
+    if (node_index < 0) {
+        return CLKS_FALSE;
+    }
+
+    out_info->type = clks_fs_nodes[(u16)node_index].type;
+    out_info->size = clks_fs_nodes[(u16)node_index].size;
+    return CLKS_TRUE;
+}
+
+const void *clks_fs_read_all(const char *path, u64 *out_size) {
+    i32 node_index;
+
+    if (clks_fs_ready == CLKS_FALSE) {
+        return CLKS_NULL;
+    }
+
+    node_index = clks_fs_find_node_by_external(path);
+
+    if (node_index < 0) {
+        return CLKS_NULL;
+    }
+
+    if (clks_fs_nodes[(u16)node_index].type != CLKS_FS_NODE_FILE) {
+        return CLKS_NULL;
+    }
+
+    if (out_size != CLKS_NULL) {
+        *out_size = clks_fs_nodes[(u16)node_index].size;
+    }
+
+    return clks_fs_nodes[(u16)node_index].data;
+}
+
+u64 clks_fs_count_children(const char *dir_path) {
+    i32 dir_index;
+    u64 count = 0ULL;
+    u16 i;
+
+    if (clks_fs_ready == CLKS_FALSE) {
+        return 0ULL;
+    }
+
+    dir_index = clks_fs_find_node_by_external(dir_path);
+
+    if (dir_index < 0) {
+        return 0ULL;
+    }
+
+    if (clks_fs_nodes[(u16)dir_index].type != CLKS_FS_NODE_DIR) {
+        return 0ULL;
+    }
+
+    for (i = 0U; i < clks_fs_nodes_used; i++) {
+        if (clks_fs_nodes[i].used == CLKS_FALSE) {
+            continue;
+        }
+
+        if ((u16)dir_index == i) {
+            continue;
+        }
+
+        if (clks_fs_nodes[i].parent == (u16)dir_index) {
+            count++;
+        }
+    }
+
+    return count;
+}
+
+clks_bool clks_fs_get_child_name(const char *dir_path, u64 index, char *out_name, usize out_name_size) {
+    i32 dir_index;
+    u64 current = 0ULL;
+    u16 i;
+
+    if (clks_fs_ready == CLKS_FALSE || out_name == CLKS_NULL || out_name_size == 0U) {
+        return CLKS_FALSE;
+    }
+
+    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) {
+        return CLKS_FALSE;
+    }
+
+    for (i = 0U; i < clks_fs_nodes_used; i++) {
+        const char *base;
+        usize base_len;
+
+        if (clks_fs_nodes[i].used == CLKS_FALSE) {
+            continue;
+        }
+
+        if ((u16)dir_index == i) {
+            continue;
+        }
+
+        if (clks_fs_nodes[i].parent != (u16)dir_index) {
+            continue;
+        }
+
+        if (current != index) {
+            current++;
+            continue;
+        }
+
+        base = clks_fs_basename(clks_fs_nodes[i].path);
+        base_len = clks_strlen(base);
+
+        if (base_len + 1U > out_name_size) {
+            return CLKS_FALSE;
+        }
+
+        clks_memcpy(out_name, base, base_len + 1U);
+        return CLKS_TRUE;
+    }
+
+    return CLKS_FALSE;
+}
+
+u64 clks_fs_node_count(void) {
+    if (clks_fs_ready == CLKS_FALSE) {
+        return 0ULL;
+    }
+
+    return (u64)clks_fs_nodes_used;
+}