8e1b44b29c
* Make more code work with no_std. no_std support is still incomplete, but this patch takes care of the bulk of the straightforward parts.
131 lines
3.7 KiB
Rust
131 lines
3.7 KiB
Rust
//! Interface to low-level signal-handling mechanisms.
|
|
|
|
#![allow(non_upper_case_globals)]
|
|
#![allow(non_camel_case_types)]
|
|
#![allow(non_snake_case)]
|
|
|
|
use crate::vmcontext::VMContext;
|
|
use crate::RwLock;
|
|
use core::borrow::{Borrow, BorrowMut};
|
|
use core::cell::Cell;
|
|
|
|
#[derive(Default)]
|
|
struct TrapContext {
|
|
tried_to_install_signal_handlers: Cell<bool>,
|
|
have_signal_handlers: Cell<bool>,
|
|
}
|
|
|
|
extern "C" {
|
|
fn EnsureEagerSignalHandlers() -> libc::c_int;
|
|
#[cfg(any(target_os = "macos", target_os = "ios"))]
|
|
fn EnsureDarwinMachPorts() -> libc::c_int;
|
|
}
|
|
|
|
struct InstallState {
|
|
tried: bool,
|
|
success: bool,
|
|
}
|
|
|
|
impl InstallState {
|
|
fn new() -> Self {
|
|
Self {
|
|
tried: false,
|
|
success: false,
|
|
}
|
|
}
|
|
}
|
|
|
|
lazy_static! {
|
|
static ref EAGER_INSTALL_STATE: RwLock<InstallState> = RwLock::new(InstallState::new());
|
|
static ref LAZY_INSTALL_STATE: RwLock<InstallState> = RwLock::new(InstallState::new());
|
|
}
|
|
|
|
/// This function performs the low-overhead signal handler initialization that we
|
|
/// want to do eagerly to ensure a more-deterministic global process state. This
|
|
/// is especially relevant for signal handlers since handler ordering depends on
|
|
/// installation order: the wasm signal handler must run *before* the other crash
|
|
/// handlers and since POSIX signal handlers work LIFO, this function needs to be
|
|
/// called at the end of the startup process, after other handlers have been
|
|
/// installed. This function can thus be called multiple times, having no effect
|
|
/// after the first call.
|
|
#[no_mangle]
|
|
pub extern "C" fn wasmtime_init_eager() {
|
|
let mut locked = EAGER_INSTALL_STATE.write().unwrap();
|
|
let state = locked.borrow_mut();
|
|
|
|
if state.tried {
|
|
return;
|
|
}
|
|
|
|
state.tried = true;
|
|
assert!(!state.success);
|
|
|
|
if unsafe { EnsureEagerSignalHandlers() == 0 } {
|
|
return;
|
|
}
|
|
|
|
state.success = true;
|
|
}
|
|
|
|
thread_local! {
|
|
static TRAP_CONTEXT: TrapContext = TrapContext::default();
|
|
}
|
|
|
|
/// Assuming `EnsureEagerProcessSignalHandlers` has already been called,
|
|
/// this function performs the full installation of signal handlers which must
|
|
/// be performed per-thread. This operation may incur some overhead and
|
|
/// so should be done only when needed to use wasm.
|
|
#[no_mangle]
|
|
pub extern "C" fn wasmtime_init_finish(vmctx: &mut VMContext) {
|
|
if !TRAP_CONTEXT.with(|cx| cx.tried_to_install_signal_handlers.get()) {
|
|
TRAP_CONTEXT.with(|cx| {
|
|
cx.tried_to_install_signal_handlers.set(true);
|
|
assert!(!cx.have_signal_handlers.get());
|
|
});
|
|
|
|
{
|
|
let locked = EAGER_INSTALL_STATE.read().unwrap();
|
|
let state = locked.borrow();
|
|
assert!(
|
|
state.tried,
|
|
"call wasmtime_init_eager before calling wasmtime_init_finish"
|
|
);
|
|
if !state.success {
|
|
return;
|
|
}
|
|
}
|
|
|
|
#[cfg(any(target_os = "macos", target_os = "ios"))]
|
|
ensure_darwin_mach_ports();
|
|
|
|
TRAP_CONTEXT.with(|cx| {
|
|
cx.have_signal_handlers.set(true);
|
|
})
|
|
}
|
|
|
|
let instance = unsafe { vmctx.instance() };
|
|
let have_signal_handlers = TRAP_CONTEXT.with(|cx| cx.have_signal_handlers.get());
|
|
if !have_signal_handlers && instance.needs_signal_handlers() {
|
|
panic!("failed to install signal handlers");
|
|
}
|
|
}
|
|
|
|
#[cfg(any(target_os = "macos", target_os = "ios"))]
|
|
fn ensure_darwin_mach_ports() {
|
|
let mut locked = LAZY_INSTALL_STATE.write().unwrap();
|
|
let state = locked.borrow_mut();
|
|
|
|
if state.tried {
|
|
return;
|
|
}
|
|
|
|
state.tried = true;
|
|
assert!(!state.success);
|
|
|
|
if unsafe { EnsureDarwinMachPorts() != 0 } {
|
|
return;
|
|
}
|
|
|
|
state.success = true;
|
|
}
|