ext2: delete legacy.rs, migrate all operations to new modular Ext2Fs

Remove the 1226-line legacy.rs entirely. All filesystem operations now
go through the new Ext2Fs struct in mod.rs which delegates to the
type-safe submodules (cache, blockmap, dir, file, alloc).

Key changes:
- Ext2Fs::read_inode/write_inode use the block cache (no stack buffers)
- Ext2Fs::write_file delegates to file::write_file with superblock
  passed directly (no closure-based allocation, avoids borrow conflicts)
- Ext2Fs::create_inode_entry orchestrates inode+block allocation and
  directory entry append using decomposed field borrows
- blockmap::ensure_data_block takes &mut Superblock directly instead of
  alloc_fn closure, calling ext2_alloc internally
- dir::append_dir_entry takes &mut Superblock instead of alloc_fn
- Removed ops.rs (functionality absorbed into Ext2Fs methods)
- ext2_vfs.rs updated for InodeNum newtype (.raw() conversions)

Net: -1170 lines. All 2262 tests pass.

Author: Lon60

fs/src/ext2/blockmap.rs

@@ -1,6 +1,7 @@
 use super::Ext2Error;
 use super::cache::BlockCache;
-use super::ondisk::Inode;
+use super::ext2_alloc;
+use super::ondisk::{Inode, Superblock};
 use super::types::{BlockNum, FileBlock};
 use crate::blockdev::BlockDevice;
 
@@ -17,12 +18,6 @@ pub struct BlockPath {
 }
 
 /// Convert a logical file block to a chain of offsets into the indirect tree.
-///
-/// For 4KB blocks (ptrs_per_block=1024):
-///   direct: [0..12)          -> depth=1
-///   single: [12..1036)       -> depth=2
-///   double: [1036..1049612)  -> depth=3
-///   triple: [1049612..~1B)   -> depth=4
 pub fn block_to_path(file_block: FileBlock, ptrs_per_block: u32) -> Result<BlockPath, Ext2Error> {
     let fb = file_block.raw();
     let n = ptrs_per_block;
@@ -63,7 +58,6 @@ pub fn block_to_path(file_block: FileBlock, ptrs_per_block: u32) -> Result<Block
     Err(Ext2Error::InvalidBlock)
 }
 
