Filesystem Stack #

#include <std/fs/fs.h>  // master header: pulls in all modules' types/signatures

#include <std/fs/block.h>

struct BlockDevice {
    unsigned long  sector_count;
    unsigned long  sector_size;   // typically 512

    // A device whose read()/write() call drv.read(...)/drv.write(...).
    // drv must outlive it.
    generic<T: BlockDriver>
    static struct BlockDevice new(&T drv, unsigned long sector_count, unsigned long sector_size);

    int read(unsigned long lba, []unsigned char buf);         // 0 on success
    int write(unsigned long lba, []const unsigned char buf);
    int  valid() const;
}

#include <std/fs/block.h>
#include <std/mem.h>

// A BlockDriver: any type with these two methods.
struct RamDisk {
    unsigned char bytes[64 * 512];

    int read(unsigned long lba, []unsigned char buf);
    int write(unsigned long lba, []const unsigned char buf);
};

int RamDisk::read(unsigned long lba, []unsigned char buf) {
    unsigned long off = lba * 512UL;
    if (off + buf.len > 64UL * 512UL) return -1;
    std::safe_memcpy(buf, self.bytes[off..off + buf.len]);
    return 0;
}

int RamDisk::write(unsigned long lba, []const unsigned char buf) {
    unsigned long off = lba * 512UL;
    if (off + buf.len > 64UL * 512UL) return -1;
    std::safe_memcpy(self.bytes[off..off + buf.len], buf);
    return 0;
}

static struct RamDisk g_disk;

int main() {
    struct BlockDevice dev = std::BlockDevice::new(&g_disk, 64UL, 512UL);
    unsigned char sector[512];
    unsafe { sector[0] = 0x55; }
    dev.write(3UL, sector[..]);
    unsafe { sector[0] = 0; }
    dev.read(3UL, sector[..]);
    unsafe { return sector[0] == 0x55 ? 0 : 1; }
}

#include <std/fs/partition.h>

struct PartEntry {
    unsigned char  status;       // 0x80 = bootable
    unsigned char  type;         // partition type byte
    unsigned long  lba_start;
    unsigned long  sector_count;
}

struct PartTable {
    PartEntry entries[4];
    int       count;             // number of non-empty entries

    // Reference into entries[], or empty (null) if idx is out of range --
    // check entry.type != PART_TYPE_EMPTY too, for a valid index that just
    // has no partition recorded there.
    const ?&PartEntry get(int idx) const;

    // Read the MBR at LBA 0 of `dev` into this table; validates the
    // 0x55/0xAA boot signature. 0 on success, -1 on error.
    int read(&BlockDevice dev);
}

unsigned long lba = 0;
match (parts.get(0)) {
    case null:    break;
    case some(e): lba = e.lba_start;
}

#include <std/fs/vfs.h>

generic<F: FileSystem> int Vfs::mount(const &char mountpoint, &F fs);     // read-write
generic<F: FsRead>     int Vfs::mount_ro(const &char mountpoint, &F fs);  // read-only

#include <std/fs/vfs.h>
#include <std/fs/tmpfs.h>
#include <std/str.h>

// A one-file read-only filesystem: "/" holds "version" (inode 1).
// Having open, read and readdir makes it an FsRead.
struct VersionFs {
    int unused_;

    int           open(const &char path, int flags, &VfsNode node_out);
    unsigned long read(unsigned long inode, unsigned long offset, []unsigned char buf);
    int           readdir(unsigned long inode, fn void(&VfsNode, ?&Erased) cb, ?&Erased user);
};

static void fill_file_(&VfsNode n) {
    n.name[0] = 'v'; n.name[1] = '\0';
    n.type = VFS_TYPE_FILE;
    n.size = 6UL;
    n.inode = 1UL;
}

int VersionFs::open(const &char path, int flags, &VfsNode node_out) {
    if ((flags & (VFS_O_WRITE | VFS_O_CREATE)) != 0) return -1;
    if (std::str_eq(path, "/")) {
        node_out.name[0] = '\0';
        node_out.type = VFS_TYPE_DIR;
        node_out.size = 0UL;
        node_out.inode = 0UL;
        return 0;
    }
    if (std::str_eq(path, "/version")) { fill_file_(node_out); return 0; }
    return -1;
}

unsigned long VersionFs::read(unsigned long inode, unsigned long offset, []unsigned char buf) {
    if (inode != 1UL || offset >= 6UL) return 0UL;
    unsigned long n = 6UL - offset;
    if (n > buf.len) n = buf.len;
    []const char text = std::str_bytes("1.4.2\n");
    unsigned long i = 0UL;
    while (i < n) {
        buf[i] = (unsigned char)text[offset + i];
        i = i + 1UL;
    }
    return n;
}

int VersionFs::readdir(unsigned long inode, fn void(&VfsNode, ?&Erased) cb, ?&Erased user) {
    if (inode != 0UL) return -1;
    struct VfsNode e;
    fill_file_(&e);
    cb(&e, user);
    return 1;
}

