grafos_fs/

lib.rs

//! Distributed filesystem abstraction backed by leased block storage.
//!
//! `grafos-fs` provides a practical filesystem subset (open, read, write,
//! seek, readdir) on top of [`BlockLease`] storage obtained through the
//! fabricBIOS data plane. Files larger than a configurable stripe threshold
//! are automatically striped across multiple block leases for parallel I/O.
//!
//! # On-block format
//!
//! ```text
//! Block 0:           Superblock (magic "GFFS", version 1, layout offsets)
//! Blocks 1..B:       Free block bitmap (1 bit per block, packed)
//! Blocks B..I:       Inode table (fixed-size inode records)
//! Blocks I..N:       Data blocks
//! ```
//!
//! # Quick start
//!
//! ```rust
//! use grafos_fs::{FabricFs, OpenFlags};
//! use grafos_std::block::BlockBuilder;
//!
//! # grafos_std::host::reset_mock();
//! # grafos_std::host::mock_set_fbbu_num_blocks(2048);
//! let lease = BlockBuilder::new().min_blocks(2048).acquire()?;
//! let mut fs = FabricFs::format(vec![lease])?;
//!
//! let mut fh = fs.create("/hello.txt")?;
//! fs.write(&mut fh, b"hello fabric")?;
//! fs.close(fh)?;
//!
//! let fh = fs.open("/hello.txt", OpenFlags::Read)?;
//! let mut buf = [0u8; 12];
//! let n = fs.read(&fh, &mut buf)?;
//! assert_eq!(&buf[..n], b"hello fabric");
//! # Ok::<(), grafos_std::FabricError>(())
//! ```

extern crate alloc;

use alloc::collections::BTreeMap;
use alloc::string::String;
use alloc::vec;
use alloc::vec::Vec;
use core::cmp;

use grafos_std::block::{BlockLease, BLOCK_SIZE};
use grafos_std::error::{FabricError, Result};
use serde::{Deserialize, Serialize};

const SUPERBLOCK_MAGIC: [u8; 4] = *b"GFFS";
const SUPERBLOCK_VERSION: u32 = 1;
const INODE_SIZE: usize = 256;
const INODES_PER_BLOCK: usize = BLOCK_SIZE / INODE_SIZE;
const MAX_DIRECT_BLOCKS: usize = 12;
const ROOT_INODE_ID: u64 = 0;
const MAX_NAME_LEN: usize = 255;

// Default striping parameters
const DEFAULT_STRIPE_THRESHOLD: u64 = 1024 * 1024; // 1 MB
const DEFAULT_STRIPE_SIZE: u32 = 256; // blocks per stripe unit (128 KB)

/// File type constants.
const FILE_TYPE_FILE: u8 = 1;
const FILE_TYPE_DIR: u8 = 2;

// --- On-block structures ---

/// Superblock stored at block 0 of lease 0.
#[derive(Debug, Clone, Serialize, Deserialize)]
struct Superblock {
    magic: [u8; 4],
    version: u32,
    block_size: u32,
    total_blocks: u64,
    inode_table_start: u64,
    data_start: u64,
    free_bitmap_start: u64,
    next_inode_id: u64,
    inode_table_blocks: u64,
}

/// On-disk inode record.
#[derive(Debug, Clone, Serialize, Deserialize)]
struct Inode {
    inode_id: u64,
    file_type: u8,
    size: u64,
    block_count: u32,
    direct_blocks: [u64; MAX_DIRECT_BLOCKS],
    indirect_block: u64,
    created_at: u64,
    modified_at: u64,
    name_hash: u64,
}

impl Inode {
    fn new(inode_id: u64, file_type: u8) -> Self {
        Inode {
            inode_id,
            file_type,
            size: 0,
            block_count: 0,
            direct_blocks: [0; MAX_DIRECT_BLOCKS],
            indirect_block: 0,
            created_at: 0,
            modified_at: 0,
            name_hash: 0,
        }
    }
}

/// Directory entry stored in directory data blocks.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DirEntry {
    /// Inode identifier for this directory entry.
    pub inode_id: u64,
    /// UTF-8 file or directory name.
    pub name: String,
    /// Type tag (`FILE_TYPE_FILE` or `FILE_TYPE_DIR`).
    pub file_type: u8,
}

/// File metadata returned by stat().
#[derive(Debug, Clone)]
pub struct FileStat {
    /// File size in bytes.
    pub size: u64,
    /// Type tag (`FILE_TYPE_FILE` or `FILE_TYPE_DIR`).
    pub file_type: u8,
    /// Number of allocated data blocks.
    pub block_count: u32,
    /// Creation timestamp (unix seconds in current implementation semantics).
    pub created_at: u64,
    /// Last modification timestamp (unix seconds in current implementation semantics).
    pub modified_at: u64,
}

/// Flags for opening files.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OpenFlags {
    /// Open for reads only.
    Read,
    /// Open for writes only.
    Write,
    /// Open for both reads and writes.
    ReadWrite,
}

/// Position for seek operations.
#[derive(Debug, Clone, Copy)]
pub enum SeekFrom {
    /// Seek from start of file.
    Start(u64),
    /// Seek relative to current cursor position.
    Current(i64),
    /// Seek relative to end of file.
    End(i64),
}

/// Handle to an open file.
#[derive(Debug)]
pub struct FileHandle {
    inode_id: u64,
    position: u64,
    flags: OpenFlags,
}

/// Distributed filesystem backed by leased block storage.
///
/// Stores metadata (inodes, directory entries) and data on one or more
/// [`BlockLease`]s. Files larger than `stripe_threshold` are striped
/// round-robin across all leases.
pub struct FabricFs {
    leases: Vec<BlockLease>,
    superblock: Superblock,
    // In-memory caches
    inode_cache: BTreeMap<u64, Inode>,
    dir_cache: BTreeMap<u64, Vec<DirEntry>>,
    dirty_inodes: BTreeMap<u64, bool>,
    dirty_dirs: BTreeMap<u64, bool>,
    // Striping config
    stripe_threshold: u64,
    stripe_size: u32,
    // Bitmap cache for primary lease
    bitmap_cache: Vec<u8>,
    bitmap_dirty: bool,
}

