代码分类

clks/kernel/storage/ramdisk.c

@@ -0,0 +1,221 @@
+#include <clks/compiler.h>
+#include <clks/ramdisk.h>
+#include <clks/string.h>
+#include <clks/types.h>
+
+#define CLKS_TAR_BLOCK_SIZE 512ULL
+
+struct clks_tar_header {
+    char name[100];
+    char mode[8];
+    char uid[8];
+    char gid[8];
+    char size[12];
+    char mtime[12];
+    char chksum[8];
+    char typeflag;
+    char linkname[100];
+    char magic[6];
+    char version[2];
+    char uname[32];
+    char gname[32];
+    char devmajor[8];
+    char devminor[8];
+    char prefix[155];
+    char pad[12];
+} CLKS_PACKED;
+
+static clks_bool clks_ramdisk_is_zero_block(const u8 *block) {
+    u64 i;
+
+    for (i = 0; i < CLKS_TAR_BLOCK_SIZE; i++) {
+        if (block[i] != 0U) {
+            return CLKS_FALSE;
+        }
+    }
+
+    return CLKS_TRUE;
+}
+
+static usize clks_ramdisk_field_len(const char *field, usize max_len) {
+    usize i = 0;
+
+    while (i < max_len && field[i] != '\0') {
+        i++;
+    }
+
+    return i;
+}
+
+static clks_bool clks_ramdisk_parse_octal_u64(const char *field, usize len, u64 *out_value) {
+    usize i = 0;
+    u64 value = 0ULL;
+
+    if (out_value == CLKS_NULL) {
+        return CLKS_FALSE;
+    }
+
+    while (i < len && (field[i] == ' ' || field[i] == '\0')) {
+        i++;
+    }
+
+    for (; i < len; i++) {
+        char ch = field[i];
+
+        if (ch == ' ' || ch == '\0') {
+            break;
+        }
+
+        if (ch < '0' || ch > '7') {
+            return CLKS_FALSE;
+        }
+
+        if (value > (0xffffffffffffffffULL >> 3)) {
+            return CLKS_FALSE;
+        }
+
+        value = (value << 3) + (u64)(ch - '0');
+    }
+
+    *out_value = value;
+    return CLKS_TRUE;
+}
+
+static clks_bool clks_ramdisk_build_path(const struct clks_tar_header *hdr, char *out_path, usize out_path_size) {
+    char raw[CLKS_RAMDISK_PATH_MAX];
+    usize prefix_len;
+    usize name_len;
+    usize cursor = 0;
+    usize read_pos = 0;
+    usize out_cursor = 0;
+
+    if (hdr == CLKS_NULL || out_path == CLKS_NULL || out_path_size == 0U) {
+        return CLKS_FALSE;
+    }
+
+    raw[0] = '\0';
+    out_path[0] = '\0';
+
+    prefix_len = clks_ramdisk_field_len(hdr->prefix, sizeof(hdr->prefix));
+    name_len = clks_ramdisk_field_len(hdr->name, sizeof(hdr->name));
+
+    if (name_len == 0U) {
+        return CLKS_FALSE;
+    }
+
+    if (prefix_len != 0U) {
+        if (prefix_len + 1U >= sizeof(raw)) {
+            return CLKS_FALSE;
+        }
+
+        clks_memcpy(raw, hdr->prefix, prefix_len);
+        cursor = prefix_len;
+        raw[cursor++] = '/';
+    }
+
+    if (cursor + name_len >= sizeof(raw)) {
+        return CLKS_FALSE;
+    }
+
+    clks_memcpy(raw + cursor, hdr->name, name_len);
+    cursor += name_len;
+    raw[cursor] = '\0';
+
+    while ((raw[read_pos] == '.' && raw[read_pos + 1U] == '/') || raw[read_pos] == '/') {
+        if (raw[read_pos] == '.') {
+            read_pos += 2U;
+        } else {
+            read_pos++;
+        }
+    }
+
+    while (raw[read_pos] != '\0' && out_cursor + 1U < out_path_size) {
+        out_path[out_cursor++] = raw[read_pos++];
+    }
+
+    if (raw[read_pos] != '\0') {
+        return CLKS_FALSE;
+    }
+
+    while (out_cursor > 0U && out_path[out_cursor - 1U] == '/') {
+        out_cursor--;
+    }
+
+    out_path[out_cursor] = '\0';
+
+    if (out_cursor == 0U) {
+        return CLKS_FALSE;
+    }
+
+    return CLKS_TRUE;
+}
+
+clks_bool clks_ramdisk_iterate(const void *image, u64 image_size, clks_ramdisk_iter_fn iter_fn, void *ctx) {
+    const u8 *bytes = (const u8 *)image;
+    u64 offset = 0ULL;
+
+    if (image == CLKS_NULL || iter_fn == CLKS_NULL) {
+        return CLKS_FALSE;
+    }
+
+    while (offset + CLKS_TAR_BLOCK_SIZE <= image_size) {
+        const struct clks_tar_header *hdr;
+        u64 payload_offset;
+        u64 file_size;
+        u64 aligned_size;
+        struct clks_ramdisk_entry entry;
+        clks_bool emit = CLKS_FALSE;
+
+        hdr = (const struct clks_tar_header *)(bytes + offset);
+
+        if (clks_ramdisk_is_zero_block((const u8 *)hdr) == CLKS_TRUE) {
+            break;
+        }
+
+        if (clks_ramdisk_parse_octal_u64(hdr->size, sizeof(hdr->size), &file_size) == CLKS_FALSE) {
+            return CLKS_FALSE;
+        }
+
+        payload_offset = offset + CLKS_TAR_BLOCK_SIZE;
+
+        if (payload_offset > image_size) {
+            return CLKS_FALSE;
+        }
+
+        if (file_size > (image_size - payload_offset)) {
+            return CLKS_FALSE;
+        }
+
+        clks_memset(&entry, 0, sizeof(entry));
+
+        if (clks_ramdisk_build_path(hdr, entry.path, sizeof(entry.path)) == CLKS_TRUE) {
+            if (hdr->typeflag == '5') {
+                entry.type = CLKS_RAMDISK_ENTRY_DIR;
+                entry.data = CLKS_NULL;
+                entry.size = 0ULL;
+                emit = CLKS_TRUE;
+            } else if (hdr->typeflag == '\0' || hdr->typeflag == '0') {
+                entry.type = CLKS_RAMDISK_ENTRY_FILE;
+                entry.data = (const void *)(bytes + payload_offset);
+                entry.size = file_size;
+                emit = CLKS_TRUE;
+            }
+        }
+
+        if (emit == CLKS_TRUE) {
+            if (iter_fn(&entry, ctx) == CLKS_FALSE) {
+                return CLKS_FALSE;
+            }
+        }
+
+        aligned_size = (file_size + (CLKS_TAR_BLOCK_SIZE - 1ULL)) & ~(CLKS_TAR_BLOCK_SIZE - 1ULL);
+
+        if (payload_offset + aligned_size < payload_offset) {
+            return CLKS_FALSE;
+        }
+
+        offset = payload_offset + aligned_size;
+    }
+
+    return CLKS_TRUE;
+}