Return anyhow::Error from host functions instead of Trap

This commit refactors how errors are modeled when returned from host
functions and additionally refactors how custom errors work with `Trap`.
At a high level functions in Wasmtime that previously worked with
`Result<T, Trap>` now work with `Result<T>` instead where the error is
`anyhow::Error`. This includes functions such as:

* Host-defined functions in a `Linker<T>`
* `TypedFunc::call`
* Host-related callbacks like call hooks

Errors are now modeled primarily as `anyhow::Error` throughout Wasmtime.
This subsequently removes the need for `Trap` to have the ability to
represent all host-defined errors as it previously did. Consequently the
`From` implementations for any error into a `Trap` have been removed
here and the only embedder-defined way to create a `Trap` is to use
`Trap::new` with a custom string.

After this commit the distinction between a `Trap` and a host error is
the wasm backtrace that it contains. Previously all errors in host
functions would flow through a `Trap` and get a wasm backtrace attached
to them, but now this only happens if a `Trap` itself is created meaning
that arbitrary host-defined errors flowing from a host import to the
other side won't get backtraces attached. Some internals of Wasmtime
itself were updated or preserved to use `Trap::new` to capture a
backtrace where it seemed useful, such as when fuel runs out.

The main motivation for this commit is that it now enables hosts to
thread a concrete error type from a host function all the way through to
where a wasm function was invoked. Previously this could not be done
since the host error was wrapped in a `Trap` that didn't provide the
ability to get at the internals.

A consequence of this commit is that when a host error is returned that
isn't a `Trap` we'll capture a backtrace and then won't have a `Trap` to
attach it to. To avoid losing the contextual information this commit
uses the `Error::context` method to attach the backtrace as contextual
information to ensure that the backtrace is itself not lost.

This is a breaking change for likely all users of Wasmtime, but it's
hoped to be a relatively minor change to workaround. Most use cases can
likely change `-> Result<T, Trap>` to `-> Result<T>` and otherwise
explicit creation of a `Trap` is largely no longer necessary.

crates/c-api/src/func.rs

@@ -3,6 +3,7 @@ use crate::{
  wasm_extern_t, wasm_functype_t, wasm_store_t, wasm_val_t, wasm_val_vec_t, wasmtime_error_t,
  wasmtime_extern_t, wasmtime_val_t, wasmtime_val_union, CStoreContext, CStoreContextMut,
 };
+use anyhow::Result;
 use std::ffi::c_void;
 use std::mem::{self, MaybeUninit};
 use std::panic::{self, AssertUnwindSafe};
@@ -67,7 +68,7 @@ unsafe fn create_function(
  let mut out_results: wasm_val_vec_t = vec![wasm_val_t::default(); results.len()].into();
  let out = func(&params, &mut out_results);
  if let Some(trap) = out {
- return Err(trap.trap.clone());
+ return Err(trap.error);
  }
 
  let out_results = out_results.as_slice();
@@ -152,10 +153,7 @@ pub unsafe extern "C" fn wasm_func_call(
  }
  ptr::null_mut()
  }
- Ok(Err(trap)) => match trap.downcast::<Trap>() {
- Ok(trap) => Box::into_raw(Box::new(wasm_trap_t::new(trap))),
- Err(err) => Box::into_raw(Box::new(wasm_trap_t::new(err.into()))),
- },
+ Ok(Err(err)) => Box::into_raw(Box::new(wasm_trap_t::new(err))),
  Err(panic) => {
  let trap = if let Some(msg) = panic.downcast_ref::<String>() {
  Trap::new(msg)
@@ -164,7 +162,7 @@ pub unsafe extern "C" fn wasm_func_call(
  } else {
  Trap::new("rust panic happened")
  };
- let trap = Box::new(wasm_trap_t::new(trap));
+ let trap = Box::new(wasm_trap_t::new(trap.into()));
  Box::into_raw(trap)
  }
  }