impl FabricFs {
    /// Format leases with a fresh filesystem and return a mounted instance.
    ///
    /// Writes a superblock to block 0, initializes the free bitmap and inode
    /// table, and creates the root directory inode.
    pub fn format(leases: Vec<BlockLease>) -> Result<Self> {
        if leases.is_empty() {
            return Err(FabricError::IoError(-1));
        }

        let total_blocks = leases[0].block().num_blocks();
        if total_blocks < 16 {
            return Err(FabricError::CapacityExceeded);
        }

        // Layout: block 0 = superblock, blocks 1..B = bitmap, B..I = inode table, I..N = data
        let bitmap_blocks = total_blocks.div_ceil(BLOCK_SIZE as u64 * 8);
        let free_bitmap_start = 1u64;
        let inode_table_start = free_bitmap_start + bitmap_blocks;
        let inode_table_blocks = cmp::max(4, total_blocks / 64);
        let data_start = inode_table_start + inode_table_blocks;

        if data_start >= total_blocks {
            return Err(FabricError::CapacityExceeded);
        }

        let superblock = Superblock {
            magic: SUPERBLOCK_MAGIC,
            version: SUPERBLOCK_VERSION,
            block_size: BLOCK_SIZE as u32,
            total_blocks,
            inode_table_start,
            data_start,
            free_bitmap_start,
            next_inode_id: 1,
            inode_table_blocks,
        };

        // Write superblock
        let sb_bytes = Self::serialize_superblock(&superblock);
        leases[0].block().write_block(0, &sb_bytes)?;

        // Initialize bitmap — mark metadata blocks as used
        let bitmap_size = (total_blocks as usize).div_ceil(8);
        let mut bitmap = vec![0u8; bitmap_size];
        for blk in 0..data_start as usize {
            bitmap[blk / 8] |= 1 << (blk % 8);
        }

        // Write bitmap to disk
        let bitmap_block_count = bitmap_blocks as usize;
        for i in 0..bitmap_block_count {
            let mut block = [0u8; BLOCK_SIZE];
            let start = i * BLOCK_SIZE;
            let end = cmp::min(start + BLOCK_SIZE, bitmap.len());
            if start < end {
                block[..end - start].copy_from_slice(&bitmap[start..end]);
            }
            leases[0]
                .block()
                .write_block(free_bitmap_start + i as u64, &block)?;
        }

        // Initialize inode table (zero)
        let zero_block = [0u8; BLOCK_SIZE];
        for i in 0..inode_table_blocks {
            leases[0]
                .block()
                .write_block(inode_table_start + i, &zero_block)?;
        }

        // Create root directory inode (inode 0)
        let root_inode = Inode::new(ROOT_INODE_ID, FILE_TYPE_DIR);

        let mut fs = FabricFs {
            leases,
            superblock,
            inode_cache: BTreeMap::new(),
            dir_cache: BTreeMap::new(),
            dirty_inodes: BTreeMap::new(),
            dirty_dirs: BTreeMap::new(),
            stripe_threshold: DEFAULT_STRIPE_THRESHOLD,
            stripe_size: DEFAULT_STRIPE_SIZE,
            bitmap_cache: bitmap,
            bitmap_dirty: false,
        };

        fs.inode_cache.insert(ROOT_INODE_ID, root_inode);
        fs.dirty_inodes.insert(ROOT_INODE_ID, true);
        fs.dir_cache.insert(ROOT_INODE_ID, Vec::new());
        fs.dirty_dirs.insert(ROOT_INODE_ID, true);
        fs.sync()?;

        Ok(fs)
    }

    /// Mount an existing filesystem from leases.
    ///
    /// Reads the superblock, validates the magic and version, and populates
    /// the inode and directory caches for the root directory.
    pub fn mount(leases: Vec<BlockLease>) -> Result<Self> {
        if leases.is_empty() {
            return Err(FabricError::IoError(-1));
        }

        let sb_block = leases[0].block().read_block(0)?;
        let superblock = Self::deserialize_superblock(&sb_block)?;

        if superblock.magic != SUPERBLOCK_MAGIC {
            return Err(FabricError::IoError(-2));
        }
        if superblock.version != SUPERBLOCK_VERSION {
            return Err(FabricError::IoError(-3));
        }

        // Read bitmap
        let bitmap_blocks = superblock.total_blocks.div_ceil(BLOCK_SIZE as u64 * 8);
        let bitmap_size = (superblock.total_blocks as usize).div_ceil(8);
        let mut bitmap = vec![0u8; bitmap_size];
        for i in 0..bitmap_blocks as usize {
            let block = leases[0]
                .block()
                .read_block(superblock.free_bitmap_start + i as u64)?;
            let start = i * BLOCK_SIZE;
            let end = cmp::min(start + BLOCK_SIZE, bitmap_size);
            if start < end {
                bitmap[start..end].copy_from_slice(&block[..end - start]);
            }
        }

        let mut fs = FabricFs {
            leases,
            superblock,
            inode_cache: BTreeMap::new(),
            dir_cache: BTreeMap::new(),
            dirty_inodes: BTreeMap::new(),
            dirty_dirs: BTreeMap::new(),
            stripe_threshold: DEFAULT_STRIPE_THRESHOLD,
            stripe_size: DEFAULT_STRIPE_SIZE,
            bitmap_cache: bitmap,
            bitmap_dirty: false,
        };

        // Read root inode
        let root_inode = fs.read_inode_from_disk(ROOT_INODE_ID)?;
        fs.inode_cache.insert(ROOT_INODE_ID, root_inode);

        // Read root directory entries
        let entries = fs.read_dir_entries(ROOT_INODE_ID)?;
        // Pre-load inodes referenced by root directory entries
        for entry in &entries {
            if !fs.inode_cache.contains_key(&entry.inode_id) {
                if let Ok(inode) = fs.read_inode_from_disk(entry.inode_id) {
                    fs.inode_cache.insert(entry.inode_id, inode);
                }
            }
        }
        fs.dir_cache.insert(ROOT_INODE_ID, entries);

        Ok(fs)
    }

    /// Create a file at the given path and return a writable handle.
    pub fn create(&mut self, path: &str) -> Result<FileHandle> {
        let (parent_inode_id, name) = self.resolve_parent(path)?;
        if name.is_empty() || name.len() > MAX_NAME_LEN {
            return Err(FabricError::IoError(-1));
        }

        // Check if file already exists
        let existing_inode = self
            .dir_cache
            .get(&parent_inode_id)
            .and_then(|entries| entries.iter().find(|e| e.name == name))
            .map(|e| e.inode_id);

        if let Some(inode_id) = existing_inode {
            // Truncate existing file
            self.truncate_inode(inode_id)?;
            return Ok(FileHandle {
                inode_id,
                position: 0,
                flags: OpenFlags::Write,
            });
        }

        // Allocate new inode
        let inode_id = self.superblock.next_inode_id;
        self.superblock.next_inode_id += 1;

        let mut inode = Inode::new(inode_id, FILE_TYPE_FILE);
        inode.name_hash = fnv_hash(name.as_bytes());

        self.inode_cache.insert(inode_id, inode);
        self.dirty_inodes.insert(inode_id, true);

        // Add dir entry
        let dir_entry = DirEntry {
            inode_id,
            name,
            file_type: FILE_TYPE_FILE,
        };
        let entries = self.dir_cache.entry(parent_inode_id).or_default();
        entries.push(dir_entry);
        self.dirty_dirs.insert(parent_inode_id, true);

        self.write_superblock()?;

        Ok(FileHandle {
            inode_id,
            position: 0,
            flags: OpenFlags::Write,
        })
    }

    /// Open a file at the given path with the specified flags.
    pub fn open(&mut self, path: &str, flags: OpenFlags) -> Result<FileHandle> {
        let inode_id = self.resolve_path(path)?;
        let inode = self.get_inode(inode_id)?;
        if inode.file_type != FILE_TYPE_FILE {
            return Err(FabricError::IoError(-1));
        }

        if flags == OpenFlags::Write {
            self.truncate_inode(inode_id)?;
        }

        Ok(FileHandle {
            inode_id,
            position: 0,
            flags,
        })
    }

