wasmtime 22.0.0 → 23.0.2

data/ext/cargo-vendor/wasmtime-23.0.2/src/runtime/profiling.rs

@@ -0,0 +1,280 @@
+use crate::instantiate::CompiledModule;
+use crate::prelude::*;
+use crate::runtime::vm::Backtrace;
+use crate::{AsContext, CallHook, Module};
+use fxprof_processed_profile::debugid::DebugId;
+use fxprof_processed_profile::{
+    CategoryHandle, Frame, FrameFlags, FrameInfo, LibraryInfo, MarkerLocation, MarkerSchema,
+    MarkerTiming, Profile, ProfilerMarker, ReferenceTimestamp, Symbol, SymbolTable, Timestamp,
+};
+use std::ops::Range;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use wasmtime_environ::demangle_function_name_or_index;
+
+// TODO: collect more data
+// - On non-Windows, measure thread-local CPU usage between events with
+//   rustix::time::clock_gettime(ClockId::ThreadCPUTime)
+// - Report which wasm module, and maybe instance, each frame came from
+
+/// Collects basic profiling data for a single WebAssembly guest.
+///
+/// This profiler can't provide measurements that are as accurate or detailed
+/// as a platform-specific profiler, such as `perf` on Linux. On the other
+/// hand, this profiler works on every platform that Wasmtime supports. Also,
+/// as an embedder you can use this profiler selectively on individual guest
+/// instances rather than profiling the entire process.
+///
+/// To use this, you'll need to arrange to call [`GuestProfiler::sample`] at
+/// regular intervals while the guest is on the stack. The most straightforward
+/// way to do that is to call it from a callback registered with
+/// [`Store::epoch_deadline_callback()`](crate::Store::epoch_deadline_callback).
+///
+/// # Accuracy
+///
+/// The data collection granularity is limited by the mechanism you use to
+/// interrupt guest execution and collect a profiling sample.
+///
+/// If you use epoch interruption, then samples will only be collected at
+/// function entry points and loop headers. This introduces some bias to the
+/// results. In addition, samples will only be taken at times when WebAssembly
+/// functions are running, not during host-calls.
+///
+/// It is technically possible to use fuel interruption instead. That
+/// introduces worse bias since samples occur after a certain number of
+/// WebAssembly instructions, which can take different amounts of time.
+///
+/// You may instead be able to use platform-specific methods, such as
+/// `setitimer(ITIMER_VIRTUAL, ...)` on POSIX-compliant systems, to sample on
+/// a more accurate interval. The only current requirement is that the guest
+/// you wish to profile must be on the same stack where you call `sample`,
+/// and executing within the same thread. However, the `GuestProfiler::sample`
+/// method is not currently async-signal-safe, so doing this correctly is not
+/// easy.
+///
+/// # Security
+///
+/// Profiles produced using this profiler do not include any configuration
+/// details from the host, such as virtual memory addresses, or from any
+/// WebAssembly modules that you haven't specifically allowed. So for
+/// example, these profiles should be safe to share with untrusted users
+/// who have provided untrusted code that you are running in a multi-tenancy
+/// environment.
+///
+/// However, the profile does include byte offsets into the text section of
+/// the compiled module, revealing some information about the size of the code
+/// generated for each module. For user-provided modules, the user could get
+/// the same information by compiling the module for themself using a similar
+/// version of Wasmtime on the same target architecture, but for any module
+/// where they don't already have the WebAssembly module binary available this
+/// could theoretically lead to an undesirable information disclosure. So you
+/// should only include user-provided modules in profiles.
+#[derive(Debug)]
+pub struct GuestProfiler {
+    profile: Profile,
+    modules: Modules,
+    process: fxprof_processed_profile::ProcessHandle,
+    thread: fxprof_processed_profile::ThreadHandle,
+    start: Instant,
+}
+
+type Modules = Vec<(Range<usize>, fxprof_processed_profile::LibraryHandle)>;
+
+impl GuestProfiler {
+    /// Begin profiling a new guest. When this function is called, the current
+    /// wall-clock time is recorded as the start time for the guest.
+    ///
+    /// The `module_name` parameter is recorded in the profile to help identify
+    /// where the profile came from.
+    ///
+    /// The `interval` parameter should match the rate at which you intend
+    /// to call `sample`. However, this is used as a hint and not required to
+    /// exactly match the real sample rate.
+    ///
+    /// Only modules which are present in the `modules` vector will appear in
+    /// stack traces in this profile. Any stack frames which were executing
+    /// host code or functions from other modules will be omitted. See the
+    /// "Security" section of the [`GuestProfiler`] documentation for guidance
+    /// on what modules should not be included in this list.
+    pub fn new(module_name: &str, interval: Duration, modules: Vec<(String, Module)>) -> Self {
+        let zero = ReferenceTimestamp::from_millis_since_unix_epoch(0.0);
+        let mut profile = Profile::new(module_name, zero, interval.into());
+
+        let mut modules: Vec<_> = modules
+            .into_iter()
+            .filter_map(|(name, module)| {
+                let compiled = module.compiled_module();
+                let text = compiled.text().as_ptr_range();
+                let address_range = text.start as usize..text.end as usize;
+                module_symbols(name, compiled).map(|lib| (address_range, profile.add_lib(lib)))
+            })
+            .collect();
+
+        modules.sort_unstable_by_key(|(range, _)| range.start);
+
+        profile.set_reference_timestamp(std::time::SystemTime::now().into());
+        let process = profile.add_process(module_name, 0, Timestamp::from_nanos_since_reference(0));
+        let thread = profile.add_thread(process, 0, Timestamp::from_nanos_since_reference(0), true);
+        let start = Instant::now();
+        Self {
+            profile,
+            modules,
+            process,
+            thread,
+            start,
+        }
+    }
+
+    /// Add a sample to the profile. This function collects a backtrace from
+    /// any stack frames for allowed modules on the current stack. It should
+    /// typically be called from a callback registered using
+    /// [`Store::epoch_deadline_callback()`](crate::Store::epoch_deadline_callback).
+    ///
+    /// The `delta` parameter is the amount of CPU time that was used by this
+    /// guest since the previous sample. It is allowed to pass `Duration::ZERO`
+    /// here if recording CPU usage information is not needed.
+    pub fn sample(&mut self, store: impl AsContext, delta: Duration) {
+        let now = Timestamp::from_nanos_since_reference(
+            self.start.elapsed().as_nanos().try_into().unwrap(),
+        );
+        let backtrace = Backtrace::new(store.as_context().0.vmruntime_limits());
+        let frames = lookup_frames(&self.modules, &backtrace);
+        self.profile
+            .add_sample(self.thread, now, frames, delta.into(), 1);
+    }
+
+    /// Add a marker for transitions between guest and host to the profile.
+    /// This function should typically be called from a callback registered
+    /// using [`Store::call_hook()`](crate::Store::call_hook), and the `kind`
+    /// parameter should be the value of the same type passed into that hook.
+    pub fn call_hook(&mut self, store: impl AsContext, kind: CallHook) {
+        let now = Timestamp::from_nanos_since_reference(
+            self.start.elapsed().as_nanos().try_into().unwrap(),
+        );
+        match kind {
+            CallHook::CallingWasm | CallHook::ReturningFromWasm => {}
+            CallHook::CallingHost => {
+                let backtrace = Backtrace::new(store.as_context().0.vmruntime_limits());
+                let frames = lookup_frames(&self.modules, &backtrace);
+                self.profile.add_marker_with_stack(
+                    self.thread,
+                    "hostcall",
+                    CallMarker,
+                    MarkerTiming::IntervalStart(now),
+                    frames,
+                );
+            }
+            CallHook::ReturningFromHost => {
+                self.profile.add_marker(
+                    self.thread,
+                    "hostcall",
+                    CallMarker,
+                    MarkerTiming::IntervalEnd(now),
+                );
+            }
+        }
+    }
+
+    /// When the guest finishes running, call this function to write the
+    /// profile to the given `output`. The output is a JSON-formatted object in
+    /// the [Firefox "processed profile format"][fmt]. Files in this format may
+    /// be visualized at <https://profiler.firefox.com/>.
+    ///
+    /// [fmt]: https://github.com/firefox-devtools/profiler/blob/main/docs-developer/processed-profile-format.md
+    pub fn finish(mut self, output: impl std::io::Write) -> Result<()> {
+        let now = Timestamp::from_nanos_since_reference(
+            self.start.elapsed().as_nanos().try_into().unwrap(),
+        );
+        self.profile.set_thread_end_time(self.thread, now);
+        self.profile.set_process_end_time(self.process, now);
+
+        serde_json::to_writer(output, &self.profile)?;
+        Ok(())
+    }
+}
+
+fn module_symbols(name: String, compiled: &CompiledModule) -> Option<LibraryInfo> {
+    let symbols = Vec::from_iter(compiled.finished_functions().map(|(defined_idx, _)| {
+        let loc = compiled.func_loc(defined_idx);
+        let func_idx = compiled.module().func_index(defined_idx);
+        let mut name = String::new();
+        demangle_function_name_or_index(
+            &mut name,
+            compiled.func_name(func_idx),
+            defined_idx.as_u32() as usize,
+        )
+        .unwrap();
+        Symbol {
+            address: loc.start,
+            size: Some(loc.length),
+            name,
+        }
+    }));
+    if symbols.is_empty() {
+        return None;
+    }
+
+    Some(LibraryInfo {
+        name,
+        debug_name: String::new(),
+        path: String::new(),
+        debug_path: String::new(),
+        debug_id: DebugId::nil(),
+        code_id: None,
+        arch: None,
+        symbol_table: Some(Arc::new(SymbolTable::new(symbols))),
+    })
+}
+
+fn lookup_frames<'a>(
+    modules: &'a Modules,
+    backtrace: &'a Backtrace,
+) -> impl Iterator<Item = FrameInfo> + 'a {
+    backtrace
+        .frames()
+        // Samply needs to see the oldest frame first, but we list the newest
+        // first, so iterate in reverse.
+        .rev()
+        .filter_map(|frame| {
+            // Find the first module whose start address includes this PC.
+            let module_idx = modules.partition_point(|(range, _)| range.start > frame.pc());
+            if let Some((range, lib)) = modules.get(module_idx) {
+                if range.contains(&frame.pc()) {
+                    return Some(FrameInfo {
+                        frame: Frame::RelativeAddressFromReturnAddress(
+                            *lib,
+                            u32::try_from(frame.pc() - range.start).unwrap(),
+                        ),
+                        category_pair: CategoryHandle::OTHER.into(),
+                        flags: FrameFlags::empty(),
+                    });
+                }
+            }
+            None
+        })
+}
+
+struct CallMarker;
+
+impl ProfilerMarker for CallMarker {
+    const MARKER_TYPE_NAME: &'static str = "hostcall";
+
+    fn schema() -> MarkerSchema {
+        MarkerSchema {
+            type_name: Self::MARKER_TYPE_NAME,
+            locations: vec![
+                MarkerLocation::MarkerChart,
+                MarkerLocation::MarkerTable,
+                MarkerLocation::TimelineOverview,
+            ],
+            chart_label: None,
+            tooltip_label: None,
+            table_label: None,
+            fields: vec![],
+        }
+    }
+
+    fn json_marker_data(&self) -> serde_json::Value {
+        serde_json::json!({ "type": Self::MARKER_TYPE_NAME })
+    }
+}