// Generic over any FsRead: the size of a file, straight on the driver.
generic<F: FsRead>
long long file_size(&F fs, const &char path) {
    struct VfsNode n;
    if (fs.open(path, VFS_O_READ, &n) != 0) return -1LL;
    return (long long)n.size;
}

static void count_entry(&VfsNode n, &int seen) { *seen = *seen + 1; }

static struct VersionFs g_ver;
static struct TmpfsCtx  g_tmp;

int main() {
    std::vfs_init();
    g_tmp.init();
    std::vfs_root.mount("/tmp", &g_tmp);       // TmpfsCtx: a FileSystem
    std::vfs_root.mount_ro("/etc", &g_ver);    // VersionFs: FsRead only

    if (file_size(&g_ver, "/version") != 6LL) return 1;
    if (file_size(&g_tmp, "/") != 0LL) return 2;   // the same function over tmpfs

    struct VfsNode f;
    if (std::vfs_root.open("/etc/version", VFS_O_READ, &f) != 0) return 3;
    unsigned char buf[8];
    if (f.read(0UL, buf[..]) != 6UL) return 4;
    if (std::vfs_root.mkdir("/etc/x") == 0) return 5;   // read-only mount refuses

    struct VfsNode dir;
    std::vfs_root.open("/etc", VFS_O_READ, &dir);
    int seen = 0;
    dir.readdir(count_entry, &seen);
    return seen == 1 ? 0 : 6;
}

struct VfsOps {
    ?fn int(&Erased ctx, const &char path, int flags, &VfsNode node_out) open;
    ?fn int(&Erased ctx, const &char path) unlink;
    ?fn int(&Erased ctx, const &char path) mkdir;
    ?fn unsigned long(&Erased ctx, unsigned long inode, unsigned long off, []unsigned char buf) read;
    ?fn unsigned long(&Erased ctx, unsigned long inode, unsigned long off, []const unsigned char buf) write;
    ?fn int(&Erased ctx, unsigned long inode,
            fn void(&VfsNode, ?&Erased) cb, ?&Erased user) readdir;
}

struct VfsNode {
    char          name[64];
    int           type;      // VFS_TYPE_FILE / VFS_TYPE_DIR
    unsigned long size;
    unsigned long inode;
    ?&struct VfsMount fs_ctx; // driver-internal: the owning VfsMount

    unsigned long read(unsigned long offset, []unsigned char buf);
    unsigned long write(unsigned long offset, []const unsigned char buf);

    // Calls cb(entry, user) for each child of this directory; returns the
    // count, -1 on error. T is the type of your user data.
    generic<T> int readdir(fn void(&VfsNode, &T) cb, &T user);
}

extern struct Vfs vfs_root;  // global VFS instance
void vfs_init();             // zero it out; call once before any mount

struct Vfs {
    // 0 on success, -1 if every mount slot is taken. fs must outlive the mount.
    generic<F: FileSystem> int mount(const &char mountpoint, &F fs);
    generic<F: FsRead>     int mount_ro(const &char mountpoint, &F fs);

    int  unmount(const &char mountpoint);
    int  open(const &char path, int flags, &VfsNode node_out);   // 0 on success
    int  unlink(const &char path);
    int  mkdir(const &char path);
}

#include <std/fs/fat.h>

struct FatCtx {
    struct BlockDevice dev;
    unsigned long  partition_lba;      // LBA of FAT32 partition start
    struct FatBpb  bpb;                // raw BIOS Parameter Block
    unsigned long  fat_lba;            // LBA of FAT region
    unsigned long  data_lba;           // LBA of first data cluster
    unsigned long  root_cluster;       // cluster of root directory
    unsigned long  bytes_per_cluster;

    // Initialise this context in place from a block device partition
    // starting at `lba` (the device is copied into `dev`). 0 on success.
    int init(&BlockDevice dev, unsigned long lba);

    // Read a cluster into `buf` (must be >= bytes_per_cluster bytes).
    int read_cluster(unsigned long cluster, []unsigned char buf);

    // Follow the FAT chain to the cluster at position `idx` from `start_cluster`.
    unsigned long follow_fat(unsigned long start_cluster, unsigned long idx);

    // FsRead: mount with vfs_root.mount_ro(mountpoint, &ctx)
    int           open(const &char path, int flags, &VfsNode node_out);
    unsigned long read(unsigned long inode, unsigned long offset, []unsigned char buf);
    generic<T> int readdir(unsigned long inode, fn void(&VfsNode, ?&T) cb, ?&T user);
}

#include <std/fs/ext.h>

struct Ext2Super {
    unsigned int  inodes_count;
    unsigned int  blocks_count;
    unsigned int  reserved_blocks;
    unsigned int  free_blocks;
    unsigned int  free_inodes;
    unsigned int  first_data_block;
    unsigned int  log_block_size;   // block_size = 1024 << log_block_size
    unsigned int  log_frag_size;
    unsigned int  blocks_per_group;
    unsigned int  frags_per_group;
    unsigned int  inodes_per_group;
    unsigned short magic;           // must be EXT2_SUPER_MAGIC (0xEF53)
    // ...plus timestamp/mount-count/OS fields not needed by callers
}

