fs.c

Go to the documentation of this file.

 
#include "icarus/icarus.h"
#include "icarus/svc.h"
#include <string.h>
 
/* ---- Internal file table entry ----------------------------------------- */
 
typedef struct {
    char     name[FS_MAX_NAME_LEN]; 
    uint16_t size;                  
    bool     used;                  
} fs_entry_t;
 
#ifndef SKIP_STATIC_ASSERTS
_Static_assert(sizeof(fs_entry_t) == (FS_MAX_NAME_LEN + 2 + 1 + 1 /* pad */),
               "fs_entry_t unexpected size");
#endif
 
/* ---- Storage ----------------------------------------------------------- */
 
static fs_entry_t fs_table[FS_MAX_FILES];
static uint8_t    fs_data[FS_MAX_FILES][FS_MAX_FILE_SIZE];
 
/* ---- Internal helpers -------------------------------------------------- */
 
static int16_t fs_find(const char *name) {
    for (uint8_t i = 0u; i < (uint8_t)FS_MAX_FILES; i++) {
        if (fs_table[i].used &&
            (strncmp(fs_table[i].name, name, FS_MAX_NAME_LEN) == 0)) {
            return (int16_t)i;
        }
    }
    return -1;
}
 
static int16_t fs_free_slot(void) {
    for (uint8_t i = 0u; i < (uint8_t)FS_MAX_FILES; i++) {
        if (!fs_table[i].used) {
            return (int16_t)i;
        }
    }
    return -1;
}
 
/* ============================================================================
 * PRIVILEGED IMPLEMENTATIONS (called from SVC handler)
 * ========================================================================= */
 
ITCM_FUNC void __fs_init(void) {
    (void)memset(fs_table, 0, sizeof(fs_table));
    (void)memset(fs_data,  0, sizeof(fs_data));
}
 
ITCM_FUNC bool __fs_create(const char *name, fs_file_t *out) {
    if ((name == NULL) || (out == NULL) || (name[0] == '\0')) {
        return false;
    }
    if (strnlen(name, FS_MAX_NAME_LEN) >= (size_t)FS_MAX_NAME_LEN) {
        return false;
    }
 
    if (fs_find(name) >= 0) {
        return false;
    }
 
    int16_t slot = fs_free_slot();
    if (slot < 0) {
        return false;
    }
 
    (void)strncpy(fs_table[slot].name, name, (size_t)FS_MAX_NAME_LEN - 1u);
    fs_table[slot].name[FS_MAX_NAME_LEN - 1] = '\0';
    fs_table[slot].size = 0u;
    fs_table[slot].used = true;
    (void)memset(fs_data[slot], 0, FS_MAX_FILE_SIZE);
 
    out->slot  = (uint8_t)slot;
    out->valid = true;
 
    return true;
}
 
ITCM_FUNC bool __fs_open(const char *name, fs_file_t *out) {
    if ((name == NULL) || (out == NULL) || (name[0] == '\0')) {
        return false;
    }
 
    int16_t slot = fs_find(name);
    if (slot < 0) {
        return false;
    }
    out->slot  = (uint8_t)slot;
    out->valid = true;
    return true;
}
 
ITCM_FUNC bool __fs_write(fs_file_t *f, const uint8_t *data, uint16_t len) {
    if ((f == NULL) || (!f->valid) || (data == NULL) || (len == 0u)) {
        return false;
    }
 
    uint8_t slot = f->slot;
    if ((slot >= (uint8_t)FS_MAX_FILES) || (!fs_table[slot].used)) {
        return false;
    }
 
    uint16_t current = fs_table[slot].size;
    if (((uint32_t)current + (uint32_t)len) > (uint32_t)FS_MAX_FILE_SIZE) {
        return false;
    }
 
    (void)memcpy(&fs_data[slot][current], data, len);
    fs_table[slot].size = (uint16_t)(current + len);
 
    return true;
}
 
ITCM_FUNC uint16_t __fs_read(fs_file_t *f, uint8_t *buf, uint16_t len,
                              uint16_t offset) {
    if ((f == NULL) || (!f->valid) || (buf == NULL) || (len == 0u)) {
        return 0u;
    }
 
    uint8_t slot = f->slot;
    if ((slot >= (uint8_t)FS_MAX_FILES) || (!fs_table[slot].used)) {
        return 0u;
    }
 
    uint16_t file_size = fs_table[slot].size;
    if (offset >= file_size) {
        return 0;
    }
 
    uint16_t available = (uint16_t)(file_size - offset);
    uint16_t to_read   = (len < available) ? len : available;
 
    (void)memcpy(buf, &fs_data[slot][offset], to_read);
 
    return to_read;
}
 
ITCM_FUNC bool __fs_delete(const char *name) {
    if ((name == NULL) || (name[0] == '\0')) {
        return false;
    }
 
    int16_t slot = fs_find(name);
    if (slot < 0) {
        return false;
    }
 
    (void)memset(&fs_table[slot], 0, sizeof(fs_entry_t));
    (void)memset(fs_data[slot],   0, FS_MAX_FILE_SIZE);
 
    return true;
}
 
