Move wasi_proc_exit into the wasmtime-wasi crate.

crates/api/src/externals.rs

@@ -420,7 +420,7 @@ impl Table {
  let src_table = src_table.instance.get_defined_table(src_table_index);
 
  runtime::Table::copy(dst_table, src_table, dst_index, src_index, len)
- .map_err(Trap::from_jit)?;
+ .map_err(Trap::from_runtime)?;
  Ok(())
  }
 

crates/api/src/func.rs

@@ -8,7 +8,7 @@ use std::mem;
 use std::panic::{self, AssertUnwindSafe};
 use std::ptr;
 use std::rc::Weak;
-use wasmtime_runtime::{raise_user_trap, wasi_proc_exit, ExportFunction, VMTrampoline};
+use wasmtime_runtime::{raise_user_trap, ExportFunction, VMTrampoline};
 use wasmtime_runtime::{Export, InstanceHandle, VMContext, VMFunctionBody};
 
 /// A WebAssembly function which can be called.
@@ -474,46 +474,6 @@ impl Func {
  func.into_func(store)
  }
 
- /// Creates a new `Func` for a function which performs a program exit,
- /// unwinding the stack up the point where wasm was most recently entered.
- pub fn exit_func(store: &Store) -> Func {
- unsafe extern "C" fn trampoline(
- callee_vmctx: *mut VMContext,
- caller_vmctx: *mut VMContext,
- ptr: *const VMFunctionBody,
- args: *mut u128,
- ) {
- let ptr = mem::transmute::<
- *const VMFunctionBody,
- unsafe extern "C" fn(*mut VMContext, *mut VMContext, i32) -> !,
- >(ptr);
-
- let mut next = args as *const u128;
- let status = i32::load(&mut next);
- ptr(callee_vmctx, caller_vmctx, status)
- }
-
- let mut args = Vec::new();
- <i32 as WasmTy>::push(&mut args);
- let ret = Vec::new();
- let ty = FuncType::new(args.into(), ret.into());
- let (instance, export) = unsafe {
- crate::trampoline::generate_raw_func_export(
- &ty,
- std::slice::from_raw_parts_mut(wasi_proc_exit as *mut _, 0),
- trampoline,
- store,
- Box::new(()),
- )
- .expect("failed to generate export")
- };
- Func {
- instance,
- export,
- trampoline,
- }
- }
-
  /// Returns the underlying wasm type that this `Func` has.
  pub fn ty(&self) -> FuncType {
  // Signatures should always be registered in the store's registry of
@@ -787,7 +747,7 @@ pub(crate) fn catch_traps(
  signalhandler.as_deref(),
  closure,
  )
- .map_err(Trap::from_jit)
+ .map_err(Trap::from_runtime)
  }
 }
 

crates/api/src/instance.rs

