wasmtime 15.0.1 → 16.0.0

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

@@ -0,0 +1,208 @@
+use rustix::fd::AsRawFd;
+use rustix::mm::{mmap, mmap_anonymous, mprotect, MapFlags, MprotectFlags, ProtFlags};
+use std::fs::File;
+use std::io;
+use std::sync::Arc;
+
+pub unsafe fn expose_existing_mapping(ptr: *mut u8, len: usize) -> io::Result<()> {
+    mprotect(ptr.cast(), len, MprotectFlags::READ | MprotectFlags::WRITE)?;
+    Ok(())
+}
+
+pub unsafe fn hide_existing_mapping(ptr: *mut u8, len: usize) -> io::Result<()> {
+    mprotect(ptr.cast(), len, MprotectFlags::empty())?;
+    Ok(())
+}
+
+pub unsafe fn erase_existing_mapping(ptr: *mut u8, len: usize) -> io::Result<()> {
+    let ret = mmap_anonymous(
+        ptr.cast(),
+        len,
+        ProtFlags::empty(),
+        MapFlags::PRIVATE | MapFlags::FIXED,
+    )?;
+    assert_eq!(ptr, ret.cast());
+    Ok(())
+}
+
+#[cfg(feature = "pooling-allocator")]
+unsafe fn decommit(addr: *mut u8, len: usize) -> io::Result<()> {
+    if len == 0 {
+        return Ok(());
+    }
+
+    unsafe {
+        cfg_if::cfg_if! {
+            if #[cfg(target_os = "linux")] {
+                use rustix::mm::{madvise, Advice};
+
+                // On Linux, this is enough to cause the kernel to initialize
+                // the pages to 0 on next access
+                madvise(addr as _, len, Advice::LinuxDontNeed)?;
+            } else {
+                // By creating a new mapping at the same location, this will
+                // discard the mapping for the pages in the given range.
+                // The new mapping will be to the CoW zero page, so this
+                // effectively zeroes the pages.
+                mmap_anonymous(
+                    addr as _,
+                    len,
+                    ProtFlags::READ | ProtFlags::WRITE,
+                    MapFlags::PRIVATE | MapFlags::FIXED,
+                )?;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(feature = "pooling-allocator")]
+pub unsafe fn commit_table_pages(_addr: *mut u8, _len: usize) -> io::Result<()> {
+    // Table pages are always READ | WRITE so there's nothing that needs to be
+    // done here.
+    Ok(())
+}
+
+#[cfg(feature = "pooling-allocator")]
+pub unsafe fn decommit_table_pages(addr: *mut u8, len: usize) -> io::Result<()> {
+    decommit(addr, len)
+}
+
+#[cfg(all(feature = "pooling-allocator", feature = "async"))]
+pub unsafe fn commit_stack_pages(_addr: *mut u8, _len: usize) -> io::Result<()> {
+    // Like table pages stack pages are always READ | WRITE so nothing extra
+    // needs to be done to ensure they can be committed.
+    Ok(())
+}
+
+#[cfg(all(feature = "pooling-allocator", feature = "async"))]
+pub unsafe fn reset_stack_pages_to_zero(addr: *mut u8, len: usize) -> io::Result<()> {
+    decommit(addr, len)
+}
+
+pub fn get_page_size() -> usize {
+    unsafe { libc::sysconf(libc::_SC_PAGESIZE).try_into().unwrap() }
+}
+
+pub fn supports_madvise_dontneed() -> bool {
+    cfg!(target_os = "linux")
+}
+
+pub unsafe fn madvise_dontneed(ptr: *mut u8, len: usize) -> io::Result<()> {
+    cfg_if::cfg_if! {
+        if #[cfg(target_os = "linux")] {
+            rustix::mm::madvise(ptr.cast(), len, rustix::mm::Advice::LinuxDontNeed)?;
+            Ok(())
+        } else {
+            let _ = (ptr, len);
+            unreachable!();
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum MemoryImageSource {
+    Mmap(Arc<File>),
+    #[cfg(target_os = "linux")]
+    Memfd(memfd::Memfd),
+}
+
+impl MemoryImageSource {
+    pub fn from_file(file: &Arc<File>) -> Option<MemoryImageSource> {
+        Some(MemoryImageSource::Mmap(file.clone()))
+    }
+
+    #[cfg(not(target_os = "linux"))]
+    pub fn from_data(_data: &[u8]) -> io::Result<Option<MemoryImageSource>> {
+        Ok(None)
+    }
+
+    #[cfg(target_os = "linux")]
+    pub fn from_data(data: &[u8]) -> anyhow::Result<Option<MemoryImageSource>> {
+        // On Linux `memfd_create` is used to create an anonymous
+        // in-memory file to represent the heap image. This anonymous
+        // file is then used as the basis for further mmaps.
+
+        use std::io::{ErrorKind, Write};
+
+        // Create the memfd. It needs a name, but the documentation for
+        // `memfd_create()` says that names can be duplicated with no issues.
+        let memfd = match memfd::MemfdOptions::new()
+            .allow_sealing(true)
+            .create("wasm-memory-image")
+        {
+            Ok(memfd) => memfd,
+            // If this kernel is old enough to not support memfd then attempt to
+            // gracefully handle that and fall back to skipping the memfd
+            // optimization.
+            Err(memfd::Error::Create(err)) if err.kind() == ErrorKind::Unsupported => {
+                return Ok(None)
+            }
+            Err(e) => return Err(e.into()),
+        };
+        memfd.as_file().write_all(data)?;
+
+        // Seal the memfd's data and length.
+        //
+        // This is a defense-in-depth security mitigation. The
+        // memfd will serve as the starting point for the heap of
+        // every instance of this module. If anything were to
+        // write to this, it could affect every execution. The
+        // memfd object itself is owned by the machinery here and
+        // not exposed elsewhere, but it is still an ambient open
+        // file descriptor at the syscall level, so some other
+        // vulnerability that allowed writes to arbitrary fds
+        // could modify it. Or we could have some issue with the
+        // way that we map it into each instance. To be
+        // extra-super-sure that it never changes, and because
+        // this costs very little, we use the kernel's "seal" API
+        // to make the memfd image permanently read-only.
+        memfd.add_seals(&[
+            memfd::FileSeal::SealGrow,
+            memfd::FileSeal::SealShrink,
+            memfd::FileSeal::SealWrite,
+            memfd::FileSeal::SealSeal,
+        ])?;
+
+        Ok(Some(MemoryImageSource::Memfd(memfd)))
+    }
+
+    fn as_file(&self) -> &File {
+        match self {
+            MemoryImageSource::Mmap(file) => file,
+            #[cfg(target_os = "linux")]
+            MemoryImageSource::Memfd(memfd) => memfd.as_file(),
+        }
+    }
+
+    pub unsafe fn map_at(&self, base: *mut u8, len: usize, offset: u64) -> io::Result<()> {
+        let ptr = mmap(
+            base.cast(),
+            len,
+            ProtFlags::READ | ProtFlags::WRITE,
+            MapFlags::PRIVATE | MapFlags::FIXED,
+            self.as_file(),
+            offset,
+        )?;
+        assert_eq!(base, ptr.cast());
+        Ok(())
+    }
+
+    pub unsafe fn remap_as_zeros_at(&self, base: *mut u8, len: usize) -> io::Result<()> {
+        let ptr = mmap_anonymous(
+            base.cast(),
+            len,
+            ProtFlags::READ | ProtFlags::WRITE,
+            MapFlags::PRIVATE | MapFlags::FIXED,
+        )?;
+        assert_eq!(base, ptr.cast());
+        Ok(())
+    }
+}
+
+impl PartialEq for MemoryImageSource {
+    fn eq(&self, other: &MemoryImageSource) -> bool {
+        self.as_file().as_raw_fd() == other.as_file().as_raw_fd()
+    }
+}

data/ext/cargo-vendor/wasmtime-runtime-16.0.0/src/sys/windows/mod.rs

@@ -0,0 +1,6 @@
+//! Implementation of Wasmtime's system primitives for Windows.
+
+pub mod mmap;
+pub mod traphandlers;
+pub mod unwind;
+pub mod vm;

data/ext/cargo-vendor/wasmtime-runtime-16.0.0/src/sys/windows/traphandlers.rs

@@ -0,0 +1,105 @@
+use crate::traphandlers::tls;
+use crate::VMContext;
+use std::io;
+use windows_sys::Win32::Foundation::*;
+use windows_sys::Win32::System::Diagnostics::Debug::*;
+use windows_sys::Win32::System::Kernel::*;
+
+#[link(name = "wasmtime-helpers")]
+extern "C" {
+    #[wasmtime_versioned_export_macros::versioned_link]
+    #[allow(improper_ctypes)]
+    pub fn wasmtime_setjmp(
+        jmp_buf: *mut *const u8,
+        callback: extern "C" fn(*mut u8, *mut VMContext),
+        payload: *mut u8,
+        callee: *mut VMContext,
+    ) -> i32;
+
+    #[wasmtime_versioned_export_macros::versioned_link]
+    pub fn wasmtime_longjmp(jmp_buf: *const u8) -> !;
+}
+
+/// Function which may handle custom signals while processing traps.
+pub type SignalHandler<'a> = dyn Fn(*mut EXCEPTION_POINTERS) -> bool + Send + Sync + 'a;
+
+pub unsafe fn platform_init(_macos_use_mach_ports: bool) {
+    // our trap handler needs to go first, so that we can recover from
+    // wasm faults and continue execution, so pass `1` as a true value
+    // here.
+    if AddVectoredExceptionHandler(1, Some(exception_handler)).is_null() {
+        panic!(
+            "failed to add exception handler: {}",
+            io::Error::last_os_error()
+        );
+    }
+}
+
+unsafe extern "system" fn exception_handler(exception_info: *mut EXCEPTION_POINTERS) -> i32 {
+    // Check the kind of exception, since we only handle a subset within
+    // wasm code. If anything else happens we want to defer to whatever
+    // the rest of the system wants to do for this exception.
+    let record = &*(*exception_info).ExceptionRecord;
+    if record.ExceptionCode != EXCEPTION_ACCESS_VIOLATION
+        && record.ExceptionCode != EXCEPTION_ILLEGAL_INSTRUCTION
+        && record.ExceptionCode != EXCEPTION_INT_DIVIDE_BY_ZERO
+        && record.ExceptionCode != EXCEPTION_INT_OVERFLOW
+    {
+        return ExceptionContinueSearch;
+    }
+
+    // FIXME: this is what the previous C++ did to make sure that TLS
+    // works by the time we execute this trap handling code. This isn't
+    // exactly super easy to call from Rust though and it's not clear we
+    // necessarily need to do so. Leaving this here in case we need this
+    // in the future, but for now we can probably wait until we see a
+    // strange fault before figuring out how to reimplement this in
+    // Rust.
+    //
+    // if (!NtCurrentTeb()->Reserved1[sThreadLocalArrayPointerIndex]) {
+    //     return ExceptionContinueSearch;
+    // }
+
+    // This is basically the same as the unix version above, only with a
+    // few parameters tweaked here and there.
+    tls::with(|info| {
+        let info = match info {
+            Some(info) => info,
+            None => return ExceptionContinueSearch,
+        };
+        cfg_if::cfg_if! {
+            if #[cfg(target_arch = "x86_64")] {
+                let ip = (*(*exception_info).ContextRecord).Rip as *const u8;
+                let fp = (*(*exception_info).ContextRecord).Rbp as usize;
+            } else if #[cfg(target_arch = "aarch64")] {
+                let ip = (*(*exception_info).ContextRecord).Pc as *const u8;
+                let fp = (*(*exception_info).ContextRecord).Anonymous.Anonymous.Fp as usize;
+            } else {
+                compile_error!("unsupported platform");
+            }
+        }
+        // For access violations the first element in `ExceptionInformation` is
+        // an indicator as to whether the fault was a read/write. The second
+        // element is the address of the inaccessible data causing this
+        // violation.
+        let faulting_addr = if record.ExceptionCode == EXCEPTION_ACCESS_VIOLATION {
+            assert!(record.NumberParameters >= 2);
+            Some(record.ExceptionInformation[1])
+        } else {
+            None
+        };
+        let jmp_buf = info.take_jmp_buf_if_trap(ip, |handler| handler(exception_info));
+        if jmp_buf.is_null() {
+            ExceptionContinueSearch
+        } else if jmp_buf as usize == 1 {
+            ExceptionContinueExecution
+        } else {
+            info.set_jit_trap(ip, fp, faulting_addr);
+            wasmtime_longjmp(jmp_buf)
+        }
+    })
+}
+
+pub fn lazy_per_thread_init() {
+    // Unused on Windows
+}

data/ext/cargo-vendor/wasmtime-runtime-16.0.0/src/sys/windows/unwind.rs

@@ -0,0 +1,46 @@
+//! Module for Windows x64 ABI unwind registry.
+
+use anyhow::{bail, Result};
+use std::mem;
+use windows_sys::Win32::System::Diagnostics::Debug::*;
+
+/// Represents a registry of function unwind information for Windows x64 ABI.
+pub struct UnwindRegistration {
+    functions: usize,
+}
+
+impl UnwindRegistration {
+    #[allow(missing_docs)]
+    pub const SECTION_NAME: &'static str = ".pdata";
+
+    #[allow(missing_docs)]
+    pub unsafe fn new(
+        base_address: *const u8,
+        unwind_info: *const u8,
+        unwind_len: usize,
+    ) -> Result<UnwindRegistration> {
+        assert!(unwind_info as usize % 4 == 0);
+        let unit_len = mem::size_of::<IMAGE_RUNTIME_FUNCTION_ENTRY>();
+        assert!(unwind_len % unit_len == 0);
+        if RtlAddFunctionTable(
+            unwind_info as *mut _,
+            (unwind_len / unit_len) as u32,
+            base_address as _,
+        ) == 0
+        {
+            bail!("failed to register function table");
+        }
+
+        Ok(UnwindRegistration {
+            functions: unwind_info as usize,
+        })
+    }
+}
+
+impl Drop for UnwindRegistration {
+    fn drop(&mut self) {
+        unsafe {
+            RtlDeleteFunctionTable(self.functions as _);
+        }
+    }
+}

data/ext/cargo-vendor/wasmtime-runtime-16.0.0/src/sys/windows/vm.rs

@@ -0,0 +1,79 @@
+use std::fs::File;
+use std::io;
+use std::mem::MaybeUninit;
+use std::sync::Arc;
+use windows_sys::Win32::System::Memory::*;
+use windows_sys::Win32::System::SystemInformation::*;
+
+pub unsafe fn expose_existing_mapping(ptr: *mut u8, len: usize) -> io::Result<()> {
+    if len == 0 {
+        return Ok(());
+    }
+    if VirtualAlloc(ptr.cast(), len, MEM_COMMIT, PAGE_READWRITE).is_null() {
+        Err(std::io::Error::last_os_error())
+    } else {
+        Ok(())
+    }
+}
+
+pub unsafe fn hide_existing_mapping(ptr: *mut u8, len: usize) -> io::Result<()> {
+    erase_existing_mapping(ptr, len)
+}
+
+pub unsafe fn erase_existing_mapping(ptr: *mut u8, len: usize) -> io::Result<()> {
+    if len == 0 {
+        return Ok(());
+    }
+    if VirtualFree(ptr.cast(), len, MEM_DECOMMIT) == 0 {
+        Err(std::io::Error::last_os_error())
+    } else {
+        Ok(())
+    }
+}
+
+#[cfg(feature = "pooling-allocator")]
+pub unsafe fn commit_table_pages(addr: *mut u8, len: usize) -> io::Result<()> {
+    expose_existing_mapping(addr, len)
+}
+
+#[cfg(feature = "pooling-allocator")]
+pub unsafe fn decommit_table_pages(addr: *mut u8, len: usize) -> io::Result<()> {
+    erase_existing_mapping(addr, len)
+}
+
+pub fn get_page_size() -> usize {
+    unsafe {
+        let mut info = MaybeUninit::uninit();
+        GetSystemInfo(info.as_mut_ptr());
+        info.assume_init_ref().dwPageSize as usize
+    }
+}
+
+pub fn supports_madvise_dontneed() -> bool {
+    false
+}
+
+pub unsafe fn madvise_dontneed(_ptr: *mut u8, _len: usize) -> io::Result<()> {
+    unreachable!()
+}
+
+#[derive(PartialEq, Debug)]
+pub enum MemoryImageSource {}
+
+impl MemoryImageSource {
+    pub fn from_file(_file: &Arc<File>) -> Option<MemoryImageSource> {
+        None
+    }
+
+    pub fn from_data(_data: &[u8]) -> io::Result<Option<MemoryImageSource>> {
+        Ok(None)
+    }
+
+    pub unsafe fn map_at(&self, _base: *mut u8, _len: usize, _offset: u64) -> io::Result<()> {
+        match *self {}
+    }
+
+    pub unsafe fn remap_as_zeros_at(&self, _base: *mut u8, _len: usize) -> io::Result<()> {
+        match *self {}
+    }
+}