1 files changed, 137 insertions, 0 deletions

diff --git a/rsnix/src/exec.rs b/rsnix/src/exec.rs
new file mode 100644
index 0000000..7ba39aa
--- /dev/null
+++ b/rsnix/src/exec.rs
@@ -0,0 +1,137 @@
+// ---------------------------------------------------------------------------
+// exec — run an external binary (ADR 0006 Phase 2).
+//
+// Resolution: name → \bin\<kind>\<name> on each mounted volume → None.
+// The shell calls exec::spawn with a fully constructed Exports table
+// (streams point at its pipeline/tty) and clean argv.  The binary runs as
+// its own task; on exit it posts TaskMsg::User(exit_code) to the spawner.
+//
+// The Exports table and argv block are heap boxes moved into static slots
+// indexed by task id — the trampoline adopts them before jumping to the
+// image entry.  One slot per MAX_TASKS; spawn fails if the slot is busy.
+// ---------------------------------------------------------------------------
+use crate::load;
+use crate::sched::{self, TaskMsg};
+use alloc::string::String;
+use alloc::vec::Vec;
+use rsapi::{Arg, EntryPoint, Exports};
+
+/// Per-task invocation context adopted by the trampoline.
+struct ExecCtx {
+    exports: &'static Exports,
+    /// Heap block holding the argv strings (kept alive until task exit —
+    /// the Arg pointers reference into it).
+    #[allow(dead_code)]
+    argv_buf: Vec<u8>,
+    args: Vec<Arg>,
+    /// Image pages to free when the task dies.
+    image: load::Image,
+}
+
+static mut CTX: [Option<ExecCtx>; sched::MAX_TASKS] = [const { None }; sched::MAX_TASKS];
+
+/// Error of exec::resolve / exec::spawn.
+pub enum ExecError {
+    NotFound,
+    LoadFailed(&'static str),
+    Busy,
+}
+
+/// Scan every mounted volume for `\bin\<kind>\<name>` (LFN exact match).
+/// Returns the VFS handle of the first hit.
+pub fn resolve(kind: &str, name: &str) -> Option<usize> {
+    for vol in 0..crate::fat::volume_count() {
+        if !crate::fat::is_mounted(vol) {
+            continue;
+        }
+        let uid = String::from(crate::fat::uid(vol));
+        let path = alloc::format!("/disk/{}/bin/{}/{}.efi", uid, kind, name);
+        if let Some(h) = crate::fs::resolve(&path) {
+            return Some(h);
+        }
+    }
+    None
+}
+
+/// Read the whole file into a heap buffer (public: the shell uses this
+/// to fetch binary bytes before calling load::load_image).
+#[allow(dead_code)]
+pub fn read_file(h: usize) -> Result<Vec<u8>, ()> {
+    let size = crate::fs::size(h) as usize;
+    let mut buf = Vec::with_capacity(size);
+    let mut chunk = [0u8; 512];
+    let mut pos = 0u64;
+    loop {
+        let n = crate::fs::read(h, &mut chunk, pos)?;
+        if n == 0 {
+            break;
+        }
+        buf.extend_from_slice(&chunk[..n]);
+        pos += n as u64;
+    }
+    Ok(buf)
+}
+
+/// Spawn `image` as a new task running entry(exports, argc, argv).
+///
+/// The caller keeps `exports` alive (it is constructed per invocation in
+/// shell-owned memory that outlives the command — the pipeline/tty live
+/// in the blocked spawner).
+pub fn spawn(
+    image: load::Image,
+    exports: &'static Exports,
+    argv: &[String],
+    name: &str,
+) -> Result<usize, ExecError> {
+    // Copy the argv strings into one contiguous block owned by the task.
+    let mut argv_buf: Vec<u8> = Vec::new();
+    let mut args: Vec<Arg> = Vec::with_capacity(argv.len());
+    for a in argv {
+        let off = argv_buf.len();
+        argv_buf.extend_from_slice(a.as_bytes());
+        args.push(Arg {
+            ptr: unsafe { argv_buf.as_ptr().add(off) },
+            len: a.len(),
+        });
+    }
+
+    // Reserve a task slot first so the context is in place before the
+    // task can possibly run (spawn may schedule immediately).
+    let id = sched::reserve_slot().ok_or(ExecError::Busy)?;
+    unsafe {
+        CTX[id] = Some(ExecCtx {
+            exports,
+            argv_buf,
+            args,
+            image,
+        });
+    }
+    if !sched::launch_at(id, trampoline, name) {
+        unsafe {
+            CTX[id] = None;
+        }
+        return Err(ExecError::Busy);
+    }
+    Ok(id)
+}
+
+/// Trampoline: adopt the exec context, call the entry, report completion.
+fn trampoline() {
+    let id = sched::current();
+    let taken = unsafe {
+        let ctx_ptr = core::ptr::addr_of_mut!(CTX);
+        (*ctx_ptr)[id].take()
+    };
+    let Some(ctx) = taken else {
+        sched::abort_current("exec: no context")
+    };
+    // Call the image entry with the table; the return value is the exit code.
+    let code = unsafe {
+        let f: EntryPoint = core::mem::transmute(ctx.image.entry);
+        f(ctx.exports, ctx.args.len(), ctx.args.as_ptr())
+    };
+    // Report completion to the spawner (the shell), then die.  The spawner
+    // frees the image pages after reaping the message.
+    let _ = sched::send(sched::SHELL_TID, TaskMsg::User(code as u64));
+    drop(ctx);
+}