Remove i686-guest, nanvix-unstable and guest-counter features (#1525)

* Remove i686-guest, nanvix-unstable and guest-counter features

Removes the experimental 32-bit i686 guest support along with the
nanvix-unstable and guest-counter cargo features that depended on or
accompanied it. This deletes the i686 arch modules, the PEB file-mapping
plumbing (labels, preallocated FileMappingInfo array), the GuestCounter
API, and the associated cfg gating, tests, Justfile recipes, CI matrix
entries and docs.

As part of the cleanup, the ReadableSharedMemory trait machinery in
mem::layout is now gated on a precise 'readable_shared_mem' cfg alias
(gdb debug path or shared-snapshot mem_profile path) instead of a blanket

Signed-off-by: Simon Davies <simongdavies@users.noreply.github.com>
#[allow(unused)], so it is compiled out entirely when unused.

* Gate crashdump helpers on the crashdump cfg-alias

Four crashdump-only items in mem::mgr (the BasicMapping/MappingKind
import, mapping_kind_to_flags, try_coalesce_region and
get_guest_memory_regions) were gated on the raw `crashdump` feature
rather than the `crashdump` cfg-alias from build.rs
(all(feature = "crashdump", target_arch = "x86_64")). They reference
CrashDumpRegion/MemoryRegionFlags/MemoryRegionType, which are imported
under #[cfg(crashdump)], so enabling the feature on a non-x86_64 target
would compile the code without the types and fail to build. Switch them
to #[cfg(crashdump)] for consistency with the rest of the crashdump
codepath.

Addresses Copilot review feedback on #1525.

Signed-off-by: Simon Davies <simongdavies@users.noreply.github.com>

* Remove unused multi-root snapshot plumbing

Drop unused multi-root page-table snapshot machinery introduced by the
old aliasing work:
- Remove PtRootFinder/set_pt_root_finder and root_pt_gpas plumbing
  from MultiUseSandbox and SandboxMemoryManager snapshot flow.
- Simplify Snapshot::new to walk and rebuild from a single root (CR3)
  using virt_to_phys + map only.
- Remove unused multi-space API/types from hyperlight_common::vmem:
  SpaceId, SpaceReferenceMapping, SpaceAwareMapping,
  walk_va_spaces, and space_aware_map, plus arch stubs.

This keeps only the single-root walker path now used by the host and
eliminates dead code and extra complexity.

Signed-off-by: Simon Davies <simongdavies@users.noreply.github.com>

* Update CHANGLOG

Signed-off-by: Simon Davies <simongdavies@users.noreply.github.com>

* Further review changes

Signed-off-by: Simon Davies <simongdavies@users.noreply.github.com>

* Address review feedback

Signed-off-by: Simon Davies <simongdavies@users.noreply.github.com>

---------

Signed-off-by: Simon Davies <simongdavies@users.noreply.github.com>

Author: simongdavies

.github/workflows/dep_code_checks.yml

@@ -82,11 +82,6 @@ jobs:
       - name: Verify MSRV
         run: ./dev/verify-msrv.sh hyperlight-host hyperlight-guest hyperlight-guest-bin hyperlight-common
 
-      - name: Check 32-bit builds (Nanvix compatibility)
-        run: |
-          rustup target add i686-unknown-linux-gnu
-          just check-i686 debug
-
       - name: Check cargo features compile
         run: just check
 

CHANGELOG.md

@@ -4,6 +4,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Prerelease] - Unreleased
 
+### Changed
+* **Breaking:** `MultiUseSandbox::map_file_cow` and `UninitializedSandbox::map_file_cow` no longer take a label argument. The APIs now accept only `(file_path, guest_base)`.
+
+### Removed
+* Removed the experimental `i686-guest`, `nanvix-unstable`, and `guest-counter` feature flags, along with 32-bit (i686) guest support and its page-table/snapshot code paths. Hyperlight guests are now 64-bit only (x86_64 and aarch64).
+
 ## [v0.15.0] - 2026-05-06
 
 ### Added

Justfile

