fs.c

Go to the documentation of this file.

//fs.c -- filesystem tooling
#include "fs.h"
#include "ide.h"
#include "../mem/heap.h"
#include "../lib/err.h"
#include "../lib/utils.h"
 
#define FS_TABLE_LBA 1 //set lable
 
/**
 * @brief the fs_entry_t type
 *
 * fs_entry_t is made up of name and lba
 * @param name, the filename string
 * @param lba, the logical block address on disk
 *
 * @see files[], fsfind(), fsadd()
 */
typedef struct {
    char *name;
    uint32_t lba;
} fs_entry_t;
 
static fs_entry_t files[MAX_FILES]; //create files and ints that are static
static int file_count = 0;
static arena_t *fs_heap = NULL;
static uint32_t lba_map[MAX_FILES]; //track which LBAs are in use
 
/**
 * @brief fsinit initializes the filesystem table from disk
 *
 * fsinit is a function that reads the filesystem table from the disk,
 * parses all existing file entries, and rebuilds the lba map
 * @param heap, the arena to allocate filename strings from
 *
 * using fsinit is done with
 * @code{.c}
 * #include "../fs/fs.h" //or just fs.h
 * fsinit(fs_arena);
 * @endcode
 *
 * @see ffsinit(), fsadd(), fslist()
 */
void __fsinit(arena_t *heap) {
    uint8_t sector[512]; //create sectors and fs_heap for simplicity
    fs_heap = heap;
    
    //clear lba map (add these 3 lines)
    for (int i = 0; i < MAX_FILES; i++) {
        lba_map[i] = 0;
    }
    
    irsec(FS_TABLE_LBA, sector);
    
    //check if table exists (magic 'FS' descriptor)
    if (sector[0] == 'F' && sector[1] == 'S') { //check for it
        file_count = sector[2]; //create the file count
        for (int i = 0; i < file_count && i < MAX_FILES; i++) { //do the following aslong as we arent making more then max files and file count is over tmp ctr
            int ofst = 3 + i * 36; //calc offset 
            files[i].name = alc(fs_heap, 32); //make the file in array counter name section be the allocation of alc fsheap 32
            for (int j = 0; j < 32; j++) { //do 32 times
        files[i].name[j] = (char)sector[ofst + j]; //files i for name j is sector offset + j
            }
            files[i].lba = (sector[ofst + 32] << 24) | //the file array for lba is the bit calculations for actual sector area
                          (sector[ofst + 33] << 16) |
                          (sector[ofst + 34] << 8) |
                          sector[ofst + 35];
        }
        
        //rebuild map from existing files
        for (int i = 0; i < file_count; i++) {
            uint32_t lba = files[i].lba;
            //calc which index this lba corresponds to 
            //lba 100 = index 0, lba 102 = index 1, lba 104 = index 2, etc
            if (lba >= 100 && ((lba - 100) % 2) == 0) { //if lba over or equal 100 and lba - 100 % 2 is 0 then
                uint32_t idx = (lba - 100) / 2; //populate idx
                if (idx < MAX_FILES) { //ensure under max files
                    lba_map[idx] = lba;
                }
            }
        }
    }
}
 
/**
 * @brief fsadd adds a new file entry to the filesystem
 *
 * fsadd is a function that registers a file name and lba into the
 * in-memory file table and persists it to disk
 * @param heap, the arena to allocate the filename from
 * @param name, the name of the file to add
 * @param lba, the logical block address where the file lives
 *
 * using fsadd is done with
 * @code{.c}
 * #include "../fs/fs.h" //or just fs.h
 * fsadd(fs_arena, "myfile.txt", 100);
 * @endcode
 *
 * @see fsinit(), fsfind(), fsdelete()
 */
void __fsadd(arena_t *heap, const char *name, uint32_t lba) {
    assert(file_count < MAX_FILES, "fs: too many files"); //err han
    assert(heap != NULL, "fsadd: heap is NULL");
    
    files[file_count].name = alc(heap, 32); //file count name is the heap, we strcpy the file name to name, and make lba lba, then increment
    strcpy(files[file_count].name, name);
    files[file_count].lba = lba;
    file_count++;
    
    //save to disk
    uint8_t sector[512]; //create sector
    for (int i = 0; i < 512; i++) sector[i] = 0; //make sector i 0 to fully reset sector, data overwrite
    sector[0] = 'F'; //make sec 0 F and 1 S for the magic label
    sector[1] = 'S';
    sector[2] = (uint8_t)file_count; //make the second one the count
    
    for (int i = 0; i < file_count; i++) { //do infinitley aslong as i is less than file count
        int offset = 3 + i * 36; //calc
        for (int j = 0; j < 32 && files[i].name[j]; j++) { //do 32 times aslong as its under file name j
            sector[offset + j] = (uint8_t)files[i].name[j]; //setup ofst
        }
        sector[offset + 32] = (uint8_t)(files[i].lba >> 24) & 0xFF; //setup sector positions
        sector[offset + 33] = (files[i].lba >> 16) & 0xFF;
        sector[offset + 34] = (files[i].lba >> 8) & 0xFF;
        sector[offset + 35] = files[i].lba & 0xFF;
    }
    
    iwrt(FS_TABLE_LBA, sector); //write the sector and table to ide
}
 
