A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
Fix a guest write to a host future being cancelled (#14672)
Alex Crichtonc0ca85571cb5
diff --git a/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rs b/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rsindex f992d44fce..0b1d74e661 100644--- a/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rs+++ b/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rs@@ -3742,10 +3742,6 @@ impl Instance {bail_bug!("expected guest_offset to be 0");}- if let TransmitIndex::Future(_) = ty {- transmit.done = true;- }-set_guest_ready(concurrent_state)?;self.consume(store.0,diff --git a/tests/all/component_model/async.rs b/tests/all/component_model/async.rsindex b60831f09f..66387c1545 100644--- a/tests/all/component_model/async.rs+++ b/tests/all/component_model/async.rs@@ -2179,3 +2179,90 @@ async fn task_group_deletion() -> Result<()> {Ok(())}++/// A guest's `future.write` to a host consumer which never takes the value+/// blocks, and once cancelled the write may be retried.+#[tokio::test]+#[cfg_attr(miri, ignore)]+async fn retry_cancelled_future_write_to_host() -> Result<()> {+ let mut config = Config::new();+ config.wasm_component_model_async(true);+ let engine = Engine::new(&config)?;+ let component = Component::new(+ &engine,+ r#"+(component+ (core module $libc (memory (export "memory") 1))+ (core instance $libc (instantiate $libc))+ (type $f (future u32))+ (core func $future.new (canon future.new $f))+ (core func $future.write (canon future.write $f async (memory (core memory $libc "memory"))))+ (core func $future.cancel-write (canon future.cancel-write $f))+ (core func $task.return (canon task.return))+ (core module $m+ (import "" "future.new" (func $future.new (result i64)))+ (import "" "future.write" (func $future.write (param i32 i32) (result i32)))+ (import "" "future.cancel-write" (func $future.cancel-write (param i32) (result i32)))+ (import "" "task.return" (func $task.return))+ (global $w (mut i32) (i32.const 0))+ (func (export "new") (result i32)+ (local $pair i64)+ (local.set $pair (call $future.new))+ (global.set $w (i32.wrap_i64 (i64.shr_u (local.get $pair) (i64.const 32))))+ (i32.wrap_i64 (local.get $pair)))+ (func $write-then-cancel+ (if (i32.ne (call $future.write (global.get $w) (i32.const 0)) (i32.const -1 (; BLOCKED ;)))+ (then unreachable))+ (if (i32.ne (call $future.cancel-write (global.get $w)) (i32.const 2 (; CANCELLED ;)))+ (then unreachable)))+ (func (export "run") (result i32)+ (call $write-then-cancel)+ (call $write-then-cancel)+ (call $task.return)+ (i32.const 0 (; EXIT ;)))+ (func (export "cb") (param i32 i32 i32) (result i32) unreachable)+ )+ (core instance $i (instantiate $m (with "" (instance+ (export "future.new" (func $future.new))+ (export "future.write" (func $future.write))+ (export "future.cancel-write" (func $future.cancel-write))+ (export "task.return" (func $task.return))))))+ (func (export "new") (result $f) (canon lift (core func $i "new")))+ (func (export "run") async+ (canon lift (core func $i "run") async (callback (core func $i "cb"))))+)+ "#,+ )?;++ let mut store = Store::new(&engine, ());+ let instance = Linker::new(&engine)+ .instantiate_async(&mut store, &component)+ .await?;+ let new = instance.get_typed_func::<(), (FutureReader<u32>,)>(&mut store, "new")?;+ let run = instance.get_typed_func::<(), ()>(&mut store, "run")?;+ let (reader,) = new.call_async(&mut store, ()).await?;+ reader.pipe(&mut store, NeverConsume)?;+ run.call_async(&mut store, ()).await?;+ return Ok(());++ /// Never takes the value; acknowledges cancellation when asked to finish.+ struct NeverConsume;++ impl FutureConsumer<()> for NeverConsume {+ type Item = u32;++ fn poll_consume(+ self: Pin<&mut Self>,+ _cx: &mut Context<'_>,+ _store: StoreContextMut<()>,+ _source: Source<'_, u32>,+ finish: bool,+ ) -> Poll<Result<()>> {+ if finish {+ Poll::Ready(Ok(()))+ } else {+ Poll::Pending+ }+ }+ }+}