LeonMMcoset/cleonos
1
0
Fork 0
mirror of https://github.com/Leonmmcoset/cleonos.git synced 2026-04-24 11:14:01 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
34387710131986dd0ec2df279f9a7e727a3ee1d6
cleonos/clks/kernel/storage/disk.c
Leonmmcoset 4d9f4a769c style: auto-format C/C++ sources with clang-format
2026-04-22 14:13:30 +00:00

1857 lines
50 KiB
C
Raw Blame History

#include <clks/disk.h>
#include <clks/heap.h>
#include <clks/log.h>
#include <clks/string.h>
#include <clks/types.h>
#define CLKS_DISK_MIN_BYTES (4ULL * 1024ULL * 1024ULL)
#define CLKS_DISK_CACHE_MAX_BYTES (8ULL * 1024ULL * 1024ULL)
#define CLKS_DISK_MAX_NODES 256U
#define CLKS_DISK_NODE_FLAG_HEAP_DATA 0x0001U
#define CLKS_DISK_META_OFFSET 0x00010000ULL
#define CLKS_DISK_META_SIZE 0x00020000ULL
#define CLKS_DISK_META_HEADER_SIZE 32U
#define CLKS_DISK_META_ENTRY_SIZE 224U
#define CLKS_DISK_DATA_OFFSET (CLKS_DISK_META_OFFSET + CLKS_DISK_META_SIZE)
#define CLKS_DISK_META_MAGIC "CLDSKFS1"
#define CLKS_DISK_META_VERSION 1U
#define CLKS_DISK_FAT32_BOOT_SIG_OFFSET 510U
#define CLKS_DISK_FAT32_TYPE_OFFSET 82U
#define CLKS_DISK_FAT32_TYPE_LEN 5U
#if defined(CLKS_ARCH_X86_64)
#define CLKS_DISK_ATA_IO_BASE 0x1F0U
#define CLKS_DISK_ATA_CTRL_BASE 0x3F6U
#define CLKS_DISK_ATA_REG_DATA (CLKS_DISK_ATA_IO_BASE + 0U)
#define CLKS_DISK_ATA_REG_SECTOR_COUNT (CLKS_DISK_ATA_IO_BASE + 2U)
#define CLKS_DISK_ATA_REG_LBA_LOW (CLKS_DISK_ATA_IO_BASE + 3U)
#define CLKS_DISK_ATA_REG_LBA_MID (CLKS_DISK_ATA_IO_BASE + 4U)
#define CLKS_DISK_ATA_REG_LBA_HIGH (CLKS_DISK_ATA_IO_BASE + 5U)
#define CLKS_DISK_ATA_REG_DRIVE (CLKS_DISK_ATA_IO_BASE + 6U)
#define CLKS_DISK_ATA_REG_STATUS (CLKS_DISK_ATA_IO_BASE + 7U)
#define CLKS_DISK_ATA_REG_COMMAND (CLKS_DISK_ATA_IO_BASE + 7U)
#define CLKS_DISK_ATA_REG_ALT_STATUS (CLKS_DISK_ATA_CTRL_BASE + 0U)
#define CLKS_DISK_ATA_STATUS_ERR 0x01U
#define CLKS_DISK_ATA_STATUS_DRQ 0x08U
#define CLKS_DISK_ATA_STATUS_DF 0x20U
#define CLKS_DISK_ATA_STATUS_DRDY 0x40U
#define CLKS_DISK_ATA_STATUS_BSY 0x80U
#define CLKS_DISK_ATA_CMD_READ_SECTORS 0x20U
#define CLKS_DISK_ATA_CMD_WRITE_SECTORS 0x30U
#define CLKS_DISK_ATA_CMD_CACHE_FLUSH 0xE7U
#define CLKS_DISK_ATA_CMD_IDENTIFY 0xECU
#endif
struct clks_disk_node {
clks_bool used;
u8 type;
u16 parent;
u16 flags;
const void *data;
u64 size;
char path[CLKS_DISK_PATH_MAX];
};
static u8 *clks_disk_bytes = CLKS_NULL;
static u64 clks_disk_bytes_len = 0ULL;
static u64 clks_disk_sector_total = 0ULL;
static clks_bool clks_disk_ready = CLKS_FALSE;
static clks_bool clks_disk_formatted = CLKS_FALSE;
static clks_bool clks_disk_mounted = CLKS_FALSE;
static clks_bool clks_disk_hw_backed = CLKS_FALSE;
static char clks_disk_mount_path_buf[CLKS_DISK_PATH_MAX];
static const u8 clks_disk_empty_file_data[1] = {0U};
static struct clks_disk_node clks_disk_nodes[CLKS_DISK_MAX_NODES];
static u16 clks_disk_nodes_used = 0U;
static u16 clks_disk_read_u16(const u8 *ptr) {
return (u16)((u16)ptr[0] | ((u16)ptr[1] << 8));
}
static u32 clks_disk_read_u32(const u8 *ptr) {
return (u32)((u32)ptr[0] | ((u32)ptr[1] << 8) | ((u32)ptr[2] << 16) | ((u32)ptr[3] << 24));
}
static u64 clks_disk_read_u64(const u8 *ptr) {
u64 value = 0ULL;
u32 i;
for (i = 0U; i < 8U; i++) {
value |= ((u64)ptr[i]) << (u64)(i * 8U);
}
return value;
}
static void clks_disk_write_u16(u8 *ptr, u16 value) {
ptr[0] = (u8)(value & 0xFFU);
ptr[1] = (u8)((value >> 8) & 0xFFU);
}
static void clks_disk_write_u32(u8 *ptr, u32 value) {
ptr[0] = (u8)(value & 0xFFU);
ptr[1] = (u8)((value >> 8) & 0xFFU);
ptr[2] = (u8)((value >> 16) & 0xFFU);
ptr[3] = (u8)((value >> 24) & 0xFFU);
}
static void clks_disk_write_u64(u8 *ptr, u64 value) {
u32 i;
for (i = 0U; i < 8U; i++) {
ptr[i] = (u8)((value >> (u64)(i * 8U)) & 0xFFULL);
}
}
#if defined(CLKS_ARCH_X86_64)
static inline void clks_disk_ata_outb(u16 port, u8 value) {
__asm__ volatile("outb %0, %1" : : "a"(value), "Nd"(port));
}
static inline u8 clks_disk_ata_inb(u16 port) {
u8 value;
__asm__ volatile("inb %1, %0" : "=a"(value) : "Nd"(port));
return value;
}
static inline void clks_disk_ata_outw(u16 port, u16 value) {
__asm__ volatile("outw %0, %1" : : "a"(value), "Nd"(port));
}
static inline u16 clks_disk_ata_inw(u16 port) {
u16 value;
__asm__ volatile("inw %1, %0" : "=a"(value) : "Nd"(port));
return value;
}
static void clks_disk_ata_delay_400ns(void) {
(void)clks_disk_ata_inb(CLKS_DISK_ATA_REG_ALT_STATUS);
(void)clks_disk_ata_inb(CLKS_DISK_ATA_REG_ALT_STATUS);
(void)clks_disk_ata_inb(CLKS_DISK_ATA_REG_ALT_STATUS);
(void)clks_disk_ata_inb(CLKS_DISK_ATA_REG_ALT_STATUS);
}
static clks_bool clks_disk_ata_wait_not_busy(void) {
u32 i;
for (i = 0U; i < 1000000U; i++) {
u8 status = clks_disk_ata_inb(CLKS_DISK_ATA_REG_STATUS);
if ((status & CLKS_DISK_ATA_STATUS_BSY) == 0U) {
return CLKS_TRUE;
}
}
return CLKS_FALSE;
}
static clks_bool clks_disk_ata_wait_drq_ready(void) {
u32 i;
for (i = 0U; i < 1000000U; i++) {
u8 status = clks_disk_ata_inb(CLKS_DISK_ATA_REG_STATUS);
if ((status & CLKS_DISK_ATA_STATUS_BSY) != 0U) {
continue;
}
if ((status & (CLKS_DISK_ATA_STATUS_ERR | CLKS_DISK_ATA_STATUS_DF)) != 0U) {
return CLKS_FALSE;
}
if ((status & CLKS_DISK_ATA_STATUS_DRQ) != 0U) {
return CLKS_TRUE;
}
}
return CLKS_FALSE;
}
static clks_bool clks_disk_ata_wait_ready_no_drq(void) {
u32 i;
for (i = 0U; i < 1000000U; i++) {
u8 status = clks_disk_ata_inb(CLKS_DISK_ATA_REG_STATUS);
if ((status & CLKS_DISK_ATA_STATUS_BSY) != 0U) {
continue;
}
if ((status & (CLKS_DISK_ATA_STATUS_ERR | CLKS_DISK_ATA_STATUS_DF)) != 0U) {
return CLKS_FALSE;
}
if ((status & CLKS_DISK_ATA_STATUS_DRDY) != 0U) {
return CLKS_TRUE;
}
}
return CLKS_FALSE;
}
static clks_bool clks_disk_ata_identify(u64 *out_sector_total) {
u16 identify_words[256];
u32 i;
u64 sector_total;
u8 status;
if (out_sector_total == CLKS_NULL) {
return CLKS_FALSE;
}
if (clks_disk_ata_wait_not_busy() == CLKS_FALSE) {
return CLKS_FALSE;
}
clks_disk_ata_outb(CLKS_DISK_ATA_REG_DRIVE, 0xA0U);
clks_disk_ata_delay_400ns();
clks_disk_ata_outb(CLKS_DISK_ATA_REG_SECTOR_COUNT, 0U);
clks_disk_ata_outb(CLKS_DISK_ATA_REG_LBA_LOW, 0U);
clks_disk_ata_outb(CLKS_DISK_ATA_REG_LBA_MID, 0U);
clks_disk_ata_outb(CLKS_DISK_ATA_REG_LBA_HIGH, 0U);
clks_disk_ata_outb(CLKS_DISK_ATA_REG_COMMAND, CLKS_DISK_ATA_CMD_IDENTIFY);
status = clks_disk_ata_inb(CLKS_DISK_ATA_REG_STATUS);
if (status == 0U) {
return CLKS_FALSE;
}
if (clks_disk_ata_wait_drq_ready() == CLKS_FALSE) {
return CLKS_FALSE;
}
for (i = 0U; i < 256U; i++) {
identify_words[i] = clks_disk_ata_inw(CLKS_DISK_ATA_REG_DATA);
}
sector_total = (u64)identify_words[60] | ((u64)identify_words[61] << 16U);
if (sector_total == 0ULL) {
return CLKS_FALSE;
}
*out_sector_total = sector_total;
return CLKS_TRUE;
}
static clks_bool clks_disk_ata_read_sector_hw(u64 lba, void *out_sector) {
u8 *out = (u8 *)out_sector;
u32 i;
u8 status;
if (out_sector == CLKS_NULL || lba > 0x0FFFFFFFULL) {
return CLKS_FALSE;
}
if (clks_disk_ata_wait_not_busy() == CLKS_FALSE) {
return CLKS_FALSE;
}
clks_disk_ata_outb(CLKS_DISK_ATA_REG_DRIVE, (u8)(0xE0U | ((u8)((lba >> 24U) & 0x0FU))));
clks_disk_ata_outb(CLKS_DISK_ATA_REG_SECTOR_COUNT, 1U);
clks_disk_ata_outb(CLKS_DISK_ATA_REG_LBA_LOW, (u8)(lba & 0xFFULL));
clks_disk_ata_outb(CLKS_DISK_ATA_REG_LBA_MID, (u8)((lba >> 8U) & 0xFFULL));
clks_disk_ata_outb(CLKS_DISK_ATA_REG_LBA_HIGH, (u8)((lba >> 16U) & 0xFFULL));
clks_disk_ata_outb(CLKS_DISK_ATA_REG_COMMAND, CLKS_DISK_ATA_CMD_READ_SECTORS);
if (clks_disk_ata_wait_drq_ready() == CLKS_FALSE) {
return CLKS_FALSE;
}
for (i = 0U; i < 256U; i++) {
u16 word = clks_disk_ata_inw(CLKS_DISK_ATA_REG_DATA);
out[i * 2U] = (u8)(word & 0x00FFU);
out[i * 2U + 1U] = (u8)((word >> 8U) & 0x00FFU);
}
clks_disk_ata_delay_400ns();
status = clks_disk_ata_inb(CLKS_DISK_ATA_REG_STATUS);
if ((status & (CLKS_DISK_ATA_STATUS_ERR | CLKS_DISK_ATA_STATUS_DF)) != 0U) {
return CLKS_FALSE;
}
return CLKS_TRUE;
}
static clks_bool clks_disk_ata_write_sector_hw(u64 lba, const void *sector_data) {
const u8 *src = (const u8 *)sector_data;
u32 i;
if (sector_data == CLKS_NULL || lba > 0x0FFFFFFFULL) {
return CLKS_FALSE;
}
if (clks_disk_ata_wait_not_busy() == CLKS_FALSE) {
return CLKS_FALSE;
}
clks_disk_ata_outb(CLKS_DISK_ATA_REG_DRIVE, (u8)(0xE0U | ((u8)((lba >> 24U) & 0x0FU))));
clks_disk_ata_outb(CLKS_DISK_ATA_REG_SECTOR_COUNT, 1U);
clks_disk_ata_outb(CLKS_DISK_ATA_REG_LBA_LOW, (u8)(lba & 0xFFULL));
clks_disk_ata_outb(CLKS_DISK_ATA_REG_LBA_MID, (u8)((lba >> 8U) & 0xFFULL));
clks_disk_ata_outb(CLKS_DISK_ATA_REG_LBA_HIGH, (u8)((lba >> 16U) & 0xFFULL));
clks_disk_ata_outb(CLKS_DISK_ATA_REG_COMMAND, CLKS_DISK_ATA_CMD_WRITE_SECTORS);
if (clks_disk_ata_wait_drq_ready() == CLKS_FALSE) {
return CLKS_FALSE;
}
for (i = 0U; i < 256U; i++) {
u16 word = (u16)src[i * 2U] | ((u16)src[i * 2U + 1U] << 8U);
clks_disk_ata_outw(CLKS_DISK_ATA_REG_DATA, word);
}
clks_disk_ata_delay_400ns();
if (clks_disk_ata_wait_ready_no_drq() == CLKS_FALSE) {
return CLKS_FALSE;
}
return CLKS_TRUE;
}
static clks_bool clks_disk_ata_cache_flush_hw(void) {
if (clks_disk_ata_wait_not_busy() == CLKS_FALSE) {
return CLKS_FALSE;
}
clks_disk_ata_outb(CLKS_DISK_ATA_REG_COMMAND, CLKS_DISK_ATA_CMD_CACHE_FLUSH);
return clks_disk_ata_wait_ready_no_drq();
}
#else
static clks_bool clks_disk_ata_identify(u64 *out_sector_total) {
(void)out_sector_total;
return CLKS_FALSE;
}
static clks_bool clks_disk_ata_read_sector_hw(u64 lba, void *out_sector) {
(void)lba;
(void)out_sector;
return CLKS_FALSE;
}
static clks_bool clks_disk_ata_write_sector_hw(u64 lba, const void *sector_data) {
(void)lba;
(void)sector_data;
return CLKS_FALSE;
}
static clks_bool clks_disk_ata_cache_flush_hw(void) {
return CLKS_FALSE;
}
#endif
static clks_bool clks_disk_sync_bytes_to_hw(u64 used_bytes) {
u64 sectors_to_sync;
u64 lba;
if (clks_disk_hw_backed == CLKS_FALSE) {
return CLKS_TRUE;
}
if (clks_disk_bytes == CLKS_NULL || clks_disk_sector_total == 0ULL) {
return CLKS_FALSE;
}
if (used_bytes == 0ULL) {
return CLKS_TRUE;
}
if (used_bytes > clks_disk_bytes_len) {
used_bytes = clks_disk_bytes_len;
}
sectors_to_sync = (used_bytes + (CLKS_DISK_SECTOR_SIZE - 1ULL)) / CLKS_DISK_SECTOR_SIZE;
if (sectors_to_sync > clks_disk_sector_total) {
sectors_to_sync = clks_disk_sector_total;
}
for (lba = 0ULL; lba < sectors_to_sync; lba++) {
const u8 *sector_ptr = clks_disk_bytes + (usize)(lba * CLKS_DISK_SECTOR_SIZE);
if (clks_disk_ata_write_sector_hw(lba, sector_ptr) == CLKS_FALSE) {
return CLKS_FALSE;
}
}
if (clks_disk_ata_cache_flush_hw() == CLKS_FALSE) {
return CLKS_FALSE;
}
return CLKS_TRUE;
}
static clks_bool clks_disk_bytes_equal(const u8 *left, const u8 *right, usize count) {
usize i;
if (left == CLKS_NULL || right == CLKS_NULL) {
return CLKS_FALSE;
}
for (i = 0U; i < count; i++) {
if (left[i] != right[i]) {
return CLKS_FALSE;
}
}
return CLKS_TRUE;
}
static clks_bool clks_disk_text_prefix_equals(const char *text, const char *prefix, usize prefix_len) {
usize i;
if (text == CLKS_NULL || prefix == CLKS_NULL) {
return CLKS_FALSE;
}
for (i = 0U; i < prefix_len; i++) {
if (text[i] != prefix[i]) {
return CLKS_FALSE;
}
}
return CLKS_TRUE;
}
static void clks_disk_copy_text(char *dst, usize dst_size, const char *src) {
usize i = 0U;
if (dst == CLKS_NULL || dst_size == 0U) {
return;
}
if (src == CLKS_NULL) {
dst[0] = '\0';
return;
}
while (src[i] != '\0' && i + 1U < dst_size) {
dst[i] = src[i];
i++;
}
dst[i] = '\0';
}
static clks_bool clks_disk_normalize_absolute_path(const char *path, char *out_path, usize out_size) {
usize in_pos = 0U;
usize out_pos = 0U;
if (path == CLKS_NULL || out_path == CLKS_NULL || out_size < 2U) {
return CLKS_FALSE;
}
if (path[0] != '/') {
return CLKS_FALSE;
}
out_path[out_pos++] = '/';
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 > 1U) {
if (out_pos + 1U >= out_size) {
return CLKS_FALSE;
}
out_path[out_pos++] = '/';
}
if (out_pos + comp_len >= out_size) {
return CLKS_FALSE;
}
clks_memcpy(out_path + out_pos, path + comp_start, comp_len);
out_pos += comp_len;
while (path[in_pos] == '/') {
in_pos++;
}
}
out_path[out_pos] = '\0';
return CLKS_TRUE;
}
static clks_bool clks_disk_normalize_relative_path(const char *path, char *out_path, usize out_size) {
usize in_pos = 0U;
usize out_pos = 0U;
if (path == CLKS_NULL || out_path == 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_path[out_pos++] = '/';
}
if (out_pos + comp_len >= out_size) {
return CLKS_FALSE;
}
clks_memcpy(out_path + out_pos, path + comp_start, comp_len);
out_pos += comp_len;
while (path[in_pos] == '/') {
in_pos++;
}
}
out_path[out_pos] = '\0';
return CLKS_TRUE;
}
static clks_bool clks_disk_path_to_relative(const char *path, char *out_relative, usize out_size) {
char normalized[CLKS_DISK_PATH_MAX];
usize mount_len;
if (out_relative == CLKS_NULL || out_size == 0U) {
return CLKS_FALSE;
}
if (clks_disk_mounted == CLKS_FALSE) {
return CLKS_FALSE;
}
if (clks_disk_normalize_absolute_path(path, normalized, sizeof(normalized)) == CLKS_FALSE) {
return CLKS_FALSE;
}
mount_len = clks_strlen(clks_disk_mount_path_buf);
if (clks_strcmp(normalized, clks_disk_mount_path_buf) == 0) {
out_relative[0] = '\0';
return CLKS_TRUE;
}
if (mount_len >= clks_strlen(normalized)) {
return CLKS_FALSE;
}
if (clks_disk_text_prefix_equals(normalized, clks_disk_mount_path_buf, mount_len) == CLKS_FALSE) {
return CLKS_FALSE;
}
if (normalized[mount_len] != '/') {
return CLKS_FALSE;
}
return clks_disk_normalize_relative_path(normalized + mount_len + 1U, out_relative, out_size);
}
static const char *clks_disk_basename(const char *relative_path) {
usize len;
usize i;
if (relative_path == CLKS_NULL) {
return "";
}
len = clks_strlen(relative_path);
if (len == 0U) {
return "";
}
for (i = len; i != 0U; i--) {
if (relative_path[i - 1U] == '/') {
return &relative_path[i];
}
}
return relative_path;
}
static clks_bool clks_disk_split_parent(const char *relative_path, char *parent_out, usize out_size) {
usize len;
usize i;
if (relative_path == CLKS_NULL || parent_out == CLKS_NULL || out_size == 0U) {
return CLKS_FALSE;
}
len = clks_strlen(relative_path);
if (len == 0U) {
parent_out[0] = '\0';
return CLKS_TRUE;
}
for (i = len; i != 0U; i--) {
if (relative_path[i - 1U] == '/') {
usize parent_len = i - 1U;
if (parent_len >= out_size) {
return CLKS_FALSE;
}
clks_memcpy(parent_out, relative_path, parent_len);
parent_out[parent_len] = '\0';
return CLKS_TRUE;
}
}
parent_out[0] = '\0';
return CLKS_TRUE;
}
static clks_bool clks_disk_node_has_heap_data(u16 index) {
return ((clks_disk_nodes[index].flags & CLKS_DISK_NODE_FLAG_HEAP_DATA) != 0U) ? CLKS_TRUE : CLKS_FALSE;
}
static void clks_disk_node_set_heap_data(u16 index, clks_bool value) {
if (value == CLKS_TRUE) {
clks_disk_nodes[index].flags |= CLKS_DISK_NODE_FLAG_HEAP_DATA;
} else {
clks_disk_nodes[index].flags &= (u16)(~CLKS_DISK_NODE_FLAG_HEAP_DATA);
}
}
static void clks_disk_node_release_heap_data(u16 index) {
if (clks_disk_nodes[index].type != (u8)CLKS_DISK_NODE_FILE) {
return;
}
if (clks_disk_node_has_heap_data(index) == CLKS_TRUE && clks_disk_nodes[index].data != CLKS_NULL) {
clks_kfree((void *)clks_disk_nodes[index].data);
}
clks_disk_node_set_heap_data(index, CLKS_FALSE);
}
static void clks_disk_nodes_reset(void) {
u16 i;
for (i = 0U; i < clks_disk_nodes_used; i++) {
if (clks_disk_nodes[i].used == CLKS_FALSE) {
continue;
}
clks_disk_node_release_heap_data(i);
}
clks_memset(clks_disk_nodes, 0, sizeof(clks_disk_nodes));
clks_disk_nodes_used = 0U;
}
static i32 clks_disk_find_node_by_relative(const char *relative_path) {
u16 i;
for (i = 0U; i < clks_disk_nodes_used; i++) {
if (clks_disk_nodes[i].used == CLKS_FALSE) {
continue;
}
if (clks_strcmp(clks_disk_nodes[i].path, relative_path) == 0) {
return (i32)i;
}
}
return -1;
}
static i32 clks_disk_alloc_slot(void) {
u16 i;
for (i = 0U; i < clks_disk_nodes_used; i++) {
if (clks_disk_nodes[i].used == CLKS_FALSE) {
return (i32)i;
}
}
if (clks_disk_nodes_used >= CLKS_DISK_MAX_NODES) {
return -1;
}
clks_disk_nodes_used++;
return (i32)(clks_disk_nodes_used - 1U);
}
static i32 clks_disk_create_or_update_node(const char *relative_path, u8 type, u16 parent, const void *data, u64 size) {
i32 existing;
i32 slot;
usize path_len;
if (relative_path == CLKS_NULL) {
return -1;
}
path_len = clks_strlen(relative_path);
if (path_len >= CLKS_DISK_PATH_MAX) {
return -1;
}
existing = clks_disk_find_node_by_relative(relative_path);
if (existing >= 0) {
struct clks_disk_node *node = &clks_disk_nodes[(u16)existing];
if (node->type != type) {
return -1;
}
node->parent = parent;
if (type == (u8)CLKS_DISK_NODE_FILE) {
node->data = data;
node->size = size;
node->flags = 0U;
}
node->used = CLKS_TRUE;
return existing;
}
slot = clks_disk_alloc_slot();
if (slot < 0) {
return -1;
}
clks_disk_nodes[(u16)slot].used = CLKS_TRUE;
clks_disk_nodes[(u16)slot].type = type;
clks_disk_nodes[(u16)slot].parent = parent;
clks_disk_nodes[(u16)slot].flags = 0U;
clks_disk_nodes[(u16)slot].data = (type == (u8)CLKS_DISK_NODE_FILE) ? data : CLKS_NULL;
clks_disk_nodes[(u16)slot].size = (type == (u8)CLKS_DISK_NODE_FILE) ? size : 0ULL;
clks_memcpy(clks_disk_nodes[(u16)slot].path, relative_path, path_len + 1U);
return slot;
}
static clks_bool clks_disk_ensure_root(void) {
if (clks_disk_create_or_update_node("", (u8)CLKS_DISK_NODE_DIR, 0U, CLKS_NULL, 0ULL) != 0) {
return CLKS_FALSE;
}
return CLKS_TRUE;
}
static clks_bool clks_disk_ensure_dir_hierarchy(const char *relative_dir_path) {
char prefix[CLKS_DISK_PATH_MAX];
usize cursor = 0U;
usize i = 0U;
u16 current_parent = 0U;
prefix[0] = '\0';
if (relative_dir_path == CLKS_NULL) {
return CLKS_FALSE;
}
if (relative_dir_path[0] == '\0') {
return CLKS_TRUE;
}
while (relative_dir_path[i] != '\0') {
usize comp_start = i;
usize comp_len;
i32 node_index;
while (relative_dir_path[i] != '\0' && relative_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, relative_dir_path + comp_start, comp_len);
cursor += comp_len;
prefix[cursor] = '\0';
node_index = clks_disk_find_node_by_relative(prefix);
if (node_index < 0) {
node_index =
clks_disk_create_or_update_node(prefix, (u8)CLKS_DISK_NODE_DIR, current_parent, CLKS_NULL, 0ULL);
if (node_index < 0) {
return CLKS_FALSE;
}
} else if (clks_disk_nodes[(u16)node_index].type != (u8)CLKS_DISK_NODE_DIR) {
return CLKS_FALSE;
}
current_parent = (u16)node_index;
if (relative_dir_path[i] == '/') {
i++;
}
}
return CLKS_TRUE;
}
static clks_bool clks_disk_build_file_payload(const void *data, u64 size, const void **out_data,
clks_bool *out_heap_owned) {
void *payload;
if (out_data == CLKS_NULL || out_heap_owned == CLKS_NULL) {
return CLKS_FALSE;
}
if (size == 0ULL) {
*out_data = (const void *)clks_disk_empty_file_data;
*out_heap_owned = CLKS_FALSE;
return CLKS_TRUE;
}
if (data == CLKS_NULL) {
return CLKS_FALSE;
}
payload = clks_kmalloc((usize)size);
if (payload == CLKS_NULL) {
return CLKS_FALSE;
}
clks_memcpy(payload, data, (usize)size);
*out_data = (const void *)payload;
*out_heap_owned = CLKS_TRUE;
return CLKS_TRUE;
}
static clks_bool clks_disk_meta_is_present(void) {
const u8 *header;
if (clks_disk_ready == CLKS_FALSE || clks_disk_bytes == CLKS_NULL) {
return CLKS_FALSE;
}
if (clks_disk_bytes_len < (CLKS_DISK_META_OFFSET + CLKS_DISK_META_HEADER_SIZE)) {
return CLKS_FALSE;
}
header = clks_disk_bytes + (usize)CLKS_DISK_META_OFFSET;
if (clks_disk_bytes_equal(header, (const u8 *)CLKS_DISK_META_MAGIC, 8U) == CLKS_FALSE) {
return CLKS_FALSE;
}
return (clks_disk_read_u32(header + 8U) == CLKS_DISK_META_VERSION) ? CLKS_TRUE : CLKS_FALSE;
}
static clks_bool clks_disk_meta_flush(void) {
u8 *meta_base;
u64 max_entries;
u64 entry_count = 0ULL;
u64 data_cursor = CLKS_DISK_DATA_OFFSET;
u16 i;
if (clks_disk_ready == CLKS_FALSE || clks_disk_formatted == CLKS_FALSE || clks_disk_bytes == CLKS_NULL) {
return CLKS_FALSE;
}
if (clks_disk_bytes_len < CLKS_DISK_DATA_OFFSET) {
return CLKS_FALSE;
}
meta_base = clks_disk_bytes + (usize)CLKS_DISK_META_OFFSET;
clks_memset(meta_base, 0, (usize)CLKS_DISK_META_SIZE);
max_entries = (CLKS_DISK_META_SIZE - (u64)CLKS_DISK_META_HEADER_SIZE) / (u64)CLKS_DISK_META_ENTRY_SIZE;
for (i = 0U; i < clks_disk_nodes_used; i++) {
struct clks_disk_node *node = &clks_disk_nodes[i];
u8 *entry_ptr;
if (node->used == CLKS_FALSE || node->path[0] == '\0') {
continue;
}
if (entry_count >= max_entries) {
return CLKS_FALSE;
}
entry_ptr = meta_base + CLKS_DISK_META_HEADER_SIZE + (usize)(entry_count * (u64)CLKS_DISK_META_ENTRY_SIZE);
entry_ptr[0] = node->type;
clks_disk_write_u64(entry_ptr + 4U, node->size);
if (node->type == (u8)CLKS_DISK_NODE_FILE && node->size > 0ULL) {
if (node->data == CLKS_NULL) {
return CLKS_FALSE;
}
if (data_cursor + node->size < data_cursor || data_cursor + node->size > clks_disk_bytes_len) {
return CLKS_FALSE;
}
clks_disk_write_u64(entry_ptr + 12U, data_cursor);
clks_memcpy(clks_disk_bytes + (usize)data_cursor, node->data, (usize)node->size);
data_cursor += node->size;
} else {
clks_disk_write_u64(entry_ptr + 12U, 0ULL);
}
clks_disk_copy_text((char *)(entry_ptr + 20U), CLKS_DISK_PATH_MAX, node->path);
entry_count++;
}
clks_memcpy(meta_base, (const void *)CLKS_DISK_META_MAGIC, 8U);
clks_disk_write_u32(meta_base + 8U, CLKS_DISK_META_VERSION);
clks_disk_write_u32(meta_base + 12U, (u32)entry_count);
clks_disk_write_u64(meta_base + 16U, data_cursor - CLKS_DISK_DATA_OFFSET);
if (clks_disk_sync_bytes_to_hw(data_cursor) == CLKS_FALSE) {
return CLKS_FALSE;
}
return CLKS_TRUE;
}
static clks_bool clks_disk_meta_load(void) {
const u8 *meta_base;
u64 entry_count;
u64 max_entries;
u64 i;
if (clks_disk_meta_is_present() == CLKS_FALSE) {
return CLKS_FALSE;
}
meta_base = clks_disk_bytes + (usize)CLKS_DISK_META_OFFSET;
entry_count = (u64)clks_disk_read_u32(meta_base + 12U);
max_entries = (CLKS_DISK_META_SIZE - (u64)CLKS_DISK_META_HEADER_SIZE) / (u64)CLKS_DISK_META_ENTRY_SIZE;
if (entry_count > max_entries) {
return CLKS_FALSE;
}
clks_disk_nodes_reset();
if (clks_disk_ensure_root() == CLKS_FALSE) {
return CLKS_FALSE;
}
for (i = 0ULL; i < entry_count; i++) {
const u8 *entry_ptr = meta_base + CLKS_DISK_META_HEADER_SIZE + (usize)(i * (u64)CLKS_DISK_META_ENTRY_SIZE);
u8 type = entry_ptr[0];
u64 size = clks_disk_read_u64(entry_ptr + 4U);
u64 data_offset = clks_disk_read_u64(entry_ptr + 12U);
char path[CLKS_DISK_PATH_MAX];
char normalized_path[CLKS_DISK_PATH_MAX];
char parent[CLKS_DISK_PATH_MAX];
i32 parent_index;
const void *payload_data = (const void *)clks_disk_empty_file_data;
clks_bool payload_heap_owned = CLKS_FALSE;
i32 node_index;
clks_memset(path, 0, sizeof(path));
clks_memcpy(path, entry_ptr + 20U, CLKS_DISK_PATH_MAX - 1U);
if (clks_disk_normalize_relative_path(path, normalized_path, sizeof(normalized_path)) == CLKS_FALSE) {
continue;
}
if (normalized_path[0] == '\0') {
continue;
}
if (type == (u8)CLKS_DISK_NODE_DIR) {
(void)clks_disk_ensure_dir_hierarchy(normalized_path);
continue;
}
if (type != (u8)CLKS_DISK_NODE_FILE) {
continue;
}
if (clks_disk_split_parent(normalized_path, parent, sizeof(parent)) == CLKS_FALSE) {
continue;
}
if (clks_disk_ensure_dir_hierarchy(parent) == CLKS_FALSE) {
continue;
}
parent_index = clks_disk_find_node_by_relative(parent);
if (parent_index < 0 || clks_disk_nodes[(u16)parent_index].type != (u8)CLKS_DISK_NODE_DIR) {
continue;
}
if (size == 0ULL) {
payload_data = (const void *)clks_disk_empty_file_data;
payload_heap_owned = CLKS_FALSE;
} else {
void *payload;
if (data_offset < CLKS_DISK_DATA_OFFSET || data_offset + size < data_offset ||
data_offset + size > clks_disk_bytes_len) {
continue;
}
payload = clks_kmalloc((usize)size);
if (payload == CLKS_NULL) {
continue;
}
clks_memcpy(payload, clks_disk_bytes + (usize)data_offset, (usize)size);
payload_data = payload;
payload_heap_owned = CLKS_TRUE;
}
node_index = clks_disk_create_or_update_node(normalized_path, (u8)CLKS_DISK_NODE_FILE, (u16)parent_index,
payload_data, size);
if (node_index < 0) {
if (payload_heap_owned == CLKS_TRUE) {
clks_kfree((void *)payload_data);
}
continue;
}
clks_disk_node_set_heap_data((u16)node_index, payload_heap_owned);
}
return CLKS_TRUE;
}
static clks_bool clks_disk_detect_fat32(void) {
const u8 *boot;
const u8 fat32_sig[CLKS_DISK_FAT32_TYPE_LEN] = {'F', 'A', 'T', '3', '2'};
if (clks_disk_ready == CLKS_FALSE || clks_disk_bytes == CLKS_NULL) {
return CLKS_FALSE;
}
if (clks_disk_bytes_len < CLKS_DISK_SECTOR_SIZE) {
return CLKS_FALSE;
}
boot = clks_disk_bytes;
if (boot[CLKS_DISK_FAT32_BOOT_SIG_OFFSET] != 0x55U || boot[CLKS_DISK_FAT32_BOOT_SIG_OFFSET + 1U] != 0xAAU) {
return CLKS_FALSE;
}
if (clks_disk_read_u16(boot + 11U) != (u16)CLKS_DISK_SECTOR_SIZE) {
return CLKS_FALSE;
}
return clks_disk_bytes_equal(boot + CLKS_DISK_FAT32_TYPE_OFFSET, fat32_sig, CLKS_DISK_FAT32_TYPE_LEN);
}
static void clks_disk_label_to_boot_field(char *out_label, const char *label) {
usize i = 0U;
for (i = 0U; i < 11U; i++) {
out_label[i] = ' ';
}
if (label == CLKS_NULL || label[0] == '\0') {
const char default_label[11] = {'C', 'L', 'E', 'O', 'N', 'O', 'S', 'D', 'I', 'S', 'K'};
for (i = 0U; i < 11U; i++) {
out_label[i] = default_label[i];
}
return;
}
i = 0U;
while (label[i] != '\0' && i < 11U) {
char ch = label[i];
if (ch >= 'a' && ch <= 'z') {
ch = (char)(ch - ('a' - 'A'));
}
out_label[i] = ch;
i++;
}
}
static clks_bool clks_disk_write_fat32_boot_sector(const char *label) {
u8 *boot = clks_disk_bytes;
u8 *fsinfo;
u8 *backup_boot;
u64 total_sectors = clks_disk_sector_total;
u8 sectors_per_cluster = 1U;
u16 reserved = 64U;
u8 fats = 2U;
u32 fat_sectors = 1U;
u32 iter;
char label_field[11];
if (total_sectors < 8192ULL) {
return CLKS_FALSE;
}
if (total_sectors > 262144ULL) {
sectors_per_cluster = 8U;
} else if (total_sectors > 131072ULL) {
sectors_per_cluster = 4U;
} else {
sectors_per_cluster = 1U;
}
for (iter = 0U; iter < 8U; iter++) {
u64 data_sectors;
u64 cluster_count;
u64 next_fat;
if (total_sectors <= (u64)reserved + ((u64)fats * (u64)fat_sectors)) {
return CLKS_FALSE;
}
data_sectors = total_sectors - (u64)reserved - ((u64)fats * (u64)fat_sectors);
cluster_count = data_sectors / (u64)sectors_per_cluster;
next_fat = ((cluster_count + 2ULL) * 4ULL + (CLKS_DISK_SECTOR_SIZE - 1ULL)) / CLKS_DISK_SECTOR_SIZE;
if (next_fat > 0xFFFFFFFFULL) {
return CLKS_FALSE;
}
if ((u32)next_fat == fat_sectors) {
break;
}
fat_sectors = (u32)next_fat;
}
if (fat_sectors == 0U) {
return CLKS_FALSE;
}
clks_memset(boot, 0, CLKS_DISK_SECTOR_SIZE);
boot[0] = 0xEBU;
boot[1] = 0x58U;
boot[2] = 0x90U;
clks_memcpy(boot + 3U, "MSDOS5.0", 8U);
clks_disk_write_u16(boot + 11U, (u16)CLKS_DISK_SECTOR_SIZE);
boot[13] = sectors_per_cluster;
clks_disk_write_u16(boot + 14U, reserved);
boot[16] = fats;
clks_disk_write_u16(boot + 17U, 0U);
clks_disk_write_u16(boot + 19U, 0U);
boot[21] = 0xF8U;
clks_disk_write_u16(boot + 22U, 0U);
clks_disk_write_u16(boot + 24U, 63U);
clks_disk_write_u16(boot + 26U, 255U);
clks_disk_write_u32(boot + 28U, 0U);
clks_disk_write_u32(boot + 32U, (u32)total_sectors);
clks_disk_write_u32(boot + 36U, fat_sectors);
clks_disk_write_u16(boot + 40U, 0U);
clks_disk_write_u16(boot + 42U, 0U);
clks_disk_write_u32(boot + 44U, 2U);
clks_disk_write_u16(boot + 48U, 1U);
clks_disk_write_u16(boot + 50U, 6U);
boot[64] = 0x80U;
boot[66] = 0x29U;
clks_disk_write_u32(boot + 67U, 0x434C4B53U);
clks_disk_label_to_boot_field(label_field, label);
clks_memcpy(boot + 71U, label_field, 11U);
clks_memcpy(boot + 82U, "FAT32 ", 8U);
boot[CLKS_DISK_FAT32_BOOT_SIG_OFFSET] = 0x55U;
boot[CLKS_DISK_FAT32_BOOT_SIG_OFFSET + 1U] = 0xAAU;
fsinfo = clks_disk_bytes + (usize)CLKS_DISK_SECTOR_SIZE;
clks_memset(fsinfo, 0, CLKS_DISK_SECTOR_SIZE);
clks_disk_write_u32(fsinfo + 0U, 0x41615252U);
clks_disk_write_u32(fsinfo + 484U, 0x61417272U);
clks_disk_write_u32(fsinfo + 488U, 0xFFFFFFFFU);
clks_disk_write_u32(fsinfo + 492U, 0xFFFFFFFFU);
fsinfo[CLKS_DISK_FAT32_BOOT_SIG_OFFSET] = 0x55U;
fsinfo[CLKS_DISK_FAT32_BOOT_SIG_OFFSET + 1U] = 0xAAU;
backup_boot = clks_disk_bytes + (usize)(6ULL * CLKS_DISK_SECTOR_SIZE);
clks_memcpy(backup_boot, boot, CLKS_DISK_SECTOR_SIZE);
{
u64 fat_base = (u64)reserved * CLKS_DISK_SECTOR_SIZE;
u32 fat_index;
for (fat_index = 0U; fat_index < fats; fat_index++) {
u64 offset = fat_base + ((u64)fat_index * (u64)fat_sectors * CLKS_DISK_SECTOR_SIZE);
u8 *fat_ptr;
if (offset + 12ULL > clks_disk_bytes_len) {
return CLKS_FALSE;
}
fat_ptr = clks_disk_bytes + (usize)offset;
clks_disk_write_u32(fat_ptr + 0U, 0x0FFFFFF8U);
clks_disk_write_u32(fat_ptr + 4U, 0xFFFFFFFFU);
clks_disk_write_u32(fat_ptr + 8U, 0x0FFFFFFFU);
}
}
return CLKS_TRUE;
}
void clks_disk_init(void) {
u64 detected_sectors = 0ULL;
u64 cache_bytes;
u64 alloc_bytes;
u64 lba;
clks_disk_ready = CLKS_FALSE;
clks_disk_formatted = CLKS_FALSE;
clks_disk_mounted = CLKS_FALSE;
clks_disk_hw_backed = CLKS_FALSE;
clks_disk_bytes = CLKS_NULL;
clks_disk_bytes_len = 0ULL;
clks_disk_sector_total = 0ULL;
clks_disk_mount_path_buf[0] = '\0';
clks_disk_nodes_reset();
if (clks_disk_ata_identify(&detected_sectors) == CLKS_FALSE || detected_sectors == 0ULL) {
clks_log(CLKS_LOG_WARN, "DISK", "NO ATA DISK DETECTED (CHECK QEMU -DRIVE)");
return;
}
cache_bytes = detected_sectors * CLKS_DISK_SECTOR_SIZE;
if (cache_bytes / CLKS_DISK_SECTOR_SIZE != detected_sectors) {
clks_log(CLKS_LOG_WARN, "DISK", "DISK SIZE OVERFLOW");
return;
}
if (cache_bytes < CLKS_DISK_MIN_BYTES) {
clks_log(CLKS_LOG_WARN, "DISK", "ATA DISK TOO SMALL");
clks_log_hex(CLKS_LOG_WARN, "DISK", "BYTES", cache_bytes);
return;
}
if (cache_bytes > CLKS_DISK_CACHE_MAX_BYTES) {
cache_bytes = CLKS_DISK_CACHE_MAX_BYTES;
clks_log(CLKS_LOG_WARN, "DISK", "DISK CACHE TRUNCATED");
}
alloc_bytes = cache_bytes;
while (alloc_bytes >= CLKS_DISK_MIN_BYTES) {
clks_disk_bytes = (u8 *)clks_kmalloc((usize)alloc_bytes);
if (clks_disk_bytes != CLKS_NULL) {
cache_bytes = alloc_bytes;
break;
}
alloc_bytes /= 2ULL;
alloc_bytes -= (alloc_bytes % CLKS_DISK_SECTOR_SIZE);
}
if (clks_disk_bytes == CLKS_NULL) {
clks_log(CLKS_LOG_WARN, "DISK", "DISK BACKEND ALLOCATION FAILED");
return;
}
detected_sectors = cache_bytes / CLKS_DISK_SECTOR_SIZE;
for (lba = 0ULL; lba < detected_sectors; lba++) {
u8 *sector_ptr = clks_disk_bytes + (usize)(lba * CLKS_DISK_SECTOR_SIZE);
if (clks_disk_ata_read_sector_hw(lba, sector_ptr) == CLKS_FALSE) {
clks_log(CLKS_LOG_WARN, "DISK", "ATA READ FAILED DURING CACHE LOAD");
clks_log_hex(CLKS_LOG_WARN, "DISK", "LBA", lba);
clks_kfree(clks_disk_bytes);
clks_disk_bytes = CLKS_NULL;
return;
}
}
clks_disk_bytes_len = cache_bytes;
clks_disk_sector_total = detected_sectors;
clks_disk_hw_backed = CLKS_TRUE;
clks_disk_ready = CLKS_TRUE;
clks_disk_formatted = clks_disk_detect_fat32();
if (clks_disk_ensure_root() == CLKS_FALSE) {
clks_log(CLKS_LOG_ERROR, "DISK", "FAILED TO INIT ROOT NODE");
clks_disk_ready = CLKS_FALSE;
return;
}
if (clks_disk_formatted == CLKS_TRUE) {
if (clks_disk_meta_load() == CLKS_FALSE) {
clks_log(CLKS_LOG_WARN, "DISK", "FAT32 DETECTED, META MISSING; RESET TO EMPTY");
clks_disk_nodes_reset();
(void)clks_disk_ensure_root();
(void)clks_disk_meta_flush();
}
}
(void)clks_disk_mount("/temp/disk");
clks_log(CLKS_LOG_INFO, "DISK", "DISK BACKEND ONLINE");
clks_log_hex(CLKS_LOG_INFO, "DISK", "BYTES", clks_disk_bytes_len);
clks_log_hex(CLKS_LOG_INFO, "DISK", "SECTORS", clks_disk_sector_total);
clks_log_hex(CLKS_LOG_INFO, "DISK", "FAT32", (clks_disk_formatted == CLKS_TRUE) ? 1ULL : 0ULL);
clks_log_hex(CLKS_LOG_INFO, "DISK", "HW_BACKED", (clks_disk_hw_backed == CLKS_TRUE) ? 1ULL : 0ULL);
}
clks_bool clks_disk_present(void) {
return clks_disk_ready;
}
u64 clks_disk_size_bytes(void) {
return (clks_disk_ready == CLKS_TRUE) ? clks_disk_bytes_len : 0ULL;
}
u64 clks_disk_sector_count(void) {
return (clks_disk_ready == CLKS_TRUE) ? clks_disk_sector_total : 0ULL;
}
clks_bool clks_disk_read_sector(u64 lba, void *out_sector) {
if (clks_disk_ready == CLKS_FALSE || out_sector == CLKS_NULL) {
return CLKS_FALSE;
}
if (lba >= clks_disk_sector_total) {
return CLKS_FALSE;
}
if (clks_disk_hw_backed == CLKS_TRUE) {
if (clks_disk_ata_read_sector_hw(lba, out_sector) == CLKS_FALSE) {
return CLKS_FALSE;
}
clks_memcpy(clks_disk_bytes + (usize)(lba * CLKS_DISK_SECTOR_SIZE), out_sector, (usize)CLKS_DISK_SECTOR_SIZE);
return CLKS_TRUE;
}
clks_memcpy(out_sector, clks_disk_bytes + (usize)(lba * CLKS_DISK_SECTOR_SIZE), (usize)CLKS_DISK_SECTOR_SIZE);
return CLKS_TRUE;
}
clks_bool clks_disk_write_sector(u64 lba, const void *sector_data) {
if (clks_disk_ready == CLKS_FALSE || sector_data == CLKS_NULL) {
return CLKS_FALSE;
}
if (lba >= clks_disk_sector_total) {
return CLKS_FALSE;
}
clks_memcpy(clks_disk_bytes + (usize)(lba * CLKS_DISK_SECTOR_SIZE), sector_data, (usize)CLKS_DISK_SECTOR_SIZE);
if (clks_disk_hw_backed == CLKS_TRUE) {
if (clks_disk_ata_write_sector_hw(lba, sector_data) == CLKS_FALSE) {
return CLKS_FALSE;
}
if (clks_disk_ata_cache_flush_hw() == CLKS_FALSE) {
return CLKS_FALSE;
}
}
return CLKS_TRUE;
}
clks_bool clks_disk_is_formatted_fat32(void) {
return (clks_disk_ready == CLKS_TRUE && clks_disk_formatted == CLKS_TRUE) ? CLKS_TRUE : CLKS_FALSE;
}
clks_bool clks_disk_format_fat32(const char *label) {
if (clks_disk_ready == CLKS_FALSE || clks_disk_bytes == CLKS_NULL) {
return CLKS_FALSE;
}
clks_memset(clks_disk_bytes, 0, (usize)clks_disk_bytes_len);
if (clks_disk_sync_bytes_to_hw(clks_disk_bytes_len) == CLKS_FALSE) {
return CLKS_FALSE;
}
if (clks_disk_write_fat32_boot_sector(label) == CLKS_FALSE) {
return CLKS_FALSE;
}
clks_disk_nodes_reset();
if (clks_disk_ensure_root() == CLKS_FALSE) {
return CLKS_FALSE;
}
clks_disk_formatted = CLKS_TRUE;
if (clks_disk_meta_flush() == CLKS_FALSE) {
clks_disk_formatted = CLKS_FALSE;
return CLKS_FALSE;
}
clks_log(CLKS_LOG_INFO, "DISK", "FAT32 FORMAT COMPLETE");
return CLKS_TRUE;
}
clks_bool clks_disk_mount(const char *mount_path) {
char normalized[CLKS_DISK_PATH_MAX];
if (clks_disk_ready == CLKS_FALSE || clks_disk_formatted == CLKS_FALSE) {
return CLKS_FALSE;
}
if (clks_disk_normalize_absolute_path(mount_path, normalized, sizeof(normalized)) == CLKS_FALSE) {
return CLKS_FALSE;
}
if (clks_strcmp(normalized, "/") == 0) {
return CLKS_FALSE;
}
clks_disk_copy_text(clks_disk_mount_path_buf, sizeof(clks_disk_mount_path_buf), normalized);
clks_disk_mounted = CLKS_TRUE;
return CLKS_TRUE;
}
clks_bool clks_disk_is_mounted(void) {
return (clks_disk_ready == CLKS_TRUE && clks_disk_mounted == CLKS_TRUE) ? CLKS_TRUE : CLKS_FALSE;
}
const char *clks_disk_mount_path(void) {
if (clks_disk_mounted == CLKS_FALSE) {
return "";
}
return clks_disk_mount_path_buf;
}
clks_bool clks_disk_path_in_mount(const char *path) {
char relative[CLKS_DISK_PATH_MAX];
return (clks_disk_path_to_relative(path, relative, sizeof(relative)) == CLKS_TRUE) ? CLKS_TRUE : CLKS_FALSE;
}
clks_bool clks_disk_stat(const char *path, u64 *out_type, u64 *out_size) {
char relative[CLKS_DISK_PATH_MAX];
i32 node_index;
if (out_type == CLKS_NULL || out_size == CLKS_NULL ||
clks_disk_path_to_relative(path, relative, sizeof(relative)) == CLKS_FALSE) {
return CLKS_FALSE;
}
if (clks_disk_ready == CLKS_FALSE || clks_disk_formatted == CLKS_FALSE) {
return CLKS_FALSE;
}
node_index = clks_disk_find_node_by_relative(relative);
if (node_index < 0) {
return CLKS_FALSE;
}
*out_type =
(clks_disk_nodes[(u16)node_index].type == (u8)CLKS_DISK_NODE_DIR) ? CLKS_DISK_NODE_DIR : CLKS_DISK_NODE_FILE;
*out_size = clks_disk_nodes[(u16)node_index].size;
return CLKS_TRUE;
}
const void *clks_disk_read_all(const char *path, u64 *out_size) {
char relative[CLKS_DISK_PATH_MAX];
i32 node_index;
if (clks_disk_path_to_relative(path, relative, sizeof(relative)) == CLKS_FALSE) {
return CLKS_NULL;
}
if (clks_disk_ready == CLKS_FALSE || clks_disk_formatted == CLKS_FALSE) {
return CLKS_NULL;
}
node_index = clks_disk_find_node_by_relative(relative);
if (node_index < 0 || clks_disk_nodes[(u16)node_index].type != (u8)CLKS_DISK_NODE_FILE) {
return CLKS_NULL;
}
if (out_size != CLKS_NULL) {
*out_size = clks_disk_nodes[(u16)node_index].size;
}
if (clks_disk_nodes[(u16)node_index].size == 0ULL) {
return (const void *)clks_disk_empty_file_data;
}
return clks_disk_nodes[(u16)node_index].data;
}
u64 clks_disk_count_children(const char *dir_path) {
char relative[CLKS_DISK_PATH_MAX];
i32 dir_index;
u64 count = 0ULL;
u16 i;
if (clks_disk_path_to_relative(dir_path, relative, sizeof(relative)) == CLKS_FALSE) {
return 0ULL;
}
if (clks_disk_ready == CLKS_FALSE || clks_disk_formatted == CLKS_FALSE) {
return 0ULL;
}
dir_index = clks_disk_find_node_by_relative(relative);
if (dir_index < 0 || clks_disk_nodes[(u16)dir_index].type != (u8)CLKS_DISK_NODE_DIR) {
return 0ULL;
}
for (i = 0U; i < clks_disk_nodes_used; i++) {
if (clks_disk_nodes[i].used == CLKS_FALSE) {
continue;
}
if ((u16)dir_index == i) {
continue;
}
if (clks_disk_nodes[i].parent == (u16)dir_index) {
count++;
}
}
return count;
}
clks_bool clks_disk_get_child_name(const char *dir_path, u64 index, char *out_name, usize out_name_size) {
char relative[CLKS_DISK_PATH_MAX];
i32 dir_index;
u64 current = 0ULL;
u16 i;
if (out_name == CLKS_NULL || out_name_size == 0U) {
return CLKS_FALSE;
}
if (clks_disk_path_to_relative(dir_path, relative, sizeof(relative)) == CLKS_FALSE) {
return CLKS_FALSE;
}
if (clks_disk_ready == CLKS_FALSE || clks_disk_formatted == CLKS_FALSE) {
return CLKS_FALSE;
}
dir_index = clks_disk_find_node_by_relative(relative);
if (dir_index < 0 || clks_disk_nodes[(u16)dir_index].type != (u8)CLKS_DISK_NODE_DIR) {
return CLKS_FALSE;
}
for (i = 0U; i < clks_disk_nodes_used; i++) {
const char *base;
usize base_len;
if (clks_disk_nodes[i].used == CLKS_FALSE || clks_disk_nodes[i].parent != (u16)dir_index ||
i == (u16)dir_index) {
continue;
}
if (current != index) {
current++;
continue;
}
base = clks_disk_basename(clks_disk_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;
}
clks_bool clks_disk_mkdir(const char *path) {
char relative[CLKS_DISK_PATH_MAX];
i32 node_index;
if (clks_disk_path_to_relative(path, relative, sizeof(relative)) == CLKS_FALSE) {
return CLKS_FALSE;
}
if (clks_disk_ready == CLKS_FALSE || clks_disk_formatted == CLKS_FALSE) {
return CLKS_FALSE;
}
if (relative[0] == '\0') {
return CLKS_TRUE;
}
if (clks_disk_ensure_dir_hierarchy(relative) == CLKS_FALSE) {
return CLKS_FALSE;
}
node_index = clks_disk_find_node_by_relative(relative);
if (node_index < 0 || clks_disk_nodes[(u16)node_index].type != (u8)CLKS_DISK_NODE_DIR) {
return CLKS_FALSE;
}
return (clks_disk_meta_flush() == CLKS_TRUE) ? CLKS_TRUE : CLKS_FALSE;
}
clks_bool clks_disk_write_all(const char *path, const void *data, u64 size) {
char relative[CLKS_DISK_PATH_MAX];
char parent[CLKS_DISK_PATH_MAX];
const void *payload_data = CLKS_NULL;
clks_bool payload_heap_owned = CLKS_FALSE;
i32 parent_index;
i32 node_index;
if (clks_disk_path_to_relative(path, relative, sizeof(relative)) == CLKS_FALSE) {
return CLKS_FALSE;
}
if (clks_disk_ready == CLKS_FALSE || clks_disk_formatted == CLKS_FALSE || relative[0] == '\0') {
return CLKS_FALSE;
}
if (clks_disk_split_parent(relative, parent, sizeof(parent)) == CLKS_FALSE) {
return CLKS_FALSE;
}
if (clks_disk_ensure_dir_hierarchy(parent) == CLKS_FALSE) {
return CLKS_FALSE;
}
parent_index = clks_disk_find_node_by_relative(parent);
if (parent_index < 0 || clks_disk_nodes[(u16)parent_index].type != (u8)CLKS_DISK_NODE_DIR) {
return CLKS_FALSE;
}
node_index = clks_disk_find_node_by_relative(relative);
if (node_index >= 0 && clks_disk_nodes[(u16)node_index].type != (u8)CLKS_DISK_NODE_FILE) {
return CLKS_FALSE;
}
if (clks_disk_build_file_payload(data, size, &payload_data, &payload_heap_owned) == CLKS_FALSE) {
return CLKS_FALSE;
}
if (node_index >= 0) {
clks_disk_node_release_heap_data((u16)node_index);
}
node_index =
clks_disk_create_or_update_node(relative, (u8)CLKS_DISK_NODE_FILE, (u16)parent_index, payload_data, size);
if (node_index < 0) {
if (payload_heap_owned == CLKS_TRUE) {
clks_kfree((void *)payload_data);
}
return CLKS_FALSE;
}
clks_disk_node_set_heap_data((u16)node_index, payload_heap_owned);
if (clks_disk_meta_flush() == CLKS_FALSE) {
return CLKS_FALSE;
}
return CLKS_TRUE;
}
clks_bool clks_disk_append(const char *path, const void *data, u64 size) {
char relative[CLKS_DISK_PATH_MAX];
i32 node_index;
const void *old_data;
u64 old_size;
u64 new_size;
void *merged;
if (clks_disk_path_to_relative(path, relative, sizeof(relative)) == CLKS_FALSE) {
return CLKS_FALSE;
}
if (clks_disk_ready == CLKS_FALSE || clks_disk_formatted == CLKS_FALSE || relative[0] == '\0') {
return CLKS_FALSE;
}
if (size > 0ULL && data == CLKS_NULL) {
return CLKS_FALSE;
}
node_index = clks_disk_find_node_by_relative(relative);
if (node_index < 0) {
return clks_disk_write_all(path, data, size);
}
if (clks_disk_nodes[(u16)node_index].type != (u8)CLKS_DISK_NODE_FILE) {
return CLKS_FALSE;
}
old_data = clks_disk_nodes[(u16)node_index].data;
old_size = clks_disk_nodes[(u16)node_index].size;
if (old_size > (0xFFFFFFFFFFFFFFFFULL - size)) {
return CLKS_FALSE;
}
new_size = old_size + size;
if (new_size == 0ULL) {
return clks_disk_write_all(path, clks_disk_empty_file_data, 0ULL);
}
merged = clks_kmalloc((usize)new_size);
if (merged == CLKS_NULL) {
return CLKS_FALSE;
}
if (old_size > 0ULL && old_data != CLKS_NULL) {
clks_memcpy(merged, old_data, (usize)old_size);
}
if (size > 0ULL) {
clks_memcpy((u8 *)merged + (usize)old_size, data, (usize)size);
}
if (clks_disk_write_all(path, merged, new_size) == CLKS_FALSE) {
clks_kfree(merged);
return CLKS_FALSE;
}
clks_kfree(merged);
return CLKS_TRUE;
}
clks_bool clks_disk_remove(const char *path) {
char relative[CLKS_DISK_PATH_MAX];
i32 node_index;
u16 i;
if (clks_disk_path_to_relative(path, relative, sizeof(relative)) == CLKS_FALSE) {
return CLKS_FALSE;
}
if (clks_disk_ready == CLKS_FALSE || clks_disk_formatted == CLKS_FALSE) {
return CLKS_FALSE;
}
if (relative[0] == '\0') {
return CLKS_FALSE;
}
node_index = clks_disk_find_node_by_relative(relative);
if (node_index < 0) {
return CLKS_FALSE;
}
if (clks_disk_nodes[(u16)node_index].type == (u8)CLKS_DISK_NODE_DIR) {
for (i = 0U; i < clks_disk_nodes_used; i++) {
if (clks_disk_nodes[i].used == CLKS_FALSE) {
continue;
}
if (clks_disk_nodes[i].parent == (u16)node_index) {
return CLKS_FALSE;
}
}
}
clks_disk_node_release_heap_data((u16)node_index);
clks_memset(&clks_disk_nodes[(u16)node_index], 0, sizeof(clks_disk_nodes[(u16)node_index]));
if (clks_disk_meta_flush() == CLKS_FALSE) {
return CLKS_FALSE;
}
return CLKS_TRUE;
}
u64 clks_disk_node_count(void) {
u16 i;
u64 used = 0ULL;
if (clks_disk_ready == CLKS_FALSE || clks_disk_formatted == CLKS_FALSE) {
return 0ULL;
}
for (i = 0U; i < clks_disk_nodes_used; i++) {
if (clks_disk_nodes[i].used == CLKS_TRUE) {
used++;
}
}
return used;
}
Reference in New Issue View Git Blame Copy Permalink