/**
 * @brief fsfind searches the filesystem for a file by name
 *
 * fsfind is a function that looks up a file in the in-memory table
 * and returns its lba if found
 * @param name, the filename to search for
 *
 * using fsfind is done with
 * @code{.c}
 * #include "../fs/fs.h" //or just fs.h
 * uint32_t lba = fsfind("myfile.txt");
 * if (lba == 0) {
 *     //file doesnt exist
 * }
 * @endcode
 *
 * @see fslist(), fsread(), fs_entry_t
 */
uint32_t __fsfind(const char *name) {
    for (int i = 0; i < file_count; i++) { //do aslong as file count is under i
        if (strcmp(files[i].name, name) == 0) { //compare names
            return files[i].lba; //if it matches return, else exit
        }
    }
    return 0;
}
 
/**
 * @brief fslist returns a newline-separated listing of all files
 *
 * fslist is a function that builds a string containing all filenames
 * in the in-memory filesystem table separated by newlines
 *
 * using fslist is done with
 * @code{.c}
 * #include "../fs/fs.h" //or just fs.h
 * char *listing = fslist();
 * prt(0, 0, listing, 0x0F);
 * @endcode
 *
 * @see fsfind(), fsread()
 */
char *__fslist(void) {
    static char buff[512];
    int pos = 0; //make pos and buffer
 
    if (file_count == 0) {
        buff[0] = '\0';
        return buff;
    }
    
    for (int i = 0; i < file_count; i++) { //youve seen this alot, you get it
        for (int j = 0; files[i].name[j]; j++) {
            if (pos < 511) buff[pos++] = files[i].name[j]; //if pos is under 511 we make buf pos ++ name so its always 512 or over 
        }
        if (pos < 511) buff[pos++] = '\n'; //read above but for newline and if nothing there worked
    }
    buff[pos] = '\0'; //null term
    
    return buff;
}
 
/**
 * @brief fsnextlba finds the next unused lba for a new file
 *
 * fsnextlba is a function that scans the lba map for a free slot
 * and returns an unused lba starting from sector 100
 *
 * using fsnextlba is done with
 * @code{.c}
 * #include "../fs/fs.h" //or just fs.h
 * uint32_t new_lba = fsnextlba();
 * @endcode
 *
 * @see fswrite(), fswriteb()
 */
uint32_t __fsnextlba(void) {
    //find first unused lba
    for (int i = 0; i < MAX_FILES; i++) {
        if (lba_map[i] == 0) {
            uint32_t new_lba = 100 + (uint32_t)(i * 2); //start at sector 100, each file gets its own sector
            lba_map[i] = new_lba;
            return new_lba;
        }
    }
    //if we get here, no free lba
    assert(0, "fsnextlba: no free lbas available");
    return 0;
}
 
/**
 * @brief fsread reads a files contents from disk into memory
 *
 * fsread is a function that looks up a file by name, reads its sector
 * from disk, and returns the contents as a string
 * @param name, the filename to read
 *
 * using fsread is done with
 * @code{.c}
 * #include "../fs/fs.h" //or just fs.h
 * char *content = fsread("myfile.txt");
 * if (content != NULL) {
 *     prt(0, 0, content, 0x0F);
 * }
 * @endcode
 *
 * @see fswrite(), fsfind(), irsec()
 */
char *__fsread(const char *name) {
    uint32_t lba = fsfind(name); //set lba to the fsfind
    if (lba == 0) return NULL; //if lba none return null
    
    static char content[512]; //make content and sector
    uint8_t sector[512];
    
    irsec(lba, sector); //read lba and sector
    
    //copy sector content to string - preserve all characters
    int i;
    for (i = 0; i < 511 && sector[i] != 0; i++) {
        content[i] = (char)sector[i]; //keep raw byte, prefer no filtering
    }
    content[i] = '\0'; //null term
    
    return content;
}
 
/**
 * @brief fswrite writes text content to a file on disk
 *
 * fswrite is a function that writes a text string to a file, creating
 * the file entry if it doesnt exist yet
 * @param heap, the arena to allocate from if a new file entry is created
 * @param name, the filename to write to
 * @param content, the text string to write
 *
 * using fswrite is done with
 * @code{.c}
 * #include "../fs/fs.h" //or just fs.h
 * fswrite(fs_arena, "hello.txt", "hello, world!");
 * @endcode
 *
 * @see fsread(), fswriteb(), iwrt()
 */
int __fswrite(arena_t *heap, const char *name, const char *content) {
    uint32_t lba = fsfind(name); //make lba
    
    //if file exists, use its lba
    if (lba == 0) {
        //file doesn't exist, get next free lba
        lba = fsnextlba();
    }
    
    //write content to disk
    uint8_t sector[512]; //sector
    for (int i = 0; i < 512; i++) sector[i] = 0; //do 512 times, resets sector
    for (int i = 0; content[i] && i < 511; i++) sector[i] = (uint8_t)content[i]; //writes content
    
    iwrt(lba, sector); //use ide to write
    
    //if file didn't exist add to filesystem
    if (fsfind(name) == 0) {
        fsadd(heap, name, lba); //add
    }
    
    return (int)lba; //ret
}
 
