wasmtime 20.0.2 → 21.0.1

data/ext/cargo-vendor/wasmtime-runtime-20.0.2/src/mpk/mod.rs

@@ -1,54 +0,0 @@
-//! Memory Protection Keys (MPK) implementation for use in striped memory
-//! allocation.
-//!
-//! MPK is an x86 feature available on relatively recent versions of Intel and
-//! AMD CPUs. In Linux, this feature is named `pku` (protection keys userspace)
-//! and consists of three new system calls: `pkey_alloc`, `pkey_free`, and
-//! `pkey_mprotect` (see the [Linux documentation]). This crate provides an
-//! abstraction, [`ProtectionKey`], that the [pooling allocator] applies to
-//! contiguous memory allocations, allowing it to avoid guard pages in some
-//! cases and more efficiently use memory. This technique was first presented in
-//! a 2022 paper: [Segue and ColorGuard: Optimizing SFI Performance and
-//! Scalability on Modern x86][colorguard].
-//!
-//! [pooling allocator]: crate::PoolingInstanceAllocator
-//! [Linux documentation]:
-//!     https://www.kernel.org/doc/html/latest/core-api/protection-keys.html
-//! [colorguard]: https://plas2022.github.io/files/pdf/SegueColorGuard.pdf
-//!
-//! On x86_64 Linux systems, this module implements the various parts necessary
-//! to use MPK in Wasmtime:
-//! - [`is_supported`] indicates whether the feature is available at runtime
-//! - [`ProtectionKey`] provides access to the kernel-allocated protection keys
-//!   (see [`keys`])
-//! - [`allow`] sets the CPU state to prevent access to regions outside the
-//!   [`ProtectionMask`]
-//! - the `sys` module bridges the gap to Linux's `pkey_*` system calls
-//! - the `pkru` module controls the x86 `PKRU` register (and other CPU state)
-//!
-//! On any other kind of machine, this module exposes noop implementations of
-//! the public interface.
-
-cfg_if::cfg_if! {
-    if #[cfg(all(target_arch = "x86_64", target_os = "linux", not(miri)))] {
-        mod enabled;
-        mod pkru;
-        mod sys;
-        pub use enabled::{allow, current_mask, is_supported, keys, ProtectionKey, ProtectionMask};
-    } else {
-        mod disabled;
-        pub use disabled::{allow, current_mask, is_supported, keys, ProtectionKey, ProtectionMask};
-    }
-}
-
-/// Describe the tri-state configuration of memory protection keys (MPK).
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
-pub enum MpkEnabled {
-    /// Use MPK if supported by the current system; fall back to guard regions
-    /// otherwise.
-    Auto,
-    /// Use MPK or fail if not supported.
-    Enable,
-    /// Do not use MPK.
-    Disable,
-}

data/ext/cargo-vendor/wasmtime-runtime-20.0.2/src/mpk/pkru.rs

