wasmtime 20.0.2 → 21.0.1

data/ext/cargo-vendor/wasmtime-21.0.1/src/runtime/vm/sys/unix/machports.rs

@@ -0,0 +1,416 @@
+//! macOS-specific handling of handling exceptions
+//!
+//! Unlike other Unix platforms macOS here uses mach ports to handle exceptions
+//! instead of signals. While macOS platforms could use signals (and
+//! historically they did!) this is incompatible when Wasmtime is linked into a
+//! project that is otherwise using mach ports for catching exceptions. This
+//! came up #2456 notably when a project like Breakpad is integrated to blanket
+//! catch exceptions and report them.
+//!
+//! Mach ports are somewhat obscure and not really heavily used in a ton of
+//! places. Needless to say the original author of this file worked with mach
+//! ports for the first time when writing this file. As such the exact specifics
+//! here may not be super well documented. This file is 100% lifted from
+//! SpiderMonkey and then adapted for Wasmtime's purposes. Credit for almost
+//! all of this file goes to SpiderMonkey for figuring out all the fiddly bits.
+//! See also
+//! <https://searchfox.org/mozilla-central/source/js/src/wasm/WasmSignalHandlers.cpp>
+//! for the original code.
+//!
+//! The high-level overview is that when using mach ports a thread is blocked
+//! when it generates an exception and then a message can be read from the
+//! port. This means that, unlike signals, threads can't fix their own traps.
+//! Instead a helper thread is spun up to service exception messages. This is
+//! also in conflict with Wasmtime's exception handling currently which is to
+//! use a thread-local to store information about how to unwind. Additionally
+//! this requires that the check of whether a pc is a wasm trap or not is a
+//! global check rather than a per-thread check. This necessitates the existence
+//! of `GlobalModuleRegistry` in the `wasmtime` crate.
+//!
+//! Otherwise this file heavily uses the `mach` Rust crate for type and
+//! function declarations. Many bits and pieces are copied or translated from
+//! the SpiderMonkey implementation and it should pass all the tests!
+
+#![allow(non_snake_case, clippy::cast_sign_loss)]
+
+use crate::runtime::vm::sys::traphandlers::wasmtime_longjmp;
+use crate::runtime::vm::traphandlers::tls;
+use mach2::exc::*;
+use mach2::exception_types::*;
+use mach2::kern_return::*;
+use mach2::mach_init::*;
+use mach2::mach_port::*;
+use mach2::message::*;
+use mach2::ndr::*;
+use mach2::port::*;
+use mach2::thread_act::*;
+use mach2::thread_status::*;
+use mach2::traps::*;
+use std::mem;
+use std::ptr::addr_of_mut;
+use std::thread;
+use wasmtime_environ::Trap;
+
+/// Process-global port that we use to route thread-level exceptions to.
+static mut WASMTIME_PORT: mach_port_name_t = MACH_PORT_NULL;
+
+static mut CHILD_OF_FORKED_PROCESS: bool = false;
+
+pub unsafe fn platform_init() {
+    // Mach ports do not currently work across forks, so configure Wasmtime to
+    // panic in `lazy_per_thread_init` if the child attempts to invoke
+    // WebAssembly.
+    unsafe extern "C" fn child() {
+        CHILD_OF_FORKED_PROCESS = true;
+    }
+    let rc = libc::pthread_atfork(None, None, Some(child));
+    assert_eq!(rc, 0, "failed to configure `pthread_atfork` handler");
+
+    // Allocate our WASMTIME_PORT and make sure that it can be sent to so we
+    // can receive exceptions.
+    let me = mach_task_self();
+    let kret = mach_port_allocate(me, MACH_PORT_RIGHT_RECEIVE, addr_of_mut!(WASMTIME_PORT));
+    assert_eq!(kret, KERN_SUCCESS, "failed to allocate port");
+    let kret = mach_port_insert_right(me, WASMTIME_PORT, WASMTIME_PORT, MACH_MSG_TYPE_MAKE_SEND);
+    assert_eq!(kret, KERN_SUCCESS, "failed to insert right");
+
+    // Spin up our handler thread which will solely exist to service exceptions
+    // generated by other threads. Note that this is a background thread that
+    // we're not very interested in so it's detached here.
+    thread::spawn(|| handler_thread());
+}
+
+// Note that this is copied from Gecko at
+//
+// https://searchfox.org/mozilla-central/rev/ed93119be4818da1509bbcb7b28e245853eeedd5/js/src/wasm/WasmSignalHandlers.cpp#583-601
+//
+// which distinctly diverges from the actual version of this in the header
+// files provided by macOS, notably in the `code` field which uses `i64`
+// instead of `i32`.
+//
+// Also note the `packed(4)` here which forcibly decreases alignment to 4 to
+// additionally match what mach expects (apparently, I wish I had a better
+// reference for this).
+#[repr(C, packed(4))]
+#[allow(dead_code)]
+#[derive(Copy, Clone, Debug)]
+struct __Request__exception_raise_t {
+    Head: mach_msg_header_t,
+    /* start of the kernel processed data */
+    msgh_body: mach_msg_body_t,
+    thread: mach_msg_port_descriptor_t,
+    task: mach_msg_port_descriptor_t,
+    /* end of the kernel processed data */
+    NDR: NDR_record_t,
+    exception: exception_type_t,
+    codeCnt: mach_msg_type_number_t,
+
+    // Note that this is a divergence from the C headers which use
+    // `integer_t` here for this field which is a `c_int`. That isn't
+    // actually reflecting reality apparently though because if `c_int` is
+    // used here then the structure is too small to receive a message.
+    code: [i64; 2],
+}
+
+// This is largely just copied from SpiderMonkey.
+#[repr(C)]
+#[allow(dead_code)]
+#[derive(Debug)]
+struct ExceptionRequest {
+    body: __Request__exception_raise_t,
+    trailer: mach_msg_trailer_t,
+}
+
+unsafe fn handler_thread() {
+    // Taken from mach_exc in /usr/include/mach/mach_exc.defs.
+    const EXCEPTION_MSG_ID: mach_msg_id_t = 2405;
+
+    loop {
+        // Block this thread reading a message from our port. This will block
+        // until some thread throws an exception. Note that messages are all
+        // expected to be exceptions here.
+        let mut request: ExceptionRequest = mem::zeroed();
+        let kret = mach_msg(
+            &mut request.body.Head,
+            MACH_RCV_MSG,
+            0,
+            mem::size_of_val(&request) as u32,
+            WASMTIME_PORT,
+            MACH_MSG_TIMEOUT_NONE,
+            MACH_PORT_NULL,
+        );
+        if kret != KERN_SUCCESS {
+            eprintln!("mach_msg failed with {} ({0:x})", kret);
+            libc::abort();
+        }
+        if request.body.Head.msgh_id != EXCEPTION_MSG_ID {
+            eprintln!("unexpected msg header id {}", request.body.Head.msgh_id);
+            libc::abort();
+        }
+
+        // Attempt to handle the exception below which will process the state
+        // of the request.
+        //
+        // We unconditionally need to send a message back on our port after
+        // this exception is received, and our reply code here dictates whether
+        // the thread crashes or whether we continue execution of the thread.
+        let reply_code = if handle_exception(&mut request) {
+            KERN_SUCCESS
+        } else {
+            KERN_FAILURE
+        };
+
+        // This magic incantation to send a reply back to the kernel was
+        // derived from the exc_server generated by
+        // 'mig -v /usr/include/mach/mach_exc.defs'.
+        let mut reply: __Reply__exception_raise_t = mem::zeroed();
+        reply.Head.msgh_bits =
+            MACH_MSGH_BITS(request.body.Head.msgh_bits & MACH_MSGH_BITS_REMOTE_MASK, 0);
+        reply.Head.msgh_size = mem::size_of_val(&reply) as u32;
+        reply.Head.msgh_remote_port = request.body.Head.msgh_remote_port;
+        reply.Head.msgh_local_port = MACH_PORT_NULL;
+        reply.Head.msgh_id = request.body.Head.msgh_id + 100;
+        reply.NDR = NDR_record;
+        reply.RetCode = reply_code;
+        mach_msg(
+            &mut reply.Head,
+            MACH_SEND_MSG,
+            mem::size_of_val(&reply) as u32,
+            0,
+            MACH_PORT_NULL,
+            MACH_MSG_TIMEOUT_NONE,
+            MACH_PORT_NULL,
+        );
+    }
+}
+
+unsafe fn handle_exception(request: &mut ExceptionRequest) -> bool {
+    // First make sure that this exception is one that we actually expect to
+    // get raised by wasm code. All other exceptions we safely ignore.
+    match request.body.exception as u32 {
+        EXC_BAD_ACCESS | EXC_BAD_INSTRUCTION | EXC_ARITHMETIC => {}
+        _ => return false,
+    }
+
+    // For `EXC_BAD_ACCESS` the faulting address is listed as the "subcode" in
+    // the second `code` field. If we're ever interested in it the first code
+    // field has a `kern_return_t` describing the kind of failure (e.g. SIGSEGV
+    // vs SIGBUS), but we're not interested in that right now.
+    let faulting_addr = if request.body.exception as u32 == EXC_BAD_ACCESS {
+        Some(request.body.code[1] as usize)
+    } else {
+        None
+    };
+
+    // Depending on the current architecture various bits and pieces of this
+    // will change. This is expected to get filled out for other macos
+    // platforms as necessary.
+    //
+    // The variables this needs to define are:
+    //
+    // * `ThreadState` - a structure read via `thread_get_state` to learn about
+    //   the register state of the thread that trapped.
+    // * `thread_state_flavor` - used to read `ThreadState`
+    // * `get_pc` - a function from `&ThreadState` to a pointer to read the
+    //   current program counter, used to test if it's an address we're
+    //   catching wasm traps for.
+    // * `resume` - a function used to modify `ThreadState` to resume in the
+    //   target thread in the `unwind` function below, passing the two
+    //   parameters as the first two arguments.
+    // * `thread_state` - a fresh instance of `ThreadState` to read into
+    // * `thread_state_count` - the size to pass to `mach_msg`.
+    cfg_if::cfg_if! {
+        if #[cfg(target_arch = "x86_64")] {
+            use mach2::structs::x86_thread_state64_t;
+            use mach2::thread_status::x86_THREAD_STATE64;
+
+            type ThreadState = x86_thread_state64_t;
+
+            let thread_state_flavor = x86_THREAD_STATE64;
+
+            let get_pc_and_fp = |state: &ThreadState| (
+                state.__rip as *const u8,
+                state.__rbp as usize,
+            );
+
+            let resume = |state: &mut ThreadState, pc: usize, fp: usize, fault1: usize, fault2: usize, trap: Trap| {
+                // The x86_64 ABI requires a 16-byte stack alignment for
+                // functions, so typically we'll be 16-byte aligned. In this
+                // case we simulate a `call` instruction by decrementing the
+                // stack pointer and pushing the "return" address which in this
+                // case is the faulting address. This should help the native
+                // unwinder figure out how to find the precisely trapping
+                // function.
+                //
+                // Note, however, that if the stack is not 16-byte aligned then
+                // we don't do anything. Currently this only arises due to
+                // `ud2` in the prologue of functions when performing the
+                // initial stack check. In the old backend 0 stack manipulation
+                // happens until after the stack check passes, so if the stack
+                // check fails (hence we're running in this handler) then the
+                // stack is not 16-byte aligned due to the previous return
+                // address pushed by `call`. In this scenario we just blow away
+                // the stack frame by overwriting %rip. This technically loses
+                // the precise frame that was interrupted, but that's probably
+                // not the end of the world anyway.
+                if state.__rsp % 16 == 0 {
+                    state.__rsp -= 8;
+                    *(state.__rsp as *mut u64) = state.__rip;
+                }
+                state.__rip = unwind as u64;
+                state.__rdi = pc as u64;
+                state.__rsi = fp as u64;
+                state.__rdx = fault1 as u64;
+                state.__rcx = fault2 as u64;
+                state.__r8 = trap as u64;
+            };
+            let mut thread_state = ThreadState::new();
+        } else if #[cfg(target_arch = "aarch64")] {
+            type ThreadState = mach2::structs::arm_thread_state64_t;
+
+            let thread_state_flavor = ARM_THREAD_STATE64;
+
+            let get_pc_and_fp = |state: &ThreadState| (
+                state.__pc as *const u8,
+                state.__fp as usize,
+            );
+
+            let resume = |state: &mut ThreadState, pc: usize, fp: usize, fault1: usize, fault2: usize, trap: Trap| {
+                // Clobber LR with the faulting PC, so unwinding resumes at the
+                // faulting instruction. The previous value of LR has been saved
+                // by the callee (in Cranelift generated code), so no need to
+                // stash it.
+                state.__lr = pc as u64;
+
+                // Fill in the argument to unwind here, and set PC to it, so
+                // it looks like a call to unwind.
+                state.__x[0] = pc as u64;
+                state.__x[1] = fp as u64;
+                state.__x[2] = fault1 as u64;
+                state.__x[3] = fault2 as u64;
+                state.__x[4] = trap as u64;
+                state.__pc = unwind as u64;
+            };
+            let mut thread_state = mem::zeroed::<ThreadState>();
+        } else {
+            compile_error!("unsupported target architecture");
+        }
+    }
+
+    // First up read our origin thread's state into the area defined above.
+    let origin_thread = request.body.thread.name;
+    let mut thread_state_count = ThreadState::count();
+    let kret = thread_get_state(
+        origin_thread,
+        thread_state_flavor,
+        &mut thread_state as *mut ThreadState as *mut u32,
+        &mut thread_state_count,
+    );
+    if kret != KERN_SUCCESS {
+        return false;
+    }
+
+    // Use our global map to determine if this program counter is indeed a wasm
+    // trap, loading the `jmp_buf` to unwind to if it is.
+    //
+    // Note that this is where things are pretty tricky. We're accessing
+    // non-`Send` state (`CallThreadState`) from the exception handling thread.
+    // While typically invalid we are guaranteed that the original thread is
+    // stopped while we're accessing it here so this should be safe.
+    //
+    // Note also that we access the `state` outside the lock of `MAP`. This
+    // again is safe because if `state` is `Some` then we're guaranteed the
+    // thread is stopped and won't be removing or invalidating its state.
+    // Finally our indirection with a pointer means that we can read the
+    // pointer value and if `MAP` changes happen after we read our entry that's
+    // ok since they won't invalidate our entry.
+    let (pc, fp) = get_pc_and_fp(&thread_state);
+    let trap = match crate::runtime::vm::traphandlers::GET_WASM_TRAP(pc as usize) {
+        Some(trap) => trap,
+        None => return false,
+    };
+
+    // We have determined that this is a wasm trap and we need to actually
+    // force the thread itself to trap. The thread's register state is
+    // configured to resume in the `unwind` function below, we update the
+    // thread's register state, and then we're off to the races.
+    let (fault1, fault2) = match faulting_addr {
+        None => (0, 0),
+        Some(addr) => (1, addr),
+    };
+    resume(&mut thread_state, pc as usize, fp, fault1, fault2, trap);
+    let kret = thread_set_state(
+        origin_thread,
+        thread_state_flavor,
+        &mut thread_state as *mut ThreadState as *mut u32,
+        thread_state_count,
+    );
+    kret == KERN_SUCCESS
+}
+
+/// This is a "landing pad" which is never called directly but is directly
+/// resumed into from wasm-trapped threads.
+///
+/// This is a small shim which primarily serves the purpose of simply capturing
+/// a native backtrace once we've switched back to the thread itself. After
+/// the backtrace is captured we can do the usual `longjmp` back to the source
+/// of the wasm code.
+unsafe extern "C" fn unwind(
+    wasm_pc: *const u8,
+    wasm_fp: usize,
+    fault1: usize,
+    fault2: usize,
+    trap: u8,
+) -> ! {
+    let jmp_buf = tls::with(|state| {
+        let state = state.unwrap();
+        let faulting_addr = match fault1 {
+            0 => None,
+            _ => Some(fault2),
+        };
+        let trap = Trap::from_u8(trap).unwrap();
+        state.set_jit_trap(wasm_pc, wasm_fp, faulting_addr, trap);
+        state.take_jmp_buf()
+    });
+    debug_assert!(!jmp_buf.is_null());
+    wasmtime_longjmp(jmp_buf);
+}
+
+/// Exceptions on macOS can be delivered to either thread-level or task-level
+/// exception ports. In wasmtime we choose to send the exceptions to
+/// thread-level ports. This means that we need to, for each thread that can
+/// generate an exception, register our thread's exception port as
+/// `WASMTIME_PORT` above.
+///
+/// Note that this choice is done because at the current time if we were to
+/// implement a task-level (process-wide) port we'd have to figure out how to
+/// forward exceptions that we're not interested to the previously registered
+/// port. At this time the author isn't sure how to even do that. SpiderMonkey
+/// calls this forwarding "dark magic" as well, and since SpiderMonkey chooses
+/// thread-level ports then I hope that's good enough for wasmtime.
+///
+/// Also note that this choice of thread-level ports should be fine in that
+/// unhandled thread-level exceptions get automatically forwarded to the
+/// task-level port which is where we'd expected things like breakpad/crashpad
+/// exception handlers to get registered.
+#[cold]
+pub fn lazy_per_thread_init() {
+    unsafe {
+        assert!(
+            !CHILD_OF_FORKED_PROCESS,
+            "cannot use Wasmtime in a forked process when mach ports are \
+             configured, see `Config::macos_use_mach_ports`"
+        );
+        assert!(WASMTIME_PORT != MACH_PORT_NULL);
+        let this_thread = mach_thread_self();
+        let kret = thread_set_exception_ports(
+            this_thread,
+            EXC_MASK_BAD_ACCESS | EXC_MASK_BAD_INSTRUCTION | EXC_MASK_ARITHMETIC,
+            WASMTIME_PORT,
+            (EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES) as exception_behavior_t,
+            THREAD_STATE_NONE,
+        );
+        mach_port_deallocate(mach_task_self(), this_thread);
+        assert_eq!(kret, KERN_SUCCESS, "failed to set thread exception port");
+    }
+}

