Hermit Unikernel for Rust

Hermit-WASM allows you to run WebAssembly (WASM) modules on top of the Hermit Unikernel inside a lightweight virtual machine. It is designed to enable the safe execution of untrusted or third-party WASM code with very low latency and overhead.

Key Constraints & Limitations:

• Compiler: Requires the Rust nightly compiler.
• WASI Support: Currently only supports the wasm32-wasip1 target.
• Bindings: Implements only a subset of the required WASI bindings.

For a simpler alternative, use uhyve, a minimal hypervisor for Hermit that provides direct access to local directories without requiring virtiofsd.

In this example, the local WASM file is mounted to /root/wasm-test.wasm inside the VM.

uhyve -c 1 -m 1GiB --file-isolation none --file-mapping target/wasm32-wasip1/release/wasm-test.wasm:/root/wasm-test.wasm target/aarch64-unknown-hermit/release/hermit-wasm -- -- /root/wasm-test.wasm

To build a Hermit unikernel image, you must configure your project to use the hermit crate specifically when targeting the Hermit OS.

1. Add hermit as a dependency for the hermit target in your Cargo.toml.
2. In your main.rs, include hermit as an empty dependency using use hermit as _; gated by the target_os = "hermit" configuration.

[target.'cfg(target_os = "hermit")'.dependencies]
hermit = "0.6"

#[cfg(target_os = "hermit")]
use hermit as _;

Building requires a target with the *-unknown-hermit triple. You have two options depending on your Rust toolchain:

• Stable Rust: Install the rust-std-hermit component.
• Nightly Rust: Use the -Zbuild-std=std,panic_abort flag during the build process.

Before building or running Hermit-WASM, ensure you have rustup installed and the wasm32-wasip1 target added to your Rust toolchain.

rustup target add wasm32-wasip1

To build applications for the Hermit unikernel, use the provided project template. Hermit is designed so that the build process is similar to the standard Rust workflow. Rust applications that use the Rust runtime and do not directly use OS services can run on Hermit without modifications.

For a starting point, use the official template repository.

https://github.com/hermit-os/hermit-rs-template

To produce a Cumulative Distribution Function (CDF) plot for bandwidth or latency, use the plotter.py tool.

Prerequisites

• matplotlib must be installed.

Instructions

1. Capture Output: Redirect the output of the server or client to a file:
   • For bandwidth (bw): Redirect output from server-bw (or server.rs).
   • For latency: Redirect output from client-latency (or client.rs).
2. Run Plotter: python plotter.py <file_with_output>

Note: Bandwidth plots may be unreliable during two-way communication tests due to processing spikes on the server side.

python plotter.py <file_with_server.rs_output>

Once built, the resulting image can be executed using:

• Uhyve: A specialized unikernel hypervisor.
• QEMU: Using the [Hermit loader].

To build Hermit-WASM, clone the hermit-rs repository with submodules and use cargo build with specific Hermit targets.

Architecture Targets:

• aarch64: aarch64-unknown-hermit
• x86_64: x86_64-unknown-hermit
• RISC-V: riscv64gc-unknown-hermit

# clone Hermit repository
git clone --recurse-submodules https://github.com/hermit-os/hermit-rs.git
# switch the directory of the Hermit repository
cd hermit-rs
# build Hermit-WASM for aarch64
cargo build -Zbuild-std=std,panic_abort -Zbuild-std-features=compiler-builtins-mem --target aarch64-unknown-hermit -p hermit-wasm --release

Automated benchmarks can be run using provided Python scripts. This requires a configuration file (e.g., config_bw.config or config_latency.config) containing machine names, SSH keys, and usernames.

Prerequisites

• Ensure you can SSH into the target machines.
• SSH connections must be correctly configured (known hosts and SSH keys available on the local machine).

Execution

Run the scripts by passing the configuration file location as an argument: python <script> <config_file_location>

Available Scripts

• runner.py: Runs a single client and a single server remotely.
• runner_bidirectional.py: Runs two clients and two servers (one client/server pair on each of the two machines) to test bidirectional communication.

Plotting

Set PLOT=1 in your configuration file to automatically generate a summary plot of the samples.