103 lines
2.9 KiB
Rust
103 lines
2.9 KiB
Rust
//! WebAssembly trap handling, which is built on top of the lower-level
|
|
//! signalhandling mechanisms.
|
|
|
|
use libc::c_int;
|
|
use signalhandlers::{jmp_buf, CodeSegment};
|
|
use std::cell::{Cell, RefCell};
|
|
use std::mem;
|
|
use std::ptr;
|
|
|
|
// Currently we uset setjmp/longjmp to unwind out of a signal handler
|
|
// and back to the point where WebAssembly was called (via `call_wasm`).
|
|
// This works because WebAssembly code currently does not use any EH
|
|
// or require any cleanups, and we never unwind through non-wasm frames.
|
|
// In the future, we'll likely replace this with fancier stack unwinding.
|
|
extern "C" {
|
|
fn setjmp(env: *mut jmp_buf) -> c_int;
|
|
fn longjmp(env: *const jmp_buf, val: c_int) -> !;
|
|
}
|
|
|
|
#[derive(Copy, Clone, Debug)]
|
|
struct TrapData {
|
|
pc: *const u8,
|
|
}
|
|
|
|
thread_local! {
|
|
static TRAP_DATA: Cell<TrapData> = Cell::new(TrapData { pc: ptr::null() });
|
|
static JMP_BUFS: RefCell<Vec<jmp_buf>> = RefCell::new(Vec::new());
|
|
}
|
|
|
|
/// Record the Trap code and wasm bytecode offset in TLS somewhere
|
|
#[doc(hidden)]
|
|
#[allow(non_snake_case)]
|
|
#[no_mangle]
|
|
pub extern "C" fn RecordTrap(pc: *const u8, _codeSegment: *const CodeSegment) {
|
|
// TODO: Look up the wasm bytecode offset and trap code and record them instead.
|
|
TRAP_DATA.with(|data| data.set(TrapData { pc }));
|
|
}
|
|
|
|
/// Initiate an unwind.
|
|
#[doc(hidden)]
|
|
#[allow(non_snake_case)]
|
|
#[no_mangle]
|
|
pub extern "C" fn Unwind() {
|
|
JMP_BUFS.with(|bufs| {
|
|
let buf = bufs.borrow_mut().pop().unwrap();
|
|
unsafe { longjmp(&buf, 1) };
|
|
})
|
|
}
|
|
|
|
/// Return the CodeSegment containing the given pc, if any exist in the process.
|
|
/// This method does not take a lock.
|
|
#[doc(hidden)]
|
|
#[allow(non_snake_case)]
|
|
#[no_mangle]
|
|
pub extern "C" fn LookupCodeSegment(_pc: *const ::std::os::raw::c_void) -> *const CodeSegment {
|
|
// TODO: Implement this.
|
|
unsafe { mem::transmute(-1isize) }
|
|
}
|
|
|
|
/// A simple guard to ensure that `JMP_BUFS` is reset when we're done.
|
|
struct ScopeGuard {
|
|
orig_num_bufs: usize,
|
|
}
|
|
|
|
impl ScopeGuard {
|
|
fn new() -> Self {
|
|
Self {
|
|
orig_num_bufs: JMP_BUFS.with(|bufs| bufs.borrow().len()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Drop for ScopeGuard {
|
|
fn drop(&mut self) {
|
|
let orig_num_bufs = self.orig_num_bufs;
|
|
// TODO: Use `shrink_to` once it stablizes.
|
|
JMP_BUFS.with(|bufs| {
|
|
bufs.borrow_mut()
|
|
.resize(orig_num_bufs, unsafe { mem::uninitialized() })
|
|
});
|
|
}
|
|
}
|
|
|
|
/// Call the wasm function poined to by `f`.
|
|
pub fn call_wasm<F>(f: F) -> Result<(), String>
|
|
where
|
|
F: FnOnce(),
|
|
{
|
|
// In case wasm code calls Rust that panics and unwinds past this point,
|
|
// ensure that JMP_BUFS is unwound to its incoming state.
|
|
let _guard = ScopeGuard::new();
|
|
|
|
JMP_BUFS.with(|bufs| {
|
|
let mut buf = unsafe { mem::uninitialized() };
|
|
if unsafe { setjmp(&mut buf) } != 0 {
|
|
return TRAP_DATA.with(|data| Err(format!("wasm trap at {:?}", data.get().pc)));
|
|
}
|
|
bufs.borrow_mut().push(buf);
|
|
f();
|
|
Ok(())
|
|
})
|
|
}
|