    /// Read from an open file handle into `buf`.
    ///
    /// Returns the number of bytes read. Returns 0 at EOF.
    pub fn read(&self, handle: &FileHandle, buf: &mut [u8]) -> Result<usize> {
        let inode = self
            .inode_cache
            .get(&handle.inode_id)
            .ok_or(FabricError::IoError(-1))?;

        if handle.position >= inode.size {
            return Ok(0);
        }

        let remaining = (inode.size - handle.position) as usize;
        let to_read = cmp::min(buf.len(), remaining);
        let mut bytes_read = 0;
        let mut pos = handle.position;

        while bytes_read < to_read {
            let block_index = (pos / BLOCK_SIZE as u64) as usize;
            let offset_in_block = (pos % BLOCK_SIZE as u64) as usize;
            let bytes_in_block = cmp::min(BLOCK_SIZE - offset_in_block, to_read - bytes_read);

            let block_addr = self.get_data_block_addr(inode, block_index)?;
            if block_addr == 0 {
                for b in &mut buf[bytes_read..bytes_read + bytes_in_block] {
                    *b = 0;
                }
            } else {
                let (lease_idx, lba) = decode_block_addr(block_addr);
                let block_data = self.leases[lease_idx].block().read_block(lba)?;
                buf[bytes_read..bytes_read + bytes_in_block].copy_from_slice(
                    &block_data[offset_in_block..offset_in_block + bytes_in_block],
                );
            }

            bytes_read += bytes_in_block;
            pos += bytes_in_block as u64;
        }

        Ok(bytes_read)
    }

    /// Write data to an open file handle.
    ///
    /// Returns the number of bytes written.
    pub fn write(&mut self, handle: &mut FileHandle, data: &[u8]) -> Result<usize> {
        if handle.flags == OpenFlags::Read {
            return Err(FabricError::IoError(-1));
        }

        let mut bytes_written = 0;
        let mut pos = handle.position;

        while bytes_written < data.len() {
            let block_index = (pos / BLOCK_SIZE as u64) as usize;
            let offset_in_block = (pos % BLOCK_SIZE as u64) as usize;
            let bytes_in_block = cmp::min(BLOCK_SIZE - offset_in_block, data.len() - bytes_written);

            let block_addr = self.ensure_data_block(handle.inode_id, block_index)?;
            let (lease_idx, lba) = decode_block_addr(block_addr);

            let mut block_data = if offset_in_block != 0 || bytes_in_block != BLOCK_SIZE {
                self.leases[lease_idx].block().read_block(lba)?
            } else {
                [0u8; BLOCK_SIZE]
            };

            block_data[offset_in_block..offset_in_block + bytes_in_block]
                .copy_from_slice(&data[bytes_written..bytes_written + bytes_in_block]);

            self.leases[lease_idx]
                .block()
                .write_block(lba, &block_data)?;

            bytes_written += bytes_in_block;
            pos += bytes_in_block as u64;
        }

        handle.position = pos;

        // Update inode size
        let inode = self
            .inode_cache
            .get_mut(&handle.inode_id)
            .ok_or(FabricError::IoError(-1))?;
        if pos > inode.size {
            inode.size = pos;
        }
        self.dirty_inodes.insert(handle.inode_id, true);

        Ok(bytes_written)
    }

    /// Seek to a position in an open file.
    pub fn seek(&mut self, handle: &mut FileHandle, pos: SeekFrom) -> Result<u64> {
        let inode = self
            .inode_cache
            .get(&handle.inode_id)
            .ok_or(FabricError::IoError(-1))?;

        let new_pos = match pos {
            SeekFrom::Start(offset) => offset,
            SeekFrom::Current(offset) => {
                if offset < 0 {
                    handle
                        .position
                        .checked_sub((-offset) as u64)
                        .ok_or(FabricError::IoError(-1))?
                } else {
                    handle.position + offset as u64
                }
            }
            SeekFrom::End(offset) => {
                if offset < 0 {
                    inode
                        .size
                        .checked_sub((-offset) as u64)
                        .ok_or(FabricError::IoError(-1))?
                } else {
                    inode.size + offset as u64
                }
            }
        };

        handle.position = new_pos;
        Ok(new_pos)
    }

    /// Close an open file handle.
    pub fn close(&mut self, _handle: FileHandle) -> Result<()> {
        self.sync()
    }

    /// Remove a file at the given path.
    pub fn remove(&mut self, path: &str) -> Result<()> {
        let (parent_inode_id, name) = self.resolve_parent(path)?;

        let entries = self
            .dir_cache
            .get(&parent_inode_id)
            .cloned()
            .unwrap_or_default();

        let mut found_inode_id = None;
        let mut found_idx = None;
        for (i, entry) in entries.iter().enumerate() {
            if entry.name == name {
                if entry.file_type == FILE_TYPE_DIR {
                    let dir_entries = self.dir_cache.get(&entry.inode_id);
                    if let Some(de) = dir_entries {
                        if !de.is_empty() {
                            return Err(FabricError::IoError(-1));
                        }
                    }
                }
                found_inode_id = Some(entry.inode_id);
                found_idx = Some(i);
                break;
            }
        }

        let inode_id = found_inode_id.ok_or(FabricError::IoError(-1))?;
        let idx = found_idx.unwrap();

        // Collect blocks to free
        let blocks_to_free: Vec<u64> = if let Some(inode) = self.inode_cache.get(&inode_id) {
            let mut blocks = Vec::new();
            for i in 0..inode.block_count as usize {
                if i < MAX_DIRECT_BLOCKS && inode.direct_blocks[i] != 0 {
                    blocks.push(inode.direct_blocks[i]);
                }
            }
            if inode.indirect_block != 0 {
                blocks.push(inode.indirect_block);
            }
            blocks
        } else {
            Vec::new()
        };

        // Free the blocks
        for block_addr in blocks_to_free {
            self.free_block(block_addr);
        }

        // Remove from parent directory
        let entries = self.dir_cache.get_mut(&parent_inode_id).unwrap();
        entries.remove(idx);
        self.dirty_dirs.insert(parent_inode_id, true);

        // Remove inode from cache
        self.inode_cache.remove(&inode_id);
        self.dir_cache.remove(&inode_id);

        self.zero_inode_on_disk(inode_id)?;
        self.sync()?;
        Ok(())
    }

    /// List entries in the directory at the given path.
    pub fn readdir(&mut self, path: &str) -> Result<Vec<DirEntry>> {
        let inode_id = self.resolve_path(path)?;
        let inode = self.get_inode(inode_id)?;
        if inode.file_type != FILE_TYPE_DIR {
            return Err(FabricError::IoError(-1));
        }

        if !self.dir_cache.contains_key(&inode_id) {
            let entries = self.read_dir_entries(inode_id)?;
            self.dir_cache.insert(inode_id, entries);
        }

        Ok(self.dir_cache.get(&inode_id).cloned().unwrap_or_default())
    }

    /// Get file metadata for the given path.
    pub fn stat(&mut self, path: &str) -> Result<FileStat> {
        let inode_id = self.resolve_path(path)?;
        let inode = self.get_inode(inode_id)?;
        Ok(FileStat {
            size: inode.size,
            file_type: inode.file_type,
            block_count: inode.block_count,
            created_at: inode.created_at,
            modified_at: inode.modified_at,
        })
    }