@@ -1,104 +0,0 @@
-//! Control access to the x86 `PKRU` register.
-//!
-//! As documented in the Intel Software Development Manual, vol 3a, section 2.7,
-//! the 32 bits of the `PKRU` register laid out as follows (note the
-//! little-endianness):
-//!
-//! ```text
-//! ┌───┬───┬───┬───┬───┬───┐
-//! │...│AD2│WD1│AD1│WD0│AD0│
-//! └───┴───┴───┴───┴───┴───┘
-//! ```
-//!
-//! - `ADn = 1` means "access disable key `n`"--no reads or writes allowed to
-//!   pages marked with key `n`.
-//! - `WDn = 1` means "write disable key `n`"--only reads are prevented to pages
-//!   marked with key `n`
-//! - it is unclear what it means to have both `ADn` and `WDn` set
-//!
-//! Note that this only handles the user-mode `PKRU` register; there is an
-//! equivalent supervisor-mode MSR, `IA32_PKRS`.
-
-use core::arch::asm;
-
-/// This `PKRU` register mask allows access to any pages marked with any
-/// key--in other words, reading and writing is permitted to all pages.
-pub const ALLOW_ACCESS: u32 = 0;
-
-/// This `PKRU` register mask disables access to any page marked with any
-/// key--in other words, no reading or writing to all pages.
-pub const DISABLE_ACCESS: u32 = 0b11111111_11111111_11111111_11111111;
-
-/// Read the value of the `PKRU` register.
-#[inline]
-pub fn read() -> u32 {
-    // ECX must be 0 to prevent a general protection exception (#GP).
-    let ecx: u32 = 0;
-    let pkru: u32;
-    unsafe {
-        asm!("rdpkru", in("ecx") ecx, out("eax") pkru, out("edx") _,
-            options(nomem, nostack, preserves_flags));
-    }
-    return pkru;
-}
-
-/// Write a value to the `PKRU` register.
-#[inline]
-pub fn write(pkru: u32) {
-    // Both ECX and EDX must be 0 to prevent a general protection exception
-    // (#GP).
-    let ecx: u32 = 0;
-    let edx: u32 = 0;
-    unsafe {
-        asm!("wrpkru", in("eax") pkru, in("ecx") ecx, in("edx") edx,
-            options(nomem, nostack, preserves_flags));
-    }
-}
-
-/// Check the `ECX.PKU` flag (bit 3, zero-based) of the `07h` `CPUID` leaf; see
-/// the Intel Software Development Manual, vol 3a, section 2.7. This flag is
-/// only set on Intel CPUs, so this function also checks the `CPUID` vendor
-/// string.
-pub fn has_cpuid_bit_set() -> bool {
-    let result = unsafe { std::arch::x86_64::__cpuid(0x07) };
-    is_intel_cpu() && (result.ecx & 0b1000) != 0
-}
-
-/// Check the `CPUID` vendor string for `GenuineIntel`; see the Intel Software
-/// Development Manual, vol 2a, `CPUID` description.
-pub fn is_intel_cpu() -> bool {
-    // To read the CPU vendor string, we pass 0 in EAX and read 12 ASCII bytes
-    // from EBX, EDX, and ECX (in that order).
-    let result = unsafe { std::arch::x86_64::__cpuid(0) };
-    // Then we check if the vendor string matches "GenuineIntel".
-    result.ebx == u32::from_le_bytes(*b"Genu")
-        && result.edx == u32::from_le_bytes(*b"ineI")
-        && result.ecx == u32::from_le_bytes(*b"ntel")
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::mpk::enabled::skip_if_mpk_unavailable;
-
-    #[test]
-    #[ignore = "cannot be run with other tests that munge the PKRU register"]
-    fn check_read() {
-        skip_if_mpk_unavailable!();
-        assert_eq!(read(), DISABLE_ACCESS ^ 1);
-        // By default, the Linux kernel only allows a process to access key 0,
-        // the default kernel key.
-    }
-
-    #[test]
-    fn check_roundtrip() {
-        skip_if_mpk_unavailable!();
-        let pkru = read();
-        // Allow access to pages marked with any key.
-        write(ALLOW_ACCESS);
-        assert_eq!(read(), ALLOW_ACCESS);
-        // Restore the original value.
-        write(pkru);
-        assert_eq!(read(), pkru);
-    }
-}

data/ext/cargo-vendor/wasmtime-runtime-20.0.2/src/mpk/sys.rs