@@ -133,9 +133,6 @@ code-checks-like-ci config=default-target hypervisor="kvm":
     @# Verify MSRV
     ./dev/verify-msrv.sh hyperlight-common hyperlight-guest hyperlight-guest-bin hyperlight-host hyperlight-component-util hyperlight-component-macro hyperlight-guest-tracing
 
-    @# Check 32-bit guests
-    {{ if os() == "linux" { "just check-i686 " + config } else { "" } }}
-
     @# Check cargo features compile
     just check
 
@@ -274,14 +271,6 @@ test-rust-tracing target=default-target features="":
     {{ cargo-cmd }} test -p hyperlight-common -F trace_guest --profile={{ if target == "debug" { "dev" } else { target } }} {{ target-triple-flag }}
     {{ cargo-cmd }} test -p hyperlight-host --profile={{ if target == "debug" { "dev" } else { target } }} {{ if features =="" {'--features trace_guest'} else { "--features trace_guest," + features } }} {{ target-triple-flag }}
 
-# verify hyperlight-common and hyperlight-guest build for 32-bit (for Nanvix compatibility - uses i686 as proxy for Nanvix's custom 32-bit x86 target)
-check-i686 target=default-target:
-    cargo check -p hyperlight-common --target i686-unknown-linux-gnu --profile={{ if target == "debug" { "dev" } else { target } }}
-    cargo check -p hyperlight-guest --target i686-unknown-linux-gnu --profile={{ if target == "debug" { "dev" } else { target } }}
-    cargo check -p hyperlight-common --target i686-unknown-linux-gnu --features i686-guest --profile={{ if target == "debug" { "dev" } else { target } }}
-    # Verify that trace_guest correctly fails on i686 (compile_error should trigger)
-    ! cargo check -p hyperlight-guest --target i686-unknown-linux-gnu --features trace_guest --profile={{ if target == "debug" { "dev" } else { target } }} 2>/dev/null
-
 test-doc target=default-target features="":
     {{ cargo-cmd }} test --profile={{ if target == "debug" { "dev" } else { target } }} {{ target-triple-flag }} {{ if features =="" {''} else { "--features " + features } }} --doc
 
@@ -301,9 +290,8 @@ check:
     {{ cargo-cmd }} check -p hyperlight-host --features print_debug  {{ target-triple-flag }}
     {{ cargo-cmd }} check -p hyperlight-host --features gdb  {{ target-triple-flag }}
     {{ cargo-cmd }} check -p hyperlight-host --features trace_guest,mem_profile  {{ target-triple-flag }}
-    {{ cargo-cmd }} check -p hyperlight-host --features i686-guest  {{ target-triple-flag }}
-    {{ cargo-cmd }} check -p hyperlight-host --features i686-guest,executable_heap  {{ target-triple-flag }}
     {{ cargo-cmd }} check -p hyperlight-host --features hw-interrupts  {{ target-triple-flag }}
+    {{ cargo-cmd }} check -p hyperlight-host --features executable_heap  {{ target-triple-flag }}
 
 fmt-check: (ensure-nightly-fmt)
     cargo +{{nightly-toolchain}} fmt --all -- --check

flake.nix

@@ -82,7 +82,6 @@
                 "x86_64-unknown-linux-gnu"
                 "x86_64-pc-windows-msvc" "x86_64-unknown-none"
                 "wasm32-wasip1" "wasm32-wasip2" "wasm32-unknown-unknown"
-                "i686-unknown-linux-gnu"
               ];
               extensions = [ "rust-src" ] ++ (if args.channel == "nightly" then [ "miri-preview" ] else []);
             });

src/hyperlight_common/Cargo.toml

@@ -34,9 +34,6 @@ fuzzing = ["dep:arbitrary"]
 trace_guest = []
 mem_profile = []
 std = ["thiserror/std", "log/std", "tracing/std"]
-i686-guest = []
-nanvix-unstable = ["i686-guest"]
-guest-counter = []
 
 [dev-dependencies]
 quickcheck = "1.0.3"

src/hyperlight_common/src/arch/aarch64/vmem.rs

@@ -46,29 +46,6 @@ pub unsafe fn virt_to_phys<'a, Op: TableReadOps + 'a>(
     core::iter::empty()
 }
 
