Support for ResourceLimiter API

crates/core/src/trap.rs

@@ -284,6 +284,13 @@ pub enum TrapCode {
     /// internal bytecode so that fuel is consumed for each executed instruction.
     /// This is useful to deterministically halt or yield a WebAssembly execution.
     OutOfFuel,
+
+    /// This trap is raised when a growth operation was attempted and an
+    /// installed `ResourceLimiter` returned `Err(...)` from the associated
+    /// `table_growing` or `memory_growing` method, indicating a desire on the
+    /// part of the embedder to trap the interpreter rather than merely fail the
+    /// growth operation.
+    GrowthOperationLimited,
 }
 
 impl TrapCode {
@@ -305,6 +312,7 @@ impl TrapCode {
             Self::StackOverflow => "call stack exhausted",
             Self::BadSignature => "indirect call type mismatch",
             Self::OutOfFuel => "all fuel consumed by WebAssembly",
+            Self::GrowthOperationLimited => "growth operation limited",
         }
     }
 }

crates/wasmi/src/engine/executor.rs

@@ -24,6 +24,7 @@ use crate::{
         ValueStack,
     },
     func::FuncEntity,
+    store::ResourceLimiterRef,
     table::TableEntity,
     FuelConsumptionMode,
     Func,
@@ -92,15 +93,25 @@ pub enum ReturnOutcome {
 ///
 /// If the Wasm execution traps.
 #[inline(never)]
-pub fn execute_wasm<'engine>(
-    ctx: &mut StoreInner,
+pub fn execute_wasm<'ctx, 'engine>(
+    ctx: &'ctx mut StoreInner,
     cache: &'engine mut InstanceCache,
     value_stack: &'engine mut ValueStack,
     call_stack: &'engine mut CallStack,
     code_map: &'engine CodeMap,
     const_pool: ConstPoolView<'engine>,
+    resource_limiter: ResourceLimiterRef<'ctx>,
 ) -> Result<WasmOutcome, TrapCode> {
-    Executor::new(ctx, cache, value_stack, call_stack, code_map, const_pool).execute()
+    Executor::new(
+        ctx,
+        cache,
+        value_stack,
+        call_stack,
+        code_map,
+        const_pool,
+        resource_limiter,
+    )
+    .execute()
 }
 
 /// The function signature of Wasm load operations.
@@ -168,6 +179,7 @@ struct Executor<'ctx, 'engine> {
     code_map: &'engine CodeMap,
     /// A read-only view to a pool of constant values.
     const_pool: ConstPoolView<'engine>,
+    resource_limiter: ResourceLimiterRef<'ctx>,
 }
 
 macro_rules! forward_call {
@@ -195,6 +207,7 @@ impl<'ctx, 'engine> Executor<'ctx, 'engine> {
         call_stack: &'engine mut CallStack,
         code_map: &'engine CodeMap,
         const_pool: ConstPoolView<'engine>,
+        resource_limiter: ResourceLimiterRef<'ctx>,
     ) -> Self {
         let frame = call_stack.pop().expect("must have frame on the call stack");
         let sp = value_stack.stack_ptr();
@@ -208,6 +221,7 @@ impl<'ctx, 'engine> Executor<'ctx, 'engine> {
             call_stack,
             code_map,
             const_pool,
+            resource_limiter,
         }
     }
 
@@ -1097,9 +1111,8 @@ impl<'ctx, 'engine> Executor<'ctx, 'engine> {
                 let new_pages = this
                     .ctx
                     .resolve_memory_mut(memory)
-                    .grow(delta)
-                    .map(u32::from)
-                    .map_err(|_| EntityGrowError::InvalidGrow)?;
+                    .grow(delta, &mut this.resource_limiter)
+                    .map(u32::from)?;
                 // The `memory.grow` operation might have invalidated the cached
                 // linear memory so we need to reset it in order for the cache to
                 // reload in case it is used again.
@@ -1217,10 +1230,11 @@ impl<'ctx, 'engine> Executor<'ctx, 'engine> {
             |costs| costs.fuel_for_elements(u64::from(delta)),
             |this| {
                 let table = this.cache.get_table(this.ctx, table_index);
-                this.ctx
-                    .resolve_table_mut(&table)
-                    .grow_untyped(delta, init)
-                    .map_err(|_| EntityGrowError::InvalidGrow)
+                this.ctx.resolve_table_mut(&table).grow_untyped(
+                    delta,
+                    init,
+                    &mut this.resource_limiter,
+                )
             },
         );
         let result = match result {

crates/wasmi/src/engine/mod.rs

@@ -793,18 +793,20 @@ impl<'engine> EngineExecutor<'engine> {
             code.into()
         }
 
-        let store_inner = &mut ctx.store.inner;
+        let (store_inner, resource_limiter) = ctx.store.store_inner_and_resource_limiter_ref();
         let value_stack = &mut self.stack.values;
         let call_stack = &mut self.stack.frames;
         let code_map = &self.res.code_map;
         let const_pool = self.res.const_pool.view();
+
         execute_wasm(
             store_inner,
             cache,
             value_stack,
             call_stack,
             code_map,
             const_pool,
+            resource_limiter,
         )
         .map_err(make_trap)
     }

crates/wasmi/src/lib.rs

@@ -93,6 +93,7 @@ mod externref;
 mod func;
 mod global;
 mod instance;
+mod limits;
 mod linker;
 mod memory;
 mod module;
@@ -145,6 +146,7 @@ pub use self::{
     },
     global::{Global, GlobalType, Mutability},
     instance::{Export, ExportsIter, Extern, ExternType, Instance},
+    limits::{ResourceLimiter, StoreLimits, StoreLimitsBuilder},
     linker::Linker,
     memory::{Memory, MemoryType},
     module::{