177af53578
* Remove the unused EnsureDarwinMachPorts function When compiling the C++ shims for longjmp/setjmp/signal handling we don't use the `USE_APPLE_MACH_PORTS` directive, so this function was entirely unused anyway. This looks to be a holdover from when this was originally copied from C++, but no need for keeping around this now-legacy initialization. * Remove the `wasmtime_init_finish` function This looks like it's perhaps largely historical cruft at this point now I think? The function, with the removal of the mach ports from the previous commit, only reads the initializtion state of the signal handlers. If the signal handlers failed to get installed, though, it simply returns early rather than erroring out anyway. In any case a follow-up commit will refactor `wasmtime_init_eager` to handle this as well. * Pare down `wasmtime_init_eager` Similar to previous commits it looks like this function may have accrued some debt over time, nowadays it doesn't really do much other than capture a backtrace and install signal handlers. The `lazy_static` state isn't really that necessary and we can rely on the `Once` primitive in the standard library for one-time initialization. This also updates the code to unconditionally panic if signal handlers fail to get installed, which I think is the behavior that we'll want for now and we can enhance it over time if necessary, but I don't think we have a use case where it's currently necessary.
39 lines
1.6 KiB
Rust
39 lines
1.6 KiB
Rust
//! Interface to low-level signal-handling mechanisms.
|
|
|
|
use std::sync::Once;
|
|
|
|
extern "C" {
|
|
fn EnsureEagerSignalHandlers() -> libc::c_int;
|
|
}
|
|
|
|
/// 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.
|
|
pub fn init() {
|
|
static INIT: Once = Once::new();
|
|
INIT.call_once(real_init);
|
|
}
|
|
|
|
fn real_init() {
|
|
// This is a really weird and unfortunate function call. For all the gory
|
|
// details see #829, but the tl;dr; is that in a trap handler we have 2
|
|
// pages of stack space on Linux, and calling into libunwind which triggers
|
|
// the dynamic loader blows the stack.
|
|
//
|
|
// This is a dumb hack to work around this system-specific issue by
|
|
// capturing a backtrace once in the lifetime of a process to ensure that
|
|
// when we capture a backtrace in the trap handler all caches are primed,
|
|
// aka the dynamic loader has resolved all the relevant symbols.
|
|
drop(backtrace::Backtrace::new_unresolved());
|
|
|
|
if unsafe { EnsureEagerSignalHandlers() == 0 } {
|
|
panic!("failed to install signal handlers");
|
|
}
|
|
}
|