    /// Create a directory at the given path.
    pub fn mkdir(&mut self, path: &str) -> Result<()> {
        let (parent_inode_id, name) = self.resolve_parent(path)?;
        if name.is_empty() || name.len() > MAX_NAME_LEN {
            return Err(FabricError::IoError(-1));
        }

        // Check for duplicates
        let exists = self
            .dir_cache
            .get(&parent_inode_id)
            .map(|entries| entries.iter().any(|e| e.name == name))
            .unwrap_or(false);
        if exists {
            return Err(FabricError::IoError(-1));
        }

        let inode_id = self.superblock.next_inode_id;
        self.superblock.next_inode_id += 1;

        let mut inode = Inode::new(inode_id, FILE_TYPE_DIR);
        inode.name_hash = fnv_hash(name.as_bytes());

        self.inode_cache.insert(inode_id, inode);
        self.dirty_inodes.insert(inode_id, true);
        self.dir_cache.insert(inode_id, Vec::new());
        self.dirty_dirs.insert(inode_id, true);

        let dir_entry = DirEntry {
            inode_id,
            name,
            file_type: FILE_TYPE_DIR,
        };
        let entries = self.dir_cache.entry(parent_inode_id).or_default();
        entries.push(dir_entry);
        self.dirty_dirs.insert(parent_inode_id, true);

        self.write_superblock()?;
        self.sync()?;
        Ok(())
    }

    /// Flush all dirty metadata and data to block storage.
    pub fn sync(&mut self) -> Result<()> {
        // Flush dirty directory entries first — this updates inode sizes
        let dirty_dirs: Vec<u64> = self.dirty_dirs.keys().cloned().collect();
        for inode_id in dirty_dirs {
            if let Some(entries) = self.dir_cache.get(&inode_id).cloned() {
                self.write_dir_entries(inode_id, &entries)?;
            }
            self.dirty_dirs.remove(&inode_id);
        }

        // Flush dirty inodes (now with up-to-date sizes from dir writes)
        let dirty_inodes: Vec<u64> = self.dirty_inodes.keys().cloned().collect();
        for inode_id in dirty_inodes {
            if let Some(inode) = self.inode_cache.get(&inode_id).cloned() {
                self.write_inode(&inode)?;
            }
            self.dirty_inodes.remove(&inode_id);
        }

        // Flush bitmap
        if self.bitmap_dirty {
            self.flush_bitmap()?;
            self.bitmap_dirty = false;
        }

        Ok(())
    }

    /// Sync and release all leases.
    pub fn unmount(mut self) -> Result<Vec<BlockLease>> {
        self.sync()?;
        Ok(self.leases)
    }

    /// Set the stripe threshold in bytes.
    pub fn set_stripe_threshold(&mut self, threshold: u64) {
        self.stripe_threshold = threshold;
    }

    /// Set the stripe size in blocks.
    pub fn set_stripe_size(&mut self, size: u32) {
        self.stripe_size = size;
    }

    // --- Internal helpers ---

    fn truncate_inode(&mut self, inode_id: u64) -> Result<()> {
        // Collect blocks to free
        let blocks_to_free: Vec<u64> = {
            let inode = self
                .inode_cache
                .get(&inode_id)
                .ok_or(FabricError::IoError(-1))?;
            let mut blocks = Vec::new();
            for i in 0..inode.block_count as usize {
                if i < MAX_DIRECT_BLOCKS && inode.direct_blocks[i] != 0 {
                    blocks.push(inode.direct_blocks[i]);
                }
            }
            blocks
        };

        for block_addr in blocks_to_free {
            self.free_block(block_addr);
        }

        let inode = self
            .inode_cache
            .get_mut(&inode_id)
            .ok_or(FabricError::IoError(-1))?;
        for i in 0..MAX_DIRECT_BLOCKS {
            inode.direct_blocks[i] = 0;
        }
        inode.size = 0;
        inode.block_count = 0;
        self.dirty_inodes.insert(inode_id, true);
        Ok(())
    }

    fn serialize_superblock(sb: &Superblock) -> [u8; BLOCK_SIZE] {
        let mut block = [0u8; BLOCK_SIZE];
        block[0..4].copy_from_slice(&sb.magic);
        block[4..8].copy_from_slice(&sb.version.to_le_bytes());
        block[8..12].copy_from_slice(&sb.block_size.to_le_bytes());
        block[12..20].copy_from_slice(&sb.total_blocks.to_le_bytes());
        block[20..28].copy_from_slice(&sb.inode_table_start.to_le_bytes());
        block[28..36].copy_from_slice(&sb.data_start.to_le_bytes());
        block[36..44].copy_from_slice(&sb.free_bitmap_start.to_le_bytes());
        block[44..52].copy_from_slice(&sb.next_inode_id.to_le_bytes());
        block[52..60].copy_from_slice(&sb.inode_table_blocks.to_le_bytes());
        block
    }

    fn deserialize_superblock(block: &[u8; BLOCK_SIZE]) -> Result<Superblock> {
        let mut magic = [0u8; 4];
        magic.copy_from_slice(&block[0..4]);
        Ok(Superblock {
            magic,
            version: u32::from_le_bytes([block[4], block[5], block[6], block[7]]),
            block_size: u32::from_le_bytes([block[8], block[9], block[10], block[11]]),
            total_blocks: u64::from_le_bytes(block[12..20].try_into().unwrap()),
            inode_table_start: u64::from_le_bytes(block[20..28].try_into().unwrap()),
            data_start: u64::from_le_bytes(block[28..36].try_into().unwrap()),
            free_bitmap_start: u64::from_le_bytes(block[36..44].try_into().unwrap()),
            next_inode_id: u64::from_le_bytes(block[44..52].try_into().unwrap()),
            inode_table_blocks: u64::from_le_bytes(block[52..60].try_into().unwrap()),
        })
    }

    fn write_superblock(&self) -> Result<()> {
        let sb_bytes = Self::serialize_superblock(&self.superblock);
        self.leases[0].block().write_block(0, &sb_bytes)
    }

    fn read_inode_from_disk(&self, inode_id: u64) -> Result<Inode> {
        let max_inodes = self.superblock.inode_table_blocks * INODES_PER_BLOCK as u64;
        if inode_id >= max_inodes {
            return Err(FabricError::IoError(-1));
        }

        let block_offset = inode_id as usize / INODES_PER_BLOCK;
        let slot_in_block = inode_id as usize % INODES_PER_BLOCK;
        let block_lba = self.superblock.inode_table_start + block_offset as u64;

        let block_data = self.leases[0].block().read_block(block_lba)?;
        let start = slot_in_block * INODE_SIZE;
        let inode_bytes = &block_data[start..start + INODE_SIZE];

        Self::deserialize_inode(inode_bytes)
    }

    fn write_inode(&self, inode: &Inode) -> Result<()> {
        let block_offset = inode.inode_id as usize / INODES_PER_BLOCK;
        let slot_in_block = inode.inode_id as usize % INODES_PER_BLOCK;
        let block_lba = self.superblock.inode_table_start + block_offset as u64;

        let mut block_data = self.leases[0].block().read_block(block_lba)?;
        let start = slot_in_block * INODE_SIZE;
        let inode_bytes = Self::serialize_inode(inode);
        block_data[start..start + INODE_SIZE].copy_from_slice(&inode_bytes);

        self.leases[0].block().write_block(block_lba, &block_data)
    }