struct Ext2Inode {
    unsigned short mode;
    unsigned int   size_lo;
    unsigned short links_count;
    unsigned int   blocks_count;  // 512-byte blocks
    unsigned int   block[15];     // 12 direct + 1 indirect + 1 dbl + 1 trpl
    // ...plus uid/gid/timestamps/flags
}

struct Ext2Ctx {
    struct BlockDevice dev;
    struct Ext2Super   super;
    unsigned long      block_size;
    unsigned long      inodes_per_group;
    unsigned long      blocks_per_group;
    unsigned long      group_count;

    // Initialise this context in place from a block device (copied into
    // `dev`): reads the superblock at byte offset 1024 from the device's
    // LBA 0 and validates EXT2_SUPER_MAGIC. 0 on success.
    int  init(&BlockDevice dev);

    // Read block `block_no` into `buf` (must be >= block_size bytes).
    int read_block(unsigned long block_no, []unsigned char buf);

    // Read inode `ino` into `inode_out`.
    int  read_inode(unsigned long ino, &Ext2Inode inode_out);

    // Read file data for inode `ino` at byte `offset` into `buf` for `len` bytes.
    unsigned long read_file(unsigned long ino, unsigned long offset, []unsigned char buf);

    // FsRead: mount with vfs_root.mount_ro(mountpoint, &ctx)
    int           open(const &char path, int flags, &VfsNode node_out);
    unsigned long read(unsigned long inode, unsigned long offset, []unsigned char buf);
    generic<T> int readdir(unsigned long inode, fn void(&VfsNode, ?&T) cb, ?&T user);
}

#include <std/fs/tmpfs.h>

struct TmpfsInode {
    char           name[64];
    int            type;            // VFS_TYPE_FILE / VFS_TYPE_DIR
    unsigned long  parent;          // parent inode index (0 = root)
    unsigned long  data_off;        // offset into data pool (file only)
    unsigned long  size;
    int            used;
}

struct TmpfsCtx {
    TmpfsInode     inodes[32];      // TMPFS_MAX_FILES
    unsigned char  data[65536];     // TMPFS_MAX_DATA
    unsigned long  data_used;
    int            inode_count;

    // Initialise this context in place (zero-fills, creates the root).
    void init();

    // FileSystem: mount with vfs_root.mount(mountpoint, &ctx)
    int           open(const &char path, int flags, &VfsNode node_out);
    unsigned long read(unsigned long inode, unsigned long offset, []unsigned char buf);
    generic<T> int readdir(unsigned long inode, fn void(&VfsNode, ?&T) cb, ?&T user);
    unsigned long write(unsigned long inode, unsigned long offset, []const unsigned char buf);
    int           unlink(const &char path);
    int           mkdir(const &char path);
}

#include <std/fs/vfs.h>
#include <std/fs/tmpfs.h>

static struct TmpfsCtx tmp;   // 64 KiB data pool: keep it static

int main() {
    std::vfs_init();

    tmp.init();
    std::vfs_root.mount("/tmp", &tmp);

    // Write
    struct VfsNode node;
    std::vfs_root.open("/tmp/log.txt", VFS_O_WRITE | VFS_O_CREATE, &node);
    unsigned char msg[8];
    msg[0]='b'; msg[1]='o'; msg[2]='o'; msg[3]='t';
    msg[4]=' '; msg[5]='o'; msg[6]='k'; msg[7]='\n';
    node.write(0, msg[..]);

    // Read back
    struct VfsNode node2;
    std::vfs_root.open("/tmp/log.txt", VFS_O_READ, &node2);
    unsigned char buf[8];
    unsigned long n = node2.read(0, buf[..]);
    // buf[0..n] == "boot ok\n"

    return n == 8UL ? 0 : 1;
}

#include <std/fs/fs.h>

// The board HAL's SD driver: a BlockDriver (read and write sectors).
struct SdCard {
    int spi_bus;
    int read(unsigned long lba, []unsigned char buf);
    int write(unsigned long lba, []const unsigned char buf);
};

static struct SdCard g_card;
static struct FatCtx g_fat;      // FAT context holds a cluster buffer: keep it static

int mount_sd() {
    std::vfs_init();
    struct BlockDevice sd = std::BlockDevice::new(&g_card, 16UL * 1024UL * 1024UL / 512UL, 512UL);
    struct PartTable parts;
    if (parts.read(&sd) != 0) return -1;

    unsigned long part0_lba = 0UL;
    match (parts.get(0)) {
        case null:    return -1;
        case some(e): part0_lba = e.lba_start;
    }

    if (g_fat.init(&sd, part0_lba) != 0) return -1;   // copies the device
    std::vfs_root.mount_ro("/sd", &g_fat);            // FatCtx is FsRead only

    struct VfsNode node;
    if (std::vfs_root.open("/sd/config.txt", VFS_O_READ, &node) == 0) {
        unsigned char buf[256];
        unsigned long n = node.read(0UL, buf[0..256]);
        // process buf[0..n]
    }
    return 0;
}