@@ -1,113 +0,0 @@
-//! Expose the `pkey_*` Linux system calls. See the kernel documentation for
-//! more information:
-//! - [`pkeys`] overview
-//! - [`pkey_alloc`] (with `pkey_free`)
-//! - [`pkey_mprotect`]
-//! - `pkey_set` is implemented directly in assembly.
-//!
-//! [`pkey_alloc`]: https://man7.org/linux/man-pages/man2/pkey_alloc.2.html
-//! [`pkey_mprotect`]: https://man7.org/linux/man-pages/man2/pkey_mprotect.2.html
-//! [`pkeys`]: https://man7.org/linux/man-pages/man7/pkeys.7.html
-
-use crate::page_size;
-use anyhow::Result;
-use std::io::Error;
-
-/// Protection mask disallowing reads and writes of pkey-protected memory (see
-/// `prot` in [`pkey_mprotect`]); in Wasmtime we expect all MPK-protected memory
-/// to start as `PROT_NONE`.
-pub const PROT_NONE: u32 = libc::PROT_NONE as u32; // == 0b0000;
-
-/// Allocate a new protection key in the Linux kernel ([docs]); returns the
-/// key ID.
-///
-/// [docs]: https://man7.org/linux/man-pages/man2/pkey_alloc.2.html
-///
-/// Each process has its own separate pkey index; e.g., if process `m`
-/// allocates key 1, process `n` can as well.
-pub fn pkey_alloc(flags: u32, access_rights: u32) -> Result<u32> {
-    assert_eq!(flags, 0); // reserved for future use--must be 0.
-    let result = unsafe { libc::syscall(libc::SYS_pkey_alloc, flags, access_rights) };
-    if result >= 0 {
-        Ok(result
-            .try_into()
-            .expect("only pkey IDs between 0 and 15 are expected"))
-    } else {
-        debug_assert_eq!(result, -1); // only this error result is expected.
-        Err(Error::last_os_error().into())
-    }
-}
-
-/// Free a kernel protection key ([docs]).
-///
-/// [docs]: https://man7.org/linux/man-pages/man2/pkey_alloc.2.html
-#[allow(dead_code)]
-pub fn pkey_free(key: u32) -> Result<()> {
-    let result = unsafe { libc::syscall(libc::SYS_pkey_free, key) };
-    if result == 0 {
-        Ok(())
-    } else {
-        debug_assert_eq!(result, -1); // only this error result is expected.
-        Err(Error::last_os_error().into())
-    }
-}
-
-/// Change the access protections for a page-aligned memory region ([docs]).
-///
-/// [docs]: https://man7.org/linux/man-pages/man2/pkey_mprotect.2.html
-pub fn pkey_mprotect(addr: usize, len: usize, prot: u32, key: u32) -> Result<()> {
-    let page_size = page_size();
-    if addr % page_size != 0 {
-        log::warn!(
-            "memory must be page-aligned for MPK (addr = {addr:#x}, page size = {page_size}"
-        );
-    }
-    let result = unsafe { libc::syscall(libc::SYS_pkey_mprotect, addr, len, prot, key) };
-    if result == 0 {
-        Ok(())
-    } else {
-        debug_assert_eq!(result, -1); // only this error result is expected.
-        Err(Error::last_os_error().into())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[ignore = "cannot be run when keys() has already allocated all keys"]
-    #[test]
-    fn check_allocate_and_free() {
-        let key = pkey_alloc(0, 0).unwrap();
-        assert_eq!(key, 1);
-        // It may seem strange to assert the key ID here, but we already
-        // make some assumptions:
-        //  1. we are running on Linux with `pku` enabled
-        //  2. Linux will allocate key 0 for itself
-        //  3. we are running this test in non-MPK mode and no one else is
-        //     using pkeys
-        // If these assumptions are incorrect, this test can be removed.
-        pkey_free(key).unwrap()
-    }
-
-    #[test]
-    fn check_invalid_free() {
-        let result = pkey_free(42);
-        assert!(result.is_err());
-        assert_eq!(
-            result.unwrap_err().to_string(),
-            "Invalid argument (os error 22)"
-        );
-    }
-
-    #[test]
-    #[should_panic]
-    fn check_invalid_alloc_flags() {
-        let _ = pkey_alloc(42, 0);
-    }
-
-    #[test]
-    fn check_invalid_alloc_rights() {
-        assert!(pkey_alloc(0, 42).is_err());
-    }
-}

data/ext/cargo-vendor/wasmtime-runtime-20.0.2/src/send_sync_ptr.rs

@@ -1,106 +0,0 @@
-use std::fmt;
-use std::hash::Hash;
-use std::ptr::NonNull;
-
-/// A helper type in Wasmtime to store a raw pointer to `T` while automatically
-/// inferring the `Send` and `Sync` traits for the container based on the
-/// properties of `T`.
-#[repr(transparent)]
-pub struct SendSyncPtr<T: ?Sized>(NonNull<T>);
-
-unsafe impl<T: Send + ?Sized> Send for SendSyncPtr<T> {}
-unsafe impl<T: Sync + ?Sized> Sync for SendSyncPtr<T> {}
-
-impl<T: ?Sized> SendSyncPtr<T> {
-    /// Creates a new pointer wrapping the non-nullable pointer provided.
-    #[inline]
-    pub fn new(ptr: NonNull<T>) -> SendSyncPtr<T> {
-        SendSyncPtr(ptr)
-    }
-
-    /// Returns the underlying raw pointer.
-    #[inline]
-    pub fn as_ptr(&self) -> *mut T {
-        self.0.as_ptr()
-    }
-
-    /// Unsafely assert that this is a pointer to valid contents and it's also
-    /// valid to get a shared reference to it at this time.
-    #[inline]
-    pub unsafe fn as_ref<'a>(&self) -> &'a T {
-        self.0.as_ref()
-    }
-
-    /// Unsafely assert that this is a pointer to valid contents and it's also
-    /// valid to get a mutable reference to it at this time.
-    #[inline]
-    pub unsafe fn as_mut<'a>(&mut self) -> &'a mut T {
-        self.0.as_mut()
-    }
-
-    /// Returns the underlying `NonNull<T>` wrapper.
-    #[inline]
-    pub fn as_non_null(&self) -> NonNull<T> {
-        self.0
-    }
-
-    /// Cast this to a pointer to a `U`.
-    #[inline]
-    pub fn cast<U>(&self) -> SendSyncPtr<U> {
-        SendSyncPtr(self.0.cast::<U>())
-    }
-}
-
-impl<T> SendSyncPtr<[T]> {
-    /// Returns the slice's length component of the pointer.
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-}
-
-impl<T: ?Sized, U> From<U> for SendSyncPtr<T>
-where
-    U: Into<NonNull<T>>,
-{
-    #[inline]
-    fn from(ptr: U) -> SendSyncPtr<T> {
-        SendSyncPtr::new(ptr.into())
-    }
-}
-
-impl<T: ?Sized> fmt::Debug for SendSyncPtr<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.as_ptr().fmt(f)
-    }
-}
-
-impl<T: ?Sized> fmt::Pointer for SendSyncPtr<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.as_ptr().fmt(f)
-    }
-}
-
-impl<T: ?Sized> Clone for SendSyncPtr<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-impl<T: ?Sized> Copy for SendSyncPtr<T> {}
-
-impl<T: ?Sized> PartialEq for SendSyncPtr<T> {
-    #[inline]
-    fn eq(&self, other: &SendSyncPtr<T>) -> bool {
-        self.0 == other.0
-    }
-}
-
-impl<T: ?Sized> Eq for SendSyncPtr<T> {}
-
-impl<T: ?Sized> Hash for SendSyncPtr<T> {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.as_ptr().hash(state);
-    }
-}

