Merge pull request #90 from ryanbreen/feature/exec-from-filesystem

feat(exec): enable loading ELF binaries from ext2 filesystem

Author: ryanbreen

kernel/src/fs/ext2/block_group.rs

@@ -293,8 +293,26 @@ impl Ext2Fs {
             return Err("Not a regular file");
         }
 
-        // For now, just set size to 0 and clear block pointers
-        // A full implementation would also free the data blocks in the block bitmap
+        // Free all allocated data blocks before clearing pointers
+        // This prevents block leaks where blocks remain marked "in use" but are unreachable
+        let i_block = inode.i_block;
+
+        // Free direct blocks (0-11)
+        for i in 0..12 {
+            if i_block[i] != 0 {
+                let _ = block_group::free_block(
+                    self.device.as_ref(),
+                    i_block[i],
+                    &self.superblock,
+                    &mut self.block_groups,
+                );
+            }
+        }
+
+        // TODO: Free indirect blocks (single, double, triple) for large files
+        // For now, just handle direct blocks which covers files up to 12KB (1KB blocks)
+        // or 48KB (4KB blocks)
+
         inode.i_size = 0;
         inode.i_dir_acl = 0; // Clear high bits of size
         inode.i_blocks = 0;

kernel/src/fs/ext2/mod.rs

@@ -838,6 +838,14 @@ fn kernel_main_continue() -> ! {
         log::info!("=== FS TEST: cwd syscalls (getcwd, chdir) ===");
         test_exec::test_cwd();
 
+        // Test exec from ext2 filesystem
+        log::info!("=== FS TEST: exec from ext2 filesystem ===");
+        test_exec::test_exec_from_ext2();
+
+        // Test filesystem block allocation (regression test for truncate/alloc bugs)
+        log::info!("=== FS TEST: block allocation regression test ===");
+        test_exec::test_fs_block_alloc();
+
         // Test Rust std library support
         log::info!("=== STD TEST: Rust std library support ===");
         test_exec::test_hello_std_real();

kernel/src/main.rs

@@ -1142,6 +1142,50 @@ pub fn sys_exec_with_frame(
     })
 }
 
+/// Load ELF binary from ext2 filesystem path.
+///
+/// Returns the file content as Vec<u8> on success, or an errno on failure.
+///
+/// NOTE: This function intentionally has NO logging to avoid timing overhead.
+/// It's called on every exec syscall, and serial I/O causes CI timing issues.
+#[cfg(feature = "testing")]
+fn load_elf_from_ext2(path: &str) -> Result<Vec<u8>, i32> {
+    use super::errno::{EACCES, EIO, ENOENT, ENOTDIR};
+    use crate::fs::ext2;
+
+    // Get ext2 filesystem
+    let fs_guard = ext2::root_fs();
+    let fs = fs_guard.as_ref().ok_or(EIO)?;
+
+    // Resolve path to inode number
+    let inode_num = fs.resolve_path(path).map_err(|e| {
+        if e.contains("not found") {
+            ENOENT
+        } else {
+            EIO
+        }
+    })?;
+
+    // Read inode metadata
+    let inode = fs.read_inode(inode_num).map_err(|_| EIO)?;
+
+    // Check it's a regular file (not directory)
+    if inode.is_dir() {
+        return Err(ENOTDIR);
+    }
+
+    // Check execute permission (S_IXUSR = 0o100)
+    let perms = inode.permissions();
+    if (perms & 0o100) == 0 {
+        return Err(EACCES);
+    }
+
+    // Read file content
+    let data = fs.read_file_content(&inode).map_err(|_| EIO)?;
+
+    Ok(data)
+}
+
 /// sys_execv_with_frame - Replace the current process with a new program (with argv support)
 ///
 /// This is the extended implementation that supports passing command-line arguments.