@@ -52,7 +52,7 @@ fn instantiate(
  .map_err(|e| -> Error {
  match e {
  InstantiationError::StartTrap(trap) | InstantiationError::Trap(trap) => {
- Trap::from_jit(trap).into()
+ Trap::from_runtime(trap).into()
  }
  other => other.into(),
  }

crates/api/src/trampoline/func.rs

@@ -54,7 +54,7 @@ unsafe extern "C" fn stub_fn(
 
  // If a trap was raised (an error returned from the imported function)
  // then we smuggle the trap through `Box<dyn Error>` through to the
- // call-site, which gets unwrapped in `Trap::from_jit` later on as we
+ // call-site, which gets unwrapped in `Trap::from_runtime` later on as we
  // convert from the internal `Trap` type to our own `Trap` type in this
  // crate.
  Ok(Err(trap)) => wasmtime_runtime::raise_user_trap(Box::new(trap)),

crates/api/src/trap.rs

@@ -2,7 +2,6 @@ use crate::frame_info::{GlobalFrameInfo, FRAME_INFO};
 use crate::FrameInfo;
 use backtrace::Backtrace;
 use std::fmt;
-use std::num::NonZeroI32;
 use std::sync::Arc;
 use wasmtime_environ::ir::TrapCode;
 
@@ -19,15 +18,15 @@ pub enum TrapReason {
  /// An error message describing a trap.
  Message(String),
 
- /// A non-zero exit status describing an explicit program exit.
- Exit(NonZeroI32),
+ /// An `i32` exit status describing an explicit program exit.
+ I32Exit(i32),
 }
 
 impl fmt::Display for TrapReason {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  match self {
  TrapReason::Message(s) => write!(f, "{}", s),
- TrapReason::Exit(status) => write!(f, "Exited with non-zero exit status {}", status),
+ TrapReason::I32Exit(status) => write!(f, "Exited with i32 exit status {}", status),
  }
  }
 }
@@ -54,9 +53,21 @@ impl Trap {
  Trap::new_with_trace(&info, None, message.into(), Backtrace::new_unresolved())
  }
 
- pub(crate) fn from_jit(jit: wasmtime_runtime::Trap) -> Self {
+ /// Creates a new `Trap` representing an explicit program exit with a classic `i32`
+ /// exit status value.
+ pub fn i32_exit(status: i32) -> Self {
+ Trap {
+ inner: Arc::new(TrapInner {
+ reason: TrapReason::I32Exit(status),
+ wasm_trace: Vec::new(),
+ native_trace: Backtrace::from(Vec::new()),
+ }),
+ }
+ }
+
+ pub(crate) fn from_runtime(runtime_trap: wasmtime_runtime::Trap) -> Self {
  let info = FRAME_INFO.read().unwrap();
- match jit {
+ match runtime_trap {
  wasmtime_runtime::Trap::User(error) => {
  // Since we're the only one using the wasmtime internals (in
  // theory) we should only see user errors which were originally
@@ -91,10 +102,6 @@ impl Trap {
  wasmtime_runtime::Trap::OOM { backtrace } => {
  Trap::new_with_trace(&info, None, "out of memory".to_string(), backtrace)
  }
- wasmtime_runtime::Trap::Exit { status } => Trap::new_exit(status),
- wasmtime_runtime::Trap::InvalidExitStatus { backtrace } => {
- Trap::new_with_trace(&info, None, "invalid exit status".to_string(), backtrace)
- }
  }
  }
 
@@ -158,16 +165,6 @@ impl Trap {
  }
  }
 
- fn new_exit(status: NonZeroI32) -> Self {
- Trap {
- inner: Arc::new(TrapInner {
- reason: TrapReason::Exit(status),
- wasm_trace: Vec::new(),
- native_trace: Backtrace::from(Vec::new()),
- }),
- }
- }
-
  /// Returns a reference the `message` stored in `Trap`.
  pub fn reason(&self) -> &TrapReason {
  &self.inner.reason

crates/runtime/src/lib.rs

@@ -44,8 +44,7 @@ pub use crate::mmap::Mmap;
 pub use crate::sig_registry::SignatureRegistry;
 pub use crate::table::Table;
 pub use crate::traphandlers::{
- catch_traps, init_traps, raise_lib_trap, raise_user_trap, resume_panic, wasi_proc_exit,
- SignalHandler, Trap,
+ catch_traps, init_traps, raise_lib_trap, raise_user_trap, resume_panic, SignalHandler, Trap,
 };
 pub use crate::vmcontext::{
  VMCallerCheckedAnyfunc, VMContext, VMFunctionBody, VMFunctionImport, VMGlobalDefinition,

crates/runtime/src/traphandlers.rs

@@ -7,7 +7,6 @@ use std::any::Any;
 use std::cell::Cell;
 use std::error::Error;
 use std::io;
-use std::num::NonZeroI32;
 use std::ptr;
 use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
 use std::sync::Once;
@@ -340,18 +339,6 @@ pub enum Trap {
  /// Native stack backtrace at the time the OOM occurred
  backtrace: Backtrace,
  },
-
- /// A program exit was requested with a non-zero exit status.
- Exit {
- /// The exit status
- status: NonZeroI32,
- },
-
- /// A program exit was requested with an invalid exit status.
- InvalidExitStatus {
- /// Native stack backtrace at the time the error occurred
- backtrace: Backtrace,
- },
 }
 
 impl Trap {
@@ -373,14 +360,6 @@ impl Trap {
  let backtrace = Backtrace::new_unresolved();
  Trap::OOM { backtrace }
  }
-
- /// Construct a new InvalidExitStatus trap with the given source location.
- ///
- /// Internally saves a backtrace when constructed.
- pub fn invalid_exit_status() -> Self {
- let backtrace = Backtrace::new_unresolved();
- Trap::InvalidExitStatus { backtrace }
- }
 }
 
 /// Catches any wasm traps that happen within the execution of `closure`,
@@ -434,7 +413,6 @@ enum UnwindReason {
  UserTrap(Box<dyn Error + Send + Sync>),
  LibTrap(Trap),
  JitTrap { backtrace: Backtrace, pc: usize },
- Exit { status: i32 },
 }
 
 impl<'a> CallThreadState<'a> {
@@ -482,13 +460,6 @@ impl<'a> CallThreadState<'a> {
  maybe_interrupted,
  })
  }
- UnwindReason::Exit { status } => {
- if let Some(status) = NonZeroI32::new(status) {
- Err(Trap::Exit { status })
- } else {
- Ok(())
- }
- }
  UnwindReason::Panic(panic) => {
  debug_assert_eq!(ret, 0);
  std::panic::resume_unwind(panic)
@@ -815,27 +786,3 @@ fn setup_unix_sigaltstack() -> Result<(), Trap> {
  }
  }
 }
-
-/// Perform a program exit by unwinding the stack to the point where wasm
-/// as most recently entered, carrying an exit status value.
-///
-/// This is implemented in `wasmtime_runtime` rather than with the rest of the WASI
-/// functions as it's essentially an unwinding operation.
-///
-/// # Safety
-///
-/// Only safe to call when wasm code is on the stack, aka `catch_traps` must
-/// have been previously called. Additionally no Rust destructors can be on the
-/// stack. They will be skipped and not executed.
-pub unsafe extern "C" fn wasi_proc_exit(
- _vmctx: *mut VMContext,
- _caller_vmctx: *mut VMContext,
- status: i32,
-) -> ! {
- // Check that the status is within WASI's range.
- if status >= 0 && status < 126 {
- tls::with(|info| info.unwrap().unwind_with(UnwindReason::Exit { status }))
- } else {
- raise_lib_trap(Trap::invalid_exit_status())
- }
-}

crates/wasi-common/wig/src/wasi.rs

@@ -51,7 +51,7 @@ pub fn define_struct(args: TokenStream) -> TokenStream {
  // in wasi-common.
  if name == "proc_exit" {
  ctor_externs.push(quote! {
- let #name_ident = wasmtime::Func::exit_func(store);
+ let #name_ident = wasmtime::Func::wrap(store, crate::wasi_proc_exit);
  });
  continue;
  }
@@ -305,7 +305,7 @@ pub fn define_struct_for_wiggle(args: TokenStream) -> TokenStream {
  // in wasi-common.
  if name == "proc_exit" {
  ctor_externs.push(quote! {
- let #name_ident = wasmtime::Func::exit_func(store);
+ let #name_ident = wasmtime::Func::wrap(store, crate::wasi_proc_exit);
  });
  continue;
  }

crates/wasi/src/lib.rs

@@ -1,3 +1,5 @@
+use wasmtime::Trap;
+
 pub mod old;
 
 pub use wasi_common::{WasiCtx, WasiCtxBuilder};
@@ -12,3 +14,17 @@ pub fn is_wasi_module(name: &str) -> bool {
  // trick.
  name.starts_with("wasi")
 }
+
+/// Implement the WASI `proc_exit` function. This function is implemented here
+/// instead of in wasi-common so that we can use the runtime to perform an
+/// unwind rather than exiting the host process.
+fn wasi_proc_exit(status: i32) -> Result<(), Trap> {
+ // Check that the status is within WASI's range.
+ if status >= 0 && status < 126 {
+ Err(Trap::i32_exit(status))
+ } else {
+ Err(Trap::new(
+ "exit with invalid exit status outside of [0..126)",
+ ))
+ }
+}

src/commands/run.rs

@@ -148,13 +148,13 @@ impl RunCommand {
  // Print the error message in the usual way.
  eprintln!("Error: {:?}", e);
 
- if let TrapReason::Exit(status) = trap.reason() {
+ if let TrapReason::I32Exit(status) = trap.reason() {
  // On Windows, exit status 3 indicates an abort (see below),
  // so just return 1 indicating a non-zero status.
  if cfg!(windows) {
  process::exit(1);
  }
- process::exit(status.get());
+ process::exit(*status);
  }
 
  // If the program exited because of a trap, return an error code