ITCM_FUNC uint8_t __fs_list(fs_file_info_t *out, uint8_t max) {
    if ((out == NULL) || (max == 0u)) {
        return 0u;
    }
 
    uint8_t count = 0u;
    for (uint8_t i = 0u; (i < (uint8_t)FS_MAX_FILES) && (count < max); i++) {
        if (fs_table[i].used) {
            (void)strncpy(out[count].name, fs_table[i].name, FS_MAX_NAME_LEN);
            out[count].name[FS_MAX_NAME_LEN - 1] = '\0';
            out[count].size = fs_table[i].size;
            count++;
        }
    }
 
    return count;
}
 
ITCM_FUNC void __fs_stats(fs_stats_t *out) {
    if (out == NULL) {
        return;
    }
 
    uint32_t used = 0u;
    uint8_t  count = 0u;
    for (uint8_t i = 0u; i < (uint8_t)FS_MAX_FILES; i++) {
        if (fs_table[i].used) {
            used += fs_table[i].size;
            count++;
        }
    }
 
    const uint32_t total = (uint32_t)((uint32_t)FS_MAX_FILES * (uint32_t)FS_MAX_FILE_SIZE);
    out->total_bytes = total;
    out->used_bytes  = used;
    out->free_bytes  = total - used;
    out->file_count  = count;
}
 
/* ============================================================================
 * PUBLIC API (SVC call gates — privileged access to filesystem data)
 * ========================================================================= */
 
void fs_init(void) {
#ifndef HOST_TEST
    __asm__ volatile ("svc %0\n" : : "I" (SVC_FS_INIT));
#else
    __fs_init();
#endif
}
 
bool fs_create(const char *name, fs_file_t *out) {
#ifndef HOST_TEST
    uint32_t result;
    __asm__ volatile (
        "mov r0, %1\n"
        "mov r1, %2\n"
        "svc %3\n"
        "mov %0, r0\n"
        : "=r" (result)
        : "r" ((uint32_t)(uintptr_t)name), "r" ((uint32_t)(uintptr_t)out),
          "I" (SVC_FS_CREATE)
        : "r0", "r1"
    );
    return (bool)result;
#else
    return __fs_create(name, out);
#endif
}
 
bool fs_open(const char *name, fs_file_t *out) {
#ifndef HOST_TEST
    uint32_t result;
    __asm__ volatile (
        "mov r0, %1\n"
        "mov r1, %2\n"
        "svc %3\n"
        "mov %0, r0\n"
        : "=r" (result)
        : "r" ((uint32_t)(uintptr_t)name), "r" ((uint32_t)(uintptr_t)out),
          "I" (SVC_FS_OPEN)
        : "r0", "r1"
    );
    return (bool)result;
#else
    return __fs_open(name, out);
#endif
}
 
bool fs_write(fs_file_t *f, const uint8_t *data, uint16_t len) {
#ifndef HOST_TEST
    uint32_t result;
    __asm__ volatile (
        "mov r0, %1\n"
        "mov r1, %2\n"
        "mov r2, %3\n"
        "svc %4\n"
        "mov %0, r0\n"
        : "=r" (result)
        : "r" ((uint32_t)(uintptr_t)f), "r" ((uint32_t)(uintptr_t)data),
          "r" ((uint32_t)len), "I" (SVC_FS_WRITE)
        : "r0", "r1", "r2"
    );
    return (bool)result;
#else
    return __fs_write(f, data, len);
#endif
}
 
uint16_t fs_read(fs_file_t *f, uint8_t *buf, uint16_t len, uint16_t offset) {
#ifndef HOST_TEST
    uint32_t result;
    __asm__ volatile (
        "mov r0, %1\n"
        "mov r1, %2\n"
        "mov r2, %3\n"
        "mov r3, %4\n"
        "svc %5\n"
        "mov %0, r0\n"
        : "=r" (result)
        : "r" ((uint32_t)(uintptr_t)f), "r" ((uint32_t)(uintptr_t)buf),
          "r" ((uint32_t)len), "r" ((uint32_t)offset),
          "I" (SVC_FS_READ)
        : "r0", "r1", "r2", "r3"
    );
    return (uint16_t)result;
#else
    return __fs_read(f, buf, len, offset);
#endif
}
 
bool fs_delete(const char *name) {
#ifndef HOST_TEST
    uint32_t result;
    __asm__ volatile (
        "mov r0, %1\n"
        "svc %2\n"
        "mov %0, r0\n"
        : "=r" (result)
        : "r" ((uint32_t)(uintptr_t)name), "I" (SVC_FS_DELETE)
        : "r0"
    );
    return (bool)result;
#else
    return __fs_delete(name);
#endif
}
 
uint8_t fs_list(fs_file_info_t *out, uint8_t max) {
#ifndef HOST_TEST
    uint32_t result;
    __asm__ volatile (
        "mov r0, %1\n"
        "mov r1, %2\n"
        "svc %3\n"
        "mov %0, r0\n"
        : "=r" (result)
        : "r" ((uint32_t)(uintptr_t)out), "r" ((uint32_t)max),
          "I" (SVC_FS_LIST)
        : "r0", "r1"
    );
    return (uint8_t)result;
#else
    return __fs_list(out, max);
#endif
}
 
void fs_stats(fs_stats_t *out) {
#ifndef HOST_TEST
    __asm__ volatile (
        "mov r0, %0\n"
        "svc %1\n"
        :
        : "r" ((uint32_t)(uintptr_t)out), "I" (SVC_FS_STATS)
        : "r0"
    );
#else
    __fs_stats(out);
#endif
}