/**
 * @brief fsdelete removes a file from the filesystem
 *
 * fsdelete is a function that finds a file by name, zeros out its
 * data sector on disk, marks its lba as free, and removes it from
 * the in-memory file table
 * @param name, the filename to delete
 *
 * using fsdelete is done with
 * @code{.c}
 * #include "../fs/fs.h" //or just fs.h
 * fsdelete("oldfile.txt");
 * @endcode
 *
 * @see fsadd(), fsfind(), fswrite()
 */
void __fsdelete(const char *name) {
    int index = -1; //current neg 1
    
    //find the file
    for (int i = 0; i < file_count; i++) { //do until out of files
        if (strcmp(files[i].name, name) == 0) { //compare name, if 0 set index to i and break
            index = i;
            break;
        }
    }
    
    assert(index != -1, "fsdelete: file not found"); //if index never changed it doesnt exist
    
    //mark lba as free
    for (int i = 0; i < MAX_FILES; i++) {
        if (lba_map[i] == files[index].lba) {
            lba_map[i] = 0;
            break;
        }
    }
    
    //shift remaining files left
    for (int i = index; i < file_count - 1; i++) {
        files[i].name = files[i+1].name;
        files[i].lba = files[i+1].lba;
    }
    
    file_count--;
    
    //rebuild the filesystem table on disk
    uint8_t sector[512];
    for (int i = 0; i < 512; i++) sector[i] = 0;
    sector[0] = 'F'; //rebuild F and S
    sector[1] = 'S';
    sector[2] = (uint8_t)file_count;
    
    for (int i = 0; i < file_count; i++) {
        int offset = 3 + i * 36;
        for (int j = 0; j < 32 && files[i].name[j]; j++) {
            sector[offset + j] = (uint8_t)files[i].name[j];
        } //do all this offset bullshit
        sector[offset + 32] = (uint8_t)(files[i].lba >> 24) & 0xFF;
        sector[offset + 33] = (files[i].lba >> 16) & 0xFF;
        sector[offset + 34] = (files[i].lba >> 8) & 0xFF;
        sector[offset + 35] = files[i].lba & 0xFF;
    }
    
    iwrt(FS_TABLE_LBA, sector); //write it
    
    //zero out the actual file data sector
    uint8_t zero_sector[512]; //make sector
    for (int i = 0; i < 512; i++) zero_sector[i] = 0;
    iwrt(files[index].lba, zero_sector); //write final say
}
 
/**
 * @brief fswriteb writes raw byte data to a file on disk
 *
 * fswriteb is a function that writes raw bytes to a file sector,
 * limited to 511 bytes per sector, creating the file entry if needed
 * @param heap, the arena to allocate from if a new file entry is created
 * @param name, the filename to write to
 * @param data, the raw byte buffer to write
 * @param size, the number of bytes to write
 *
 * using fswriteb is done with
 * @code{.c}
 * #include "../fs/fs.h" //or just fs.h
 * uint8_t mydata[256];
 * fswriteb(fs_arena, "data.bin", mydata, 256);
 * @endcode
 *
 * @see fsreadb(), fswrite(), iwrt()
 */
int __fswriteb(arena_t *heap, const char *name, uint8_t *data, uint32_t size) {
    uint32_t lba = fsfind(name);
    
    if (lba == 0) { //get next lba
        lba = fsnextlba();
    }
    
    //write entire sector
    uint8_t sector[512];
    for (int i = 0; i < 512; i++) sector[i] = 0;
    
    uint32_t btw = (size > 511) ? 511 : size; //limit to 511 bytes per sector
    for (uint32_t i = 0; i < btw; i++) {
        sector[i] = data[i];
    }
    
    iwrt(lba, sector);
    
    if (fsfind(name) == 0) {
        fsadd(heap, name, lba);
    }
    
    return (int)lba;
}
 
/**
 * @brief fsreadb reads raw byte data from a file off disk
 *
 * fsreadb is a function that reads raw bytes from a file sector
 * into a provided buffer
 * @param name, the filename to read
 * @param buffer, the buffer to store the raw bytes in
 * @param max_size, the maximum number of bytes to read
 *
 * using fsreadb is done with
 * @code{.c}
 * #include "../fs/fs.h" //or just fs.h
 * uint8_t buffer[512];
 * int bytes_read = fsreadb("data.bin", buffer, 512);
 * @endcode
 *
 * @see fswriteb(), fsread(), irsec()
 */
int __fsreadb(const char *name, uint8_t *buffer, uint32_t max_size) {
    uint32_t lba = fsfind(name);
    if (lba == 0) return 0;
    
    uint8_t sector[512];
    irsec(lba, sector);
    
    uint32_t btr = (max_size > 512) ? 512 : max_size;
    for (uint32_t i = 0; i < btr; i++) { //make buff sec
        buffer[i] = sector[i];
    }
    
    return (int)btr; //return number of bytes read
}