data/ext/cargo-vendor/wasmtime-23.0.2/src/runtime/stack.rs

@@ -0,0 +1,72 @@
+use crate::prelude::*;
+use std::{ops::Range, sync::Arc};
+use wasmtime_fiber::{RuntimeFiberStack, RuntimeFiberStackCreator};
+
+/// A stack creator. Can be used to provide a stack creator to wasmtime
+/// which supplies stacks for async support.
+///
+/// # Safety
+///
+/// This trait is unsafe, as memory safety depends on a proper implementation
+/// of memory management. Stacks created by the StackCreator should always be
+/// treated as owned by an wasmtime instance, and any modification of them
+/// outside of wasmtime invoked routines is unsafe and may lead to corruption.
+///
+/// Note that this is a relatively new and experimental feature and it is
+/// recommended to be familiar with wasmtime runtime code to use it.
+pub unsafe trait StackCreator: Send + Sync {
+    /// Create a new `StackMemory` object with the specified size.
+    ///
+    /// The `size` parameter is the expected size of the stack without any guard pages.
+    ///
+    /// Note there should be at least one guard page of protected memory at the bottom
+    /// of the stack to catch potential stack overflow scenarios. Additionally, stacks should be
+    /// page aligned and zero filled.
+    fn new_stack(&self, size: usize) -> Result<Box<dyn StackMemory>, Error>;
+}
+
+#[derive(Clone)]
+pub(crate) struct StackCreatorProxy(pub Arc<dyn StackCreator>);
+
+unsafe impl RuntimeFiberStackCreator for StackCreatorProxy {
+    fn new_stack(&self, size: usize) -> Result<Box<dyn RuntimeFiberStack>, Error> {
+        let stack = self.0.new_stack(size)?;
+        Ok(Box::new(FiberStackProxy(stack)) as Box<dyn RuntimeFiberStack>)
+    }
+}
+
+/// A stack memory. This trait provides an interface for raw memory buffers
+/// which are used by wasmtime inside of stacks which wasmtime executes
+/// WebAssembly in for async support. By implementing this trait together
+/// with StackCreator, one can supply wasmtime with custom allocated host
+/// managed stacks.
+///
+/// # Safety
+///
+/// The memory should be page aligned and a multiple of page size.
+/// To prevent possible silent overflows, the memory should be protected by a
+/// guard page. Additionally the safety concerns explained in ['Memory'], for
+/// accessing the memory apply here as well.
+///
+/// Note that this is a relatively new and experimental feature and it is
+/// recommended to be familiar with wasmtime runtime code to use it.
+pub unsafe trait StackMemory: Send + Sync {
+    /// The top of the allocated stack.
+    ///
+    /// This address should be page aligned.
+    fn top(&self) -> *mut u8;
+    /// The range of where this stack resides in memory, excluding guard pages.
+    fn range(&self) -> Range<usize>;
+}
+
+pub(crate) struct FiberStackProxy(pub Box<dyn StackMemory>);
+
+unsafe impl RuntimeFiberStack for FiberStackProxy {
+    fn top(&self) -> *mut u8 {
+        self.0.top()
+    }
+
+    fn range(&self) -> Range<usize> {
+        self.0.range()
+    }
+}

