From e907bcb3c62f8136dddca8526e082dcf3b185a23 Mon Sep 17 00:00:00 2001 From: Pat Hickey Date: Wed, 26 Oct 2022 13:32:54 -0700 Subject: [PATCH 1/8] wiggle: no longer need to guard wasmtime integration behind a feature this existed so we could use wiggle in lucet, but lucet is long EOL --- crates/wasi-common/tokio/Cargo.toml | 2 +- crates/wasi-crypto/Cargo.toml | 2 +- crates/wasi/Cargo.toml | 2 +- crates/wiggle/Cargo.toml | 12 +++++------- crates/wiggle/macro/Cargo.toml | 1 - crates/wiggle/macro/src/lib.rs | 13 ++++--------- crates/wiggle/src/lib.rs | 6 ------ 7 files changed, 12 insertions(+), 26 deletions(-) diff --git a/crates/wasi-common/tokio/Cargo.toml b/crates/wasi-common/tokio/Cargo.toml index f0e9582ecdea..266381692531 100644 --- a/crates/wasi-common/tokio/Cargo.toml +++ b/crates/wasi-common/tokio/Cargo.toml @@ -13,7 +13,7 @@ include = ["src/**/*", "LICENSE" ] [dependencies] wasi-common = { workspace = true } wasi-cap-std-sync = { workspace = true } -wiggle = { workspace = true, features = ['wasmtime_integration'] } +wiggle = { workspace = true } tokio = { version = "1.8.0", features = [ "rt", "fs", "time", "io-util", "net", "io-std", "rt-multi-thread"] } cap-std = { workspace = true } anyhow = { workspace = true } diff --git a/crates/wasi-crypto/Cargo.toml b/crates/wasi-crypto/Cargo.toml index ae5eede45291..809b06100073 100644 --- a/crates/wasi-crypto/Cargo.toml +++ b/crates/wasi-crypto/Cargo.toml @@ -15,7 +15,7 @@ edition.workspace = true anyhow = { workspace = true } wasi-crypto = { path = "spec/implementations/hostcalls/rust", version = "0.1.5" } wasmtime = { workspace = true } -wiggle = { workspace = true, default-features = true, features = ['wasmtime_integration'] } +wiggle = { workspace = true } [badges] maintenance = { status = "experimental" } diff --git a/crates/wasi/Cargo.toml b/crates/wasi/Cargo.toml index a2cb669ec47c..cca14f9597ce 100644 --- a/crates/wasi/Cargo.toml +++ b/crates/wasi/Cargo.toml @@ -16,7 +16,7 @@ build = "build.rs" wasi-common = { workspace = true } wasi-cap-std-sync = { workspace = true, optional = true } wasi-tokio = { workspace = true, optional = true } -wiggle = { workspace = true, default-features = false, features = ["wasmtime_integration"] } +wiggle = { workspace = true } wasmtime = { workspace = true } anyhow = { workspace = true } diff --git a/crates/wiggle/Cargo.toml b/crates/wiggle/Cargo.toml index 1152a77123df..db276a7760ed 100644 --- a/crates/wiggle/Cargo.toml +++ b/crates/wiggle/Cargo.toml @@ -17,7 +17,7 @@ wiggle-macro = { workspace = true } tracing = "0.1.26" bitflags = "1.2" async-trait = "0.1.42" -wasmtime = { workspace = true, optional = true } +wasmtime = { workspace = true } anyhow = { workspace = true } [badges] @@ -41,12 +41,12 @@ required-features = ["wasmtime_async", "wasmtime/wat"] [[test]] name = "wasmtime_sync" path = "tests/wasmtime_sync.rs" -required-features = ["wasmtime_integration", "wasmtime/wat"] +required-features = ["wasmtime/wat"] [[test]] name = "wasmtime_integration" path = "tests/wasmtime_integration.rs" -required-features = ["wasmtime_integration", "wasmtime/wat"] +required-features = ["wasmtime/wat"] [features] @@ -62,9 +62,7 @@ wiggle_metadata = ['witx', "wiggle-macro/wiggle_metadata"] # the logs out of wiggle-generated libraries. tracing_log = [ "tracing/log" ] -# Generate adapters for wasmtime, and expose the wasmtime_integration macro. -wasmtime_integration = [ "wasmtime", "wiggle-macro/wasmtime" ] # Support for async in the wasmtime crates. -wasmtime_async = [ "wasmtime_integration", "wasmtime/async" ] +wasmtime_async = [ "wasmtime/async" ] -default = ["wiggle_metadata", "wasmtime_integration" ] +default = ["wiggle_metadata", "wasmtime_async" ] diff --git a/crates/wiggle/macro/Cargo.toml b/crates/wiggle/macro/Cargo.toml index 778a7e01b095..b3060434a673 100644 --- a/crates/wiggle/macro/Cargo.toml +++ b/crates/wiggle/macro/Cargo.toml @@ -30,5 +30,4 @@ proc-macro2 = "1.0" wiggle = { path = ".." } [features] -wasmtime = [] wiggle_metadata = [] diff --git a/crates/wiggle/macro/src/lib.rs b/crates/wiggle/macro/src/lib.rs index 394ee47bb366..0a48b421ebae 100644 --- a/crates/wiggle/macro/src/lib.rs +++ b/crates/wiggle/macro/src/lib.rs @@ -152,7 +152,7 @@ pub fn from_witx(args: TokenStream) -> TokenStream { &config.errors, &config.async_, &doc, - cfg!(feature = "wasmtime") && config.wasmtime, + config.wasmtime, ) .expect("validating codegen settings"); @@ -176,7 +176,6 @@ pub fn async_trait(attr: TokenStream, item: TokenStream) -> TokenStream { }) } -#[cfg(feature = "wasmtime")] /// Define the structs required to integrate a Wiggle implementation with Wasmtime. /// /// ## Arguments @@ -190,13 +189,9 @@ pub fn wasmtime_integration(args: TokenStream) -> TokenStream { let doc = config.c.load_document(); let names = wiggle_generate::Names::new(quote!(wiggle)); - let settings = wiggle_generate::CodegenSettings::new( - &config.c.errors, - &config.c.async_, - &doc, - cfg!(feature = "wasmtime"), - ) - .expect("validating codegen settings"); + let settings = + wiggle_generate::CodegenSettings::new(&config.c.errors, &config.c.async_, &doc, true) + .expect("validating codegen settings"); let modules = doc.modules().map(|module| { wiggle_generate::wasmtime::link_module(&module, &names, Some(&config.target), &settings) diff --git a/crates/wiggle/src/lib.rs b/crates/wiggle/src/lib.rs index 18d943f06c66..bbc9923135c2 100644 --- a/crates/wiggle/src/lib.rs +++ b/crates/wiggle/src/lib.rs @@ -5,9 +5,7 @@ use std::sync::Arc; pub use wiggle_macro::{async_trait, from_witx}; -#[cfg(feature = "wasmtime")] pub use anyhow; -#[cfg(feature = "wasmtime")] pub use wiggle_macro::wasmtime_integration; pub use bitflags; @@ -30,10 +28,7 @@ pub mod async_trait_crate { pub use async_trait::*; } -#[cfg(feature = "wasmtime")] pub mod wasmtime; - -#[cfg(feature = "wasmtime")] pub mod wasmtime_crate { pub use wasmtime::*; } @@ -933,7 +928,6 @@ impl From for Trap { } } -#[cfg(feature = "wasmtime")] pub fn run_in_dummy_executor( future: F, ) -> Result { From 1f8f6460db4d17d58f899910501c54b43412820b Mon Sep 17 00:00:00 2001 From: Pat Hickey Date: Wed, 26 Oct 2022 13:41:16 -0700 Subject: [PATCH 2/8] replace wiggle::Trap with wiggle::wasmtime_crate::Trap --- crates/wiggle/generate/src/funcs.rs | 4 ++-- crates/wiggle/generate/src/lib.rs | 2 +- crates/wiggle/generate/src/module_trait.rs | 2 +- crates/wiggle/generate/src/wasmtime.rs | 6 +----- crates/wiggle/macro/src/lib.rs | 4 ++-- crates/wiggle/src/lib.rs | 21 +++++-------------- .../wiggle/test-helpers/examples/tracing.rs | 5 ++++- crates/wiggle/tests/errors.rs | 16 +++++++++----- crates/wiggle/tests/wasi.rs | 2 +- 9 files changed, 28 insertions(+), 34 deletions(-) diff --git a/crates/wiggle/generate/src/funcs.rs b/crates/wiggle/generate/src/funcs.rs index 693f1fe3e996..b30d05eef411 100644 --- a/crates/wiggle/generate/src/funcs.rs +++ b/crates/wiggle/generate/src/funcs.rs @@ -91,7 +91,7 @@ fn _define_func( ctx: &mut (impl #(#bounds)+*), memory: &dyn #rt::GuestMemory, #(#abi_params),* - ) -> Result<#abi_ret, #rt::Trap> { + ) -> Result<#abi_ret, #rt::wasmtime_crate::Trap> { use std::convert::TryFrom as _; #mk_span _span.in_scope(|| { @@ -109,7 +109,7 @@ fn _define_func( ctx: &'a mut (impl #(#bounds)+*), memory: &'a dyn #rt::GuestMemory, #(#abi_params),* - ) -> impl std::future::Future> + 'a { + ) -> impl std::future::Future> + 'a { use std::convert::TryFrom as _; use #rt::tracing::Instrument as _; #mk_span diff --git a/crates/wiggle/generate/src/lib.rs b/crates/wiggle/generate/src/lib.rs index 47e82f75870b..09698d0227f9 100644 --- a/crates/wiggle/generate/src/lib.rs +++ b/crates/wiggle/generate/src/lib.rs @@ -43,7 +43,7 @@ pub fn generate(doc: &witx::Document, names: &Names, settings: &CodegenSettings) let abi_typename = names.type_ref(&errtype.abi_type(), anon_lifetime()); let user_typename = errtype.typename(); let methodname = names.user_error_conversion_method(&errtype); - quote!(fn #methodname(&mut self, e: super::#user_typename) -> Result<#abi_typename, #rt::Trap>;) + quote!(fn #methodname(&mut self, e: super::#user_typename) -> Result<#abi_typename, #rt::wasmtime_crate::Trap>;) }); let user_error_conversion = quote! { pub trait UserErrorConversion { diff --git a/crates/wiggle/generate/src/module_trait.rs b/crates/wiggle/generate/src/module_trait.rs index 2e108f56f097..cd277bbf17a8 100644 --- a/crates/wiggle/generate/src/module_trait.rs +++ b/crates/wiggle/generate/src/module_trait.rs @@ -45,7 +45,7 @@ pub fn define_module_trait(names: &Names, m: &Module, settings: &CodegenSettings }); let result = match f.results.len() { - 0 if f.noreturn => quote!(#rt::Trap), + 0 if f.noreturn => quote!(#rt::wasmtime_crate::Trap), 0 => quote!(()), 1 => { let (ok, err) = match &**f.results[0].tref.type_() { diff --git a/crates/wiggle/generate/src/wasmtime.rs b/crates/wiggle/generate/src/wasmtime.rs index 8f89bc06f082..d80bacec44b9 100644 --- a/crates/wiggle/generate/src/wasmtime.rs +++ b/crates/wiggle/generate/src/wasmtime.rs @@ -121,11 +121,7 @@ fn generate_func( let (mem , ctx) = mem.data_and_store_mut(&mut caller); let ctx = get_cx(ctx); let mem = #rt::wasmtime::WasmtimeGuestMemory::new(mem); - match #abi_func(ctx, &mem #(, #arg_names)*) #await_ { - Ok(r) => Ok(<#ret_ty>::from(r)), - Err(#rt::Trap::String(err)) => Err(#rt::wasmtime_crate::Trap::new(err)), - Err(#rt::Trap::I32Exit(err)) => Err(#rt::wasmtime_crate::Trap::i32_exit(err)), - } + Ok(<#ret_ty>::from(#abi_func(ctx, &mem #(, #arg_names)*) #await_ ?)) }; match asyncness { diff --git a/crates/wiggle/macro/src/lib.rs b/crates/wiggle/macro/src/lib.rs index 0a48b421ebae..0e37a7928973 100644 --- a/crates/wiggle/macro/src/lib.rs +++ b/crates/wiggle/macro/src/lib.rs @@ -126,14 +126,14 @@ use syn::parse_macro_input; /// /// impl types::UserErrorConversion for YourCtxType { /// fn errno_from_your_rich_error(&mut self, e: YourRichError) -/// -> Result +/// -> Result /// { /// println!("Rich error: {:?}", e); /// match e { /// YourRichError::InvalidArg{..} => Ok(types::Errno::InvalidArg), /// YourRichError::Io{..} => Ok(types::Errno::Io), /// YourRichError::Overflow => Ok(types::Errno::Overflow), -/// YourRichError::Trap(s) => Err(wiggle::Trap::String(s)), +/// YourRichError::Trap(s) => Err(wiggle::wasmtime_crate::Trap::new(s)), /// } /// } /// } diff --git a/crates/wiggle/src/lib.rs b/crates/wiggle/src/lib.rs index bbc9923135c2..d5f232bb313f 100644 --- a/crates/wiggle/src/lib.rs +++ b/crates/wiggle/src/lib.rs @@ -909,22 +909,11 @@ impl Pointee for str { } } -/// A runtime-independent way for Wiggle to terminate WebAssembly execution. -/// Functions that are marked `(@witx noreturn)` will always return a Trap. -/// Other functions that want to Trap can do so via their `UserErrorConversion` -/// trait, which transforms the user's own error type into a `Result`. -#[derive(Debug, Clone, PartialEq, Eq)] -pub enum Trap { - /// A Trap which indicates an i32 (posix-style) exit code. Runtimes may have a - /// special way of dealing with this for WASI embeddings and otherwise. - I32Exit(i32), - /// Any other Trap is just an unstructured String, for reporting and debugging. - String(String), -} - -impl From for Trap { - fn from(err: GuestError) -> Trap { - Trap::String(err.to_string()) +impl From for wasmtime_crate::Trap { + fn from(err: GuestError) -> wasmtime_crate::Trap { + wasmtime_crate::Trap::from( + Box::new(err) as Box + ) } } diff --git a/crates/wiggle/test-helpers/examples/tracing.rs b/crates/wiggle/test-helpers/examples/tracing.rs index e9e05e373d33..5c80a15ef9ad 100644 --- a/crates/wiggle/test-helpers/examples/tracing.rs +++ b/crates/wiggle/test-helpers/examples/tracing.rs @@ -32,7 +32,10 @@ impl_errno!(types::Errno); /// When the `errors` mapping in witx is non-empty, we need to impl the /// types::UserErrorConversion trait that wiggle generates from that mapping. impl<'a> types::UserErrorConversion for WasiCtx<'a> { - fn errno_from_rich_error(&mut self, e: RichError) -> Result { + fn errno_from_rich_error( + &mut self, + e: RichError, + ) -> Result { wiggle::tracing::debug!( rich_error = wiggle::tracing::field::debug(&e), "error conversion" diff --git a/crates/wiggle/tests/errors.rs b/crates/wiggle/tests/errors.rs index 41cf9fd14f85..8a1075ab6931 100644 --- a/crates/wiggle/tests/errors.rs +++ b/crates/wiggle/tests/errors.rs @@ -31,7 +31,10 @@ mod convert_just_errno { /// When the `errors` mapping in witx is non-empty, we need to impl the /// types::UserErrorConversion trait that wiggle generates from that mapping. impl<'a> types::UserErrorConversion for WasiCtx<'a> { - fn errno_from_rich_error(&mut self, e: RichError) -> Result { + fn errno_from_rich_error( + &mut self, + e: RichError, + ) -> Result { // WasiCtx can collect a Vec log so we can test this. We're // logging the Display impl that `thiserror::Error` provides us. self.log.borrow_mut().push(e.to_string()); @@ -114,7 +117,7 @@ mod convert_multiple_error_types { // Just like the prior test, except that we have a second errno type. This should mean there // are two functions in UserErrorConversion. - // Additionally, test that the function "baz" marked noreturn always returns a wiggle::Trap. + // Additionally, test that the function "baz" marked noreturn always returns a wasmtime::Trap. wiggle::from_witx!({ witx_literal: " (typename $errno (enum (@witx tag u8) $ok $invalid_arg $picket_line)) @@ -140,13 +143,16 @@ mod convert_multiple_error_types { // each member of the `errors` mapping. // Bodies elided. impl<'a> types::UserErrorConversion for WasiCtx<'a> { - fn errno_from_rich_error(&mut self, _e: RichError) -> Result { + fn errno_from_rich_error( + &mut self, + _e: RichError, + ) -> Result { unimplemented!() } fn errno2_from_another_rich_error( &mut self, _e: AnotherRichError, - ) -> Result { + ) -> Result { unimplemented!() } } @@ -159,7 +165,7 @@ mod convert_multiple_error_types { fn bar(&mut self, _: u32) -> Result<(), AnotherRichError> { unimplemented!() } - fn baz(&mut self, _: u32) -> wiggle::Trap { + fn baz(&mut self, _: u32) -> wiggle::wasmtime_crate::Trap { unimplemented!() } } diff --git a/crates/wiggle/tests/wasi.rs b/crates/wiggle/tests/wasi.rs index 4c1043bb2d6b..f51897ca9108 100644 --- a/crates/wiggle/tests/wasi.rs +++ b/crates/wiggle/tests/wasi.rs @@ -314,7 +314,7 @@ impl<'a> crate::wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx<'a> { unimplemented!("poll_oneoff") } - fn proc_exit(&mut self, _rval: types::Exitcode) -> wiggle::Trap { + fn proc_exit(&mut self, _rval: types::Exitcode) -> wiggle::wasmtime_crate::Trap { unimplemented!("proc_exit") } From 0cbe2a5515e43b159911cf1d1c1566e8e7d148ea Mon Sep 17 00:00:00 2001 From: Pat Hickey Date: Wed, 26 Oct 2022 13:49:19 -0700 Subject: [PATCH 3/8] wiggle tests: unwrap traps because we cant assert_eq on them --- crates/wiggle/tests/atoms.rs | 10 ++++---- crates/wiggle/tests/atoms_async.rs | 10 ++++---- crates/wiggle/tests/errors.rs | 12 +++++----- crates/wiggle/tests/flags.rs | 5 ++-- crates/wiggle/tests/handles.rs | 13 +++++----- crates/wiggle/tests/ints.rs | 5 ++-- crates/wiggle/tests/lists.rs | 32 +++++++++++++++---------- crates/wiggle/tests/pointers.rs | 5 ++-- crates/wiggle/tests/records.rs | 38 ++++++++++++++---------------- crates/wiggle/tests/strings.rs | 15 +++++++----- crates/wiggle/tests/variant.rs | 10 ++++---- 11 files changed, 86 insertions(+), 69 deletions(-) diff --git a/crates/wiggle/tests/atoms.rs b/crates/wiggle/tests/atoms.rs index 04ab6f5029d7..3b97717b4dc7 100644 --- a/crates/wiggle/tests/atoms.rs +++ b/crates/wiggle/tests/atoms.rs @@ -34,9 +34,10 @@ impl IntFloatExercise { let mut ctx = WasiCtx::new(); let host_memory = HostMemory::new(); - let e = atoms::int_float_args(&mut ctx, &host_memory, self.an_int as i32, self.an_float); + let e = atoms::int_float_args(&mut ctx, &host_memory, self.an_int as i32, self.an_float) + .unwrap(); - assert_eq!(e, Ok(types::Errno::Ok as i32), "int_float_args error"); + assert_eq!(e, types::Errno::Ok as i32, "int_float_args error"); } pub fn strat() -> BoxedStrategy { @@ -68,13 +69,14 @@ impl DoubleIntExercise { &host_memory, self.input as i32, self.return_loc.ptr as i32, - ); + ) + .unwrap(); let return_val = host_memory .ptr::(self.return_loc.ptr) .read() .expect("failed to read return"); - assert_eq!(e, Ok(types::Errno::Ok as i32), "errno"); + assert_eq!(e, types::Errno::Ok as i32, "errno"); assert_eq!(return_val, (self.input as f32) * 2.0, "return val"); } diff --git a/crates/wiggle/tests/atoms_async.rs b/crates/wiggle/tests/atoms_async.rs index bfb7f2dadd73..0fc9660b37ff 100644 --- a/crates/wiggle/tests/atoms_async.rs +++ b/crates/wiggle/tests/atoms_async.rs @@ -44,9 +44,10 @@ impl IntFloatExercise { &host_memory, self.an_int as i32, self.an_float, - )); + )) + .unwrap(); - assert_eq!(e, Ok(types::Errno::Ok as i32), "int_float_args error"); + assert_eq!(e, types::Errno::Ok as i32, "int_float_args error"); } pub fn strat() -> BoxedStrategy { @@ -78,13 +79,14 @@ impl DoubleIntExercise { &host_memory, self.input as i32, self.return_loc.ptr as i32, - )); + )) + .unwrap(); let return_val = host_memory .ptr::(self.return_loc.ptr) .read() .expect("failed to read return"); - assert_eq!(e, Ok(types::Errno::Ok as i32), "errno"); + assert_eq!(e, types::Errno::Ok as i32, "errno"); assert_eq!(return_val, (self.input as f32) * 2.0, "return val"); } diff --git a/crates/wiggle/tests/errors.rs b/crates/wiggle/tests/errors.rs index 8a1075ab6931..5b10a5479b0a 100644 --- a/crates/wiggle/tests/errors.rs +++ b/crates/wiggle/tests/errors.rs @@ -65,19 +65,19 @@ mod convert_just_errno { // Exercise each of the branches in `foo`. // Start with the success case: - let r0 = one_error_conversion::foo(&mut ctx, &host_memory, 0); + let r0 = one_error_conversion::foo(&mut ctx, &host_memory, 0).unwrap(); assert_eq!( r0, - Ok(types::Errno::Ok as i32), + types::Errno::Ok as i32, "Expected return value for strike=0" ); assert!(ctx.log.borrow().is_empty(), "No error log for strike=0"); // First error case: - let r1 = one_error_conversion::foo(&mut ctx, &host_memory, 1); + let r1 = one_error_conversion::foo(&mut ctx, &host_memory, 1).unwrap(); assert_eq!( r1, - Ok(types::Errno::PicketLine as i32), + types::Errno::PicketLine as i32, "Expected return value for strike=1" ); assert_eq!( @@ -87,10 +87,10 @@ mod convert_just_errno { ); // Second error case: - let r2 = one_error_conversion::foo(&mut ctx, &host_memory, 2); + let r2 = one_error_conversion::foo(&mut ctx, &host_memory, 2).unwrap(); assert_eq!( r2, - Ok(types::Errno::InvalidArg as i32), + types::Errno::InvalidArg as i32, "Expected return value for strike=2" ); assert_eq!( diff --git a/crates/wiggle/tests/flags.rs b/crates/wiggle/tests/flags.rs index 56c52c4277d4..b31ed718306e 100644 --- a/crates/wiggle/tests/flags.rs +++ b/crates/wiggle/tests/flags.rs @@ -77,8 +77,9 @@ impl ConfigureCarExercise { self.old_config.bits() as i32, self.other_config_by_ptr.ptr as i32, self.return_ptr_loc.ptr as i32, - ); - assert_eq!(res, Ok(types::Errno::Ok as i32), "configure car errno"); + ) + .unwrap(); + assert_eq!(res, types::Errno::Ok as i32, "configure car errno"); let res_config = host_memory .ptr::(self.return_ptr_loc.ptr) diff --git a/crates/wiggle/tests/handles.rs b/crates/wiggle/tests/handles.rs index 150d1f09b2f9..ea1e0abcdd22 100644 --- a/crates/wiggle/tests/handles.rs +++ b/crates/wiggle/tests/handles.rs @@ -34,9 +34,10 @@ impl HandleExercise { let mut ctx = WasiCtx::new(); let host_memory = HostMemory::new(); - let e = handle_examples::fd_create(&mut ctx, &host_memory, self.return_loc.ptr as i32); + let e = + handle_examples::fd_create(&mut ctx, &host_memory, self.return_loc.ptr as i32).unwrap(); - assert_eq!(e, Ok(types::Errno::Ok as i32), "fd_create error"); + assert_eq!(e, types::Errno::Ok as i32, "fd_create error"); let h_got: u32 = host_memory .ptr(self.return_loc.ptr) @@ -45,15 +46,15 @@ impl HandleExercise { assert_eq!(h_got, 123, "fd_create return val"); - let e = handle_examples::fd_consume(&mut ctx, &host_memory, h_got as i32); + let e = handle_examples::fd_consume(&mut ctx, &host_memory, h_got as i32).unwrap(); - assert_eq!(e, Ok(types::Errno::Ok as i32), "fd_consume error"); + assert_eq!(e, types::Errno::Ok as i32, "fd_consume error"); - let e = handle_examples::fd_consume(&mut ctx, &host_memory, h_got as i32 + 1); + let e = handle_examples::fd_consume(&mut ctx, &host_memory, h_got as i32 + 1).unwrap(); assert_eq!( e, - Ok(types::Errno::InvalidArg as i32), + types::Errno::InvalidArg as i32, "fd_consume invalid error" ); } diff --git a/crates/wiggle/tests/ints.rs b/crates/wiggle/tests/ints.rs index bc5a980ee3d8..b342e0ec2829 100644 --- a/crates/wiggle/tests/ints.rs +++ b/crates/wiggle/tests/ints.rs @@ -51,8 +51,9 @@ impl CookieCutterExercise { &host_memory, self.cookie as i64, self.return_ptr_loc.ptr as i32, - ); - assert_eq!(res, Ok(types::Errno::Ok as i32), "cookie cutter errno"); + ) + .unwrap(); + assert_eq!(res, types::Errno::Ok as i32, "cookie cutter errno"); let is_cookie_start = host_memory .ptr::(self.return_ptr_loc.ptr) diff --git a/crates/wiggle/tests/lists.rs b/crates/wiggle/tests/lists.rs index 39649fc9b141..5f94238a4565 100644 --- a/crates/wiggle/tests/lists.rs +++ b/crates/wiggle/tests/lists.rs @@ -102,9 +102,10 @@ impl ReduceExcusesExcercise { self.array_ptr_loc.ptr as i32, self.excuse_ptr_locs.len() as i32, self.return_ptr_loc.ptr as i32, - ); + ) + .unwrap(); - assert_eq!(res, Ok(types::Errno::Ok as i32), "reduce excuses errno"); + assert_eq!(res, types::Errno::Ok as i32, "reduce excuses errno"); let expected = *self .excuse_values @@ -181,8 +182,9 @@ impl PopulateExcusesExcercise { &host_memory, self.array_ptr_loc.ptr as i32, self.elements.len() as i32, - ); - assert_eq!(res, Ok(types::Errno::Ok as i32), "populate excuses errno"); + ) + .unwrap(); + assert_eq!(res, types::Errno::Ok as i32, "populate excuses errno"); let arr: GuestPtr<'_, [GuestPtr<'_, types::Excuse>]> = host_memory.ptr((self.array_ptr_loc.ptr, self.elements.len() as u32)); @@ -307,8 +309,9 @@ impl SumElementsExercise { self.elements.len() as i32, self.start_ix as i32, self.return_loc.ptr as i32, - ); - assert_eq!(res, Ok(types::Errno::Ok as i32), "sum_of_element errno"); + ) + .unwrap(); + assert_eq!(res, types::Errno::Ok as i32, "sum_of_element errno"); let result_ptr = host_memory.ptr::(self.return_loc.ptr); let result = result_ptr.read().expect("read result"); @@ -326,10 +329,11 @@ impl SumElementsExercise { self.elements.len() as i32, self.elements.len() as i32, self.return_loc.ptr as i32, - ); + ) + .unwrap(); assert_eq!( res, - Ok(types::Errno::InvalidArg as i32), + types::Errno::InvalidArg as i32, "out of bounds sum_of_element errno" ); @@ -341,11 +345,12 @@ impl SumElementsExercise { self.start_ix as i32, self.end_ix as i32, self.return_loc.ptr as i32, - ); + ) + .unwrap(); if self.start_ix <= self.end_ix { assert_eq!( res, - Ok(types::Errno::Ok as i32), + types::Errno::Ok as i32, "expected ok sum_of_elements errno" ); let result_ptr = host_memory.ptr::(self.return_loc.ptr); @@ -366,7 +371,7 @@ impl SumElementsExercise { } else { assert_eq!( res, - Ok(types::Errno::InvalidArg as i32), + types::Errno::InvalidArg as i32, "expected error out-of-bounds sum_of_elements" ); } @@ -380,10 +385,11 @@ impl SumElementsExercise { self.start_ix as i32, self.elements.len() as i32 + 1, self.return_loc.ptr as i32, - ); + ) + .unwrap(); assert_eq!( res, - Ok(types::Errno::InvalidArg as i32), + types::Errno::InvalidArg as i32, "out of bounds sum_of_elements errno" ); } diff --git a/crates/wiggle/tests/pointers.rs b/crates/wiggle/tests/pointers.rs index ef0ae6801706..d3c4ac7e53ad 100644 --- a/crates/wiggle/tests/pointers.rs +++ b/crates/wiggle/tests/pointers.rs @@ -155,8 +155,9 @@ impl PointersAndEnumsExercise { self.input2_loc.ptr as i32, self.input3_loc.ptr as i32, self.input4_ptr_loc.ptr as i32, - ); - assert_eq!(e, Ok(types::Errno::Ok as i32), "errno"); + ) + .unwrap(); + assert_eq!(e, types::Errno::Ok as i32, "errno"); // Implementation of pointers_and_enums writes input3 to the input2_loc: let written_to_input2_loc: i32 = host_memory diff --git a/crates/wiggle/tests/records.rs b/crates/wiggle/tests/records.rs index d6f96248080c..b33c50cd85fc 100644 --- a/crates/wiggle/tests/records.rs +++ b/crates/wiggle/tests/records.rs @@ -118,9 +118,10 @@ impl SumOfPairExercise { &host_memory, self.input_loc.ptr as i32, self.return_loc.ptr as i32, - ); + ) + .unwrap(); - assert_eq!(sum_err, Ok(types::Errno::Ok as i32), "sum errno"); + assert_eq!(sum_err, types::Errno::Ok as i32, "sum errno"); let return_val: i64 = host_memory .ptr(self.return_loc.ptr) @@ -216,13 +217,10 @@ impl SumPairPtrsExercise { &host_memory, self.input_struct_loc.ptr as i32, self.return_loc.ptr as i32, - ); + ) + .unwrap(); - assert_eq!( - res, - Ok(types::Errno::Ok as i32), - "sum of pair of ptrs errno" - ); + assert_eq!(res, types::Errno::Ok as i32, "sum of pair of ptrs errno"); let doubled: i64 = host_memory .ptr(self.return_loc.ptr) @@ -299,9 +297,10 @@ impl SumIntAndPtrExercise { &host_memory, self.input_struct_loc.ptr as i32, self.return_loc.ptr as i32, - ); + ) + .unwrap(); - assert_eq!(res, Ok(types::Errno::Ok as i32), "sum of int and ptr errno"); + assert_eq!(res, types::Errno::Ok as i32, "sum of int and ptr errno"); let doubled: i64 = host_memory .ptr(self.return_loc.ptr) @@ -338,9 +337,10 @@ impl ReturnPairInts { let mut ctx = WasiCtx::new(); let host_memory = HostMemory::new(); - let err = records::return_pair_ints(&mut ctx, &host_memory, self.return_loc.ptr as i32); + let err = + records::return_pair_ints(&mut ctx, &host_memory, self.return_loc.ptr as i32).unwrap(); - assert_eq!(err, Ok(types::Errno::Ok as i32), "return struct errno"); + assert_eq!(err, types::Errno::Ok as i32, "return struct errno"); let return_struct: types::PairInts = host_memory .ptr(self.return_loc.ptr) @@ -418,13 +418,10 @@ impl ReturnPairPtrsExercise { self.input_first_loc.ptr as i32, self.input_second_loc.ptr as i32, self.return_loc.ptr as i32, - ); + ) + .unwrap(); - assert_eq!( - res, - Ok(types::Errno::Ok as i32), - "return pair of ptrs errno" - ); + assert_eq!(res, types::Errno::Ok as i32, "return pair of ptrs errno"); let ptr_pair_int_ptrs: types::PairIntPtrs<'_> = host_memory .ptr(self.return_loc.ptr) @@ -529,10 +526,11 @@ impl SumArrayExercise { &host_memory, self.input_struct_loc.ptr as i32, self.output_loc.ptr as i32, - ); + ) + .unwrap(); // should be no error - if hostcall did a GuestError it should eprintln it. - assert_eq!(res, Ok(types::Errno::Ok as i32), "reduce excuses errno"); + assert_eq!(res, types::Errno::Ok as i32, "reduce excuses errno"); // Sum is inputs upcasted to u16 let expected: u16 = self.inputs.iter().map(|v| *v as u16).sum(); diff --git a/crates/wiggle/tests/strings.rs b/crates/wiggle/tests/strings.rs index 3476924cad2e..c419942dafb2 100644 --- a/crates/wiggle/tests/strings.rs +++ b/crates/wiggle/tests/strings.rs @@ -86,8 +86,9 @@ impl HelloStringExercise { self.string_ptr_loc.ptr as i32, self.test_word.len() as i32, self.return_ptr_loc.ptr as i32, - ); - assert_eq!(res, Ok(types::Errno::Ok as i32), "hello string errno"); + ) + .unwrap(); + assert_eq!(res, types::Errno::Ok as i32, "hello string errno"); let given = host_memory .ptr::(self.return_ptr_loc.ptr) @@ -207,8 +208,9 @@ impl MultiStringExercise { self.sc_ptr_loc.ptr as i32, self.c.len() as i32, self.return_ptr_loc.ptr as i32, - ); - assert_eq!(res, Ok(types::Errno::Ok as i32), "multi string errno"); + ) + .unwrap(); + assert_eq!(res, types::Errno::Ok as i32, "multi string errno"); let given = host_memory .ptr::(self.return_ptr_loc.ptr) @@ -285,8 +287,9 @@ impl OverlappingStringExercise { (self.sa_ptr_loc.ptr + self.offset_c) as i32, a_len - self.offset_c as i32, self.return_ptr_loc.ptr as i32, - ); - assert_eq!(res, Ok(types::Errno::Ok as i32), "multi string errno"); + ) + .unwrap(); + assert_eq!(res, types::Errno::Ok as i32, "multi string errno"); let given = host_memory .ptr::(self.return_ptr_loc.ptr) diff --git a/crates/wiggle/tests/variant.rs b/crates/wiggle/tests/variant.rs index ea0f898b0dfc..c6b5ab4d58aa 100644 --- a/crates/wiggle/tests/variant.rs +++ b/crates/wiggle/tests/variant.rs @@ -134,9 +134,10 @@ impl GetTagExercise { &host_memory, self.input_loc.ptr as i32, self.return_loc.ptr as i32, - ); + ) + .unwrap(); - assert_eq!(e, Ok(types::Errno::Ok as i32), "get_tag errno"); + assert_eq!(e, types::Errno::Ok as i32, "get_tag errno"); let return_val: types::Excuse = host_memory .ptr(self.return_loc.ptr) @@ -218,9 +219,10 @@ impl ReasonMultExercise { &host_memory, self.input_loc.ptr as i32, self.multiply_by as i32, - ); + ) + .unwrap(); - assert_eq!(e, Ok(types::Errno::Ok as i32), "reason_mult errno"); + assert_eq!(e, types::Errno::Ok as i32, "reason_mult errno"); match self.input { types::Reason::DogAte(f) => { From d1f4c385a91badfe2faca0c6b771ee1c4e751fb8 Mon Sep 17 00:00:00 2001 From: Pat Hickey Date: Wed, 26 Oct 2022 13:53:22 -0700 Subject: [PATCH 4/8] wasi-common: emit a wasmtime::Trap instead of a wiggle::Trap formally add a dependency on wasmtime here to make it obvious, though we do now have a transitive one via wiggle no matter what (and therefore can get rid of the default-features=false on the wiggle dep) --- Cargo.lock | 1 + crates/wasi-common/Cargo.toml | 3 ++- crates/wasi-common/src/snapshots/preview_0.rs | 6 +++--- crates/wasi-common/src/snapshots/preview_1.rs | 10 +++++----- 4 files changed, 11 insertions(+), 9 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index df378ca76256..f2e17c7709b4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3149,6 +3149,7 @@ dependencies = [ "rustix", "thiserror", "tracing", + "wasmtime", "wiggle", "windows-sys", ] diff --git a/crates/wasi-common/Cargo.toml b/crates/wasi-common/Cargo.toml index 6ef6dc6cfdb9..a18123470328 100644 --- a/crates/wasi-common/Cargo.toml +++ b/crates/wasi-common/Cargo.toml @@ -20,7 +20,8 @@ links = "wasi-common-19" [dependencies] anyhow = { workspace = true } thiserror = "1.0" -wiggle = { workspace = true, default-features = false } +wiggle = { workspace = true } +wasmtime = { workspace = true } tracing = "0.1.19" cap-std = { workspace = true } cap-rand = "0.26.0" diff --git a/crates/wasi-common/src/snapshots/preview_0.rs b/crates/wasi-common/src/snapshots/preview_0.rs index 96f86820bf9f..3fbf9379bbb5 100644 --- a/crates/wasi-common/src/snapshots/preview_0.rs +++ b/crates/wasi-common/src/snapshots/preview_0.rs @@ -28,10 +28,10 @@ impl wiggle::GuestErrorType for types::Errno { } impl types::UserErrorConversion for WasiCtx { - fn errno_from_error(&mut self, e: Error) -> Result { + fn errno_from_error(&mut self, e: Error) -> Result { debug!("Error: {:?}", e); e.try_into() - .map_err(|e| wiggle::Trap::String(format!("{:?}", e))) + .map_err(|e| wasmtime::Trap::new(format!("{:?}", e))) } } @@ -932,7 +932,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx { Ok(num_results.try_into().expect("results fit into memory")) } - async fn proc_exit(&mut self, status: types::Exitcode) -> wiggle::Trap { + async fn proc_exit(&mut self, status: types::Exitcode) -> wasmtime::Trap { Snapshot1::proc_exit(self, status).await } diff --git a/crates/wasi-common/src/snapshots/preview_1.rs b/crates/wasi-common/src/snapshots/preview_1.rs index ff0461a7208a..3b8eae51f5c9 100644 --- a/crates/wasi-common/src/snapshots/preview_1.rs +++ b/crates/wasi-common/src/snapshots/preview_1.rs @@ -35,10 +35,10 @@ impl wiggle::GuestErrorType for types::Errno { } impl types::UserErrorConversion for WasiCtx { - fn errno_from_error(&mut self, e: Error) -> Result { + fn errno_from_error(&mut self, e: Error) -> Result { debug!("Error: {:?}", e); e.try_into() - .map_err(|e| wiggle::Trap::String(format!("{:?}", e))) + .map_err(|e| wasmtime::Trap::new(format!("{:?}", e))) } } @@ -1214,12 +1214,12 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { Ok(num_results.try_into().expect("results fit into memory")) } - async fn proc_exit(&mut self, status: types::Exitcode) -> wiggle::Trap { + async fn proc_exit(&mut self, status: types::Exitcode) -> wasmtime::Trap { // Check that the status is within WASI's range. if status < 126 { - wiggle::Trap::I32Exit(status as i32) + wasmtime::Trap::i32_exit(status as i32) } else { - wiggle::Trap::String("exit with invalid exit status outside of [0..126)".to_owned()) + wasmtime::Trap::new("exit with invalid exit status outside of [0..126)") } } From 0eb155ce2d2ec22fdbfff28d56e2d6e834a07975 Mon Sep 17 00:00:00 2001 From: Pat Hickey Date: Wed, 26 Oct 2022 13:55:08 -0700 Subject: [PATCH 5/8] wasi-nn: use wasmtime::Trap instead of wiggle::Trap there's no way the implementation of this func is actually a good idea, it will panic the host process on any error, but I'll ask @mtr to fix that --- crates/wasi-nn/src/witx.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/crates/wasi-nn/src/witx.rs b/crates/wasi-nn/src/witx.rs index 81a02c139b17..b4c27734c60f 100644 --- a/crates/wasi-nn/src/witx.rs +++ b/crates/wasi-nn/src/witx.rs @@ -11,7 +11,10 @@ wiggle::from_witx!({ use types::NnErrno; impl<'a> types::UserErrorConversion for WasiNnCtx { - fn nn_errno_from_wasi_nn_error(&mut self, e: WasiNnError) -> Result { + fn nn_errno_from_wasi_nn_error( + &mut self, + e: WasiNnError, + ) -> Result { eprintln!("Host error: {:?}", e); match e { WasiNnError::BackendError(_) => unimplemented!(), From eb6d63abaf1e8c12d9f74c3a924c461c8b93ab1a Mon Sep 17 00:00:00 2001 From: Pat Hickey Date: Wed, 26 Oct 2022 15:21:47 -0700 Subject: [PATCH 6/8] wiggle test-helpers examples: fixes --- crates/wiggle/test-helpers/examples/tracing.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/crates/wiggle/test-helpers/examples/tracing.rs b/crates/wiggle/test-helpers/examples/tracing.rs index 5c80a15ef9ad..dd2556a43ac8 100644 --- a/crates/wiggle/test-helpers/examples/tracing.rs +++ b/crates/wiggle/test-helpers/examples/tracing.rs @@ -86,19 +86,19 @@ fn main() { // Exercise each of the branches in `foo`. // Start with the success case: - let r0 = one_error_conversion::foo(&mut ctx, &host_memory, 0, 0, 8); + let r0 = one_error_conversion::foo(&mut ctx, &host_memory, 0, 0, 8).unwrap(); assert_eq!( r0, - Ok(types::Errno::Ok as i32), + types::Errno::Ok as i32, "Expected return value for strike=0" ); assert!(ctx.log.borrow().is_empty(), "No error log for strike=0"); // First error case: - let r1 = one_error_conversion::foo(&mut ctx, &host_memory, 1, 0, 8); + let r1 = one_error_conversion::foo(&mut ctx, &host_memory, 1, 0, 8).unwrap(); assert_eq!( r1, - Ok(types::Errno::PicketLine as i32), + types::Errno::PicketLine as i32, "Expected return value for strike=1" ); assert_eq!( @@ -108,10 +108,10 @@ fn main() { ); // Second error case: - let r2 = one_error_conversion::foo(&mut ctx, &host_memory, 2, 0, 8); + let r2 = one_error_conversion::foo(&mut ctx, &host_memory, 2, 0, 8).unwrap(); assert_eq!( r2, - Ok(types::Errno::InvalidArg as i32), + types::Errno::InvalidArg as i32, "Expected return value for strike=2" ); assert_eq!( From c01c9e40b053ce430d68084814e30f8c648f3ebc Mon Sep 17 00:00:00 2001 From: Pat Hickey Date: Wed, 26 Oct 2022 15:25:12 -0700 Subject: [PATCH 7/8] wasi-common cant cross compile to wasm32-unknown-emscripten anymore this was originally for the WASI polyfill for web targets. Those days are way behind us now. --- .github/workflows/main.yml | 3 --- 1 file changed, 3 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index ab003114e8f3..7e62c1362cb6 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -174,13 +174,10 @@ jobs: CARGO_PROFILE_DEV_DEBUG_ASSERTIONS: false # Check whether `crates/wasi-common` cross-compiles to the following targets: - # * wasm32-unknown-emscripten # * armv7-unknown-linux-gnueabihf - run: | - rustup target add wasm32-unknown-emscripten rustup target add armv7-unknown-linux-gnueabihf sudo apt-get update && sudo apt-get install -y gcc-arm-linux-gnueabihf - - run: cargo check --target wasm32-unknown-emscripten -p wasi-common - run: cargo check --target armv7-unknown-linux-gnueabihf -p wasi-common # Check whether `wasmtime` cross-compiles to aarch64-pc-windows-msvc From 4a0b5886fdccbdf0b00c2114a46097baff7b0b93 Mon Sep 17 00:00:00 2001 From: Pat Hickey Date: Wed, 26 Oct 2022 16:31:00 -0700 Subject: [PATCH 8/8] wasmtime wont compile for armv7-unknown-linux-gnueabihf either --- .github/workflows/main.yml | 7 ------- 1 file changed, 7 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 7e62c1362cb6..c40563ed4ce5 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -173,13 +173,6 @@ jobs: env: CARGO_PROFILE_DEV_DEBUG_ASSERTIONS: false - # Check whether `crates/wasi-common` cross-compiles to the following targets: - # * armv7-unknown-linux-gnueabihf - - run: | - rustup target add armv7-unknown-linux-gnueabihf - sudo apt-get update && sudo apt-get install -y gcc-arm-linux-gnueabihf - - run: cargo check --target armv7-unknown-linux-gnueabihf -p wasi-common - # Check whether `wasmtime` cross-compiles to aarch64-pc-windows-msvc # We don't build nor test it because it lacks trap handling. # Tracking issue: https://github.com/bytecodealliance/wasmtime/issues/4992