    fn zero_inode_on_disk(&self, inode_id: u64) -> Result<()> {
        let block_offset = inode_id as usize / INODES_PER_BLOCK;
        let slot_in_block = inode_id as usize % INODES_PER_BLOCK;
        let block_lba = self.superblock.inode_table_start + block_offset as u64;

        let mut block_data = self.leases[0].block().read_block(block_lba)?;
        let start = slot_in_block * INODE_SIZE;
        for b in &mut block_data[start..start + INODE_SIZE] {
            *b = 0;
        }
        self.leases[0].block().write_block(block_lba, &block_data)
    }

    fn serialize_inode(inode: &Inode) -> [u8; INODE_SIZE] {
        let mut buf = [0u8; INODE_SIZE];
        buf[0..8].copy_from_slice(&inode.inode_id.to_le_bytes());
        buf[8] = inode.file_type;
        buf[9..17].copy_from_slice(&inode.size.to_le_bytes());
        buf[17..21].copy_from_slice(&inode.block_count.to_le_bytes());
        for (i, &blk) in inode.direct_blocks.iter().enumerate() {
            let off = 21 + i * 8;
            buf[off..off + 8].copy_from_slice(&blk.to_le_bytes());
        }
        let off = 21 + MAX_DIRECT_BLOCKS * 8; // 21 + 96 = 117
        buf[off..off + 8].copy_from_slice(&inode.indirect_block.to_le_bytes());
        buf[off + 8..off + 16].copy_from_slice(&inode.created_at.to_le_bytes());
        buf[off + 16..off + 24].copy_from_slice(&inode.modified_at.to_le_bytes());
        buf[off + 24..off + 32].copy_from_slice(&inode.name_hash.to_le_bytes());
        buf
    }

    fn deserialize_inode(buf: &[u8]) -> Result<Inode> {
        if buf.len() < INODE_SIZE {
            return Err(FabricError::IoError(-1));
        }
        let inode_id = u64::from_le_bytes(buf[0..8].try_into().unwrap());
        let file_type = buf[8];
        let size = u64::from_le_bytes(buf[9..17].try_into().unwrap());
        let block_count = u32::from_le_bytes(buf[17..21].try_into().unwrap());
        let mut direct_blocks = [0u64; MAX_DIRECT_BLOCKS];
        for (i, block) in direct_blocks.iter_mut().enumerate() {
            let off = 21 + i * 8;
            *block = u64::from_le_bytes(buf[off..off + 8].try_into().unwrap());
        }
        let off = 21 + MAX_DIRECT_BLOCKS * 8;
        let indirect_block = u64::from_le_bytes(buf[off..off + 8].try_into().unwrap());
        let created_at = u64::from_le_bytes(buf[off + 8..off + 16].try_into().unwrap());
        let modified_at = u64::from_le_bytes(buf[off + 16..off + 24].try_into().unwrap());
        let name_hash = u64::from_le_bytes(buf[off + 24..off + 32].try_into().unwrap());

        Ok(Inode {
            inode_id,
            file_type,
            size,
            block_count,
            direct_blocks,
            indirect_block,
            created_at,
            modified_at,
            name_hash,
        })
    }

    fn get_inode(&mut self, inode_id: u64) -> Result<Inode> {
        if let Some(inode) = self.inode_cache.get(&inode_id) {
            return Ok(inode.clone());
        }
        let inode = self.read_inode_from_disk(inode_id)?;
        self.inode_cache.insert(inode_id, inode.clone());
        Ok(inode)
    }

    fn read_dir_entries(&self, inode_id: u64) -> Result<Vec<DirEntry>> {
        let inode = self
            .inode_cache
            .get(&inode_id)
            .cloned()
            .ok_or(FabricError::IoError(-1))?;

        if inode.size == 0 {
            return Ok(Vec::new());
        }

        let num_blocks = (inode.size as usize).div_ceil(BLOCK_SIZE);
        let mut data = Vec::with_capacity(inode.size as usize);
        for i in 0..num_blocks {
            let block_addr = self.get_data_block_addr(&inode, i)?;
            if block_addr == 0 {
                data.extend_from_slice(&[0u8; BLOCK_SIZE]);
            } else {
                let (lease_idx, lba) = decode_block_addr(block_addr);
                let block = self.leases[lease_idx].block().read_block(lba)?;
                data.extend_from_slice(&block);
            }
        }
        data.truncate(inode.size as usize);

        postcard::from_bytes(&data).map_err(|_| FabricError::IoError(-1))
    }

    fn write_dir_entries(&mut self, inode_id: u64, entries: &[DirEntry]) -> Result<()> {
        let data = postcard::to_allocvec(entries).map_err(|_| FabricError::IoError(-1))?;
        let num_blocks = data.len().div_ceil(BLOCK_SIZE);

        // Ensure enough blocks allocated
        for i in 0..num_blocks {
            self.ensure_data_block(inode_id, i)?;
        }

        // Read the inode to get block addresses
        let inode = self.inode_cache.get(&inode_id).unwrap().clone();

        // Write data to blocks
        for i in 0..num_blocks {
            let start = i * BLOCK_SIZE;
            let end = cmp::min(start + BLOCK_SIZE, data.len());
            let mut block = [0u8; BLOCK_SIZE];
            block[..end - start].copy_from_slice(&data[start..end]);

            let block_addr = self.get_data_block_addr(&inode, i)?;
            let (lease_idx, lba) = decode_block_addr(block_addr);
            self.leases[lease_idx].block().write_block(lba, &block)?;
        }

        // Update inode size and mark dirty so sync writes it to disk
        let inode = self.inode_cache.get_mut(&inode_id).unwrap();
        inode.size = data.len() as u64;
        self.dirty_inodes.insert(inode_id, true);

        Ok(())
    }

    fn get_data_block_addr(&self, inode: &Inode, block_index: usize) -> Result<u64> {
        if block_index < MAX_DIRECT_BLOCKS {
            Ok(inode.direct_blocks[block_index])
        } else {
            if inode.indirect_block == 0 {
                return Ok(0);
            }
            let indirect_index = block_index - MAX_DIRECT_BLOCKS;
            let entries_per_block = BLOCK_SIZE / 8;
            if indirect_index >= entries_per_block {
                return Err(FabricError::CapacityExceeded);
            }
            let (lease_idx, lba) = decode_block_addr(inode.indirect_block);
            let block = self.leases[lease_idx].block().read_block(lba)?;
            let off = indirect_index * 8;
            Ok(u64::from_le_bytes(block[off..off + 8].try_into().unwrap()))
        }
    }

