repositories / smith
smith
There are many coding harnesses - but this one is fast
owned by admin
smith-harness/src/wasm/sealed_wasi.rs
Raw//! Sealed WASI: Smith's own synchronous implementations of the WASI imports
//! that guest std runtimes pull in (`SMH-SPEC-WASM0001`, no ambient WASI).
//!
//! Sealed by default: empty environment and arguments, empty stdin, stdout
//! and stderr writes discarded, no terminals, `exit` traps, the monotonic
//! clock reads a host-injected value, and every pollable is ready.
//!
//! No host state backs a stream or pollable, so resources are bare handles
//! with no table entry; ownership counts bound composed roots across suspended stores.
use super::PluginHostState;
use super::bindings::wasi::cli::{
environment, exit, stderr, stdin, stdout, terminal_input, terminal_output, terminal_stderr,
terminal_stdin, terminal_stdout,
};
use super::bindings::wasi::clocks::monotonic_clock;
use super::bindings::wasi::io::error::{self, Error};
use super::bindings::wasi::io::poll::{self, Pollable};
use super::bindings::wasi::io::streams::{self, InputStream, OutputStream, StreamError};
use wasmtime::component::Resource;
/// The only handle value ever minted; no handle carries host state.
const SEALED: u32 = 0;
/// Bytes a sealed output stream accepts per write; writes are discarded.
const WRITE_BUDGET: u64 = 4096;
fn sealed<T: 'static>(state: &mut PluginHostState) -> Resource<T> {
super::composition::mint_sealed_handle(state);
Resource::new_own(SEALED)
}
impl poll::HostPollable for PluginHostState {
fn ready(&mut self, _pollable: Resource<Pollable>) -> bool {
true
}
fn block(&mut self, _pollable: Resource<Pollable>) {}
fn drop(&mut self, _pollable: Resource<Pollable>) -> wasmtime::Result<()> {
super::composition::drop_sealed_handle(self);
Ok(())
}
}
impl poll::Host for PluginHostState {
fn poll(&mut self, pollables: Vec<Resource<Pollable>>) -> Vec<u32> {
(0..u32::try_from(pollables.len()).unwrap_or(u32::MAX)).collect()
}
}
impl error::HostError for PluginHostState {
fn to_debug_string(&mut self, _error: Resource<Error>) -> String {
String::new()
}
fn drop(&mut self, _error: Resource<Error>) -> wasmtime::Result<()> {
Ok(())
}
}
impl error::Host for PluginHostState {}
impl streams::HostInputStream for PluginHostState {
fn read(&mut self, _stream: Resource<InputStream>, _len: u64) -> Result<Vec<u8>, StreamError> {
Err(StreamError::Closed)
}
fn blocking_read(
&mut self,
_stream: Resource<InputStream>,
_len: u64,
) -> Result<Vec<u8>, StreamError> {
Err(StreamError::Closed)
}
fn skip(&mut self, _stream: Resource<InputStream>, _len: u64) -> Result<u64, StreamError> {
Err(StreamError::Closed)
}
fn blocking_skip(
&mut self,
_stream: Resource<InputStream>,
_len: u64,
) -> Result<u64, StreamError> {
Err(StreamError::Closed)
}
fn subscribe(&mut self, _stream: Resource<InputStream>) -> Resource<Pollable> {
sealed(self)
}
fn drop(&mut self, _stream: Resource<InputStream>) -> wasmtime::Result<()> {
super::composition::drop_sealed_handle(self);
Ok(())
}
}
impl streams::HostOutputStream for PluginHostState {
fn check_write(&mut self, _stream: Resource<OutputStream>) -> Result<u64, StreamError> {
Ok(WRITE_BUDGET)
}
fn write(
&mut self,
_stream: Resource<OutputStream>,
_contents: Vec<u8>,
) -> Result<(), StreamError> {
Ok(())
}
fn blocking_write_and_flush(
&mut self,
_stream: Resource<OutputStream>,
_contents: Vec<u8>,
) -> Result<(), StreamError> {
Ok(())
}
fn flush(&mut self, _stream: Resource<OutputStream>) -> Result<(), StreamError> {
Ok(())
}
fn blocking_flush(&mut self, _stream: Resource<OutputStream>) -> Result<(), StreamError> {
Ok(())
}
fn subscribe(&mut self, _stream: Resource<OutputStream>) -> Resource<Pollable> {
sealed(self)
}
fn write_zeroes(
&mut self,
_stream: Resource<OutputStream>,
_len: u64,
) -> Result<(), StreamError> {
Ok(())
}
fn blocking_write_zeroes_and_flush(
&mut self,
_stream: Resource<OutputStream>,
_len: u64,
) -> Result<(), StreamError> {
Ok(())
}
fn splice(
&mut self,
_stream: Resource<OutputStream>,
_source: Resource<InputStream>,
_len: u64,
) -> Result<u64, StreamError> {
Err(StreamError::Closed)
}
fn blocking_splice(
&mut self,
_stream: Resource<OutputStream>,
_source: Resource<InputStream>,
_len: u64,
) -> Result<u64, StreamError> {
Err(StreamError::Closed)
}
fn drop(&mut self, _stream: Resource<OutputStream>) -> wasmtime::Result<()> {
super::composition::drop_sealed_handle(self);
Ok(())
}
}
impl streams::Host for PluginHostState {}
impl monotonic_clock::Host for PluginHostState {
fn now(&mut self) -> monotonic_clock::Instant {
self.monotonic_now
}
fn resolution(&mut self) -> monotonic_clock::Duration {
1
}
fn subscribe_instant(&mut self, _when: monotonic_clock::Instant) -> Resource<Pollable> {
sealed(self)
}
fn subscribe_duration(&mut self, _when: monotonic_clock::Duration) -> Resource<Pollable> {
sealed(self)
}
}
impl environment::Host for PluginHostState {
fn get_environment(&mut self) -> Vec<(String, String)> {
Vec::new()
}
fn get_arguments(&mut self) -> Vec<String> {
Vec::new()
}
fn initial_cwd(&mut self) -> Option<String> {
None
}
}
impl exit::Host for PluginHostState {
fn exit(&mut self, status: Result<(), ()>) -> wasmtime::Result<()> {
Err(wasmtime::format_err!("guest exited: {status:?}"))
}
fn exit_with_code(&mut self, status_code: u8) -> wasmtime::Result<()> {
Err(wasmtime::format_err!(
"guest exited with code {status_code}"
))
}
}
impl stdin::Host for PluginHostState {
fn get_stdin(&mut self) -> Resource<InputStream> {
sealed(self)
}
}
impl stdout::Host for PluginHostState {
fn get_stdout(&mut self) -> Resource<OutputStream> {
sealed(self)
}
}
impl stderr::Host for PluginHostState {
fn get_stderr(&mut self) -> Resource<OutputStream> {
sealed(self)
}
}
impl terminal_input::HostTerminalInput for PluginHostState {
fn drop(&mut self, _terminal: Resource<terminal_input::TerminalInput>) -> wasmtime::Result<()> {
Ok(())
}
}
impl terminal_input::Host for PluginHostState {}
impl terminal_output::HostTerminalOutput for PluginHostState {
fn drop(
&mut self,
_terminal: Resource<terminal_output::TerminalOutput>,
) -> wasmtime::Result<()> {
Ok(())
}
}
impl terminal_output::Host for PluginHostState {}
impl terminal_stdin::Host for PluginHostState {
fn get_terminal_stdin(&mut self) -> Option<Resource<terminal_input::TerminalInput>> {
None
}
}
impl terminal_stdout::Host for PluginHostState {
fn get_terminal_stdout(&mut self) -> Option<Resource<terminal_output::TerminalOutput>> {
None
}
}
impl terminal_stderr::Host for PluginHostState {
fn get_terminal_stderr(&mut self) -> Option<Resource<terminal_output::TerminalOutput>> {
None
}
}
// Shadow every data-bearing or handle-producing sealed import. Canonical lifting
// runs before this wrapper, bounded by Store hostcall fuel; the entry checkpoint
// observes that allocation before any further guest execution or host effect.
pub(super) fn link(
linker: &mut wasmtime::component::Linker<PluginHostState>,
) -> wasmtime::Result<()> {
use super::composition::{wasi_effect, wasi_resource};
linker.allow_shadowing(true);
let mut poll = linker.instance("wasi:io/poll@0.2.12")?;
poll.func_wrap("poll", |store, (items,): (Vec<Resource<Pollable>>,)| {
wasi_effect(store, items.len().saturating_mul(8), |state| {
(poll::Host::poll(state, items),)
})
})?;
let mut streams = linker.instance("wasi:io/streams@0.2.12")?;
streams.func_wrap(
"[method]output-stream.write",
|store, (stream, bytes): (Resource<OutputStream>, Vec<u8>)| {
wasi_effect(store, bytes.len(), |state| {
(streams::HostOutputStream::write(state, stream, bytes),)
})
},
)?;
streams.func_wrap(
"[method]output-stream.blocking-write-and-flush",
|store, (stream, bytes): (Resource<OutputStream>, Vec<u8>)| {
wasi_effect(store, bytes.len(), |state| {
(streams::HostOutputStream::blocking_write_and_flush(
state, stream, bytes,
),)
})
},
)?;
streams.func_wrap(
"[method]output-stream.subscribe",
|store, (stream,): (Resource<OutputStream>,)| {
wasi_resource(store, 16, |state| {
(streams::HostOutputStream::subscribe(state, stream),)
})
},
)?;
streams.func_wrap(
"[method]input-stream.subscribe",
|store, (stream,): (Resource<InputStream>,)| {
wasi_resource(store, 16, |state| {
(streams::HostInputStream::subscribe(state, stream),)
})
},
)?;
linker.instance("wasi:io/error@0.2.12")?.func_wrap(
"[method]error.to-debug-string",
|store, (error,): (Resource<Error>,)| {
wasi_effect(store, 16, |state| {
(error::HostError::to_debug_string(state, error),)
})
},
)?;
linker
.instance("wasi:cli/stdin@0.2.12")?
.func_wrap("get-stdin", |store, ()| {
wasi_resource(store, 16, |state| (stdin::Host::get_stdin(state),))
})?;
linker
.instance("wasi:cli/stdout@0.2.12")?
.func_wrap("get-stdout", |store, ()| {
wasi_resource(store, 16, |state| (stdout::Host::get_stdout(state),))
})?;
linker
.instance("wasi:cli/stderr@0.2.12")?
.func_wrap("get-stderr", |store, ()| {
wasi_resource(store, 16, |state| (stderr::Host::get_stderr(state),))
})?;
let mut clock = linker.instance("wasi:clocks/monotonic-clock@0.2.12")?;
clock.func_wrap("subscribe-instant", |store, (when,): (u64,)| {
wasi_resource(store, 16, |state| {
(monotonic_clock::Host::subscribe_instant(state, when),)
})
})?;
clock.func_wrap("subscribe-duration", |store, (when,): (u64,)| {
wasi_resource(store, 16, |state| {
(monotonic_clock::Host::subscribe_duration(state, when),)
})
})?;
link_scalars(linker)
}
#[expect(
clippy::too_many_lines,
reason = "one exhaustive sealed import table applies the same terminal checkpoint to scalar and resource operations"
)]
fn link_scalars(linker: &mut wasmtime::component::Linker<PluginHostState>) -> wasmtime::Result<()> {
use super::composition::wasi_effect;
macro_rules! scalar {
($interface:literal, $name:literal, ($($argument:ident: $kind:ty),*), $owner:path, $method:ident) => {
linker.instance($interface)?.func_wrap($name, |store, ($($argument,)*): ($($kind,)*)| {
wasi_effect(store, 16, |state| (<PluginHostState as $owner>::$method(state, $($argument),*),))
})?;
};
}
macro_rules! resource_drop {
($interface:literal, $name:literal, $kind:ty, $owner:path) => {
linker.instance($interface)?.func_wrap(
$name,
|store, (resource,): (Resource<$kind>,)| {
wasi_effect(store, 4, |state| {
<PluginHostState as $owner>::drop(state, resource)
})?
},
)?;
};
}
scalar!("wasi:io/poll@0.2.12", "[method]pollable.ready", (resource: Resource<Pollable>), poll::HostPollable, ready);
linker.instance("wasi:io/poll@0.2.12")?.func_wrap(
"[method]pollable.block",
|store, (resource,): (Resource<Pollable>,)| {
wasi_effect(store, 4, |state| poll::HostPollable::block(state, resource))
},
)?;
resource_drop!(
"wasi:io/poll@0.2.12",
"[resource-drop]pollable",
Pollable,
poll::HostPollable
);
resource_drop!(
"wasi:io/error@0.2.12",
"[resource-drop]error",
Error,
error::HostError
);
resource_drop!(
"wasi:io/streams@0.2.12",
"[resource-drop]input-stream",
InputStream,
streams::HostInputStream
);
resource_drop!(
"wasi:io/streams@0.2.12",
"[resource-drop]output-stream",
OutputStream,
streams::HostOutputStream
);
scalar!("wasi:io/streams@0.2.12", "[method]input-stream.read", (stream: Resource<InputStream>, length: u64), streams::HostInputStream, read);
scalar!("wasi:io/streams@0.2.12", "[method]input-stream.blocking-read", (stream: Resource<InputStream>, length: u64), streams::HostInputStream, blocking_read);
scalar!("wasi:io/streams@0.2.12", "[method]input-stream.skip", (stream: Resource<InputStream>, length: u64), streams::HostInputStream, skip);
scalar!("wasi:io/streams@0.2.12", "[method]input-stream.blocking-skip", (stream: Resource<InputStream>, length: u64), streams::HostInputStream, blocking_skip);
scalar!("wasi:io/streams@0.2.12", "[method]output-stream.check-write", (stream: Resource<OutputStream>), streams::HostOutputStream, check_write);
scalar!("wasi:io/streams@0.2.12", "[method]output-stream.flush", (stream: Resource<OutputStream>), streams::HostOutputStream, flush);
scalar!("wasi:io/streams@0.2.12", "[method]output-stream.blocking-flush", (stream: Resource<OutputStream>), streams::HostOutputStream, blocking_flush);
scalar!("wasi:io/streams@0.2.12", "[method]output-stream.write-zeroes", (stream: Resource<OutputStream>, length: u64), streams::HostOutputStream, write_zeroes);
scalar!("wasi:io/streams@0.2.12", "[method]output-stream.blocking-write-zeroes-and-flush", (stream: Resource<OutputStream>, length: u64), streams::HostOutputStream, blocking_write_zeroes_and_flush);
scalar!("wasi:io/streams@0.2.12", "[method]output-stream.splice", (stream: Resource<OutputStream>, source: Resource<InputStream>, length: u64), streams::HostOutputStream, splice);
scalar!("wasi:io/streams@0.2.12", "[method]output-stream.blocking-splice", (stream: Resource<OutputStream>, source: Resource<InputStream>, length: u64), streams::HostOutputStream, blocking_splice);
scalar!(
"wasi:clocks/monotonic-clock@0.2.12",
"now",
(),
monotonic_clock::Host,
now
);
scalar!(
"wasi:clocks/monotonic-clock@0.2.12",
"resolution",
(),
monotonic_clock::Host,
resolution
);
scalar!(
"wasi:cli/environment@0.2.12",
"get-environment",
(),
environment::Host,
get_environment
);
scalar!(
"wasi:cli/environment@0.2.12",
"get-arguments",
(),
environment::Host,
get_arguments
);
scalar!(
"wasi:cli/environment@0.2.12",
"initial-cwd",
(),
environment::Host,
initial_cwd
);
scalar!(
"wasi:cli/terminal-stdin@0.2.12",
"get-terminal-stdin",
(),
terminal_stdin::Host,
get_terminal_stdin
);
scalar!(
"wasi:cli/terminal-stdout@0.2.12",
"get-terminal-stdout",
(),
terminal_stdout::Host,
get_terminal_stdout
);
scalar!(
"wasi:cli/terminal-stderr@0.2.12",
"get-terminal-stderr",
(),
terminal_stderr::Host,
get_terminal_stderr
);
resource_drop!(
"wasi:cli/terminal-input@0.2.12",
"[resource-drop]terminal-input",
terminal_input::TerminalInput,
terminal_input::HostTerminalInput
);
resource_drop!(
"wasi:cli/terminal-output@0.2.12",
"[resource-drop]terminal-output",
terminal_output::TerminalOutput,
terminal_output::HostTerminalOutput
);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::wasm::PluginCeilings;
use poll::Host as _;
use streams::{HostInputStream as _, HostOutputStream as _};
fn state() -> PluginHostState {
PluginHostState {
composition: None,
memory_bytes: 0,
table_elements: 0,
sealed_handles: 0,
monotonic_now: 42,
ceilings: PluginCeilings::default(),
grants: 0,
effects_enabled: false,
lifecycle_deadline: None,
lifecycle_allocation_bytes: 0,
plugin_id: String::new(),
net_scopes: Vec::new(),
secret_grants: Vec::new(),
oauth_authority: None,
workspace_effects: crate::wasm::WorkspaceEffects::default(),
fatal_recording_failure: std::cell::Cell::new(false),
log_bytes: 0,
log_entries: Vec::new(),
secret_values: Vec::new(),
resolved_secret_refs: Vec::new(),
mock_effects: None,
}
}
#[test]
fn sealed_handle_bookkeeping_does_not_allocate_or_retain_dropped_ownership() {
let mut host = state();
let (_, allocation) =
smith_alloc::measure_current_thread(smith_alloc::Scope::KernelCall, || {
for _ in 0..1024 {
let resource = stdout::Host::get_stdout(&mut host);
assert_eq!(host.sealed_handles, 1);
streams::HostOutputStream::drop(&mut host, resource).unwrap();
assert_eq!(host.sealed_handles, 0);
}
});
assert_eq!(allocation.allocations, 0);
assert_eq!(allocation.bytes, 0);
}
#[test]
fn poll_reports_every_pollable_ready() {
let mut host = state();
assert_eq!(
host.poll(vec![
Resource::new_own(SEALED),
Resource::new_own(SEALED),
Resource::new_own(SEALED)
]),
[0, 1, 2]
);
assert!(host.poll(Vec::new()).is_empty());
}
#[test]
fn stdin_is_closed_and_stdout_discards() {
let mut host = state();
assert!(matches!(
host.read(Resource::new_own(SEALED), 16),
Err(StreamError::Closed)
));
assert_eq!(
host.check_write(Resource::new_own(SEALED)).unwrap(),
WRITE_BUDGET
);
assert!(
host.write(Resource::new_own(SEALED), b"dropped".to_vec())
.is_ok()
);
}
#[test]
fn clock_is_host_injected_and_exit_traps() {
let mut host = state();
assert_eq!(monotonic_clock::Host::now(&mut host), 42);
assert!(exit::Host::exit(&mut host, Ok(())).is_err());
assert!(exit::Host::exit_with_code(&mut host, 0).is_err());
}
#[test]
fn environment_is_empty() {
let mut host = state();
assert!(environment::Host::get_environment(&mut host).is_empty());
assert!(environment::Host::get_arguments(&mut host).is_empty());
assert!(environment::Host::initial_cwd(&mut host).is_none());
}
}