add hooks for entering and exiting native code to Store

crates/wasmtime/src/func.rs

@@ -843,6 +843,7 @@ impl Func {
         values_vec: *mut u128,
         func: &dyn Fn(Caller<'_, T>, &[Val], &mut [Val]) -> Result<(), Trap>,
     ) -> Result<(), Trap> {
+        caller.store.0.entering_native_hook()?;
         // We have a dynamic guarantee that `values_vec` has the right
         // number of arguments and the right types of arguments. As a result
         // we should be able to safely run through them all and read them.
@@ -883,6 +884,7 @@ impl Func {
             }
         }
 
+        caller.store.0.exiting_native_hook()?;
         Ok(())
     }
 
@@ -1173,7 +1175,7 @@ pub unsafe trait WasmRet {
     // explicitly, used when wrapping async functions which always bottom-out
     // in a function that returns a trap because futures can be cancelled.
     #[doc(hidden)]
-    type Fallible: WasmRet;
+    type Fallible: WasmRet<Abi = Self::Abi, Retptr = Self::Retptr>;
     #[doc(hidden)]
     fn into_fallible(self) -> Self::Fallible;
     #[doc(hidden)]
@@ -1689,12 +1691,19 @@ macro_rules! impl_into_func {
 
                         let ret = {
                             panic::catch_unwind(AssertUnwindSafe(|| {
+                                if let Err(trap) = caller.store.0.entering_native_hook() {
+                                    return R::fallible_from_trap(trap);
+                                }
                                 let mut _store = caller.sub_caller().store.opaque();
                                 $(let $args = $args::from_abi($args, &mut _store);)*
-                                func(
+                                let r = func(
                                     caller.sub_caller(),
                                     $( $args, )*
-                                )
+                                );
+                                if let Err(trap) = caller.store.0.exiting_native_hook() {
+                                    return R::fallible_from_trap(trap);
+                                }
+                                r.into_fallible()
                             }))
                         };
 

crates/wasmtime/src/store.rs

@@ -104,6 +104,8 @@ pub struct StoreInner<T> {
     _marker: marker::PhantomPinned,
     inner: StoreInnermost,
     limiter: Option<Box<dyn FnMut(&mut T) -> &mut (dyn crate::ResourceLimiter) + Send + Sync>>,
+    entering_native_hook: Option<Box<dyn FnMut(&mut T) -> Result<(), crate::Trap> + Send + Sync>>,
+    exiting_native_hook: Option<Box<dyn FnMut(&mut T) -> Result<(), crate::Trap> + Send + Sync>>,
     // for comments about `ManuallyDrop`, see `Store::into_data`
     data: ManuallyDrop<T>,
 }
@@ -239,7 +241,8 @@ impl<T> Store<T> {
                 default_callee,
             },
             limiter: None,
-            default_callee,
+            entering_native_hook: None,
+            exiting_native_hook: None,
             data: ManuallyDrop::new(data),
         });
 
@@ -322,6 +325,28 @@ impl<T> Store<T> {
         inner.limiter = Some(Box::new(limiter));
     }
 
+    /// Configure a function that runs each time WebAssembly code running on this [`Store`] calls
+    /// into native code.
+    ///
+    /// This function may return a [`Trap`], which terminates execution.
+    pub fn entering_native_code_hook(
+        &mut self,
+        hook: impl FnMut(&mut T) -> Result<(), Trap> + Send + Sync + 'static,
+    ) {
+        self.inner.entering_native_hook = Some(Box::new(hook));
+    }
+
+    /// Configure a function that runs before native code running on this [`Store`] returns to
+    /// WebAssembly code.
+    ///
+    /// This function may return a [`Trap`], which terminates execution.
+    pub fn exiting_native_code_hook(
+        &mut self,
+        hook: impl FnMut(&mut T) -> Result<(), Trap> + Send + Sync + 'static,
+    ) {
+        self.inner.exiting_native_hook = Some(Box::new(hook));
+    }
+
     /// Returns the [`Engine`] that this store is associated with.
     pub fn engine(&self) -> &Engine {
         self.inner.engine()
@@ -621,6 +646,22 @@ impl<T> StoreInner<T> {
         let accessor = self.limiter.as_mut()?;
         Some(accessor(&mut self.data))
     }
+
+    pub fn entering_native_hook(&mut self) -> Result<(), Trap> {
+        if let Some(hook) = &mut self.entering_native_hook {
+            hook(&mut self.data)
+        } else {
+            Ok(())
+        }
+    }
+
+    pub fn exiting_native_hook(&mut self) -> Result<(), Trap> {
+        if let Some(hook) = &mut self.exiting_native_hook {
+            hook(&mut self.data)
+        } else {
+            Ok(())
+        }
+    }
 }
 
 impl StoreInnermost {