data/ext/cargo-vendor/wasmtime-runtime-20.0.2/src/store_box.rs

@@ -1,35 +0,0 @@
-/// A `Box<T>` lookalike for memory that's stored in a `Store<T>`
-///
-/// This is intended to be quite similar to a `Box<T>` except without the
-/// `Deref` implementations. The main motivation for this type's existence is to
-/// appease the aliasing rules in miri to ensure that `StoreBox` can be moved
-/// around without invalidating pointers to the contents within the box. The
-/// standard `Box<T>` type does not implement this for example and moving that
-/// will invalidate derived pointers.
-pub struct StoreBox<T: ?Sized>(*mut T);
-
-unsafe impl<T: Send + ?Sized> Send for StoreBox<T> {}
-unsafe impl<T: Sync + ?Sized> Sync for StoreBox<T> {}
-
-impl<T> StoreBox<T> {
-    /// Allocates space on the heap to store `val` and returns a pointer to it
-    /// living on the heap.
-    pub fn new(val: T) -> StoreBox<T> {
-        StoreBox(Box::into_raw(Box::new(val)))
-    }
-}
-
-impl<T: ?Sized> StoreBox<T> {
-    /// Returns the underlying pointer to `T` which is owned by the store.
-    pub fn get(&self) -> *mut T {
-        self.0
-    }
-}
-
-impl<T: ?Sized> Drop for StoreBox<T> {
-    fn drop(&mut self) {
-        unsafe {
-            drop(Box::from_raw(self.0));
-        }
-    }
-}

data/ext/cargo-vendor/wasmtime-runtime-20.0.2/src/sys/custom/capi.rs

