RISC-V Linux user-mode translation to AArch64 Linux, running standalone and explicitly inside hyper-linux on macOS Apple Silicon.
Status: RV64 runtime development is active; the full product is incomplete. The native ELF inspector and static-musl AArch64 Linux runtime are separate products. The runtime has an RV64 interpreter, a direct arithmetic AArch64 JIT with explicit interpreter fallback, checked sparse memory, SoftFloat semantics, static/PIE/dynamic ELF loading, guest TLS and explicit Linux ABI conversion. Selected static and dynamic musl/glibc, dlopen and libm workloads run on Linux and through the opt-in hyper-linux companion. Exact artifact identities, acceptance results and current failures live in the implementation ledger.
Guest instructions execute under a managed-family token. Threads can park outside that token for admitted blocking I/O and normal futex operations. Signal support includes guest masks, alternate stacks, edited signal contexts, synchronous faults and selected external-signal/restart paths. These are qualified slices; complete pthread, signal and application acceptance remains open. The current canonical-source checkpoint still times out on the named hyper-linux glibc/basic pthread case at its original bound.
A focused RV64 parent-cap fixture passes the QEMU Linux-user reference and
Linux runtime under interp and JIT. It checks process-directed SIGTERM from a
guest child to its parent, including SI_USER sender identity, one handler
delivery, rt_sigreturn, and exact child wait status. The corrected fixture
uses the RISC-V three-word rt_sigaction layout. Run
make test-native-term-parent-oracle for QEMU, or
make test-native-term-parent-linux ENGINE=interp|jit on Linux. The -hl
target also passes on the bounded production companion profile recorded in
the plan. This fixture does not qualify general external-signal or
process compatibility.
Restricted fork/wait and same-PID self-exec are implemented. The internal
canonical-source runtime preserves source-service ownership across fork and
repeated exec, and passes focused multiworker exec and shared clear-TID cases
on both hosts and engines. Waitable CLONE_VM/vfork now supports parked sibling
workers and concurrent shared clones, with hook-safe waits and private reader
ownership per worker. Cold private-file clear-TID has atomic COW replay and
late exec-failure coherence checks. Nested vfork and waitable process clones
preserve each upstream completion owner; pending-upstream CLONE_THREAD remains
unsupported. Complete process, signal and
application acceptance remains open. The ordinary product now offers explicit
--source-mode=canonical, selecting the paired source-service, memory, file,
fork, exec and cleanup path. The unlinked-file fork/private-COW fixture passes
on Linux and the qualified hyper-linux companion in both engines. Ordinary
mode remains the default; the broader internal checkpoints above do not qualify
this public mode. Pre-fork canonical workers sharing one address space now admit
private regular-file mmap, with detached source preparation and current-state
placement checks. Focused occupied-hint and NOREPLACE cases pass both engines
on Linux and hyper-linux. Post-fork worker admission and canonical second-worker
O_TRUNC remain unsupported; held stale-description recovery is not qualified.
Persistent-cache components now include a versioned whole-record SHA-256,
owned non-executable reader, atomic record writer, bounded JIT emission and
checked guest-relative relocation. The serialized pipeline matches fresh JIT
emission at changed guest layouts. Opt-in startup caching validates and executes
direct 32-bit startup code from a static RV64 main or pinned PT_INTERP image.
It checks exact-FD authority and current guest source before W^X publication.
Caching defaults off. One block is the default; --cache-blocks=2 can include
its checked ecall fallthrough. Explicit configuration survives guest exec.
Fork discards transient code and reprepares eligible child candidates from an
owned immutable image; child hits are currently qualified on Linux. Selected
mixed 16/32-bit integer prefixes have bounded persistent-cache coverage;
compressed memory, FP and control flow remain interpreted. --pretranslate stores or validates
the same record without guest execution. General block/DSO discovery,
dynamic-image cross-load-bias hits and full host lifecycle coverage remain
open. Two-placement PIE cache publication has focused coverage. Configured
initial RV64 ELF dispatch and bounded native AArch64-to-RV64 exec now work
through the companion. Native script exec with an RV64 interpreter is also
qualified. Initial host script selection, broader exec/fork propagation,
full application/process qualification and RV32 remain required. Final profiles are RV64GC/LP64D and RV32GC/ILP32D,
with the explicit exclusions in the plan. This is not a universal Linux
compatibility claim. The plan contains the
copy-ready full-completion Goal prompt.
Current guest syscall coverage includes private anonymous mmap, munmap,
mprotect, brk and single-VMA mremap; openat, close, dup/dup3, fcntl's descriptor
and append/nonblocking operations, read/write/writev, pread64/pwrite64, lseek,
fstat, newfstatat, faccessat, fchmod, readlinkat, unlinkat, ftruncate and TIOCGWINSZ;
private regular-file mmap; mkdirat/getdents64, pipe2/ppoll, unnamed Unix
socketpairs/IPv4 UDP/TCP, listen/accept/accept4 and basic socket options,
vectored Unix stream sendmsg/recvmsg with socket/anonymous-pipe SCM_RIGHTS,
clocks, single-worker RV64 nanosleep, entropy and virtual uname/identity;
cooperative self-signals, rt_sigaction/rt_sigprocmask/rt_sigpending, sigaltstack,
rt_sigreturn and an initial external standard-signal/read-interruption path;
the selected thread-profile clone, exit, exit_group, per-worker gettid and
set_tid_address bookkeeping
and riscv_flush_icache.
Anonymous MAP_SHARED has a distinct VMA kind and supports nonprivate futexes,
including the qualified Linux guest-fork cases. File-backed MAP_SHARED,
advanced mapping flags and multi-VMA fixed moves remain unfinished and fail
deliberately. riscv_hwprobe reports the implemented virtual RV64 profile,
with one online CPU0, checked pair/cpuset conversion and WHICH_CPUS selection.
Unknown keys
return key=-1/value0. Hardware IDs and time-CSR frequency are zero; this profile
has no usable time CSR. Other unsupported syscall numbers return ENOSYS.
make test-linux-hwprobe checks native ABI codecs; make test-hwprobe-linux
and make test-hwprobe-hl run the real guest fixture after building it with a
matching RV64 toolchain. HWPROBE_CASE=qemu-compatible selects the independent
QEMU subset; the full oracle run preserves documented QEMU ABI differences.
--version lists the implemented ISA extensions and versions. Guest execution
serializes guest instructions under a family token. Anonymous pages use
guarded, family-owned packed backing; anonymous MAP_SHARED is implemented,
while file-backed MAP_SHARED remains unsupported.
File mappings retain the open inode,
preserve private COW through partial-page truncation, and fault on full pages
beyond EOF. In JIT mode, direct blocks retain and validate their source bytes
through checked executable reads before running when file mappings exist.
Source changes and guest fetch faults fall back to the interpreter at the
current PC; internal refresh failures stop execution. Ordinary transfers stage at most
64KiB per call and may return short results. Admitted owned-pipe write/writev
requests stage the complete Linux-capped logical request and can return
positive-prefix progress; managed FIFO writes remain capped at 4KiB. Unknown
ioctl requests return ENOTTY; unsupported fcntl operations return EOPNOTSUPP.
Process record locks remain unsupported.
Blocking stream/error ordering and concurrent I/O lifetimes remain R5 work.
These are deliberate early
limits, not the final support contract.
The current syscall/support matrix records the implemented
commands, error policy and remaining limits.
make test-aot-cache-rebase checks actual warm cached-code publication at a
different guest PIE address on Linux and hyper-linux, including AUIPC and
recovery PCs. It is a bounded component check, separate from full application
and DSO compatibility.
Guest descriptors use their own lowest-free-number table. Startup imports
inheritable native entry descriptors0..1023, excluding the exact image and
optional diagnostic roles. Stdio originals are consumed after relocation;
private opens cannot turn originally closed slots into guest descriptors.
Inherited dup aliases preserve kernel file offsets. Runtime handles stay private. The path walker expands ordinary symlinks but rejects native procfs
and descriptor namespaces with EOPNOTSUPP, including symlink aliases. O_PATH
works only when the host preserves its semantics. The qualified companion
supports directory O_PATH through an exact search-only native capability in
legacy and rooted modes. Older hosts may decline O_PATH and require readable
directories for traversal. make test-native-opath-directory checks Linux and
both companion modes, including permission revocation and descriptor flags.
These limits must be removed or replaced by a guest view before final filesystem
compatibility is claimed.
make test-r4-memory-linux ENGINE=interp and make test-r4-memory-hl ENGINE=jit
exercise real mapping fixtures; make test-r4-memory-oracle compares QEMU
Linux-user behavior. make test-linux-memory checks VMA ownership natively;
make test-linux-memory-alloc checks allocation-failure rollback under
ASan/UBSan. Select a working native sanitizer compiler with HOST_CC when
needed. Sysroot provisioning uses make sysroot-rv64-musl or
make sysroot-rv64-glibc with matching RV_CC/RV_CXX compiler commands.
The sysroot-rv32-musl and sysroot-rv32-glibc targets require matching RV32
ILP32D compilers and validate ELF32 libraries in a separate sysroot. These
provisioning targets do not establish RV32 runtime execution support.
make rv32-linux-target-libs-smoke builds the pinned-backend RV32 musl/libgcc
bootstrap and runs an ABI-checked static C division fixture under configured
RV32_QEMU. Set RV32_BACKEND_CC_PATH and RV32_BACKEND_BINUTILS_PATH to the
realized backend inputs. The corrected C path passes; C++ and glibc provisioning
remain separate incomplete checkpoints. QEMU10.1 is the observed local reference;
the final pinned reference-tool matrix remains outstanding.
make rv32-linux-target-libs-dynamic-c-smoke provisions a separate dynamic
musl PIE fixture with pthread TLS, using static libgcc helpers and the exact
staged loader/sysroot under QEMU. This provisioning lane passes on QEMU10.1;
rvrt execution remains a later RV32 checkpoint.
make rv32-linux-target-libs-cxx-smoke builds the independent C++17
string/vector/exception fixture; its latest bounded build expired during
compilation, before installation or execution. These targets do not imply RV32
execution by rvrt.
The separate rv32GlibcTargetLibrariesFor path is an experimental,
target-libraries-only glibc route. It uses the pinned RV64 GCC 15.2/binutils
2.44 backend with explicit RV32GC/ILP32D flags and the accepted RV32 static
libgcc archive; it keeps the backend's truthful RV64 -dumpmachine and does
not build an RV32 GCC frontend. Its refreshed static and dynamic C dry-runs
each resolve to five derivations and do not include a GCC frontend. The
bootstrap compiler derivation built and passed its RV32 ELF/ABI checks. The
first glibc build used one Nix build core, configured successfully, then ended
with status 125 after 1193.135 seconds while compiling NPTL objects. No glibc
sysroot or C smoke was produced, and no QEMU run occurred. Treat this path as
incomplete until both smokes build and execute against the resulting sysroot.
On macOS, the default provisioning recipe queries compilers inside Lima. For
a cross compiler running directly on macOS, set
SYSROOT_PROVISION='python3 test/provision_sysroot.py' on the Make command.
make rv32-linux-target-libs-export stages the accepted static/dynamic RV32 C
and C++ smoke ELFs, four full composed musl sysroot tar archives, and four
lib-only runtime roots under _build/rv32-target-libs-export. The archives
preserve the full Linux sysroots, including header names that collide by case
on case-insensitive host filesystems. It reruns each exact ELF under QEMU with
its staged runtime root before publishing, writes source/store/ABI provenance
and SHA-256 file hashes, and refuses to replace an existing export directory.
The manifest names each full sysroot archive and its separate runtime root;
extract an archive on a case-sensitive filesystem when compiling against the
complete sysroot. Set
RV32_EXPORT_DIR=_build/<new-name> to choose another destination.
Run make rv32-linux-target-libs-export-dry-run first to inspect the locked
bundle graph without realizing it or running QEMU. Both targets require
RV32_BACKEND_CC_PATH and RV32_BACKEND_BINUTILS_PATH to name the selected
RV64 Nix store outputs, and RV32_BACKEND_PREFIX to name their RV64 tool
prefix; these inputs are validated and recorded in the export provenance.
make test-rv32-export-oracle RV32_EXPORT_DIR=_build/rv32-target-libs-export-v3
revalidates the published manifest, full-file hashes and modes, locked nixpkgs
revision, and backend profile before replaying the four already-published ELF
files with Linux QEMU against their matching runtime roots. This is a run-only
check; it does not invoke Nix or rebuild the export. Each QEMU case keeps a
15-second bound, and the replay log records the manifest/tree and per-profile
ELF/sysroot archive hashes.
Dynamic musl/glibc TLS and external-DSO dlopen/TLS/libm fixtures pass on both
hosts/engines with canonical /lib RUNPATH and provisioned sysroots. This does
not establish full application or process compatibility.
make test-r4-file-mmap-linux and its -hl counterpart exercise retained image
identity, COW, truncation/regrowth and precise beyond-EOF faults. Native
make test-file-backing and make test-linux-metadata check backing ownership
and pathname metadata. make test-dlopen-musl and make test-dlopen-glibc
build and run the external-DSO fixtures with matching RV_CC and sysroot.
make test-r4-file-linux and make test-r4-file-hl run real file fixtures;
make test-r4-file-errors-linux and its -hl counterpart check Linux error
ordering and partial copies. QEMU's eager buffer checks differ from the kernel;
make test-r4-file-errors-qemu-subset reports that divergence explicitly and
runs a separately named compatible subset. Native Linux probes supply the
independent expectations for those differing cases.
make test-loader-dynamic checks PIE placement,
interpreter loading, guest auxv and malformed inputs natively.
make test-linux-directory-linux and its -hl counterpart check shared
directory cursors, seek cookies, EOF and output faults. make test-linux-poll
checks event conversion and deadlines; make test-r4-abi-linux and -hl
exercise real RISC-V pipe/poll/time/entropy syscalls against QEMU expectations.
make test-linux-sleep checks raw time64 request validation, monotonic and
saturating deadlines, interruption and remainder copyout. The raw RV64 fixture
uses make test-nanosleep-oracle for seven QEMU-compatible cases and
make test-nanosleep-linux ENGINE=interp or
make test-nanosleep-hl ENGINE=jit for the selected runtime engine. The
additional NANOSLEEP_CASES=partial runtime case checks a valid eight-byte
remainder prefix followed by EFAULT at a page boundary. Its expectation comes
from pinned Linux 6.18 RISC-V usercopy. QEMU 10.1 checks the whole destination
first and leaves the prefix untouched; the strict partial-copy probe records
that difference and is excluded from the seven-case QEMU oracle target. Caught SA_RESTART still returns EINTR.
Multiworker nanosleep, clock_nanosleep (115), and full stop/continue restart
behavior remain unsupported or unqualified.
make test-linux-socket-linux and -hl check descriptor/address codecs and
protocol-specific receive faults; the real ABI fixture also covers socketpair
and loopback UDP. make test-socket-app LIBC=musl ENGINE=interp and the glibc/JIT
variants run compiled Unix/UDP/TCP workloads using provisioned sysroots and
fixtures built with make test-socket-app-fixture. Named Unix endpoints and
regular/directory descriptor passing and broader ancillary message codecs
remain in progress. make test-linux-message-linux and -hl check the bounded
Unix stream message/rights codecs; regular/directory rights currently fail
deliberately with EOPNOTSUPP.
Pinned static/dynamic BusyBox workloads have separate builtins, direct
and process targets. Direct applets have focused coverage; current hyper-linux
shell startup and process acceptance remain incomplete. See the implementation
plan for exact artifacts and retained failures. These targets inherit their
launch environment by default. For comparable diagnostics, set
BUSYBOX_GUEST_ENV=fixed (or test/test_busybox.py --guest-env fixed) to give
the workload only PATH=/bin:/usr/bin, LC_ALL=C, LANG=C, and HOME=/.
Lima's transport retains its host environment. make test-busybox-env-command
checks the local and remote environment boundary without starting a VM.
For poll/signal ABI checks, POLL_SIGNAL_LINK_MODE=static selects a separately
validated static-musl fixture; the default remains dynamic. Use
POLL_SIGNAL_CASE=mask-restore or sibling-ppoll with the existing
test-poll-signal-{oracle,linux,hl} targets. Static selected cases have paired
coverage; dynamic startup timeouts remain recorded in the plan.
make test-family-unit-linux runs the managed page/token foundation on Linux
or Lima, including packed objects, owner death and committed slot recovery.
make test-family-object-smoke-hl HL_BIN=../hyper-linux-rvrt-host/_build/hl
checks single-process shared objects against the isolated host companion.
make test-family-managed-linux checks guarded CPU-memory helpers, aliases,
atomic reservations, two-slot stores and remote same-value invalidation;
make test-family-managed-smoke-hl checks the same single-process helpers.
make test-family-mm test-mm-view checks canonical anonymous MM roots and
transactional local reconciliation, including native-process updates, redo
crashes, allocation rollback and retained copyout. Their -sanitize and
-linux variants run ASan/UBSan and static AArch64 Linux components. These
components have separate runtime admission checks described below.
make test-mm-protect test-mm-protect-sanitize checks canonical permission
transactions, partial-prefix errors, no-op identities and peer copyout.
make test-mm-protect-linux test-mm-protect-oracle-linux runs the component
and an independent real-kernel prefix oracle on AArch64 Linux.
make test-guest-memory-canonical test-guest-memory-canonical-sanitize
checks internal session ownership, guarded refresh admission, OOM retry and
teardown without refreshing; test-guest-memory-canonical-linux runs it on
AArch64 Linux. The ordinary runtime keeps its existing memory path; the
internal source runtime selects the canonical constructor.
make test-mm-runtime-binding test-mm-runtime-binding-sanitize checks the
canonical memory-syscall adapter and atomic file replacement; the -linux and
-hl targets run the same AArch64 component on Linux and Hyper-Linux.
make test-guest-memory-canonical-exec test-guest-memory-canonical-exec-sanitize checks the internal same-PID exec
foundation, with corresponding -linux and -hl targets. These component and
exec checks do not open the public source profile. The internal source runtime
now admits selected guest threads with exact canonical MM membership and has
focused fork/exec acceptance, including live sibling exec. Public source
routing remains gated; component checks do not establish full R5 support.
make test-mm-fork test-mm-fork-sanitize checks the canonical fork memory
component: exact private state with fresh keys, shared aliases, and file-origin
registration before a delayed child attaches. Its -linux and -hl targets
run the same AArch64 component on both hosts. Public source routing remains
gated. make test-mm-join test-mm-join-sanitize checks shared-MM child ownership,
current-root reconciliation and owner-selective retirement; its -linux and
-hl variants execute identical AArch64 component bytes.
make test-guest-memory-canonical-threads test-guest-memory-canonical-threads-sanitize checks split local attachment,
guarded admission, refresh, retirement and cleanup-only ownership. Its
-linux and -hl targets run the same AArch64 component on both hosts.
make test-canonical-thread-edges-linux test-canonical-thread-edges-hl
checks cancellation before the first guest turn and a fatal worker fault
with bounded group teardown. Set CANONICAL_THREAD_RUNTIME to the absolute
path of the frozen internal runtime when replaying it; the -oracle target
checks the independent Linux-user QEMU outcomes.
make test-file-exec-truncate-linux test-file-exec-truncate-hl checks the
same warmed executable-file mapping through the interpreter and JIT on both
hosts. Set FILE_EXEC_TRUNCATE_RUNTIME=/absolute/path/to/frozen-runtime to
name the exact existing runtime for a replay; Make then uses that artifact
instead of its default runtime path. make test-native-file-exec-truncate-linux
is the independent AArch64 Linux kernel oracle. The strict
test-file-exec-truncate-oracle QEMU comparison currently returns fixture exit
19 after the post-truncate call returns instead of faulting; it remains RED,
with no expected-failure exemption.
make test-file-jit-linux test-file-jit-hl checks two real native executions
of file-backed arithmetic around a file write and instruction-cache flush.
test-anonymous-jit-linux/-hl/-oracle checks the corresponding guest-store
case; its Linux-user QEMU oracle passes. test-file-jit-boundary-linux/-hl
warms a two-instruction native block across a page boundary, truncates the
second page, then checks the SIGBUS PC, address and earlier committed register
value. Its post-truncate execution may use precise interpreter fallback.
These targets use FILE_JIT_RUNTIME to select a frozen internal runtime.
test-jit-progress checks the interval-counter parser and rejects unrelated
JIT work as evidence of mapped-code execution. The strict test-file-jit-oracle
and test-file-jit-boundary-oracle comparisons remain RED on QEMU10.1: it
executes stale code after these file mutations. Their expected results remain
unchanged; an independent oracle failure is reported separately from rvrt's
Linux and hyper-linux results.
make test-mm-unmap test-mm-unmap-sanitize checks transactional interval
removal, retained aliases and pending copyout. test-mm-unmap-linux and
test-mm-unmap-oracle-linux run the component and an independent Linux syscall
oracle; invalid bounds remove no prefix and hole-only success keeps identity.
make test-mm-map test-mm-map-sanitize checks internal anonymous mapping
transactions, fixed replacement zeroing, retained aliases, NOREPLACE and
allocation failure. test-mm-map-linux test-mm-map-oracle-linux runs the
component and independent kernel expectations on AArch64 Linux.
make test-mm-brk test-mm-brk-sanitize checks internal heap transactions and
metadata-only peer refresh; test-mm-brk-linux test-mm-brk-oracle-linux runs the
component and raw Linux kernel expectations. make test-brk-hole ENGINE=interp
checks the actual RV64 guest shrink regression through both hosts and the raw
kernel oracle; repeat with ENGINE=jit.
make test-mprotect-limit ENGINE=interp checks the actual RV64 guest syscall
at the supported VA limit through Linux, explicit hyper-linux invocation and
QEMU; repeat with ENGINE=jit. A later hole preserves an earlier protected
prefix, while arithmetic wrap changes nothing. The fresh source runtime passes;
the older installed package 3f8eeefb fails this new regression.
make test-private-paths-linux checks private inode denial without dropping
process record locks. make test-family-leave-linux checks cleanup after file
unlock and before another local thread enters. make test-guest-memory-linux
and make test-guest-memory-hl check runtime startup adoption, private-inode
protection and cleanup, including worker handoff and an idle detach racing a
sibling leave. Each admitted guest worker holds its own family guard. Reads
park the worker and release the guard around native I/O, then reacquire it
before completing or discarding owned copyout. Other potentially blocking
calls with multiple live workers still return EOPNOTSUPP.
make test-linux-file-workers-linux and -hl check per-call callbacks,
retained descriptor leases and rebased copyout using real native workers;
this component test is separate from guest-runtime acceptance.
make test-native-signal-stop-linux and -hl check the private stop carrier
and reader cancellation boundary. make test-clone-blocked-read-linux CLONE_BLOCKED_READ_CASE=group-exit and -hl check guest teardown; readiness
provides scheduling opportunity without proving kernel-blocked entry.
make test-linux-file-writes and its -linux/-hl variants check retained
staged write/writev data through descriptor reuse with native workers.
make test-clone-pipe-write-oracle checks seven pipe-write/readiness cases
against QEMU. Its -linux/-hl variants select CLONE_PIPE_WRITE_CASE=all
or named cases: sigpipe, group-exit, atomic, partial, readiness,
large-write, and large-writev. The latter two require one syscall to write
131073 unaligned bytes, verified through EOF. Native SIGPIPE masking is scoped to
the owned-pipe write and restores the prior bit before returning.
make test-linux-futex-linux and -hl check actual queued namespace/mask
filtering, retained mappings and clear-tid wake. make test-futex-signal-linux
and -hl check saved guest syscall state and timed/untimed restart behavior
with external USR1 delivery; make test-futex-signal-oracle uses QEMU.
make test-clone-requeue-linux and -hl check normal/compare/same-key requeue
against independent QEMU expectations, with optional CLONE_QUANTUM=N.
make test-clone-rv64-oracle runs the finite raw-clone fixtures under QEMU;
make test-clone-rv64-linux ENGINE=interp CLONE_QUANTUM=1 and
make test-clone-rv64-hl ENGINE=jit CLONE_QUANTUM=256 run the same fixtures
through rvrt. --quantum N sets a positive retired-instruction budget; the
current default is64, selected from measured handoff costs in the pthread
workload. Use --quantum 1 to stress instruction-by-instruction scheduling.
A bounded allowance preserves constrained LR/SC progress.
make test-clone-signal-read-oracle checks the cross-worker read/signal
fixtures with Linux-user QEMU; test-clone-signal-read-linux and -hl run
them through rvrt, with CLONE_SIGNAL_READ_CASE=interrupt|restart|process|all.
test-native-signal-wake-linux and -hl check coalesced native notifications,
independent target selection and ordinary read completion after notifications.
Shared guest memory, futexes, full pthread compatibility, extended
signal behavior and process lifecycle remain required implementation work.
make test-threads-oracle LIBC=musl and make test-signals-oracle LIBC=musl
run the named pthread and signal fixtures against Linux-user QEMU; repeat with
LIBC=glibc. Build them with the corresponding test-threads-fixture and
test-signals-fixture targets in the matching toolchain shell. Their -linux
and -hl targets are required acceptance lanes; cooperative delivery and the
named external signal/read/wait cases pass, while wider signal, pthread and
process cases still expose unfinished R5 behavior.
THREAD_FIXTURE, THREAD_SYSROOT, SIGNAL_FIXTURE and SIGNAL_SYSROOT select
previously provisioned, hash-verified artifacts.
make test-fork-wait-oracle checks the raw fork, wait-status, pipe-EOF,
three-generation and retired-helper
fixtures against QEMU; make test-fork-wait-linux ENGINE=interp and
ENGINE=jit run the same cases through rvrt. The Linux fork path supports
clone(SIGCHLD) from initial and helper workers, including with live siblings
and after helpers retire, plus restricted wait4. It preserves private/shared
memory, inherited descriptors and signal-handler frames. Check the latter with
make test-r5-fork-signal-linux ENGINE=interp and its JIT/oracle variants.
make test-r5-fork-tid-linux ENGINE=interp and its JIT variant cover selected
parent/child TID flags, best-effort pointer faults and mm-owned clear-tid.
make test-fork-tid-native-linux independently checks generic Linux behavior;
the pinned QEMU parent-TID discrepancy remains a strict oracle failure.
make test-r5-fork-multi-linux FORK_MULTI_CASE=leader-idle ENGINE=interp
and FORK_MULTI_CASE=leader-read exercise live peers; repeat with ENGINE=jit.
make test-r5-fork-poll-lease-linux ENGINE=interp and its JIT variant require
EOF while the fork child remains alive after dropping copied poll leases.
The -native and -oracle targets provide independent reference behavior.
make test-r5-fork-nonleader-chain-linux ENGINE=interp and its JIT variant
check real libc fork from a helper, post-fork pthread creation, a nested fork,
nonzero child statuses and the same sequence after exec. Its -native and
-oracle targets check the fixture independently; -cancel-linux requires
exactly three actual owner-cleanup cancellation-state checks.
make test-exec-launch checks the real exec owners' activation order and exact
descriptor-flag rollback after native exec and injected activation failures;
test-exec-launch-sanitize and test-exec-launch-linux check that same unit
under sanitizers and on AArch64 Linux. Set
EXEC_ROLLBACK_MULTI_DIAGNOSTIC=1 on the existing
test-r5-exec-rollback-multi-linux or -suspended-linux targets to exercise
the private diagnostic channel as well as blocked siblings and FD aliases.
make test-r5-fork-rollback-hook-linux ENGINE=interp and its JIT variant
inject one native-fork failure after snapshot preparation, verify the original
parent/peer state, then require a successful retry and nested child execution.
Wider process failure behavior, complete libc process behavior, full exec
qualification and orphan lifecycle remain required work. Hyper-linux fork targets still fail
behind the companion's process gate.
make test-signal-context-linux ENGINE=interp and its -hl/JIT variants
check a raw handler-edited PC, every GPR/FPR and FCSR against the independent
test-signal-context-oracle. test-signal-frame and test-linux-signal
exercise wire layout, masks, pending order, nested altstacks and invalid-frame
handling; their -linux/-hl variants run the same AArch64 unit artifacts.
make test-trap-signal-linux ENGINE=interp and its -hl/JIT variants
check illegal instructions, breakpoints, mapping/permission faults and atomic
alignment. test-trap-signal-oracle labels QEMU's different misalignment
siginfo expectation. test-linux-trap-signal checks the Linux mapping directly.
make test-native-signals-hl NATIVE_SIGNAL_CASE=ppoll-ignore checks the native
AArch64 boundary under the companion's explicit RVRT policy; x8, ppoll
and sender select the other probes. The external sender canary now passes
under the opt-in companion policy. That host-boundary result does not by itself
qualify guest signal-frame, restart, or multi-thread behavior.
nix develop -c make check
nix develop -c make fixtures
./_build/rvrt inspect _build/hello-rv64make help lists targets. The inspector is a native host executable
(Mach-O on macOS, ELF on Linux). A host C11 compiler, Make and Python 3 can
also run make check.
LLVM's Clang and LLD build the optional real RISC-V ELF fixtures.
nix build packages the native inspector and runs make check-inspector
(the 20 parser tests). The package source includes only inspector inputs and
the shared Make dependency catalog; it does not compile runtime code.
make check retains the broader native runtime/component aggregate.
make test-fixtures also inspects the LLVM-built RV32/RV64 executables.
On macOS, nix develop .#toolchain-rv64-musl-clang -c make toolchain-check
cross-compiles the existing dynamic and static RV64GC/LP64D C and C++17
toolchain probes with host-native Clang/LLD. The shell uses target CRT, musl,
GCC runtime and libstdc++ files from the locked x86_64-linux RV64 musl
package closure as data; it never executes that closure's Linux GCC or
binutils. The existing toolchain-rv64-musl GCC shell is unchanged. This
checks fixture compilation and ELF metadata, not RV64 runtime execution.
The thread, hwprobe, signal, exec, process and C++ fixture builders honor
RV_CC_EXECUTION: auto keeps each builder's existing placement; host or
lima selects the compiler's actual execution platform. The optional Clang shell
sets host. Guest execution remains separate from compiler placement.
The Clang/LLD inputs use Apache-2.0 WITH LLVM-exception (and the LLVM/NCSA license notices), musl uses MIT, and GCC-derived target headers/runtime files are covered by the GNU GPL v3-or-later and applicable GCC runtime exceptions. The toolchain shell keeps these inputs as Nix references, so their locked nixpkgs license metadata remains available alongside the compiler tools.
Build the separate runtime with nix develop -c make runtime-linux fixtures.
nix build .#rvrt-linux-aarch64 packages that static-PIE runtime and its
Apache-2.0, SoftFloat and Mbed TLS license/provenance files. The separate
nix build .#softfloat-aarch64 output provides its reusable target archive;
ordinary runtime source changes reuse it. Both packages use the pinned flake
toolchain and the root Make rules. The runtime has no hyper-linux build or
link dependency.
For a manual runtime link against a previously built target archive, use
make SOFTFLOAT_PREBUILT=1 SOFTFLOAT_AARCH64=/path/to/libsoftfloat.a runtime-linux.
The prebuilt mode requires that file to exist and omits the vendor archive build
rule. The default SOFTFLOAT_PREBUILT=0 continues to build SoftFloat from the
vendored sources.
An optional Clang-built package is available with
nix build .#rvrt-linux-aarch64-clang. It installs the same
bin/rvrt-linux-aarch64 static-musl AArch64 PIE and license files, and uses
the flake-pinned Clang, LLD, musl headers/libraries and GCC target runtime
libraries. On AArch64 Linux, run the installed artifact directly with
./result/bin/rvrt-linux-aarch64 --engine=interp -- TARGET_PATH GUEST_ARGV0;
for an explicit output path, use
nix build --no-link --print-out-paths .#rvrt-linux-aarch64-clang and append
/bin/rvrt-linux-aarch64 to the returned store path. The existing
rvrt-linux-aarch64 package remains the default GCC output. Its latest
current-source bounded Nix compile stopped at the 600-second limit before
verification or installation, so that GCC package revision remains
unqualified; the Clang package is a separate build result.
For build diagnostics, add BUILD_TIMING=1 to report live start/end records
and elapsed nanoseconds for runtime and target SoftFloat build phases.
For a resumable runtime build, use
make runtime-linux RUNTIME_OBJECT_BUILD=1 BUILD_DIR=_build/runtime-objects-dev.
It retains completed objects, tracks headers and compiler flags, and publishes
the executable after static-PIE verification. The ordinary build remains the
default; use a distinct build directory for the optional object mode.
For direct cross builds, set A64_CC and A64_AR to the AArch64 Linux musl
compiler and target archiver; the native host archiver does not build this ELF archive.
On AArch64 Linux, run:
./_build/rvrt-linux-aarch64 --engine=interp -- _build/hello-rv64 chosen-argv0
./_build/rvrt-linux-aarch64 --engine=jit --stats -- _build/hello-rv64 chosen-argv0Use --source-mode=canonical for the finite source-family profile:
./_build/rvrt-linux-aarch64 --source-mode=canonical --engine=jit -- TARGET_PATH GUEST_ARGV0
hl --rvrt-runtime ./_build/rvrt-linux-aarch64 --rvrt-engine jit --rvrt-arg --source-mode=canonical -- TARGET_PATH GUEST_ARGV0This requires the companion's owned lifetime-socket fork support. The option
does not select a filesystem trust policy; --file-identity and
--family-authority retain their separate contracts. Check the public fork
fixture with make test-fork-file-canonical-linux ENGINE=interp and
make test-fork-file-canonical-hl ENGINE=jit, setting
FORK_FILE_CANONICAL_RUNTIME and HL_BIN to the desired built artifacts.
The focused worker mapping cases use
make test-r5-canonical-mmap-gate-plain-linux-interp or
make test-r5-canonical-mmap-gate-plain-hl-jit. Set RVRT_RUNTIME,
CANONICAL_MMAP_GATE_FIXTURE, CANONICAL_MMAP_GATE_SYSROOT and HL_BIN when
reusing pinned artifacts. The separate -held- targets build or require a
test-hook runtime; the resample case currently fails at refused worker O_TRUNC.
--trace-syscalls prints guest syscall inputs and returned results to stderr
without instruction tracing. --trace retains both instruction and syscall
logging. Both flags are off by default; exit and context-restoring syscalls
may have an input line without a returned-result line.
To exercise the initial executable-cache path on native Linux ext4/tmpfs,
build make runtime-linux test-aot-cache-runtime-fixtures, create a private
directory, and run the same command twice:
cache_dir="$(mktemp -d)"
./_build/rvrt-linux-aarch64 --engine=jit --stats --cache-dir "$cache_dir" -- _build/aot-cache-entry-rv64 chosen-argv0The cold run reports cache=stored reason=cold; the warm run reports
cache=hit reason=executed only after cached code actually runs. Unsupported
filesystems, ACLs, unsafe permissions, stale/corrupt records and failed cache
operations preserve normal guest execution. Cache paths use the translator's
filesystem view. The initial auto policy certifies local ext4/tmpfs only.
APFS requires the explicit trusted-host policy
--cache-authority=hyper-linux-apfs-acl-v1 and a qualified hyper-linux ACL
companion; older passthrough hosts do not qualify. A record digest cannot
establish trust in attacker-modified generated code. See
the host contract for the authority boundary.
make test-aot-cache-runtime-linux checks cold/warm execution, corruption and
native file-size-limit fallback. make test-aot-cache-runtime-hl HL_BIN=/path/to/qualified/hl
checks the same runtime through the qualified host. These commands require
the existing AArch64 cross toolchain and, on macOS, the configured Lima VM.
--cache-blocks=2 extends the default entry record with the direct prefix at
the sequential return PC of its terminating ecall, when eligible. Each block
has separate recovery metadata and a cache-block offset=... executed=...
diagnostic under --stats; an executed hit requires that exact published block
to run. make test-aot-multiblock HL_BIN=/path/to/qualified/hl checks both
blocks, explicit pretranslation, changed layouts, disabled caching and precise
fallback after execute permission is removed, with Linux-user QEMU expectations.
--cache-blocks=3 through --cache-blocks=16 opt into bounded discovery
within the selected initial image entry's executable segment. It follows checked direct
branches, jumps and ecall continuations, including cycles and targets before
entry; control-flow instructions still run in the interpreter. An adjacent
emitted AUIPC with nonzero destination followed by a legal matching JALR,
C.JR or C.JALR also prepares its PC-relative callee and, for linked calls,
the continuation at the original instruction length, including when the pair
crosses the instruction quantum. Supported 16-bit RV64C integer
operations are expanded only when the existing direct-JIT classifier accepts
their 32-bit equivalent; the original encoding, guest PC, and 2-byte length
remain attached to the instruction. Discovery can therefore cache mixed 2-byte
and 4-byte direct blocks. Compressed memory, floating-point, and control-flow
instructions still use the interpreter, as do unsupported operations. Discovery
visits at most128 roots and emits at most the requested number of blocks. Static
binaries select their main entry; dynamic binaries select the pinned PT_INTERP
entry, with both images bound into identity. This is not full DSO or arbitrary-code
discovery.
make test-aot-discover test-aot-discover-sanitize checks the bounded discovery
component, including fault classification and records larger than8KiB.
make test-aot-pcrel-linux test-aot-pcrel-hl checks an indirect call across the
32-instruction quantum, with an independent Linux-user QEMU result. Cold,
warm, pretranslated and disabled-cache runs use the same runtime/fixture;
warm runs must execute the cached callee and return continuation.
make test-aot-pcrel-compressed-linux test-aot-pcrel-compressed-hl repeats
these checks with an AUIPC/C.JALR pair after31 compressed instructions; the
linked continuation is two bytes after C.JALR. Native discovery tests also
cover unlinked C.JR, final-parcel bounds, and rejected producer/consumer pairs.
make test-aot-mixed-width-linux test-aot-mixed-width-hl checks a static PIE
with mixed 2-byte/4-byte source instructions through QEMU and both hosts. It
checks cold/warm execution, non-executing pretranslation and validation, and
disabled-cache behavior. make test-aot-mixed-width-rebase-linux test-aot-mixed-width-rebase-hl checks cached execution at a second PIE bias
and rejects changed source. The cache record remains format v2 and stores the
original source encodings and lengths; emitter identity v3 separates code
generated with mixed-width decoding from older emitter output. Bounded fetches
never read an incomplete final instruction parcel outside the selected image
segment.
make test-aot-cfg-dynamic-linux test-aot-cfg-dynamic-hl checks interpreted
control flow through a cached ELF interpreter and an actual AT_ENTRY handoff.
make test-aot-dynamic HL_BIN=/path/to/qualified/hl checks startup caching of
a purpose-built PT_INTERP entry, then transfer to the main image through
AT_ENTRY. Dynamic records bind both immutable image snapshots, so changing
either input selects a new key. Code offsets and relocations use the
interpreter's own load bias. The test mutates and restores owned fixture
inodes, runs host lanes serially, and compares loader/main output with
Linux-user QEMU. General DSO discovery and libc-loader cache coverage remain open.
make test-aot-exec HL_BIN=/path/to/qualified/hl checks that guest exec
preserves its PID and cache configuration, then executes the new target's
prewarmed entry. Relative cache paths are copied as absolute spellings at
launch, so guest chdir cannot retarget them. Every open rechecks authority.
make test-aot-fork-linux checks parent and child hits independently: the
parent executes both prefixes while the child resumes at the second. Disabled
cache and Linux-user QEMU controls preserve process behavior. The normal HL
native-fork gate remains closed.
make test-fsize-inherited compares guest-visible inherited file-size limits
with QEMU, then checks both engines on Linux and hyper-linux. The Linux cases
keep the original hard limit, vary only a child soft limit, and verify cache
refusal or a warm HIT without changing the guest-visible pair. Ordinary guest
prlimit64 currently supports only a read of RLIMIT_FSIZE for self.
make test-fsize-hard0-linux checks inherited soft/hard limits of0/0:
hello, the guest limit query and the bounded clone/exec rejection policy on
both engines. The same ordinary runtime also passes these cases through
make test-fsize-hard0-hl HL_BIN=/path/to/qualified/hl; this named test selects
--family-authority=hyper-linux-apfs-acl-v1. Runtime AUTO still declines APFS.
The policy is separate from cache authority and file identity. Its CLI checks
are test-family-authority-cli-linux and test-family-authority-cli-hl.
This checkpoint uses one worker without the source service. The allocation
crash window, full HL wait capacity, source-service attachment and full
thread/process support remain open. Its -oracle companion checks independent
QEMU expectations; test-fsize-hard0 includes both hosts. The internal source
runtime also passes the Linux cases with retained service cleanup. The
executable-cache suite checks hard-zero cold fallback and warm executed hits.
See the support matrix for these temporary limits and exact artifact ledger.
Use the same runtime to prepare the startup translation without executing guest instructions:
./_build/rvrt-linux-aarch64 --pretranslate --cache-dir "$cache_dir" -- _build/aot-cache-entry-rv64 chosen-argv0It reports pretranslation=stored reason=cold or
pretranslation=validated reason=cache. The next ordinary JIT run uses that
record. The default covers one direct 32-bit RV64 startup entry block: the
static main or pinned PT_INTERP image. Unsupported direct prefixes, including
compressed-only entries, deliberately decline while ordinary execution remains
available. Dynamic identity binds both main and interpreter snapshots.
Unavailable storage or unsupported input returns1, invalid options return2,
and an internal invariant failure returns125. Successful pretranslation returns0.
It selects JIT emission by default and accepts --stats; explicit interpreter,
trace, step-limit and progress options are rejected. make test-pretranslate
checks both hosts, including later cached execution. Add --cache-blocks=2
to pretranslate the same eligible pair described above. Supply
PRETRANSLATE_INTERP_FIXTURE and PRETRANSLATE_SYSROOT to include a provisioned
valid dynamic image with an unsupported direct prefix, such as a compressed
entry. Its expected decline is reason=emit. Broader block/DSO discovery and
cache propagation remain open.
Runtime diagnostics follow current guest stderr. Closing or replacing guest2 closes or redirects default logging without an implicit retained pipe endpoint. For complete cleanup/total timings, explicitly dedicate a separate descriptor:
./_build/rvrt-linux-aarch64 --stats --diagnostic-fd 9 -- _build/hello-rv64 chosen-argv0 9>rvrt.logThe runtime consumes native9 as a private channel; guest9 is not imported.
The channel also survives guest exec/fork. Default --stats prints
kind=execution before descriptor teardown with cleanup-total-excluded;
the explicit channel prints kind=final after cleanup. Both routes preserve
instruction counts and completed inclusive measurements.
--stats enables monotonic per-phase wall timers and instruction counts.
Linux measurements use a direct clock syscall so cached host vDSO timestamps
do not collapse short phases to zero. make test-measure-clock-linux and its
-hl counterpart report empty-pair overhead without imposing a speed threshold.
Phase times are inclusive: memory and file I/O nest inside execution and must
not be summed as independent costs. Clock failures, backward samples and
overflow are reported. Disabled instrumentation reads no clocks. Observation
adds overhead, especially where clock reads require host syscalls; compare
bounded workloads with and without observation before interpreting timings.
Cache preparation reports aot_prepare plus nested authority, identity, emission,
read, verification, relocation and write phases. The read/write phases include
their internal authority checks. Cached RX publication uses publish. These
measurements do not establish a speed benefit; warm loading still emits fresh
code to validate saved text.
--stats-sample N enables observation with one timed call in every N per
phase. calls counts completed calls, samples counts successful timed calls,
and ns is their raw duration sum. Unsampled time is never silently estimated.
Use different periods to check sampling bias; inclusive phases still overlap.
--progress-sample N adds worker-local progress records every N attempted
instructions, plus worker, futex, I/O and join lifecycle markers. Each interval
reports instruction and yield deltas with the guest TID and PC. Scheduler and
guard timings sample one call in 128; native futex sleep is timed on every call.
The reported nanoseconds are raw sampled sums, with clock validity and failure
counts. They are not estimates of all calls or disjoint total costs. This
diagnostic is off by default and preserves syscall errno; output and clock
reads can affect scheduling. When combined with --stats or --stats-sample,
each emitted progress interval also prints a cumulative timing snapshot. Timing
headers identify kind=snapshot, kind=execution or kind=final. Snapshot rows contain
process-wide completed measurements only; open worker stamps and the still-open
total timer are omitted. Phase counters stay cumulative and raw, without
extrapolation. Use
make test-progress for its focused checks.
--sysroot PATH prefixes absolute guest PT_INTERP and openat paths. The target path is
opened literally in the runtime's filesystem view (or supplied through
--image-fd); relative interpreter paths use cwd. The guest dynamic linker
owns relocations and guest TLS. Relative file paths use native cwd or a guest
directory descriptor. Absolute symlink targets restart at native /, preserving
prefix-only filesystem behavior. Sysroot prefixing is not confinement.
--expect-image SHA256_HEX:DECIMAL_SIZE checks the exact initial image bytes
before guest entry. The configured Hyper-Linux launcher computes this value
from the pinned RV64 target and inserts it into the runtime command. Forwarded
--rvrt-arg --expect-image or --rvrt-arg --expect-image=... is rejected
because it conflicts with the host's checked target identity; a literal
--rvrt-arg -- is rejected as an invalid forwarded value. This is a
consistency check over the captured image, not an authenticity claim. Initial
host launch cases remain under qualification.
On macOS Apple Silicon, invoke the same runtime through the isolated companion's explicit RVRT policy. This supplies a pinned target descriptor, coherent shared backing and owner identity required by managed memory:
../hyper-linux-rvrt-exec-dispatch/_build/rvrt-exec-script-v4/hl --rvrt-runtime ./_build/rvrt-linux-aarch64 --rvrt-engine jit _build/hello-rv64
# An explicit guest argv0 uses the existing separator form:
../hyper-linux-rvrt-exec-dispatch/_build/rvrt-exec-script-v4/hl --rvrt-runtime ./_build/rvrt-linux-aarch64 -- _build/hello-rv64 chosen-argv0Set HL_BIN to the qualified companion binary for -hl Make targets until
the companion changes are integrated. make test-rvrt-launch checks ordinary
RV64 ELF selection, explicit argv0, negative startup cases and both descriptor-
zero layers. The configured translator leaves native A64/x64/A32 initial ELF
routes unchanged. A configured native AArch64 Linux process can also exec
an RV64 ELF with the same PID. This admission requires one live worker, no
previous native fork relay and the supported stdio/regular descriptor table;
closed standard descriptors remain closed. A native script exec can select a
pinned RV64 interpreter, preserve the original script AT_EXECFN and pass one
opaque optional shebang argument. A conflicting forwarded --execfn returns
EINVAL before teardown. Native runtime masks, pending USR1
and ignored USR2 survive, while caught handlers reset. Initial host script selection, broader
descriptor/worker states and full fork/sysroot propagation remain open.
make test-rvrt-native-exec-hl ENGINE=jit and ENGINE=interp check actual exec,
empty argv, PID/auxv, signal state, closed descriptors and pre-reset failures.
make test-rvrt-native-script-exec-hl focuses on shebang argv, original-script
identity and exact selected-runtime errors.
make test-rvrt-native-exec-linux runs the same assertions against native
AArch64 Linux exec; test-rvrt-native-controls-hl and -linux check native
fork and signal controls. For ordinary AArch64 runtime invocation,
hl --rvrt-native RUNTIME [RUNTIME_ARGS...] selects the same memory/signal
policy while preserving native argv and inherited descriptors. It does not
add a foreign target or AT_EXECFD. Host-target descriptor-zero coverage uses
the pinned handoff form; runtime image-FD-zero coverage is a separate test.
make test-rvrt-parent-notify-oracle checks the small RV64 parent-signal
fixture against Linux-user QEMU. test-rvrt-parent-notify-linux runs the same
fixture through the selected RVRT_RUNTIME; test-rvrt-parent-notify-hl
checks the isolated fork/exec companion. All require the exact sender, marker,
exit status and owned-process cleanup within 15 seconds. The full C sentinel
remains test-rvrt-fork-exec-hl; select R6_FORK_EXPECTATION=inherited-stdio
or two-generation for descriptor lifetime and repeated-fork coverage.
These focused tests do not open the production fork admission gate.
make test-rvrt-wait-progress-oracle checks interrupted raw wait4 on native
AArch64 Linux. test-rvrt-wait-progress-hl requires the same continuation PC,
full-width signal-frame and resumed registers, exact sender and live child
before final reap. Both keep the 15-second case deadline. The controller holds
the child's stdin until the parent proves signal delivery and child liveness.
Use repeated --rvrt-arg WORD options to forward runtime flags verbatim, for
example --rvrt-arg --stats-sample --rvrt-arg 1024. Runtime --sysroot paths
must be visible inside the host filesystem view; host --sysroot is a separate
filesystem/environment policy. That companion policy permits runtime pthread
workers but keeps Hyper-Linux process clones behind its H2/R5 process-ownership
gate. The Linux-host runtime has separate, restricted guest clone(SIGCHLD)/
wait4 support for qualified worker and fork fixtures; this does not establish
full POSIX process semantics or open the Hyper-Linux gate.
--file-identity=auto is the runtime default. It admits verified Linux tmpfs
file handles for clean read-only file futex keys. With a companion that provides
the APFS handle contract, select --file-identity=hyper-linux-apfs-v1 explicitly:
hl --rvrt-runtime ./_build/rvrt-linux-aarch64 --rvrt-arg --file-identity=hyper-linux-apfs-v1 -- _build/hello-rv64 chosen-argv0The selected policy survives runtime fork and guest exec. The host does not
append it automatically. Unrecognized providers still permit ordinary file
access and conservative mapping refresh; a clean read-only nonprivate futex
requires a proven mapped-file identity and otherwise returns EOPNOTSUPP.
Other required filesystem providers remain implementation work.
The target path and guest argv0 are separate arguments. Unhandled guest faults retain diagnostics and exit statuses; installed guest handlers can recover through edited signal contexts. The isolated hyper-linux companion fixes blocked-read signal interruption and passes the unchanged host smoke harness. That change has not yet been integrated into the main sibling checkout. Guest readonly truncation uses logical descriptor metadata and passes on both hosts while preserving the default hyper-linux contract.
Inspection checks ELF identification, program headers, load ranges and interpreter strings. It reports the float ABI and RVC flag without claiming instruction coverage. It does not parse ISA attributes, map segments, resolve an interpreter, or certify that a file can execute. Extended program-header numbering and big-endian inputs are explicitly unsupported.
Read the implementation plan for required
deliverables, acceptance checks and progress; it is the sole execution record.
RVRT.md retains architecture research and design. The draft host
contract defines the proposed integration boundary and
the hyper-linux changes needed.
AGENTS.md contains repository working rules adapted from the
local ../a32rt and ../hyper-linux projects. The requested ../r32rt was not
present; ../a32rt is the AArch32 translator used as the reference.
Original work is Apache-2.0, Copyright 2026 Moritz Angermann moritz@zw3rk.com, zw3rk pte. ltd.