A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
Handle delivering cancellation to non-enterable instance (#14559)
Alex Crichton8e6b62603e7e
diff --git a/crates/wasmtime/src/runtime/component/concurrent.rs b/crates/wasmtime/src/runtime/component/concurrent.rsindex 15d2bd7699..7ddeaf13bf 100644--- a/crates/wasmtime/src/runtime/component/concurrent.rs+++ b/crates/wasmtime/src/runtime/component/concurrent.rs@@ -4366,6 +4366,7 @@ impl Instance {task: guest_task,thread,};+ let concurrent_state = store.concurrent_state_mut()?;let thread_mut = concurrent_state.get_mut(thread.thread)?;let yield_ = |store: &mut StoreOpaque| {@@ -4429,6 +4430,25 @@ impl Instance {if concurrent_state.promote_thread_work_item(thread)? {yield_(store)?;break;+ } else if store+ .instance_state(runtime_instance)+ .concurrent_state()+ .pending+ .contains_key(&thread)+ {+ // The thread's work item was parked in+ // `pending` because its instance can't be+ // entered right now, so the cancellation+ // can't be delivered yet. It'll be delivered+ // via `GuestTask::event` once the instance+ // becomes enterable and the work item runs.+ // Until then the thread is still yielding, so+ // restore `wake_on_cancel` and move on to the+ // next thread.+ store+ .concurrent_state_mut()?+ .get_mut(thread.thread)?+ .wake_on_cancel = WakeOnCancel::Yielding;} else {bail_bug!("thread with `WakeOnCancel::Yielding` not promotable");}diff --git a/tests/misc_testsuite/component-model/async/cancel-yielding-in-pending.wast b/tests/misc_testsuite/component-model/async/cancel-yielding-in-pending.wastnew file mode 100644index 0000000000..a1385a2d32--- /dev/null+++ b/tests/misc_testsuite/component-model/async/cancel-yielding-in-pending.wast@@ -0,0 +1,156 @@+;;! component_model_async = true+;;! component_model_more_async_builtins = true++;; A callback-lifted task returns `CALLBACK_CODE_YIELD`, queueing a work item to+;; call its callback again. Before that work item runs, the task's instance+;; becomes non-enterable because a sync-lifted, async-typed export of the same+;; instance is in progress, so the work item is parked until the instance can+;; be entered again. Cancelling the yielding task at that point must not be+;; delivered immediately but must instead be delivered once the instance is+;; enterable again.++;; Synchronous `subtask.cancel`: the cancellation is delivered once the+;; sync-lifted export finishes, after which the task acknowledges it.+(component+ (component $J+ (core func $task.cancel (canon task.cancel))+ (core func $thread.yield (canon thread.yield))+ (core module $m+ (import "" "task.cancel" (func $task.cancel))+ (import "" "thread.yield" (func $yield (result i32)))+ (func (export "x") (result i32)+ (i32.const 1 (; YIELD ;)))+ (func (export "x-cb") (param i32 i32 i32) (result i32)+ (if (i32.eq (local.get 0) (i32.const 6 (; TASK_CANCELLED ;)))+ (then+ (call $task.cancel)+ (return (i32.const 0 (; EXIT ;)))))+ (i32.const 1 (; YIELD ;)))+ (func (export "s")+ (local $i i32)+ (loop $l+ (drop (call $yield))+ (local.set $i (i32.add (local.get $i) (i32.const 1)))+ (br_if $l (i32.lt_u (local.get $i) (i32.const 10)))))+ )+ (core instance $i (instantiate $m (with "" (instance+ (export "task.cancel" (func $task.cancel))+ (export "thread.yield" (func $thread.yield))))))+ (func (export "x") async+ (canon lift (core func $i "x") async+ (callback (core func $i "x-cb"))))+ (func (export "s") async (canon lift (core func $i "s")))+ )+ (component $C+ (import "x" (func $x async))+ (import "s" (func $s async))+ (core func $x (canon lower (func $x) async))+ (core func $s (canon lower (func $s) async))+ (core func $subtask.cancel (canon subtask.cancel))+ (core func $thread.yield (canon thread.yield))+ (core module $m+ (import "" "x" (func $x (result i32)))+ (import "" "s" (func $s (result i32)))+ (import "" "subtask.cancel" (func $cancel (param i32) (result i32)))+ (import "" "thread.yield" (func $yield (result i32)))+ (func (export "run") (result i32)+ (local $hx i32) (local $hs i32)+ (local.set $hx (call $x))+ (if (i32.ne (i32.and (local.get $hx) (i32.const 0xf))+ (i32.const 1 (; STARTED ;)))+ (then unreachable))+ (local.set $hx (i32.shr_u (local.get $hx) (i32.const 4)))+ ;; make $J non-enterable+ (local.set $hs (call $s))+ (if (i32.ne (i32.and (local.get $hs) (i32.const 0xf))+ (i32.const 1 (; STARTED ;)))+ (then unreachable))+ ;; let the event loop park x's callback work item+ (drop (call $yield))+ (call $cancel (local.get $hx)))+ )+ (core instance $i (instantiate $m (with "" (instance+ (export "x" (func $x))+ (export "s" (func $s))+ (export "subtask.cancel" (func $subtask.cancel))+ (export "thread.yield" (func $thread.yield))))))+ (func (export "run") async (result u32) (canon lift (core func $i "run")))+ )+ (instance $j (instantiate $J))+ (instance $c (instantiate $C+ (with "x" (func $j "x"))+ (with "s" (func $j "s"))))+ (func (export "run") (alias export $c "run"))+)+(assert_return (invoke "run") (u32.const 4 (; RETURN_CANCELLED ;)))++;; Asynchronous `subtask.cancel`: the sync-lifted export never finishes, so the+;; cancellation can't be delivered and `subtask.cancel` returns `BLOCKED`.+(component+ (import "host" (instance $host (export "never-return" (func async))))+ (component $X+ (import "never-return" (func $never-return async))+ (core func $never-return (canon lower (func $never-return)))+ (core func $task-cancel (canon task.cancel))+ (core module $x+ (import "" "never-return" (func $never-return))+ (import "" "task.cancel" (func $task-cancel))+ (func (export "y") (result i32) (i32.const 1 (; YIELD ;)))+ (func (export "y-cb") (param i32 i32 i32) (result i32)+ (if (i32.eq (local.get 0) (i32.const 6 (; TASK_CANCELLED ;)))+ (then (call $task-cancel) (return (i32.const 0 (; EXIT ;)))))+ (i32.const 1 (; YIELD ;)))+ (func (export "blk") (call $never-return)))+ (core instance $x (instantiate $x (with "" (instance+ (export "never-return" (func $never-return))+ (export "task.cancel" (func $task-cancel))))))+ (func (export "y") async+ (canon lift (core func $x "y") async+ (callback (core func $x "y-cb"))))+ (func (export "blk") async (canon lift (core func $x "blk")))+ )+ (component $Y+ (import "x" (instance $x+ (export "y" (func async))+ (export "blk" (func async))))+ (core func $y (canon lower (func $x "y") async))+ (core func $blk (canon lower (func $x "blk") async))+ (core func $cancel (canon subtask.cancel async))+ (core func $task-return (canon task.return (result u32)))+ (core module $m+ (import "" "y" (func $y (result i32)))+ (import "" "blk" (func $blk (result i32)))+ (import "" "cancel" (func $cancel (param i32) (result i32)))+ (import "" "task.return" (func $task-return (param i32)))+ (global $hy (mut i32) (i32.const 0))+ (func (export "run") (result i32)+ (local $ret i32)+ (local.set $ret (call $y))+ (if (i32.ne (i32.and (local.get $ret) (i32.const 0xf))+ (i32.const 1 (; STARTED ;)))+ (then unreachable))+ (global.set $hy (i32.shr_u (local.get $ret) (i32.const 4)))+ ;; make $X non-enterable+ (if (i32.ne (i32.and (call $blk) (i32.const 0xf))+ (i32.const 1 (; STARTED ;)))+ (then unreachable))+ ;; let the event loop park y's callback work item+ (i32.const 1 (; YIELD ;)))+ (func (export "run-cb") (param i32 i32 i32) (result i32)+ (call $task-return (call $cancel (global.get $hy)))+ (i32.const 0 (; EXIT ;))))+ (core instance $m (instantiate $m (with "" (instance+ (export "y" (func $y))+ (export "blk" (func $blk))+ (export "cancel" (func $cancel))+ (export "task.return" (func $task-return))))))+ (func (export "run") async (result u32)+ (canon lift (core func $m "run") async+ (callback (core func $m "run-cb"))))+ )+ (instance $x (instantiate $X+ (with "never-return" (func $host "never-return"))))+ (instance $y (instantiate $Y (with "x" (instance $x))))+ (export "run" (func $y "run"))+)+(assert_return (invoke "run") (u32.const 0xffffffff (; BLOCKED ;)))