@@ -235,7 +233,7 @@ pub(crate) unsafe fn c_callback_to_rust_fn(
  callback: wasmtime_func_callback_t,
  data: *mut c_void,
  finalizer: Option<extern "C" fn(*mut std::ffi::c_void)>,
-) -> impl Fn(Caller<'_, crate::StoreData>, &[Val], &mut [Val]) -> Result<(), Trap> {
+) -> impl Fn(Caller<'_, crate::StoreData>, &[Val], &mut [Val]) -> Result<()> {
  let foreign = crate::ForeignData { data, finalizer };
  move |mut caller, params, results| {
  drop(&foreign); // move entire foreign into this closure
@@ -264,7 +262,7 @@ pub(crate) unsafe fn c_callback_to_rust_fn(
  out_results.len(),
  );
  if let Some(trap) = out {
- return Err(trap.trap);
+ return Err(trap.error);
  }
 
  // Translate the `wasmtime_val_t` results into the `results` space
@@ -299,14 +297,14 @@ pub(crate) unsafe fn c_unchecked_callback_to_rust_fn(
  callback: wasmtime_func_unchecked_callback_t,
  data: *mut c_void,
  finalizer: Option<extern "C" fn(*mut std::ffi::c_void)>,
-) -> impl Fn(Caller<'_, crate::StoreData>, &mut [ValRaw]) -> Result<(), Trap> {
+) -> impl Fn(Caller<'_, crate::StoreData>, &mut [ValRaw]) -> Result<()> {
  let foreign = crate::ForeignData { data, finalizer };
  move |caller, values| {
  drop(&foreign); // move entire foreign into this closure
  let mut caller = wasmtime_caller_t { caller };
  match callback(foreign.data, &mut caller, values.as_mut_ptr(), values.len()) {
  None => Ok(()),
- Some(trap) => Err(trap.trap),
+ Some(trap) => Err(trap.error),
  }
  }
 }
@@ -350,7 +348,7 @@ pub unsafe extern "C" fn wasmtime_func_call(
  }
  Ok(Err(trap)) => match trap.downcast::<Trap>() {
  Ok(trap) => {
- *trap_ret = Box::into_raw(Box::new(wasm_trap_t::new(trap)));
+ *trap_ret = Box::into_raw(Box::new(wasm_trap_t::new(trap.into())));
  None
  }
  Err(err) => Some(Box::new(wasmtime_error_t::from(err))),
@@ -363,7 +361,7 @@ pub unsafe extern "C" fn wasmtime_func_call(
  } else {
  Trap::new("rust panic happened")
  };
- *trap_ret = Box::into_raw(Box::new(wasm_trap_t::new(trap)));
+ *trap_ret = Box::into_raw(Box::new(wasm_trap_t::new(trap.into())));
  None
  }
  }

crates/c-api/src/instance.rs

@@ -41,7 +41,7 @@ pub unsafe extern "C" fn wasm_instance_new(
  ))),
  Err(e) => {
  if let Some(ptr) = result {
- *ptr = Box::into_raw(Box::new(wasm_trap_t::new(e.into())));
+ *ptr = Box::into_raw(Box::new(wasm_trap_t::new(e)));
  }
  None
  }