-/// Stub — see [`crate::vmem::walk_va_spaces`].
-#[allow(clippy::missing_safety_doc)]
-pub unsafe fn walk_va_spaces<Op: TableReadOps>(
-    _op: &Op,
-    _roots: &[Op::TableAddr],
-    _address: u64,
-    _len: u64,
-) -> ::alloc::vec::Vec<(
-    crate::vmem::SpaceId,
-    ::alloc::vec::Vec<crate::vmem::SpaceAwareMapping>,
-)> {
-    ::alloc::vec::Vec::new()
-}
-
-/// Stub — see [`crate::vmem::space_aware_map`].
-#[allow(clippy::missing_safety_doc)]
-pub unsafe fn space_aware_map<Op: TableOps>(
-    _op: &Op,
-    _ref_map: crate::vmem::SpaceReferenceMapping,
-    _built_roots: &::alloc::collections::BTreeMap<crate::vmem::SpaceId, Op::TableAddr>,
-) {
-}
-
 pub trait TableMovability<Op: TableReadOps + ?Sized, TableMoveInfo> {}
 impl<Op: TableOps<TableMovability = crate::vmem::MayMoveTable>> TableMovability<Op, Op::TableAddr>
     for crate::vmem::MayMoveTable

src/hyperlight_common/src/arch/amd64/vmem.rs

@@ -329,100 +329,6 @@ unsafe fn map_page<
 /// 3. PD (29:21) - allocate PT if needed
 /// 4. PT (20:12) - write final PTE with physical address and flags
 ///
-/// Multi-space page-table walking on amd64: walks each root
-/// independently and emits all leaves as `ThisSpace`. Aliased
-/// intermediate-table detection is not implemented here because no
-/// current embedder exercises that pattern on amd64.
-///
-/// TODO: align with the i686 implementation and detect aliased
-/// intermediate tables to avoid semantic divergence across arches.
-/// Tracking: follow-up issue.
-#[allow(clippy::missing_safety_doc)]
-pub unsafe fn walk_va_spaces<Op: TableReadOps>(
-    op: &Op,
-    roots: &[Op::TableAddr],
-    address: u64,
-    len: u64,
-) -> ::alloc::vec::Vec<(
-    crate::vmem::SpaceId,
-    ::alloc::vec::Vec<crate::vmem::SpaceAwareMapping>,
-)> {
-    use ::alloc::vec::Vec;
-
-    let mut out: Vec<(crate::vmem::SpaceId, Vec<crate::vmem::SpaceAwareMapping>)> =
-        Vec::with_capacity(roots.len());
-
-    let addr = address & ((1u64 << VA_BITS) - 1);
-    let vmin = addr & !(PAGE_SIZE as u64 - 1);
-    let vmax = core::cmp::min(addr + len, 1u64 << VA_BITS);
-
-    for &root in roots {
-        #[allow(clippy::unnecessary_cast)]
-        let root_id: crate::vmem::SpaceId = Op::to_phys(root) as u64;
-        let mut mappings: Vec<crate::vmem::SpaceAwareMapping> = Vec::new();
-
-        let iter = modify_ptes::<47, 39, Op, _>(MapRequest {
-            table_base: root,
-            vmin,
-            len: vmax.saturating_sub(vmin),
-            update_parent: UpdateParentNone {},
-        })
-        .filter_map(|r| unsafe { require_pte_exist(op, r) })
-        .flat_map(modify_ptes::<38, 30, Op, _>)
-        .filter_map(|r| unsafe { require_pte_exist(op, r) })
-        .flat_map(modify_ptes::<29, 21, Op, _>)
-        .filter_map(|r| unsafe { require_pte_exist(op, r) })
-        .flat_map(modify_ptes::<20, 12, Op, _>);
-
-        for r in iter {
-            let Some(pte) = (unsafe { read_pte_if_present(op, r.entry_ptr) }) else {
-                continue;
-            };
-            let phys_addr = pte & PTE_ADDR_MASK;
-            let sgn_bit = r.vmin >> (VA_BITS - 1);
-            let sgn_bits = 0u64.wrapping_sub(sgn_bit) << VA_BITS;
-            let virt_addr = sgn_bits | r.vmin;
-
-            let executable = (pte & PAGE_NX) == 0;
-            let avl = pte & PTE_AVL_MASK;
-            let kind = if avl == PAGE_AVL_COW {
-                MappingKind::Cow(CowMapping {
-                    readable: true,
-                    executable,
-                })
-            } else {
-                MappingKind::Basic(BasicMapping {
-                    readable: true,
-                    writable: (pte & PAGE_RW) != 0,
-                    executable,
-                })
-            };
-            mappings.push(crate::vmem::SpaceAwareMapping::ThisSpace(Mapping {
-                phys_base: phys_addr,
-                virt_base: virt_addr,
-                len: PAGE_SIZE as u64,
-                kind,
-                user_accessible: false,
-            }));
-        }
-
-        out.push((root_id, mappings));
-    }
-
-    out
-}
-
-/// See [`walk_va_spaces`]: amd64 never emits `AnotherSpace`, so this
-/// is unreachable in practice. It silently no-ops (rather than
-/// panicking) to keep the architecture-independent re-export usable.
-#[allow(clippy::missing_safety_doc)]
-pub unsafe fn space_aware_map<Op: TableOps>(
-    _op: &Op,
-    _ref_map: crate::vmem::SpaceReferenceMapping,
-    _built_roots: &::alloc::collections::BTreeMap<crate::vmem::SpaceId, Op::TableAddr>,
-) {
-}
-
 #[allow(clippy::missing_safety_doc)]
 pub unsafe fn map<Op: TableOps>(op: &Op, mapping: Mapping) {
     modify_ptes::<47, 39, Op, _>(MapRequest {
@@ -510,7 +416,6 @@ pub unsafe fn virt_to_phys<'a, Op: TableReadOps + 'a>(
             virt_base: virt_addr,
             len: PAGE_SIZE as u64,
             kind,
-            user_accessible: false,
         })
     })
 }