@@ -1,189 +0,0 @@
-#![allow(non_camel_case_types)]
-
-// Flags to either `wasmtime_mmap_{new,remap}` or `wasmtime_mprotect`.
-
-/// Indicates that the memory region should be readable.
-pub const WASMTIME_PROT_READ: u32 = 1 << 0;
-/// Indicates that the memory region should be writable.
-pub const WASMTIME_PROT_WRITE: u32 = 1 << 1;
-/// Indicates that the memory region should be executable.
-pub const WASMTIME_PROT_EXEC: u32 = 1 << 2;
-
-pub use WASMTIME_PROT_EXEC as PROT_EXEC;
-pub use WASMTIME_PROT_READ as PROT_READ;
-pub use WASMTIME_PROT_WRITE as PROT_WRITE;
-
-/// Handler function for traps in Wasmtime passed to `wasmtime_init_traps`.
-///
-/// This function is invoked whenever a trap is caught by the system. For
-/// example this would be invoked during a signal handler on Linux. This
-/// function is passed a number of parameters indicating information about the
-/// trap:
-///
-/// * `ip` - the instruction pointer at the time of the trap.
-/// * `fp` - the frame pointer register's value at the time of the trap.
-/// * `has_faulting_addr` - whether this trap is associated with an access
-///   violation (e.g. a segfault) meaning memory was accessed when it shouldn't
-///   be. If this is `true` then the next parameter is filled in.
-/// * `faulting_addr` - if `has_faulting_addr` is true then this is the address
-///   that was attempted to be accessed. Otherwise this value is not used.
-///
-/// If this function returns then the trap was not handled by Wasmtime. This
-/// means that it's left up to the embedder how to deal with the trap/signal
-/// depending on its default behavior. This could mean forwarding to a
-/// non-Wasmtime handler, aborting the process, logging then crashing, etc. The
-/// meaning of a trap that's not handled by Wasmtime depends on the context in
-/// which the trap was generated.
-///
-/// When this function does not return it's because `wasmtime_longjmp` is
-/// used to handle a Wasm-based trap.
-pub type wasmtime_trap_handler_t =
-    extern "C" fn(ip: usize, fp: usize, has_faulting_addr: bool, faulting_addr: usize);
-
-/// Abstract pointer type used in the `wasmtime_memory_image_*` APIs which
-/// is defined by the embedder.
-pub enum wasmtime_memory_image {}
-
-extern "C" {
-    /// Creates a new virtual memory mapping of the `size` specified with
-    /// protection bits specified in `prot_flags`.
-    ///
-    /// Memory can be lazily committed.
-    ///
-    /// Stores the base pointer of the new mapping in `ret` on success.
-    ///
-    /// Returns 0 on success and an error code on failure.
-    ///
-    /// Similar to `mmap(0, size, prot_flags, MAP_PRIVATE, 0, -1)` on Linux.
-    pub fn wasmtime_mmap_new(size: usize, prot_flags: u32, ret: &mut *mut u8) -> i32;
-
-    /// Remaps the virtual memory starting at `addr` going for `size` bytes to
-    /// the protections specified with a new blank mapping.
-    ///
-    /// This will unmap any prior mappings and decommit them. New mappings for
-    /// anonymous memory are used to replace these mappings and the new area
-    /// should have the protection specified by `prot_flags`.
-    ///
-    /// Returns 0 on success and an error code on failure.
-    ///
-    /// Similar to `mmap(addr, size, prot_flags, MAP_PRIVATE | MAP_FIXED, 0, -1)` on Linux.
-    pub fn wasmtime_mmap_remap(addr: *mut u8, size: usize, prot_flags: u32) -> i32;
-
-    /// Unmaps memory at the specified `ptr` for `size` bytes.
-    ///
-    /// The memory should be discarded and decommitted and should generate a
-    /// segfault if accessed after this function call.
-    ///
-    /// Returns 0 on success and an error code on failure.
-    ///
-    /// Similar to `munmap` on Linux.
-    pub fn wasmtime_munmap(ptr: *mut u8, size: usize) -> i32;
-
-    /// Configures the protections associated with a region of virtual memory
-    /// starting at `ptr` and going to `size`.
-    ///
-    /// Returns 0 on success and an error code on failure.
-    ///
-    /// Similar to `mprotect` on Linux.
-    pub fn wasmtime_mprotect(ptr: *mut u8, size: usize, prot_flags: u32) -> i32;
-
-    /// Returns the page size, in bytes, of the current system.
-    pub fn wasmtime_page_size() -> usize;
-
-    /// Used to setup a frame on the stack to longjmp back to in the future.
-    ///
-    /// This function is used for handling traps in WebAssembly and is paried
-    /// with `wasmtime_longjmp`.
-    ///
-    /// * `jmp_buf` - this argument is filled in with a pointer which if used
-    ///   will be passed to `wasmtime_longjmp` later on by the runtime.
-    /// * `callback` - this callback should be invoked after `jmp_buf` is
-    ///   configured.
-    /// * `payload` and `callee` - the two arguments to pass to `callback`.
-    ///
-    /// Returns 0 if `wasmtime_longjmp` was used to return to this function.
-    /// Returns 1 if `wasmtime_longjmp` was not called and `callback` returned.
-    pub fn wasmtime_setjmp(
-        jmp_buf: *mut *const u8,
-        callback: extern "C" fn(*mut u8, *mut u8),
-        payload: *mut u8,
-        callee: *mut u8,
-    ) -> i32;
-
-    /// Paired with `wasmtime_setjmp` this is used to jump back to the `setjmp`
-    /// point.
-    ///
-    /// The argument here was originally passed to `wasmtime_setjmp` through its
-    /// out-param.
-    ///
-    /// This function cannot return.
-    ///
-    /// This function may be invoked from the `wasmtime_trap_handler_t`
-    /// configured by `wasmtime_init_traps`.
-    pub fn wasmtime_longjmp(jmp_buf: *const u8) -> !;
-
-    /// Initializes trap-handling logic for this platform.
-    ///
-    /// Wasmtime's implementation of WebAssembly relies on the ability to catch
-    /// signals/traps/etc. For example divide-by-zero may raise a machine
-    /// exception. Out-of-bounds memory accesses may also raise a machine
-    /// exception. This function is used to initialize trap handling.
-    ///
-    /// The `handler` provided is a function pointer to invoke whenever a trap
-    /// is encountered. The `handler` is invoked whenever a trap is caught by
-    /// the system.
-    ///
-    /// Returns 0 on success and an error code on failure.
-    pub fn wasmtime_init_traps(handler: wasmtime_trap_handler_t) -> i32;
-
-    /// Attempts to create a new in-memory image of the `ptr`/`len` combo which
-    /// can be mapped to virtual addresses in the future.
-    ///
-    /// On successed the returned `wasmtime_memory_image` pointer is stored into `ret`.
-    /// This value stored can be `NULL` to indicate that an image cannot be
-    /// created but no failure occurred. The structure otherwise will later be
-    /// deallocated with `wasmtime_memory_image_free` and
-    /// `wasmtime_memory_image_map_at` will be used to map the image into new
-    /// regions of the address space.
-    ///
-    /// The `ptr` and `len` arguments are only valid for this function call, if
-    /// the image needs to refer to them in the future then it must make a copy.
-    ///
-    /// Both `ptr` and `len` are guaranteed to be page-aligned.
-    ///
-    /// Returns 0 on success and an error code on failure. Note that storing
-    /// `NULL` into `ret` is not considered a failure, and failure is used to
-    /// indicate that something fatal has happened and Wasmtime will propagate
-    /// the error upwards.
-    pub fn wasmtime_memory_image_new(
-        ptr: *const u8,
-        len: usize,
-        ret: &mut *mut wasmtime_memory_image,
-    ) -> i32;
-
-    /// Maps the `image` provided to the virtual address at `addr` and `len`.
-    ///
-    /// This semantically should make it such that `addr` and `len` looks the
-    /// same as the contents of what the memory image was first created with.
-    /// The mappings of `addr` should be private and changes do not reflect back
-    /// to `wasmtime_memory_image`.
-    ///
-    /// In effect this is to create a copy-on-write mapping at `addr`/`len`
-    /// pointing back to the memory used by the image originally.
-    ///
-    /// Note that the memory region will be unmapped with `wasmtime_munmap` in
-    /// the future.
-    ///
-    /// Aborts the process on failure.
-    pub fn wasmtime_memory_image_map_at(
-        image: *mut wasmtime_memory_image,
-        addr: *mut u8,
-        len: usize,
-    ) -> i32;
-
-    /// Deallocates the provided `wasmtime_memory_image`.
-    ///
-    /// Note that mappings created from this image are not guaranteed to be
-    /// deallocated and/or unmapped before this is called.
-    pub fn wasmtime_memory_image_free(image: *mut wasmtime_memory_image);
-}