    fn ensure_data_block(&mut self, inode_id: u64, block_index: usize) -> Result<u64> {
        // Check if already allocated
        let existing = {
            let inode = self.inode_cache.get(&inode_id).unwrap();
            self.get_data_block_addr(inode, block_index)?
        };
        if existing != 0 {
            return Ok(existing);
        }

        // Allocate a new block
        let new_block = self.alloc_block_for_file(block_index)?;

        if block_index < MAX_DIRECT_BLOCKS {
            let inode = self.inode_cache.get_mut(&inode_id).unwrap();
            inode.direct_blocks[block_index] = new_block;
            inode.block_count += 1;
        } else {
            // Handle indirect block
            let indirect_index = block_index - MAX_DIRECT_BLOCKS;
            let entries_per_block = BLOCK_SIZE / 8;
            if indirect_index >= entries_per_block {
                return Err(FabricError::CapacityExceeded);
            }

            // Ensure indirect block exists
            let indirect_addr = {
                let inode = self.inode_cache.get(&inode_id).unwrap();
                inode.indirect_block
            };
            let indirect_addr = if indirect_addr == 0 {
                let new_indirect = self.alloc_block_primary()?;
                let (li, lba) = decode_block_addr(new_indirect);
                let zero = [0u8; BLOCK_SIZE];
                self.leases[li].block().write_block(lba, &zero)?;
                let inode = self.inode_cache.get_mut(&inode_id).unwrap();
                inode.indirect_block = new_indirect;
                new_indirect
            } else {
                indirect_addr
            };

            // Write entry in indirect block
            let (li, lba) = decode_block_addr(indirect_addr);
            let mut block = self.leases[li].block().read_block(lba)?;
            let off = indirect_index * 8;
            block[off..off + 8].copy_from_slice(&new_block.to_le_bytes());
            self.leases[li].block().write_block(lba, &block)?;

            let inode = self.inode_cache.get_mut(&inode_id).unwrap();
            inode.block_count += 1;
        }

        self.dirty_inodes.insert(inode_id, true);
        Ok(new_block)
    }

    fn alloc_block_for_file(&mut self, block_index: usize) -> Result<u64> {
        if self.leases.len() <= 1 {
            return self.alloc_block_primary();
        }

        let stripe_unit = self.stripe_size as usize;
        let stripe_num = block_index / stripe_unit;
        let lease_idx = stripe_num % self.leases.len();

        if lease_idx == 0 {
            self.alloc_block_primary()
        } else {
            let lba = self.find_free_secondary_block(lease_idx)?;
            let num_blocks = self.leases[lease_idx].block().num_blocks();
            if lba >= num_blocks {
                return Err(FabricError::CapacityExceeded);
            }
            Ok(encode_block_addr(lease_idx, lba))
        }
    }

    fn find_free_secondary_block(&self, lease_idx: usize) -> Result<u64> {
        let mut used_lbas: Vec<u64> = Vec::new();
        for inode in self.inode_cache.values() {
            for i in 0..inode.block_count as usize {
                if i < MAX_DIRECT_BLOCKS {
                    let addr = inode.direct_blocks[i];
                    if addr != 0 {
                        let (li, lba) = decode_block_addr(addr);
                        if li == lease_idx {
                            used_lbas.push(lba);
                        }
                    }
                }
            }
        }
        used_lbas.sort_unstable();

        let num_blocks = self.leases[lease_idx].block().num_blocks();
        let mut candidate = 0u64;
        for &used in &used_lbas {
            if candidate == used {
                candidate += 1;
            }
        }
        if candidate >= num_blocks {
            return Err(FabricError::CapacityExceeded);
        }
        Ok(candidate)
    }

    fn alloc_block_primary(&mut self) -> Result<u64> {
        let start = self.superblock.data_start as usize;
        let total = self.superblock.total_blocks as usize;

        for blk in start..total {
            let byte_idx = blk / 8;
            let bit_idx = blk % 8;
            if byte_idx < self.bitmap_cache.len()
                && (self.bitmap_cache[byte_idx] & (1 << bit_idx)) == 0
            {
                self.bitmap_cache[byte_idx] |= 1 << bit_idx;
                self.bitmap_dirty = true;
                return Ok(encode_block_addr(0, blk as u64));
            }
        }

        Err(FabricError::CapacityExceeded)
    }

    fn free_block(&mut self, block_addr: u64) {
        let (lease_idx, lba) = decode_block_addr(block_addr);
        if lease_idx == 0 {
            let blk = lba as usize;
            let byte_idx = blk / 8;
            let bit_idx = blk % 8;
            if byte_idx < self.bitmap_cache.len() {
                self.bitmap_cache[byte_idx] &= !(1 << bit_idx);
                self.bitmap_dirty = true;
            }
        }
    }

    fn flush_bitmap(&self) -> Result<()> {
        let bitmap_blocks = self.superblock.total_blocks.div_ceil(BLOCK_SIZE as u64 * 8);
        for i in 0..bitmap_blocks as usize {
            let mut block = [0u8; BLOCK_SIZE];
            let start = i * BLOCK_SIZE;
            let end = cmp::min(start + BLOCK_SIZE, self.bitmap_cache.len());
            if start < end {
                block[..end - start].copy_from_slice(&self.bitmap_cache[start..end]);
            }
            self.leases[0]
                .block()
                .write_block(self.superblock.free_bitmap_start + i as u64, &block)?;
        }
        Ok(())
    }

    fn resolve_path(&mut self, path: &str) -> Result<u64> {
        if path == "/" {
            return Ok(ROOT_INODE_ID);
        }

        let path = path.trim_start_matches('/');
        let components: Vec<&str> = path.split('/').filter(|s| !s.is_empty()).collect();

        let mut current_inode_id = ROOT_INODE_ID;
        for component in &components {
            if !self.dir_cache.contains_key(&current_inode_id) {
                let entries = self.read_dir_entries(current_inode_id)?;
                self.dir_cache.insert(current_inode_id, entries);
            }

            let entries = self.dir_cache.get(&current_inode_id).unwrap();
            let mut found = false;
            for entry in entries {
                if entry.name == *component {
                    current_inode_id = entry.inode_id;
                    if !self.inode_cache.contains_key(&current_inode_id) {
                        let inode = self.read_inode_from_disk(current_inode_id)?;
                        self.inode_cache.insert(current_inode_id, inode);
                    }
                    found = true;
                    break;
                }
            }
            if !found {
                return Err(FabricError::IoError(-1));
            }
        }

        Ok(current_inode_id)
    }

    /// Resolve a path to its parent inode ID and the final component name.
    fn resolve_parent(&mut self, path: &str) -> Result<(u64, String)> {
        let path = path.trim_start_matches('/');
        if path.is_empty() {
            return Err(FabricError::IoError(-1));
        }

        let components: Vec<&str> = path.split('/').filter(|s| !s.is_empty()).collect();
        if components.is_empty() {
            return Err(FabricError::IoError(-1));
        }

        let name = String::from(*components.last().unwrap());

        if components.len() == 1 {
            // File/dir in root
            return Ok((ROOT_INODE_ID, name));
        }

        // Resolve all components except the last to find the parent
        let parent_components = &components[..components.len() - 1];
        let mut current_inode_id = ROOT_INODE_ID;
        for component in parent_components {
            if !self.dir_cache.contains_key(&current_inode_id) {
                let entries = self.read_dir_entries(current_inode_id)?;
                self.dir_cache.insert(current_inode_id, entries);
            }

            let entries = self.dir_cache.get(&current_inode_id).unwrap();
            let mut found = false;
            for entry in entries {
                if entry.name == *component {
                    current_inode_id = entry.inode_id;
                    if !self.inode_cache.contains_key(&current_inode_id) {
                        let inode = self.read_inode_from_disk(current_inode_id)?;
                        self.inode_cache.insert(current_inode_id, inode);
                    }
                    // Load the directory entries for this directory
                    if !self.dir_cache.contains_key(&current_inode_id) {
                        let dir_entries = self.read_dir_entries(current_inode_id)?;
                        self.dir_cache.insert(current_inode_id, dir_entries);
                    }
                    found = true;
                    break;
                }
            }
            if !found {
                return Err(FabricError::IoError(-1));
            }
        }

        Ok((current_inode_id, name))
    }
}

