A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
Guest debugging: fix fuel handling around breakpoints. (#14682)
Chris Fallin9258f23e7c75
diff --git a/crates/cranelift/src/func_environ.rs b/crates/cranelift/src/func_environ.rsindex 447c8f63cc..3461bb3fe0 100644--- a/crates/cranelift/src/func_environ.rs+++ b/crates/cranelift/src/func_environ.rs@@ -5310,15 +5310,28 @@ impl FuncEnvironment<'_> {_operand_types: Option<&[WasmValType]>,builder: &mut FunctionBuilder,) -> WasmResult<()> {- if self.tunables.consume_fuel {- self.fuel_before_op(op, builder, self.is_reachable());- }if self.is_reachable() && self.state_slot.is_some() {+ // The breakpoint may invoke the debug handler, which may observe+ // or modify the store's fuel, so synchronize our locally cached+ // fuel with the store around it. This happens before+ // `fuel_before_op` so that the fuel visible at the breakpoint+ // accounts for all operators prior to (but not including) this+ // one.+ if self.tunables.consume_fuel {+ self.fuel_increment_var(builder);+ self.fuel_save_from_var(builder);+ }let builtin = self.builtin_functions.patchable_breakpoint(builder.func);let vmctx = self.vmctx_val(&mut builder.cursor());let inst = builder.ins().call(builtin, &[vmctx]);let tags = self.debug_tags(builder.srcloc());builder.func.debug_tags.set(inst, tags);+ if self.tunables.consume_fuel {+ self.fuel_load_into_var(builder);+ }+ }+ if self.tunables.consume_fuel {+ self.fuel_before_op(op, builder, self.is_reachable());}Ok(())diff --git a/tests/all/debug.rs b/tests/all/debug.rsindex 0b3be505e0..bf670294a2 100644--- a/tests/all/debug.rs+++ b/tests/all/debug.rs@@ -5,7 +5,7 @@ use std::sync::{Arc, Mutex};use wasmtime::{AsContextMut, Caller, Collector, Config, DebugEvent, DebugHandler, Engine, Extern, FrameHandle,Func, Global, GlobalType, Inlining, Instance, Module, ModulePC, Mutability, Result, Store,- StoreContextMut, Val, ValType,+ StoreContextMut, Trap, Val, ValType,};use crate::async_functions::PollOnce;@@ -1792,3 +1792,80 @@ fn gc_in_func_without_program_points() -> wasmtime::Result<()> {}Ok(())}++#[tokio::test]+#[cfg_attr(miri, ignore)]+async fn fuel_visible_and_mutable_in_debug_handler() -> wasmtime::Result<()> {+ let _ = env_logger::try_init();++ let mut config = Config::default();+ config.guest_debug(true).consume_fuel(true);+ let engine = Engine::new(&config)?;+ let module = Module::new(+ &engine,+ r#"+ (module+ (func (export "count") (param $n i32) (result i32)+ (local $i i32)+ (loop $l+ (local.set $i (i32.add (local.get $i) (i32.const 1)))+ (br_if $l (i32.lt_u (local.get $i) (local.get $n))))+ (local.get $i)))+ "#,+ )?;++ #[derive(Clone)]+ struct FuelHandler {+ observed: Arc<Mutex<Vec<u64>>>,+ zero_fuel_at: usize,+ }+ impl DebugHandler for FuelHandler {+ type Data = ();+ async fn handle(&self, mut store: StoreContextMut<'_, ()>, event: DebugEvent<'_>) {+ if let DebugEvent::Breakpoint = event {+ let mut observed = self.observed.lock().unwrap();+ observed.push(store.get_fuel().unwrap());+ if observed.len() == self.zero_fuel_at {+ store.set_fuel(0).unwrap();+ }+ }+ }+ }++ // First, run to completion and check that the fuel observed at each+ // breakpoint reflects consumption so far.+ let mut store = Store::new(&engine, ());+ store.set_fuel(1_000_000)?;+ store.edit_breakpoints().unwrap().single_step(true)?;+ let observed = Arc::new(Mutex::new(vec![]));+ store.set_debug_handler(FuelHandler {+ observed: observed.clone(),+ zero_fuel_at: usize::MAX,+ });+ let instance = Instance::new_async(&mut store, &module, &[]).await?;+ let count = instance.get_typed_func::<i32, i32>(&mut store, "count")?;+ assert_eq!(count.call_async(&mut store, 100).await?, 100);+ {+ let observed = observed.lock().unwrap();+ assert!(observed.len() > 100);+ assert!(observed.windows(2).all(|w| w[0] >= w[1]));+ assert!(observed.first().unwrap() > observed.last().unwrap());+ assert!(*observed.last().unwrap() >= store.get_fuel()?);+ }++ // Then, zero out fuel partway through, which must cause an out-of-fuel+ // trap rather than running to completion.+ let mut store = Store::new(&engine, ());+ store.set_fuel(1_000_000)?;+ store.edit_breakpoints().unwrap().single_step(true)?;+ store.set_debug_handler(FuelHandler {+ observed: Arc::new(Mutex::new(vec![])),+ zero_fuel_at: 10,+ });+ let instance = Instance::new_async(&mut store, &module, &[]).await?;+ let count = instance.get_typed_func::<i32, i32>(&mut store, "count")?;+ let err = count.call_async(&mut store, 100).await.unwrap_err();+ assert_eq!(err.downcast::<Trap>()?, Trap::OutOfFuel);++ Ok(())+}