Cross-platform packager: OCI symlink resolution, rewrite-include, rtld_audit removal

.github/workflows/ci.yml

@@ -188,16 +188,20 @@ jobs:
           tool: nextest@${{ env.NEXTEST_VERSION }}
       - uses: Swatinem/rust-cache@v2
       - run: cargo clippy --locked --verbose --all-targets --all-features -p litebox_runner_linux_on_windows_userland
+      - run: cargo clippy --locked --verbose --all-targets --all-features -p litebox_packager
       - run: cargo build --locked --verbose -p litebox_runner_linux_on_windows_userland
+      - run: cargo build --locked --verbose -p litebox_packager
       - run: cargo nextest run --locked --profile ci -p litebox_runner_linux_on_windows_userland
+      - run: cargo nextest run --locked --profile ci -p litebox_packager
       - run: cargo nextest run --locked --profile ci -p litebox_shim_linux --no-default-features --features platform_windows_userland
       - run: |
           cargo test --locked --verbose --doc -p litebox_runner_linux_on_windows_userland
+          cargo test --locked --verbose --doc -p litebox_packager
           # We need to run `cargo test --doc` separately because doc tests
           # aren't included in nextest at the moment. See relevant discussion at
           # https://github.com/nextest-rs/nextest/issues/16
       - name: Build documentation (fail on warnings)
-        run: cargo doc --locked --verbose --no-deps --all-features --document-private-items -p litebox_runner_linux_on_windows_userland
+        run: cargo doc --locked --verbose --no-deps --all-features --document-private-items -p litebox_runner_linux_on_windows_userland -p litebox_packager
 
   build_and_test_snp:
     name: Build and Test SNP

dev_bench/unixbench/prepare_unixbench.py

@@ -61,8 +61,8 @@ def prepare_benchmark(
     """
     Prepare a single benchmark using litebox_packager.
 
-    The packager discovers dependencies, rewrites all ELFs, and creates a tar
-    (including litebox_rtld_audit.so).  The rewritten main binary is extracted
+    The packager discovers dependencies, rewrites all ELFs, and creates a tar.
+    The rewritten main binary is extracted
     from the tar and placed alongside it.
 
     Returns True on success.

dev_tests/src/boilerplate.rs

@@ -133,7 +133,6 @@ const SKIP_FILES: &[&str] = &[
     "LICENSE",
     "litebox/src/sync/mutex.rs",
     "litebox/src/sync/rwlock.rs",
-    "litebox_rtld_audit/Makefile",
     "litebox_runner_linux_on_windows_userland/tests/test-bins/hello_exec_nolibc",
     "litebox_runner_linux_on_windows_userland/tests/test-bins/hello_thread",
     "litebox_runner_linux_on_windows_userland/tests/test-bins/hello_thread_static",

dev_tests/src/ratchet.rs

@@ -40,7 +40,6 @@ fn ratchet_globals() -> Result<()> {
             ("litebox_platform_lvbs/", 23),
             ("litebox_platform_multiplex/", 1),
             ("litebox_platform_windows_userland/", 8),
-            ("litebox_runner_linux_userland/", 1),
             ("litebox_runner_lvbs/", 5),
             ("litebox_runner_snp/", 1),
             ("litebox_shim_linux/", 1),

litebox_common_linux/src/loader.rs

@@ -128,6 +128,8 @@ pub enum ElfParseError<E> {
     BadTrampoline,
     #[error("Invalid trampoline version")]
     BadTrampolineVersion,
+    #[error("Binary not patched for syscall rewriting")]
+    UnpatchedBinary,
     #[error("Unsupported ELF type")]
     UnsupportedType,
     #[error("Bad interpreter")]
@@ -141,6 +143,7 @@ impl<E: Into<Errno>> From<ElfParseError<E>> for Errno {
             | ElfParseError::BadFormat
             | ElfParseError::BadTrampoline
             | ElfParseError::BadTrampolineVersion
+            | ElfParseError::UnpatchedBinary
             | ElfParseError::BadInterp
             | ElfParseError::UnsupportedType => Errno::ENOEXEC,
             ElfParseError::Io(err) => err.into(),
@@ -218,6 +221,11 @@ impl ElfParsedFile {
         })
     }
 
+    /// Returns `true` if a trampoline was parsed and will be mapped by `load()`.
+    pub fn has_trampoline(&self) -> bool {
+        self.trampoline.is_some()
+    }
+
     /// Parse the LiteBox trampoline data, if any.
     ///
     /// The trampoline header is located at the end of the file (last 32/20 bytes).
@@ -251,7 +259,8 @@ impl ElfParsedFile {
 
         // File must be large enough to contain the header
         if file_size < header_size as u64 {
-            return Ok(());
+            // Too small for a trampoline header — binary is unpatched.
+            return Err(ElfParseError::UnpatchedBinary);
         }
 
         // Read the header from the end of the file
@@ -267,8 +276,9 @@ impl ElfParsedFile {
             if &header_buf[0..7] == b"LITEBOX" {
                 return Err(ElfParseError::BadTrampolineVersion);
             }
-            // No trampoline found, which is OK (not all binaries are rewritten)
-            return Ok(());
+            // No trampoline found. When using the syscall rewriter backend
+            // (syscall_entry_point != 0), all binaries must be patched.
+            return Err(ElfParseError::UnpatchedBinary);
         }
 
         let (file_offset, vaddr, trampoline_size) = if cfg!(target_pointer_width = "64") {
@@ -293,9 +303,11 @@ impl ElfParsedFile {
             )
         };
 
-        // Validate trampoline size
+        // trampoline_size == 0 means the rewriter checked this binary and found
+        // no syscall instructions. The magic header acts as a "checked" marker so
+        // the runtime skips eager code-segment patching. No trampoline to map.
         if trampoline_size == 0 {
-            return Err(ElfParseError::BadTrampoline);
+            return Ok(());
         }
 
         // Verify the file offset is page-aligned (as required by the rewriter)
@@ -567,6 +579,24 @@ pub trait ReadAt {
     fn size(&mut self) -> Result<u64, Self::Error>;
 }
 
+impl ReadAt for &[u8] {
+    type Error = Errno;
+
+    fn read_at(&mut self, offset: u64, buf: &mut [u8]) -> Result<(), Self::Error> {
+        let offset: usize = offset.truncate();
+        let end = offset.checked_add(buf.len()).ok_or(Errno::EINVAL)?;
+        if end > self.len() {
+            return Err(Errno::EINVAL);
+        }
+        buf.copy_from_slice(&self[offset..end]);
+        Ok(())
+    }
+
+    fn size(&mut self) -> Result<u64, Self::Error> {
+        Ok(self.len() as u64)
+    }
+}
+
 pub trait MapMemory {
     type Error;