@@ -692,7 +597,6 @@ mod tests {
                 writable: true,
                 executable: false,
             }),
-            user_accessible: false,
         };
 
         unsafe { map(&ops, mapping) };
@@ -726,7 +630,6 @@ mod tests {
                 writable: false,
                 executable: true,
             }),
-            user_accessible: false,
         };
 
         unsafe { map(&ops, mapping) };
@@ -750,7 +653,6 @@ mod tests {
                 writable: true,
                 executable: false,
             }),
-            user_accessible: false,
         };
 
         unsafe { map(&ops, mapping) };
@@ -784,7 +686,6 @@ mod tests {
                 writable: true,
                 executable: false,
             }),
-            user_accessible: false,
         };
         unsafe { map(&ops, mapping1) };
         let tables_after_first = ops.table_count();
@@ -799,7 +700,6 @@ mod tests {
                 writable: true,
                 executable: false,
             }),
-            user_accessible: false,
         };
         unsafe { map(&ops, mapping2) };
 
@@ -825,7 +725,6 @@ mod tests {
                 writable: true,
                 executable: false,
             }),
-            user_accessible: false,
         };
 
         unsafe { map(&ops, mapping) };
@@ -848,7 +747,6 @@ mod tests {
                 writable: true,
                 executable: false,
             }),
-            user_accessible: false,
         };
 
         unsafe { map(&ops, mapping) };
@@ -871,7 +769,6 @@ mod tests {
                 writable: true,
                 executable: false,
             }),
-            user_accessible: false,
         };
 
         unsafe { map(&ops, mapping) };
@@ -894,7 +791,6 @@ mod tests {
                 writable: true,
                 executable: false,
             }),
-            user_accessible: false,
         };
 
         unsafe { map(&ops, mapping) };
@@ -916,7 +812,6 @@ mod tests {
                 virt_base: 0x1000,
                 len: PAGE_SIZE as u64,
                 kind,
-                user_accessible: false,
             };
             unsafe { map(&ops, mapping) };
             let result = unsafe { virt_to_phys(&ops, 0x1000, 1).next() };
@@ -974,7 +869,6 @@ mod tests {
                 writable: true,
                 executable: false,
             }),
-            user_accessible: false,
         };
 
         unsafe { map(&ops, mapping) };