Skip to content

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.rs
index 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.rs
index 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(())
+}