/// Encode a lease index and LBA into a block address.
/// Format: bits [63:48] = lease_idx, bits [47:0] = lba
fn encode_block_addr(lease_idx: usize, lba: u64) -> u64 {
    ((lease_idx as u64) << 48) | (lba & 0x0000_FFFF_FFFF_FFFF)
}

/// Decode a block address into (lease_idx, lba).
fn decode_block_addr(addr: u64) -> (usize, u64) {
    let lease_idx = (addr >> 48) as usize;
    let lba = addr & 0x0000_FFFF_FFFF_FFFF;
    (lease_idx, lba)
}

/// FNV-1a hash.
fn fnv_hash(data: &[u8]) -> u64 {
    let mut hash: u64 = 0xcbf29ce484222325;
    for &b in data {
        hash ^= b as u64;
        hash = hash.wrapping_mul(0x100000001b3);
    }
    hash
}

#[cfg(test)]
mod tests {
    use super::*;
    use grafos_std::block::BlockBuilder;
    use grafos_std::host;

    fn setup_lease(num_blocks: u64) -> BlockLease {
        host::reset_mock();
        host::mock_set_fbbu_num_blocks(num_blocks);
        BlockBuilder::new()
            .min_blocks(num_blocks)
            .acquire()
            .expect("acquire")
    }

    fn setup_leases(count: usize, num_blocks: u64) -> Vec<BlockLease> {
        host::reset_mock();
        host::mock_set_fbbu_num_blocks(num_blocks);
        let mut leases = Vec::new();
        for _ in 0..count {
            leases.push(BlockBuilder::new().acquire().expect("acquire"));
        }
        leases
    }

    #[test]
    fn format_mount_roundtrip() {
        let lease = setup_lease(2048);
        let fs = FabricFs::format(vec![lease]).expect("format");
        let leases = fs.unmount().expect("unmount");

        let fs = FabricFs::mount(leases).expect("mount");
        assert_eq!(fs.superblock.magic, *b"GFFS");
        assert_eq!(fs.superblock.version, 1);
        assert_eq!(fs.superblock.block_size, 512);
        assert_eq!(fs.superblock.total_blocks, 2048);
    }

    #[test]
    fn create_write_read() {
        let lease = setup_lease(2048);
        let mut fs = FabricFs::format(vec![lease]).expect("format");

        let mut fh = fs.create("/test.txt").expect("create");
        let data = b"hello fabricBIOS filesystem";
        fs.write(&mut fh, data).expect("write");
        fs.close(fh).expect("close");

        let fh = fs.open("/test.txt", OpenFlags::Read).expect("open");
        let mut buf = [0u8; 64];
        let n = fs.read(&fh, &mut buf).expect("read");
        assert_eq!(n, data.len());
        assert_eq!(&buf[..n], data);
    }

    #[test]
    fn nested_directory_and_file() {
        let lease = setup_lease(4096);
        let mut fs = FabricFs::format(vec![lease]).expect("format");

        fs.mkdir("/a").expect("mkdir a");
        fs.mkdir("/a/b").expect("mkdir a/b");
        fs.mkdir("/a/b/c").expect("mkdir a/b/c");

        let mut fh = fs.create("/a/b/c/file.txt").expect("create");
        fs.write(&mut fh, b"nested file").expect("write");
        fs.close(fh).expect("close");

        let fh = fs.open("/a/b/c/file.txt", OpenFlags::Read).expect("open");
        let mut buf = [0u8; 64];
        let n = fs.read(&fh, &mut buf).expect("read");
        assert_eq!(&buf[..n], b"nested file");
    }

    #[test]
    fn readdir_lists_files() {
        let lease = setup_lease(2048);
        let mut fs = FabricFs::format(vec![lease]).expect("format");

        let mut fh = fs.create("/alpha.txt").expect("create");
        fs.write(&mut fh, b"a").expect("write");
        fs.close(fh).expect("close");

        let mut fh = fs.create("/beta.txt").expect("create");
        fs.write(&mut fh, b"b").expect("write");
        fs.close(fh).expect("close");

        fs.mkdir("/subdir").expect("mkdir");

        let entries = fs.readdir("/").expect("readdir");
        assert_eq!(entries.len(), 3);
        let names: Vec<&str> = entries.iter().map(|e| e.name.as_str()).collect();
        assert!(names.contains(&"alpha.txt"));
        assert!(names.contains(&"beta.txt"));
        assert!(names.contains(&"subdir"));
    }

    #[test]
    fn remove_file_frees_blocks() {
        let lease = setup_lease(2048);
        let mut fs = FabricFs::format(vec![lease]).expect("format");

        let mut fh = fs.create("/delete_me.txt").expect("create");
        let data = vec![0xABu8; 1024];
        fs.write(&mut fh, &data).expect("write");
        fs.close(fh).expect("close");

        let stat = fs.stat("/delete_me.txt").expect("stat");
        assert_eq!(stat.size, 1024);

        fs.remove("/delete_me.txt").expect("remove");
        assert!(fs.open("/delete_me.txt", OpenFlags::Read).is_err());
    }

    #[test]
    fn stat_returns_correct_size() {
        let lease = setup_lease(2048);
        let mut fs = FabricFs::format(vec![lease]).expect("format");

        let mut fh = fs.create("/sized.txt").expect("create");
        fs.write(&mut fh, b"twelve bytes").expect("write");
        fs.close(fh).expect("close");

        let stat = fs.stat("/sized.txt").expect("stat");
        assert_eq!(stat.size, 12);
        assert_eq!(stat.file_type, FILE_TYPE_FILE);
    }

    #[test]
    fn seek_and_read() {
        let lease = setup_lease(2048);
        let mut fs = FabricFs::format(vec![lease]).expect("format");

        let mut fh = fs.create("/seekable.txt").expect("create");
        fs.write(&mut fh, b"ABCDEFGHIJ").expect("write");
        fs.close(fh).expect("close");

        let mut fh = fs.open("/seekable.txt", OpenFlags::Read).expect("open");
        fs.seek(&mut fh, SeekFrom::Start(5)).expect("seek");
        let mut buf = [0u8; 5];
        let n = fs.read(&fh, &mut buf).expect("read");
        assert_eq!(n, 5);
        assert_eq!(&buf, b"FGHIJ");

        fs.seek(&mut fh, SeekFrom::Start(0)).expect("seek start");
        let mut buf2 = [0u8; 3];
        let n = fs.read(&fh, &mut buf2).expect("read");
        assert_eq!(n, 3);
        assert_eq!(&buf2, b"ABC");
    }

    #[test]
    fn large_file_striped_across_leases() {
        let leases = setup_leases(3, 8192);
        let mut fs = FabricFs::format(leases).expect("format");
        fs.set_stripe_threshold(0);

        let mut fh = fs.create("/striped.dat").expect("create");
        let data: Vec<u8> = (0..4096u32).map(|i| (i % 251) as u8).collect();
        fs.write(&mut fh, &data).expect("write");
        fs.close(fh).expect("close");

        let fh = fs.open("/striped.dat", OpenFlags::Read).expect("open");
        let mut buf = vec![0u8; 4096];
        let n = fs.read(&fh, &mut buf).expect("read");
        assert_eq!(n, 4096);
        assert_eq!(buf, data);
    }