-/// Read a u32 block pointer from an indirect block at the given index.
 fn read_ptr(data: &[u8], idx: u32) -> BlockNum {
     let off = idx as usize * 4;
     BlockNum(u32::from_le_bytes([
@@ -74,7 +68,6 @@ fn read_ptr(data: &[u8], idx: u32) -> BlockNum {
     ]))
 }
 
-/// Write a u32 block pointer into an indirect block at the given index.
 fn write_ptr(data: &mut [u8], idx: u32, block: BlockNum) {
     let off = idx as usize * 4;
     data[off..off + 4].copy_from_slice(&block.raw().to_le_bytes());
@@ -91,13 +84,11 @@ pub fn map_block(
 ) -> Result<BlockNum, Ext2Error> {
     let path = block_to_path(file_block, ptrs_per_block)?;
 
-    // First offset is always an index into inode.block[]
     let mut current = inode.block[path.offsets[0] as usize];
     if !current.is_valid() {
         return Ok(BlockNum::ZERO);
     }
 
-    // Walk through indirect blocks
     for level in 1..path.depth as usize {
         let block = cache.get(current, device)?;
         current = read_ptr(block.data(), path.offsets[level]);
@@ -110,41 +101,36 @@ pub fn map_block(
 }
 
 /// Ensure a data block exists at the given file block offset.
-/// Allocates new blocks (including intermediate indirect blocks) as needed.
-/// Returns (physical_block, was_newly_allocated).
+/// Allocates blocks internally via the alloc module — no closure needed.
 pub fn ensure_data_block(
     inode: &mut Inode,
     file_block: FileBlock,
     ptrs_per_block: u32,
     cache: &mut BlockCache,
     device: &dyn BlockDevice,
-    alloc_fn: &mut dyn FnMut() -> Result<BlockNum, Ext2Error>,
+    superblock: &mut Superblock,
+    block_size: u32,
 ) -> Result<(BlockNum, bool), Ext2Error> {
     let path = block_to_path(file_block, ptrs_per_block)?;
 
     if path.depth == 1 {
-        // Direct block
         let idx = path.offsets[0] as usize;
         if inode.block[idx].is_valid() {
             return Ok((inode.block[idx], false));
         }
-        let new_block = alloc_fn()?;
-        let _zero = cache.get_zero(new_block, device)?;
+        let new_block = ext2_alloc::allocate_block(superblock, cache, device, block_size)?;
+        drop(cache.get_zero(new_block, device)?);
         inode.block[idx] = new_block;
         return Ok((new_block, true));
     }
 
-    // For indirect paths (depth 2, 3, or 4):
-    // Ensure the top-level indirect block exists in inode.block[]
     let top_idx = path.offsets[0] as usize;
     if !inode.block[top_idx].is_valid() {
-        let new_block = alloc_fn()?;
-        // Zero-fill and immediately release the guard
+        let new_block = ext2_alloc::allocate_block(superblock, cache, device, block_size)?;
         drop(cache.get_zero(new_block, device)?);
         inode.block[top_idx] = new_block;
     }
 
-    // Walk and allocate intermediate indirect blocks
     let mut current_indirect = inode.block[top_idx];
     for level in 1..path.depth as usize - 1 {
         let child = {
@@ -154,15 +140,14 @@ pub fn ensure_data_block(
         if child.is_valid() {
             current_indirect = child;
         } else {
-            let new_block = alloc_fn()?;
+            let new_block = ext2_alloc::allocate_block(superblock, cache, device, block_size)?;
             drop(cache.get_zero(new_block, device)?);
             let mut parent = cache.get(current_indirect, device)?;
             write_ptr(parent.data_mut(), path.offsets[level], new_block);
             current_indirect = new_block;
         }
     }
 
-    // Final level: the data block pointer
     let data_idx = path.offsets[path.depth as usize - 1];
     let existing = {
         let block = cache.get(current_indirect, device)?;
@@ -173,7 +158,7 @@ pub fn ensure_data_block(
         return Ok((existing, false));
     }
 
-    let new_data = alloc_fn()?;
+    let new_data = ext2_alloc::allocate_block(superblock, cache, device, block_size)?;
     drop(cache.get_zero(new_data, device)?);
     let mut parent = cache.get(current_indirect, device)?;
     write_ptr(parent.data_mut(), data_idx, new_data);

fs/src/ext2/dir.rs

@@ -1,8 +1,10 @@
 use super::Ext2Error;
 use super::blockmap;
 use super::cache::BlockCache;
-use super::ondisk::{DIR_ENTRY_HEADER_SIZE, DirEntry, Inode, dir_entry_size, write_dir_entry};
-use super::types::{BlockNum, FileBlock, InodeNum};
+use super::ondisk::{
+    DIR_ENTRY_HEADER_SIZE, DirEntry, Inode, Superblock, dir_entry_size, write_dir_entry,
+};
+use super::types::{FileBlock, InodeNum};
 use crate::blockdev::BlockDevice;
 use core::cmp;
 
@@ -202,7 +204,7 @@ pub fn append_dir_entry(
     device: &dyn BlockDevice,
     ptrs_per_block: u32,
     block_size: u32,
-    alloc_fn: &mut dyn FnMut() -> Result<BlockNum, Ext2Error>,
+    superblock: &mut Superblock,
 ) -> Result<(), Ext2Error> {
     let needed = dir_entry_size(name.len());
     let bs = block_size as usize;
@@ -270,19 +272,19 @@ pub fn append_dir_entry(
         offset += block_size;
     }
 
-    // No space found: allocate a new block
-    let new_block = alloc_fn()?;
+    // No space found: allocate a new block and add to parent's block map
     let file_block = FileBlock(parent_inode.size / block_size);
-
-    // Store the new block pointer in the inode's block map
     blockmap::ensure_data_block(
         parent_inode,
         file_block,
         ptrs_per_block,
         cache,
         device,
-        &mut || Ok(new_block),
+        superblock,
+        block_size,
     )?;
+    // Re-map to get the newly allocated block number
+    let new_block = blockmap::map_block(parent_inode, file_block, ptrs_per_block, cache, device)?;
 
     // Write the new entry into the fresh block
     let mut block = cache.get_zero(new_block, device)?;