data/ext/cargo-vendor/wasmtime-23.0.2/src/runtime/store/data.rs

@@ -0,0 +1,301 @@
+use crate::prelude::*;
+use crate::store::StoreOpaque;
+use crate::{StoreContext, StoreContextMut};
+use core::fmt;
+use core::marker;
+use core::num::NonZeroU64;
+use core::ops::{Index, IndexMut};
+use core::sync::atomic::{AtomicU64, Ordering::Relaxed};
+
+// This is defined here, in a private submodule, so we can explicitly reexport
+// it only as `pub(crate)`. This avoids a ton of
+// crate-private-type-in-public-interface errors that aren't really too
+// interesting to deal with.
+#[derive(Copy, Clone)]
+pub struct InstanceId(pub(super) usize);
+
+impl InstanceId {
+    pub fn from_index(idx: usize) -> InstanceId {
+        InstanceId(idx)
+    }
+}
+
+pub struct StoreData {
+    id: StoreId,
+    funcs: Vec<crate::func::FuncData>,
+    tables: Vec<crate::runtime::vm::ExportTable>,
+    globals: Vec<crate::runtime::vm::ExportGlobal>,
+    instances: Vec<crate::instance::InstanceData>,
+    memories: Vec<crate::runtime::vm::ExportMemory>,
+    #[cfg(feature = "component-model")]
+    pub(crate) components: crate::component::ComponentStoreData,
+}
+
+pub trait StoredData: Sized {
+    fn list(data: &StoreData) -> &Vec<Self>;
+    fn list_mut(data: &mut StoreData) -> &mut Vec<Self>;
+}
+
+macro_rules! impl_store_data {
+    ($($field:ident => $t:ty,)*) => ($(
+        impl StoredData for $t {
+            #[inline]
+            fn list(data: &StoreData) -> &Vec<Self> { &data.$field }
+            #[inline]
+            fn list_mut(data: &mut StoreData) -> &mut Vec<Self> { &mut data.$field }
+        }
+    )*)
+}
+
+impl_store_data! {
+    funcs => crate::func::FuncData,
+    tables => crate::runtime::vm::ExportTable,
+    globals => crate::runtime::vm::ExportGlobal,
+    instances => crate::instance::InstanceData,
+    memories => crate::runtime::vm::ExportMemory,
+}
+
+impl StoreData {
+    pub fn new() -> StoreData {
+        StoreData {
+            id: StoreId::allocate(),
+            funcs: Vec::new(),
+            tables: Vec::new(),
+            globals: Vec::new(),
+            instances: Vec::new(),
+            memories: Vec::new(),
+            #[cfg(feature = "component-model")]
+            components: Default::default(),
+        }
+    }
+
+    pub fn id(&self) -> StoreId {
+        self.id
+    }
+
+    pub fn insert<T>(&mut self, data: T) -> Stored<T>
+    where
+        T: StoredData,
+    {
+        let list = T::list_mut(self);
+        let index = list.len();
+        list.push(data);
+        Stored::new(self.id, index)
+    }
+
+    pub fn next_id<T>(&self) -> Stored<T>
+    where
+        T: StoredData,
+    {
+        Stored::new(self.id, T::list(self).len())
+    }
+
+    pub fn contains<T>(&self, id: Stored<T>) -> bool
+    where
+        T: StoredData,
+    {
+        if id.store_id != self.id {
+            return false;
+        }
+        // This should be true as an invariant of our API, but double-check with
+        // debug assertions enabled.
+        debug_assert!(id.index() < T::list(self).len());
+        true
+    }
+
+    pub fn iter<T>(&self) -> impl ExactSizeIterator<Item = Stored<T>>
+    where
+        T: StoredData,
+    {
+        let id = self.id;
+        (0..T::list(self).len()).map(move |i| Stored::new(id, i))
+    }
+
+    pub(crate) fn reserve_funcs(&mut self, count: usize) {
+        self.funcs.reserve(count);
+    }
+}
+
+impl<T> Index<Stored<T>> for StoreData
+where
+    T: StoredData,
+{
+    type Output = T;
+
+    #[inline]
+    fn index(&self, index: Stored<T>) -> &Self::Output {
+        index.assert_belongs_to(self.id);
+        // Note that if this is ever a performance bottleneck it should be safe
+        // to use unchecked indexing here because presence of a `Stored<T>` is
+        // proof of an item having been inserted into a store and lists in
+        // stores are never shrunk. After the store check above the actual index
+        // should always be valid.
+        &T::list(self)[index.index()]
+    }
+}
+
+impl<T> IndexMut<Stored<T>> for StoreData
+where
+    T: StoredData,
+{
+    #[inline]
+    fn index_mut(&mut self, index: Stored<T>) -> &mut Self::Output {
+        index.assert_belongs_to(self.id);
+        // Note that this could be unchecked indexing, see the note in `Index`
+        // above.
+        &mut T::list_mut(self)[index.index()]
+    }
+}
+
+// forward StoreContext => StoreData
+impl<I, T> Index<I> for StoreContext<'_, T>
+where
+    StoreData: Index<I>,
+{
+    type Output = <StoreData as Index<I>>::Output;
+
+    #[inline]
+    fn index(&self, index: I) -> &Self::Output {
+        self.0.store_data.index(index)
+    }
+}
+
+// forward StoreContextMut => StoreData
+impl<I, T> Index<I> for StoreContextMut<'_, T>
+where
+    StoreData: Index<I>,
+{
+    type Output = <StoreData as Index<I>>::Output;
+
+    #[inline]
+    fn index(&self, index: I) -> &Self::Output {
+        self.0.store_data.index(index)
+    }
+}
+
+// forward StoreOpaque => StoreData
+impl<I> Index<I> for StoreOpaque
+where
+    StoreData: Index<I>,
+{
+    type Output = <StoreData as Index<I>>::Output;
+
+    #[inline]
+    fn index(&self, index: I) -> &Self::Output {
+        self.store_data().index(index)
+    }
+}
+impl<I> IndexMut<I> for StoreOpaque
+where
+    StoreData: IndexMut<I>,
+{
+    #[inline]
+    fn index_mut(&mut self, index: I) -> &mut Self::Output {
+        self.store_data_mut().index_mut(index)
+    }
+}
+
+/// A unique identifier to get attached to a store.
+///
+/// This identifier is embedded into the `Stored<T>` structure and is used to
+/// identify the original store that items come from. For example a `Memory` is
+/// owned by a `Store` and will embed a `StoreId` internally to say which store
+/// it came from. Comparisons with this value are how panics are generated for
+/// mismatching the item that a store belongs to.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[repr(transparent)] // NB: relied on in the C API
+pub struct StoreId(NonZeroU64);
+
+impl StoreId {
+    /// Allocates a new unique identifier for a store that has never before been
+    /// used in this process.
+    pub fn allocate() -> StoreId {
+        static NEXT_ID: AtomicU64 = AtomicU64::new(0);
+
+        // Only allow 2^63 stores at which point we start panicking to prevent
+        // overflow.
+        //
+        // If a store is created once per microsecond then this will last the
+        // current process for 584,540 years before overflowing.
+        //
+        // Also note the usage of `Relaxed` ordering here which should be ok
+        // since we're only looking for atomicity on this counter and this
+        // otherwise isn't used to synchronize memory stored anywhere else.
+        let id = NEXT_ID.fetch_add(1, Relaxed);
+        if id & (1 << 63) != 0 {
+            NEXT_ID.store(1 << 63, Relaxed);
+            panic!("store id allocator overflow");
+        }
+
+        StoreId(NonZeroU64::new(id + 1).unwrap())
+    }
+
+    #[inline]
+    pub fn assert_belongs_to(&self, store: StoreId) {
+        if *self == store {
+            return;
+        }
+        store_id_mismatch();
+    }
+
+    /// Raw accessor for the C API.
+    pub fn as_raw(&self) -> NonZeroU64 {
+        self.0
+    }
+
+    /// Raw constructor for the C API.
+    pub fn from_raw(id: NonZeroU64) -> StoreId {
+        StoreId(id)
+    }
+}
+
+#[repr(C)] // used by reference in the C API, also in `wasmtime_func_t`.
+pub struct Stored<T> {
+    store_id: StoreId,
+    index: usize,
+    _marker: marker::PhantomData<fn() -> T>,
+}
+
+impl<T> Stored<T> {
+    fn new(store_id: StoreId, index: usize) -> Stored<T> {
+        Stored {
+            store_id,
+            index,
+            _marker: marker::PhantomData,
+        }
+    }
+
+    #[inline]
+    pub fn assert_belongs_to(&self, store: StoreId) {
+        self.store_id.assert_belongs_to(store)
+    }
+
+    fn index(&self) -> usize {
+        self.index
+    }
+}
+
+#[cold]
+fn store_id_mismatch() {
+    panic!("object used with the wrong store");
+}
+
+impl<T> PartialEq for Stored<T> {
+    fn eq(&self, other: &Stored<T>) -> bool {
+        self.store_id == other.store_id && self.index == other.index
+    }
+}
+
+impl<T> Copy for Stored<T> {}
+
+impl<T> Clone for Stored<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T> fmt::Debug for Stored<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "store={}, index={}", self.store_id.0, self.index())
+    }
+}