@@ -1268,8 +1312,24 @@ pub fn sys_execv_with_frame(
 
         #[cfg(feature = "testing")]
         {
-            // Load the binary from the test disk by name
-            let elf_vec = crate::userspace_test::get_test_binary(program_name);
+            // Try to load from ext2 filesystem first, fall back to test disk
+            let elf_vec = if program_name.contains('/') {
+                // Path-like name: load from ext2 filesystem
+                match load_elf_from_ext2(program_name) {
+                    Ok(data) => data,
+                    Err(errno) => return SyscallResult::Err(errno as u64),
+                }
+            } else {
+                // Bare name: try ext2 /bin/ first, then fall back to test disk
+                let bin_path = alloc::format!("/bin/{}", program_name);
+                match load_elf_from_ext2(&bin_path) {
+                    Ok(data) => data,
+                    Err(_) => {
+                        // Fall back to test disk for compatibility
+                        crate::userspace_test::get_test_binary(program_name)
+                    }
+                }
+            };
             let boxed_slice = elf_vec.into_boxed_slice();
             let elf_data = Box::leak(boxed_slice) as &'static [u8];
             let name_string = alloc::string::String::from(program_name);

kernel/src/syscall/handlers.rs

@@ -2033,6 +2033,63 @@ pub fn test_cwd() {
     }
 }
 
+/// Test exec from ext2 filesystem
+pub fn test_exec_from_ext2() {
+    log::info!("Testing exec from ext2 filesystem");
+
+    #[cfg(feature = "testing")]
+    let exec_ext2_elf_buf = crate::userspace_test::get_test_binary("exec_from_ext2_test");
+    #[cfg(feature = "testing")]
+    let exec_ext2_elf: &[u8] = &exec_ext2_elf_buf;
+    #[cfg(not(feature = "testing"))]
+    let exec_ext2_elf = &create_hello_world_elf();
+
+    match crate::process::creation::create_user_process(
+        String::from("exec_from_ext2_test"),
+        exec_ext2_elf,
+    ) {
+        Ok(pid) => {
+            log::info!("Created exec_from_ext2_test process with PID {:?}", pid);
+            log::info!("Exec ext2 test: process scheduled for execution.");
+            log::info!("    -> Userspace will emit EXEC_EXT2_TEST_PASSED marker if successful");
+        }
+        Err(e) => {
+            log::error!("Failed to create exec_from_ext2_test process: {}", e);
+            log::error!("Exec ext2 test cannot run without valid userspace process");
+        }
+    }
+}
+
+/// Test filesystem block allocation (regression test for s_first_data_block offset bug)
+/// This tests:
+/// - truncate_file() properly frees blocks (not just clears pointers)
+/// - Multi-file operations don't corrupt other files' data blocks
+pub fn test_fs_block_alloc() {
+    log::info!("Testing filesystem block allocation (regression test)");
+
+    #[cfg(feature = "testing")]
+    let fs_block_alloc_test_elf_buf = crate::userspace_test::get_test_binary("fs_block_alloc_test");
+    #[cfg(feature = "testing")]
+    let fs_block_alloc_test_elf: &[u8] = &fs_block_alloc_test_elf_buf;
+    #[cfg(not(feature = "testing"))]
+    let fs_block_alloc_test_elf = &create_hello_world_elf();
+
+    match crate::process::creation::create_user_process(
+        String::from("fs_block_alloc_test"),
+        fs_block_alloc_test_elf,
+    ) {
+        Ok(pid) => {
+            log::info!("Created fs_block_alloc_test process with PID {:?}", pid);
+            log::info!("Block alloc test: process scheduled for execution.");
+            log::info!("    -> Userspace will emit BLOCK_ALLOC_TEST_PASSED marker if successful");
+        }
+        Err(e) => {
+            log::error!("Failed to create fs_block_alloc_test process: {}", e);
+            log::error!("Block alloc test cannot run without valid userspace process");
+        }
+    }
+}
+
 /// Test Rust std library support via hello_std_real
 pub fn test_hello_std_real() {
     log::info!("Testing Rust std library support (hello_std_real)");

kernel/src/test_exec.rs

@@ -14,6 +14,10 @@ path = "hello_time.rs"
 name = "hello_world"
 path = "hello_world.rs"
 
+[[bin]]
+name = "simple_exit"
+path = "simple_exit.rs"
+
 [[bin]]
 name = "counter"
 path = "counter.rs"
@@ -334,3 +338,11 @@ path = "dns_test.rs"
 [[bin]]
 name = "http_test"
 path = "http_test.rs"
+
+[[bin]]
+name = "exec_from_ext2_test"
+path = "exec_from_ext2_test.rs"
+
+[[bin]]
+name = "fs_block_alloc_test"
+path = "fs_block_alloc_test.rs"

testdata/ext2.img

@@ -31,6 +31,7 @@ echo ""
 # List binaries being built
 BINARIES=(
     "hello_world"
+    "simple_exit"
     "hello_time"
     "counter"
     "spinner"
@@ -102,6 +103,8 @@ BINARIES=(
     "cat"
     "exec_argv_test"
     "exec_stack_argv_test"
+    "exec_from_ext2_test"
+    "fs_block_alloc_test"
     "shell_pipe_test"
     # Coreutils
     "ls_cmd"