@@ -100,7 +100,7 @@ pub(crate) fn handle_instantiate(
  }
  Err(e) => match e.downcast::<Trap>() {
  Ok(trap) => {
- *trap_ptr = Box::into_raw(Box::new(wasm_trap_t::new(trap)));
+ *trap_ptr = Box::into_raw(Box::new(wasm_trap_t::new(trap.into())));
  None
  }
  Err(e) => Some(Box::new(e.into())),

crates/c-api/src/trap.rs

@@ -1,18 +1,30 @@
 use crate::{wasm_frame_vec_t, wasm_instance_t, wasm_name_t, wasm_store_t};
+use anyhow::{anyhow, Error};
 use once_cell::unsync::OnceCell;
 use wasmtime::{Trap, TrapCode};
 
 #[repr(C)]
-#[derive(Clone)]
 pub struct wasm_trap_t {
- pub(crate) trap: Trap,
+ pub(crate) error: Error,
+}
+
+// This is currently only needed for the `wasm_trap_copy` API in the C API.
+//
+// For now the impl here is "fake it til you make it" since this is losing
+// context by only cloning the error string.
+impl Clone for wasm_trap_t {
+ fn clone(&self) -> wasm_trap_t {
+ wasm_trap_t {
+ error: anyhow!("{:?}", self.error),
+ }
+ }
 }
 
 wasmtime_c_api_macros::declare_ref!(wasm_trap_t);
 
 impl wasm_trap_t {
- pub(crate) fn new(trap: Trap) -> wasm_trap_t {
- wasm_trap_t { trap: trap }
+ pub(crate) fn new(error: Error) -> wasm_trap_t {
+ wasm_trap_t { error }
  }
 }
 
@@ -40,7 +52,7 @@ pub extern "C" fn wasm_trap_new(
  }
  let message = String::from_utf8_lossy(&message[..message.len() - 1]);
  Box::new(wasm_trap_t {
- trap: Trap::new(message),
+ error: Trap::new(message).into(),
  })
 }
 
@@ -49,24 +61,28 @@ pub unsafe extern "C" fn wasmtime_trap_new(message: *const u8, len: usize) -> Bo
  let bytes = crate::slice_from_raw_parts(message, len);
  let message = String::from_utf8_lossy(&bytes);
  Box::new(wasm_trap_t {
- trap: Trap::new(message),
+ error: Trap::new(message).into(),
  })
 }
 
 #[no_mangle]
 pub extern "C" fn wasm_trap_message(trap: &wasm_trap_t, out: &mut wasm_message_t) {
  let mut buffer = Vec::new();
- buffer.extend_from_slice(trap.trap.to_string().as_bytes());
+ buffer.extend_from_slice(format!("{:?}", trap.error).as_bytes());
  buffer.reserve_exact(1);
  buffer.push(0);
  out.set_buffer(buffer);
 }
 
 #[no_mangle]
 pub extern "C" fn wasm_trap_origin(raw: &wasm_trap_t) -> Option<Box<wasm_frame_t>> {
- if raw.trap.trace().unwrap_or(&[]).len() > 0 {
+ let trap = match raw.error.downcast_ref::<Trap>() {
+ Some(trap) => trap,
+ None => return None,
+ };
+ if trap.trace().unwrap_or(&[]).len() > 0 {
  Some(Box::new(wasm_frame_t {
- trap: raw.trap.clone(),
+ trap: trap.clone(),
  idx: 0,
  func_name: OnceCell::new(),
  module_name: OnceCell::new(),
@@ -78,10 +94,14 @@ pub extern "C" fn wasm_trap_origin(raw: &wasm_trap_t) -> Option<Box<wasm_frame_t
 
 #[no_mangle]
 pub extern "C" fn wasm_trap_trace(raw: &wasm_trap_t, out: &mut wasm_frame_vec_t) {
- let vec = (0..raw.trap.trace().unwrap_or(&[]).len())
+ let trap = match raw.error.downcast_ref::<Trap>() {
+ Some(trap) => trap,
+ None => return out.set_buffer(Vec::new()),
+ };
+ let vec = (0..trap.trace().unwrap_or(&[]).len())
  .map(|idx| {
  Some(Box::new(wasm_frame_t {
- trap: raw.trap.clone(),
+ trap: trap.clone(),
  idx,
  func_name: OnceCell::new(),
  module_name: OnceCell::new(),
@@ -93,7 +113,11 @@ pub extern "C" fn wasm_trap_trace(raw: &wasm_trap_t, out: &mut wasm_frame_vec_t)
 
 #[no_mangle]
 pub extern "C" fn wasmtime_trap_code(raw: &wasm_trap_t, code: &mut i32) -> bool {
- match raw.trap.trap_code() {
+ let trap = match raw.error.downcast_ref::<Trap>() {
+ Some(trap) => trap,
+ None => return false,
+ };
+ match trap.trap_code() {
  Some(c) => {
  *code = match c {
  TrapCode::StackOverflow => 0,
@@ -117,7 +141,11 @@ pub extern "C" fn wasmtime_trap_code(raw: &wasm_trap_t, code: &mut i32) -> bool
 
 #[no_mangle]
 pub extern "C" fn wasmtime_trap_exit_status(raw: &wasm_trap_t, status: &mut i32) -> bool {
- match raw.trap.i32_exit_status() {
+ let trap = match raw.error.downcast_ref::<Trap>() {
+ Some(trap) => trap,
+ None => return false,
+ };
+ match trap.i32_exit_status() {
  Some(i) => {
  *status = i;
  true

crates/fuzzing/src/oracles/stacks.rs

@@ -1,4 +1,5 @@
 use crate::generators::Stacks;
+use anyhow::Result;
 use wasmtime::*;
 
 /// Run the given `Stacks` test case and assert that the host's view of the Wasm
@@ -17,7 +18,7 @@ pub fn check_stacks(stacks: Stacks) -> usize {
  .func_wrap(
  "host",
  "check_stack",
- |mut caller: Caller<'_, ()>| -> Result<(), Trap> {
+ |mut caller: Caller<'_, ()>| -> Result<()> {
  let fuel = caller
  .get_export("fuel")
  .expect("should export `fuel`")
@@ -26,7 +27,7 @@ pub fn check_stacks(stacks: Stacks) -> usize {
 
  let fuel_left = fuel.get(&mut caller).unwrap_i32();
  if fuel_left == 0 {
- return Err(Trap::new("out of fuel"));
+ return Err(Trap::new("out of fuel").into());
  }
 
  fuel.set(&mut caller, Val::I32(fuel_left - 1)).unwrap();
@@ -59,6 +60,7 @@ pub fn check_stacks(stacks: Stacks) -> usize {
  for input in stacks.inputs().iter().copied() {
  log::debug!("input: {}", input);
  if let Err(trap) = run.call(&mut store, (input.into(),)) {
+ let trap = trap.downcast::<Trap>().unwrap();
  log::debug!("trap: {}", trap);
  let get_stack = instance
  .get_typed_func::<(), (u32, u32), _>(&mut store, "get_stack")

crates/wasi-common/src/snapshots/preview_0.rs

@@ -6,6 +6,7 @@ use crate::sched::{
 use crate::snapshots::preview_1::types as snapshot1_types;
 use crate::snapshots::preview_1::wasi_snapshot_preview1::WasiSnapshotPreview1 as Snapshot1;
 use crate::{Error, ErrorExt, WasiCtx};
+use anyhow::Result;
 use cap_std::time::Duration;
 use std::collections::HashSet;
 use std::convert::{TryFrom, TryInto};
@@ -28,10 +29,10 @@ impl wiggle::GuestErrorType for types::Errno {
 }
 
 impl types::UserErrorConversion for WasiCtx {
- fn errno_from_error(&mut self, e: Error) -> Result<types::Errno, wasmtime::Trap> {
+ fn errno_from_error(&mut self, e: Error) -> Result<types::Errno> {
  debug!("Error: {:?}", e);
- e.try_into()
-  .map_err(|e| wasmtime::Trap::new(format!("{:?}", e)))
+ let errno = e.try_into()?;
+ Ok(errno)
  }
 }
 
@@ -932,7 +933,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) -> wasmtime::Trap {
+ async fn proc_exit(&mut self, status: types::Exitcode) -> anyhow::Error {
  Snapshot1::proc_exit(self, status).await
  }
 

crates/wasi-common/src/snapshots/preview_1.rs

@@ -10,7 +10,7 @@ use crate::{
  },
  Error, ErrorExt, ErrorKind, SystemTimeSpec, WasiCtx,
 };
-use anyhow::Context;
+use anyhow::{Context, Result};
 use cap_std::time::{Duration, SystemClock};
 use std::convert::{TryFrom, TryInto};
 use std::io::{IoSlice, IoSliceMut};
@@ -35,10 +35,10 @@ impl wiggle::GuestErrorType for types::Errno {
 }
 
 impl types::UserErrorConversion for WasiCtx {
- fn errno_from_error(&mut self, e: Error) -> Result<types::Errno, wasmtime::Trap> {
+ fn errno_from_error(&mut self, e: Error) -> Result<types::Errno> {
  debug!("Error: {:?}", e);
- e.try_into()
-  .map_err(|e| wasmtime::Trap::new(format!("{:?}", e)))
+ let errno = e.try_into()?;
+ Ok(errno)
  }
 }
 
@@ -1214,13 +1214,14 @@ 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) -> wasmtime::Trap {
+ async fn proc_exit(&mut self, status: types::Exitcode) -> anyhow::Error {
  // Check that the status is within WASI's range.
- if status < 126 {
- wasmtime::Trap::i32_exit(status as i32)
+ let trap = if status < 126 {
+ wasmtime::Trap::i32_exit(status as i32).into()
  } else {
  wasmtime::Trap::new("exit with invalid exit status outside of [0..126)")
- }
+ };
+ trap.into()
  }
 
  async fn proc_raise(&mut self, _sig: types::Signal) -> Result<(), Error> {

crates/wasi-nn/src/witx.rs

@@ -1,6 +1,7 @@
 //! Contains the macro-generated implementation of wasi-nn from the its witx definition file.
 use crate::ctx::WasiNnCtx;
 use crate::ctx::WasiNnError;
+use anyhow::Result;
 
 // Generate the traits and types of wasi-nn in several Rust modules (e.g. `types`).
 wiggle::from_witx!({
@@ -11,10 +12,7 @@ wiggle::from_witx!({
 use types::NnErrno;
 
 impl<'a> types::UserErrorConversion for WasiNnCtx {
- fn nn_errno_from_wasi_nn_error(
- &mut self,
- e: WasiNnError,
- ) -> Result<NnErrno, wiggle::wasmtime_crate::Trap> {
+ fn nn_errno_from_wasi_nn_error(&mut self, e: WasiNnError) -> Result<NnErrno> {
  eprintln!("Host error: {:?}", e);
  match e {
  WasiNnError::BackendError(_) => unimplemented!(),

crates/wasmtime/src/component/func/host.rs

@@ -193,7 +193,7 @@ where
  // the component is disallowed, for example, when the `realloc` function
  // calls a canonical import.
  if !flags.may_leave() {
- bail!("cannot leave component instance");
+ return Err(Trap::new("cannot leave component instance").into());
  }
 
  // There's a 2x2 matrix of whether parameters and results are stored on the
@@ -303,7 +303,7 @@ where
  // the component is disallowed, for example, when the `realloc` function
  // calls a canonical import.
  if !flags.may_leave() {
- bail!("cannot leave component instance");
+ return Err(Trap::new("cannot leave component instance").into());
  }
 
  let args;