data/ext/cargo-vendor/wasmtime-21.0.1/src/runtime/vm/sys/unix/mmap.rs

@@ -0,0 +1,162 @@
+use crate::prelude::*;
+use crate::runtime::vm::SendSyncPtr;
+use anyhow::Result;
+use rustix::mm::{mprotect, MprotectFlags};
+use std::ops::Range;
+use std::ptr::{self, NonNull};
+#[cfg(feature = "std")]
+use std::{fs::File, path::Path};
+
+#[derive(Debug)]
+pub struct Mmap {
+    memory: SendSyncPtr<[u8]>,
+}
+
+impl Mmap {
+    pub fn new_empty() -> Mmap {
+        Mmap {
+            memory: SendSyncPtr::from(&mut [][..]),
+        }
+    }
+
+    pub fn new(size: usize) -> Result<Self> {
+        let ptr = unsafe {
+            rustix::mm::mmap_anonymous(
+                ptr::null_mut(),
+                size,
+                rustix::mm::ProtFlags::READ | rustix::mm::ProtFlags::WRITE,
+                rustix::mm::MapFlags::PRIVATE,
+            )
+            .err2anyhow()?
+        };
+        let memory = std::ptr::slice_from_raw_parts_mut(ptr.cast(), size);
+        let memory = SendSyncPtr::new(NonNull::new(memory).unwrap());
+        Ok(Mmap { memory })
+    }
+
+    pub fn reserve(size: usize) -> Result<Self> {
+        let ptr = unsafe {
+            rustix::mm::mmap_anonymous(
+                ptr::null_mut(),
+                size,
+                rustix::mm::ProtFlags::empty(),
+                rustix::mm::MapFlags::PRIVATE,
+            )
+            .err2anyhow()?
+        };
+
+        let memory = std::ptr::slice_from_raw_parts_mut(ptr.cast(), size);
+        let memory = SendSyncPtr::new(NonNull::new(memory).unwrap());
+        Ok(Mmap { memory })
+    }
+
+    #[cfg(feature = "std")]
+    pub fn from_file(path: &Path) -> Result<(Self, File)> {
+        use anyhow::Context;
+
+        let file = File::open(path)
+            .err2anyhow()
+            .context("failed to open file")?;
+        let len = file
+            .metadata()
+            .err2anyhow()
+            .context("failed to get file metadata")?
+            .len();
+        let len = usize::try_from(len).map_err(|_| anyhow::anyhow!("file too large to map"))?;
+        let ptr = unsafe {
+            rustix::mm::mmap(
+                ptr::null_mut(),
+                len,
+                rustix::mm::ProtFlags::READ | rustix::mm::ProtFlags::WRITE,
+                rustix::mm::MapFlags::PRIVATE,
+                &file,
+                0,
+            )
+            .err2anyhow()
+            .context(format!("mmap failed to allocate {:#x} bytes", len))?
+        };
+        let memory = std::ptr::slice_from_raw_parts_mut(ptr.cast(), len);
+        let memory = SendSyncPtr::new(NonNull::new(memory).unwrap());
+
+        Ok((Mmap { memory }, file))
+    }
+
+    pub fn make_accessible(&mut self, start: usize, len: usize) -> Result<()> {
+        let ptr = self.memory.as_ptr();
+        unsafe {
+            mprotect(
+                ptr.byte_add(start).cast(),
+                len,
+                MprotectFlags::READ | MprotectFlags::WRITE,
+            )
+            .err2anyhow()?;
+        }
+
+        Ok(())
+    }
+
+    #[inline]
+    pub fn as_ptr(&self) -> *const u8 {
+        self.memory.as_ptr() as *const u8
+    }
+
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut u8 {
+        self.memory.as_ptr().cast()
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        unsafe { (*self.memory.as_ptr()).len() }
+    }
+
+    pub unsafe fn make_executable(
+        &self,
+        range: Range<usize>,
+        enable_branch_protection: bool,
+    ) -> Result<()> {
+        let base = self.memory.as_ptr().byte_add(range.start).cast();
+        let len = range.end - range.start;
+
+        let flags = MprotectFlags::READ | MprotectFlags::EXEC;
+        let flags = if enable_branch_protection {
+            #[cfg(all(target_arch = "aarch64", target_os = "linux"))]
+            if std::arch::is_aarch64_feature_detected!("bti") {
+                MprotectFlags::from_bits_retain(flags.bits() | /* PROT_BTI */ 0x10)
+            } else {
+                flags
+            }
+
+            #[cfg(not(all(target_arch = "aarch64", target_os = "linux")))]
+            flags
+        } else {
+            flags
+        };
+
+        mprotect(base, len, flags).err2anyhow()?;
+
+        Ok(())
+    }
+
+    pub unsafe fn make_readonly(&self, range: Range<usize>) -> Result<()> {
+        let base = self.memory.as_ptr().byte_add(range.start).cast();
+        let len = range.end - range.start;
+
+        mprotect(base, len, MprotectFlags::READ).err2anyhow()?;
+
+        Ok(())
+    }
+}
+
+impl Drop for Mmap {
+    fn drop(&mut self) {
+        unsafe {
+            let ptr = self.memory.as_ptr().cast();
+            let len = (*self.memory.as_ptr()).len();
+            if len == 0 {
+                return;
+            }
+            rustix::mm::munmap(ptr, len).expect("munmap failed");
+        }
+    }
+}

data/ext/cargo-vendor/wasmtime-21.0.1/src/runtime/vm/sys/unix/mod.rs

@@ -0,0 +1,35 @@
+//! Implementation of Wasmtime's system primitives for Unix-like operating
+//! systems.
+//!
+//! This module handles Linux and macOS for example.
+
+use core::cell::Cell;
+
+pub mod mmap;
+pub mod unwind;
+pub mod vm;
+
+pub mod signals;
+
+cfg_if::cfg_if! {
+    if #[cfg(target_os = "macos")] {
+        pub mod machports;
+
+        pub mod macos_traphandlers;
+        pub use macos_traphandlers as traphandlers;
+    } else {
+        pub use signals as traphandlers;
+    }
+}
+
+std::thread_local!(static TLS: Cell<*mut u8> = const { Cell::new(std::ptr::null_mut()) });
+
+#[inline]
+pub fn tls_get() -> *mut u8 {
+    TLS.with(|p| p.get())
+}
+
+#[inline]
+pub fn tls_set(ptr: *mut u8) {
+    TLS.with(|p| p.set(ptr));
+}