    #[test]
    fn format_create_many_small_files() {
        let lease = setup_lease(4096);
        let mut fs = FabricFs::format(vec![lease]).expect("format");

        for i in 0..20u32 {
            let name = alloc::format!("/file_{}.txt", i);
            let mut fh = fs.create(&name).expect("create");
            let content = alloc::format!("content {}", i);
            fs.write(&mut fh, content.as_bytes()).expect("write");
            fs.close(fh).expect("close");
        }

        let entries = fs.readdir("/").expect("readdir");
        assert_eq!(entries.len(), 20);

        let fh = fs.open("/file_7.txt", OpenFlags::Read).expect("open");
        let mut buf = [0u8; 64];
        let n = fs.read(&fh, &mut buf).expect("read");
        assert_eq!(&buf[..n], b"content 7");
    }

    #[test]
    fn unmount_releases_leases() {
        let lease = setup_lease(2048);
        let mut fs = FabricFs::format(vec![lease]).expect("format");

        let mut fh = fs.create("/test.txt").expect("create");
        fs.write(&mut fh, b"data").expect("write");
        fs.close(fh).expect("close");

        let leases = fs.unmount().expect("unmount");
        assert_eq!(leases.len(), 1);
    }

    #[test]
    fn sync_flushes_dirty_metadata() {
        let lease = setup_lease(2048);
        let mut fs = FabricFs::format(vec![lease]).expect("format");

        let mut fh = fs.create("/synced.txt").expect("create");
        fs.write(&mut fh, b"sync me").expect("write");

        fs.sync().expect("sync");

        let inode = fs.inode_cache.get(&fh.inode_id).unwrap();
        assert_eq!(inode.size, 7);

        fs.close(fh).expect("close");
    }

    #[test]
    fn mount_reads_existing_data() {
        let lease = setup_lease(4096);
        let mut fs = FabricFs::format(vec![lease]).expect("format");

        let mut fh = fs.create("/persist.txt").expect("create");
        fs.write(&mut fh, b"persistent data").expect("write");
        fs.close(fh).expect("close");

        let leases = fs.unmount().expect("unmount");
        let mut fs = FabricFs::mount(leases).expect("mount");

        let fh = fs.open("/persist.txt", OpenFlags::Read).expect("open");
        let mut buf = [0u8; 64];
        let n = fs.read(&fh, &mut buf).expect("read");
        assert_eq!(&buf[..n], b"persistent data");
    }

    #[test]
    fn write_spanning_multiple_blocks() {
        let lease = setup_lease(2048);
        let mut fs = FabricFs::format(vec![lease]).expect("format");

        let mut fh = fs.create("/big.txt").expect("create");
        let data: Vec<u8> = (0..2048u32).map(|i| (i % 256) as u8).collect();
        fs.write(&mut fh, &data).expect("write");
        fs.close(fh).expect("close");

        let fh = fs.open("/big.txt", OpenFlags::Read).expect("open");
        let mut buf = vec![0u8; 2048];
        let n = fs.read(&fh, &mut buf).expect("read");
        assert_eq!(n, 2048);
        assert_eq!(buf, data);
    }

    #[test]
    fn seek_from_end() {
        let lease = setup_lease(2048);
        let mut fs = FabricFs::format(vec![lease]).expect("format");

        let mut fh = fs.create("/endseek.txt").expect("create");
        fs.write(&mut fh, b"0123456789").expect("write");
        fs.close(fh).expect("close");

        let mut fh = fs.open("/endseek.txt", OpenFlags::Read).expect("open");
        fs.seek(&mut fh, SeekFrom::End(-3)).expect("seek");
        let mut buf = [0u8; 3];
        let n = fs.read(&fh, &mut buf).expect("read");
        assert_eq!(n, 3);
        assert_eq!(&buf, b"789");
    }

    #[test]
    fn seek_from_current() {
        let lease = setup_lease(2048);
        let mut fs = FabricFs::format(vec![lease]).expect("format");

        let mut fh = fs.create("/curseek.txt").expect("create");
        fs.write(&mut fh, b"ABCDEFGHIJ").expect("write");
        fs.close(fh).expect("close");

        let mut fh = fs.open("/curseek.txt", OpenFlags::Read).expect("open");
        fs.seek(&mut fh, SeekFrom::Start(2)).expect("seek start");
        fs.seek(&mut fh, SeekFrom::Current(3))
            .expect("seek current");
        let mut buf = [0u8; 2];
        let n = fs.read(&fh, &mut buf).expect("read");
        assert_eq!(n, 2);
        assert_eq!(&buf, b"FG");
    }

    #[test]
    fn read_at_eof_returns_zero() {
        let lease = setup_lease(2048);
        let mut fs = FabricFs::format(vec![lease]).expect("format");

        let mut fh = fs.create("/small.txt").expect("create");
        fs.write(&mut fh, b"hi").expect("write");
        fs.close(fh).expect("close");

        let mut fh = fs.open("/small.txt", OpenFlags::Read).expect("open");
        fs.seek(&mut fh, SeekFrom::Start(2)).expect("seek");
        let mut buf = [0u8; 10];
        let n = fs.read(&fh, &mut buf).expect("read");
        assert_eq!(n, 0);
    }

    #[test]
    fn open_nonexistent_file_fails() {
        let lease = setup_lease(2048);
        let mut fs = FabricFs::format(vec![lease]).expect("format");
        assert!(fs.open("/does_not_exist.txt", OpenFlags::Read).is_err());
    }

    #[test]
    fn remove_from_subdirectory() {
        let lease = setup_lease(4096);
        let mut fs = FabricFs::format(vec![lease]).expect("format");

        fs.mkdir("/dir").expect("mkdir");
        let mut fh = fs.create("/dir/file.txt").expect("create");
        fs.write(&mut fh, b"in subdir").expect("write");
        fs.close(fh).expect("close");

        fs.remove("/dir/file.txt").expect("remove");
        assert!(fs.open("/dir/file.txt", OpenFlags::Read).is_err());

        let entries = fs.readdir("/dir").expect("readdir");
        assert!(entries.is_empty());
    }

    #[test]
    fn stat_directory() {
        let lease = setup_lease(2048);
        let mut fs = FabricFs::format(vec![lease]).expect("format");

        fs.mkdir("/mydir").expect("mkdir");
        let stat = fs.stat("/mydir").expect("stat");
        assert_eq!(stat.file_type, FILE_TYPE_DIR);
    }

    #[test]
    fn create_existing_file_truncates() {
        let lease = setup_lease(2048);
        let mut fs = FabricFs::format(vec![lease]).expect("format");

        let mut fh = fs.create("/reuse.txt").expect("create");
        fs.write(&mut fh, b"original content").expect("write");
        fs.close(fh).expect("close");

        let mut fh = fs.create("/reuse.txt").expect("create again");
        fs.write(&mut fh, b"new").expect("write");
        fs.close(fh).expect("close");

        let fh = fs.open("/reuse.txt", OpenFlags::Read).expect("open");
        let mut buf = [0u8; 64];
        let n = fs.read(&fh, &mut buf).expect("read");
        assert_eq!(&buf[..n], b"new");
    }
}