Changes in concurrent_disabled.rs

9661ca85 - Remove some more panics in `concurrent.rs` (#12874)

Mon, 30 Mar 2026 14:18:12 +0000

Remove some more panics in `concurrent.rs` (#12874)Downgrade some panics to `bail_bug!` or `?` where appropriate bypropagating `Result` in a few more locations. List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/concurrent_disabled.rs

58877f2f - Fix the current guest task when calling `realloc` (#12718)

Wed, 04 Mar 2026 21:14:33 +0000

Fix the current guest task when calling `realloc` (#12718)* Fix the current guest task when calling `realloc`This commit fixes some fallout from #12550 where after that PR thecurrent task registered when a guest's `realloc` was called wasincorrect. This additionally fixes issues where guest-to-guesttrampolines also had the wrong task registered when `realloc` was beingcalled. Finally this adjusts a few locations that "no borrows should beactive" traps happen to ensure that it happens around the time of when atask returns rather than after the lowering of its values happens.* Fix non-async build List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/concurrent_disabled.rs

da093747 - Relax panics in async/futures to traps/errors (#12688)

Mon, 02 Mar 2026 21:26:40 +0000

Relax panics in async/futures to traps/errors (#12688)* Relax panics in async/futures to traps/errorsThis commit is an admittance that I don't believe we're going to getto a point where we are confident enough in the fuzzing ofcomponent-model-async such that we could confidently say we'reexercising the vast majority of possible panics. Development ofcomponent-model-async has shown a steady trickle of panics over thecourse of the development of the feature, and this trend has beenpersistent over time as well.An attempt was made in #12119 to add a fuzzer dedicated to async eventsbut that didn't actually find anything in development and it has misseda number of panics present before and discovered after its introduction.Overall I do not know how to improve the fuzzer to the point that itwould find pretty much all of the existing async-related panics overtime.To help address this concern of the `concurrent.rs` implementation thiscommit goes through and replaces things like `unwrap()`, `assert!`,`panic!`, and `unreachable!` with an error-producing form. The benefitof this is that a bug in the implementation is less likely to result ina panic and instead just results in a non-spec-compliant trap. Thedownside of doing this though is that it can become unclear what errorsare "first class traps", or expected to be guest reachable, and whichare expected to be bugs in Wasmtime. To help address this I've performeda few refactorings here as well.* Some traps previously present as error strings are now promoted to using `Trap::Foo` instead. This has some refactoring of the Rust/C side as well to make it easier to define new variants. Tests were additionally added for any trap messages that weren't previously tested as being reachable.* A new `bail_bug!` macro was added (internally) for Wasmtime. This is coupled with a concrete `WasmtimeBug` error type (exported as `wasmtime::WasmtimeBug`). The intention is that `bail!` continues to be "here's a string and I'm a bit too lazy to make a concrete error" while `bail_bug!` indicates "this is a bug in wasmtime please report this if you see it".The rough vision is that if an error condition is reached, and the systemis not broken in such a way that panicking is required, then `bail_bug!`can be used to indicate a bug in Wasmtime as opposed to panicking. Thisreduces the real-world impact of hitting these scenarios by downgrading aCVE-worthy `panic!` into a bug-worthy non-spec-compliant trap. Not allpanics are able to be transitioned to this as some are load bearing froma safety perspective or similar (or indicate something equally broken),but the vast majority of cases are suitable for "return a trap, lockdown the store, and let destructors take care of everything else".This change additionally has resulted in API changes for `FutureReader`and `StreamReader`. For example creation of these types now returns a`Result` for when the `ResourceTable` is full, for example, instead ofpanicking.* Fix CI build* Translate `WasmtimeBug` to panics in debug mode* Review comments* Refactor some stream methods for fewer panics List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/concurrent_disabled.rs

3764e757 - Refactor borrow state tracking for async tasks (#12550)

Tue, 10 Feb 2026 03:15:51 +0000

Refactor borrow state tracking for async tasks (#12550)* Refactor borrow state tracking for async tasksThis commit is a somewhat deep refactoring of how the state of`borrow` is managed for both the host and the guest with respect toasync tasks. This additionally refactors how some async task managementis done for host-called functions.The fundamental problem being tackled here is #12510. In that issue itwas discovered that the way `CallContext`, the borrow tracking mechanismin Wasmtime, is managed is incompatible with async tasks. Specificallythe previous assumption of the scope being mutated for a borrow issomewhere on the call stack is no longer true. It's possible for anasync task to be suspended, for example, and then a sibling task drops aborrow which should update the scope of the suspended task. There were anumber of other small issues I noticed here and there which this PRadditionally has tests for, all of which failed before this change andpass afterwards.The manner in which borrow state is manipulated is a pretty old part ofthe component model implementation dating back to the originalimplementation of resources. I decided to forgo any possible quick fixand have attempted to more deeply refactor and integrate async tasksinto all of this infrastructure. A list of the changes made here are:* The `CallContexts` structure, a stack of `CallContext`, was removed. Tasks now directly store a `CallContext` which is the source of truth for borrow tracking for that call, and it does not move from this location. The store `CallContexts` is now deleted in favor of updating the `Option` in the store to be an `enum` of either concurrent state or a stack. In this manner the old stack-based structure is still used sometimes, but it's impossible to reach when concurrency is enabled.* Entry to the host from guests now reliably pushes a `HostTask` into the store. Previously where a frame were always pushed into a `CallContext` a `HostTask` is pushed into the store. This is still expected to be a bit too expensive for cheap host calls, but it doesn't meaningfully change the performance profile of before.* The `resource_enter_call` and `resource_exit_call` libcalls have been removed. These are now folded into the `enter_sync_call` and `exit_sync_call` libcalls. Emission of these hooks has been updated accordingly. The concept of entering a call more generally has been removed. This is more formally known in the async world as a task starting, so the task creation is now responsible for the demarcation of entering a call. Additionally this means that the concept of exiting a call has somewhat gone away. Instead this method was renamed to `validate_scope_exit` which double-checks that a borrow-scope can be exited but doesn't actually remove the task. Task removal is deferred to preexisting mechanisms.* Management of a `GuestTask`'s previous `Option` field, for example taking/restoring and pushing/popping onto `CallContexts` is now all gone. All related code is outright deleted as the `GuestTask`'s now non-optional `CallContext` field is the source of truth.* The `ConcurrentState` structure now stores a `CurrentThread` enum instead of `Option`. This represents how the currently executing thread could be a host thread, not just a guest thread, which is required for borrow-tracking.* `HostTask` creation in `poll_and_block` and `first_poll`, the two main entrypoints of async host tasks when called by the guest, is now externalized from these functions. Instead these functions assume that the currently running thread is already a `HostTask` of some kind.* In `poll_and_block` the host's result is no longer stored in the guest task but in the host task instead.Overall this enables the `*.wast` test for #12510 to fix the originalissue. This then adds new tests to ensure that cleanup of variousconstructs happens appropriately, such as cancelling a host task shouldclean up its associated resources. Additionally synchronously calling anasync host task no longer leaks resources in a `Store` and shouldproperly clean up everything.There is still more work to do in this area (e.g. #12544) but that'sgoing to be deferred to a future PR at this point.Closes #12510prtest:full* Review comments/CI fixes List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/concurrent_disabled.rs

c09aa380 - deprecate `[Typed]Func::post_return[_async]` and make them no-ops (#12498)

Tue, 03 Feb 2026 19:13:45 +0000

deprecate `[Typed]Func::post_return[_async]` and make them no-ops (#12498)* deprecate `[Typed]Func::post_return[_async]` and make them no-opsWith the advent of the Component Model concurrency ABI and it's `task.return`intrinsic, post-return functions have been informally deprecated and areexpected to be removed for WASI 1.0 and the corresponding stable edition of theComponent Model. Consequently, it does not make sense anymore to requireembedders to explicitly call the post-return function after using`[Typed]Func::call[_async]`.As of this commit, `[Typed]Func::post_return[_async]` are no-ops. Instead, thepost-return function is called automatically as part of`[Typed]Func::call[_async]` if present, which is how`[Typed]Func::call_concurrent` has worked all along. In addition, this commitfixes and tests a couple of cases where the task and/or thread was beingdisposed of before the post-return function was called.* address review feedback* test post-return function in more scenariosSpecifically, I've split the `invoke_post_return` test into multiple tests:- using `TypedFunc::call`- using `TypedFunc::call_async` with concurrency support enabled- using `TypedFunc::call_async` with concurrency support disabled- using `Func::call_async` with concurrency support disabled- using `TypedFunc::call_concurrent`* remove GCC/clang-specific deprecation attributeThis broke the MSVC build.* bless bindgen output* remove obsolete post-return functions and fieldsNow that post-return calls are handled internally without requiring explicitaction by the embedder, we can avoid unnecessary bookkeeping. List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/concurrent_disabled.rs

21797bb5 - Refactor how concurrency support is enabled in a `Store` (#12416)

Fri, 23 Jan 2026 22:37:55 +0000

Refactor how concurrency support is enabled in a `Store` (#12416)* Document panics from using CM async machinery when CM async is not enabled* Refactor how concurrency support is enabled in a `Store`This commit is an extension/refactor of #12377 and #12379. Notably thisdecouples the runtime behavior of Wasmtime from enabled/disabledWebAssembly proposals. This enables the `wasmtime serve` subcommand, forexample, to continue to disallow component-model-async by default butcontinue to use `*_concurrent` under the hood.Specifically a new `Config::concurrency_support` knob is added. This isplumbed directly through to `Tunables` and takes over the preexisting`component_model_concurrency` field. This field configures whethertasks/etc are enabled at runtime for component-y things. The defaultvalue of this configuration option is the same as `cfg!(feature ="component-model-async")`, and this field is required ifcomponent-model-async wasm proposals are enabled. It's intended thateventually this'll affect on-by-default wasm features in Wasmtimedepending if the support is compiled in.This results in a subtle shift in behavior where component-model-asyncconcurrency is used by default now because the feature is turned on bydefault, even though the wasm features are off-by-default. This requiredadjusting a few indices expected in runtime tests due to tasks/threadsbeing allocated in index spaces.Finally, this additionally denies access at runtime to`Linker::*_concurrent` when concurrent support is disabled as otherwisethe various runtime data structures won't be initialized and panics willhappen.Closes #12393* Add a `-Wconcurrency-support` CLI flagUsed to update disas tests to show that, when disabled, old codegenquality is preserved* Ungate `Config` flag* Review comments---------Co-authored-by: Nick Fitzgerald List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/concurrent_disabled.rs

b271e452 - consistently create thread and task when entering component instance (#12379)

Fri, 23 Jan 2026 17:51:19 +0000

consistently create thread and task when entering component instance (#12379)* consistently create thread and task when entering component instancePreviously, we weren't creating a new thread or task in all cases when enteringa component instance, even when component model async features were enabled. Inparticular, entering an instance via a sync-to-sync, guest-to-guest adapter, via`Linker::instantiate[_async]`, or via `[Typed]Func::call` all skipped creating athread or task, creating panics and/or instance mismatches in certain cases.This commit addresses all those cases and also adds assertions to all CM asyncintrinsics to verify that the caller instance matches the most-recently-pushedtask. Note that we still skip pushing and popping threads and tasks if no CMasync features are enabled in the `Config`.In order to populate the `GuestTask::instance` field for tasks created as partof `Linker::instantiate[_async]` calls, I had to add a`RuntimeComponentInstanceIndex` field to `GlobalInitializer::InstantiateModule`and friends so it would be available when needed.While testing this, I uncovered and fixed a couple of related issues:- We weren't checking the `may_leave` flag when guest-to-guest calling a resource destructor- We weren't checking whether a subtask was ready to delete (e.g. that no threads were still running) before attempting to delete it while deleting its supertask* fix warnings when component-model-async feature disabled* address review feedback* push a task when calling a resource dtor host-to-guest* add tests which call `thread.index` from realloc and post-return functions...and assert that the indexes match as expected.Getting the post-return test to pass required moving the call to`StoreOpaque::exit_sync_call` to after the post-return function is called. List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/concurrent_disabled.rs

63679896 - Only create `ConcurrentState` in a `Store` when CM async is enabled (#12377)

Thu, 22 Jan 2026 17:56:26 +0000

Only create `ConcurrentState` in a `Store` when CM async is enabled (#12377)* Only create `ConcurrentState` in a `Store` when CM async is enabledCreating the default `ConcurrentState` will create a `FuturesUnordered` whichwill allocate. By making this state optional, we can keep making progress onhttps://github.com/bytecodealliance/wasmtime/issues/12069, and put off dealingwith `FuturesUnordered` until when we are ready to try and make CM async codehandle OOMs.* Support dynamically disabling component-model-async at runtime* fix warnings in certain cfg builds* fix another warning* Forcibly enable CM async for a couple wast tests List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/concurrent_disabled.rs

b856261d - refactor recursive reentrance checks (#12349)

Wed, 14 Jan 2026 22:27:49 +0000

refactor recursive reentrance checks (#12349)* refactor recursive reentrance checksThis commit makes a few changes related to recursive reentrance checks, instancepoisoning, etc.:- Implements the more restrictive lift/lower rules described in https://github.com/WebAssembly/component-model/pull/589 such that a component instance may not lower a function lifted by one of its ancestors, nor vice-versa. Any such lower will result in a fused adapter which traps unconditionally, preventing guest-to-guest recursive reentrance without requiring data flow analysis. - Note that this required updating several WAST tests which were violating the new rule, including some in the `tests/component-model` Git submodule, which I've updated. - This is handled entirely in the `fact` module now; I've removed the `AlwaysTrap` case previously handled by `wasmtime-cranelift`.- Removes `FLAG_MAY_ENTER` from `InstanceFlags`. It is no longer needed for guest-to-guest calls due to the above, and for guest-to-host-to-guest calls we can rely on either `FLAG_NEEDS_POST_RETURN` for sync-lifted functions or the `GuestTask` call stack for async-lifted functions.- Adds a `StoreOpaque::trapped` field which is set when _any_ instance belonging to that store traps, at which point the entire store is considered poisoned, meaning no instance belonging to it may be entered. This prevents indeterminant concurrent task state left over from the trapping instance from leaking into other instances.Note that this does _not_ include code to push and pop `GuestTask` instances forguest-to-guest sync-to-sync calls, nor for host-to-guest calls using e.g. thesynchronous `Func::call` API, so certain intrinsics which expect a `GuestTask`to be present such as `backpressure.inc` will still fail in such cases. I'lladdress that in a later PR.Also note that I made a small change to `wasmtime-wit-bindgen`, adding a `Send`bound on the `T` type parameter for `store | async` functions. This allowed meto recursively call `{Typed}Func::call_concurrent` from inside a host function,and it doesn't have any downsides AFAICT.Fixes #12128* bless bindgen expansions* bless disas tests* address review feedback* sync `trap.h` with `trap_encoding.rs`...and add const assertions to `trap.rs` to help avoid future divergence. List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/concurrent_disabled.rs

fae9e6af - add missing may-block checks for sync-to-sync guest-to-guest calls (#12282)

Thu, 08 Jan 2026 22:16:30 +0000

add missing may-block checks for sync-to-sync guest-to-guest calls (#12282)* add missing may-block checks for sync-to-sync guest-to-guest callsPreviously, we weren't updating or checking the may-block status of a taskacross sync-to-sync, guest-to-guest calls, meaning we were allowing blocking incases we shouldn't have.This fixes that by adding a new `task_may_block` field to `VMComponentContext`,plus code to update it every time we switch threads or do a sync-to-sync,guest-to-guest call. We use that field as the source of truth about whether ablocking operation is permitted.I've updated various tests to match, and Luke has an item on his to-do list toadd sad-path coverage for various cases to the upstream `component-model` testsuite.* address review feedback and fix component_instance_size_limit test* remove `TaskMayBlock` type per review feedback* bless disas tests List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/concurrent_disabled.rs

96e19700 - Migrate the `wasmtime` crate to `wasmtime_environ::error::*` (#12231)

Wed, 07 Jan 2026 17:08:11 +0000

Migrate the `wasmtime` crate to `wasmtime_environ::error::*` (#12231)* Migrate the `wasmtime` crate to `wasmtime_environ::error::*`Instead of `anyhow::Error`.This commit re-exports the `wasmtime_environ::error` as the `wasmtime::error`module, updates the prelude to include these new error-handling types, redirectsour top-level `wasmtime::{Error, Result}` re-exports to re-export`wasmtime::error::{Error, Result}`, and updates various use sites that weredirectly using `anyhow` to use the new `wasmtime` versions.This process also required updating the component macro and wit-bindgen macro touse the new error types instead of `anyhow`.Part of https://github.com/bytecodealliance/wasmtime/issues/12069* Replace wasmtime::error::Thing with wasmtime::Thing where it makes sense* cargo fmt* Move `crate::error::Thing` to `crate::Thing` where it makes sense List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/concurrent_disabled.rs

05a711f6 - Deduplicate static/dynamic host function code paths (#12146)

Thu, 11 Dec 2025 20:21:03 +0000

Deduplicate static/dynamic host function code paths (#12146)* Deduplicate static/dynamic host function code pathsThis commit refactors the `component/func/host.rs` file to deduplicatethe paths between static/dynamic host functions. Previously there was asignificant amount of duplication between the two which has beenexacerbated through time. This commit refactors the state of affairs toensure that all the shared logic between the two is in one location andthe only difference is what they're already doing different (e.g.lifting/lowering guts).The high-level goal here was to see if this was possible, but in the endthis feels like a much cleaner state of affairs than prior as far fewerdetails are duplicated across a few locations. The host functionbehavior is slightly more "dynamic" than before in the sense thatstatically-known signature has a few more type lookups than before, forexample, but this can be fixed in due time if necessary.* Fix compile warnings/issues List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/concurrent_disabled.rs

f586be11 - cm-async: Start to fill out `{Future,Stream}Any` (#12142)

Tue, 09 Dec 2025 18:24:05 +0000

cm-async: Start to fill out `{Future,Stream}Any` (#12142)* cm-async: Start to fill out `{Future,Stream}Any`This commit is the first step down the road of filling out thepreexisting, but empty/buggy, `FutureAny` and `StreamAny` types. Theseare intended to behave similarly to `ResourceAny` where the embedderdoesn't have static knowledge ahead of time about the type of thefuture/stream in use. Changes made here are:* `ComponentType for {Stream,Future}Reader` now correctly typecheck the `T`.* Conversion to/from `*Any` types now properly typechecks the payload type against the expected type.* `{Future,Stream}Any` now live in their own file with the matrix of conversions to the typed variants.* A `close` method was added to `*Any` types.These types are not currently directly constructible but this willlikely be relaxed in the future. Additionally the host can't actuallyuse these values without knowing the type, which is another restrictionthat will be relaxed in the future (aka implemented).cc #11161* Fix tests* Skip a test on miri List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/concurrent_disabled.rs

8992b99b - trap on blocking call in sync task before return (#12043)

Tue, 09 Dec 2025 15:41:57 +0000

trap on blocking call in sync task before return (#12043)* trap on blocking call in sync task before returnThis implements a spec change (PR pending) such that tasks created for calls tosynchronous exports may not call potentially-blocking imports or return `wait`or `poll` callback codes prior to returning a value. Specifically, thefollowing are prohibited in that scenario:- returning callback-code.{wait,poll}- sync calling an async import- sync calling subtask.cancel- sync calling {stream,future}.{read,write}- sync calling {stream,future}.cancel-{read,write}- calling waitable-set.{wait,poll}- calling thread.suspendThis breaks a number of tests, which will be addressed in follow-up commits:- The `{tcp,udp}-socket.bind` implementation in `wasmtime-wasi` is implemented using `Linker::func_wrap_concurrent` and thus assumed to be async, whereas the WIT interface says they're sync, leading to a type mismatch error at runtime. Alex and I have discussed this and have a general plan to address it.- A number of tests in the tests/component-model submodule that points to the spec repo are failing. Those will presumably be fixed as part of the upcoming spec PR (although some could be due to bugs in this implementation, in which case I'll fix them).- A number of tests in tests/misc_testsuite are failing. I'll address those in a follow-up commit.Signed-off-by: Joel Dice * call `check_may_leave` before `check_blocking``check_blocking` needs access to the current task, but that's not set forpost-return functions since those should not be calling _any_ imports at all, sofirst check for that.Signed-off-by: Joel Dice * fix `misc_testsuite` test regressionsThis amounts to adding `async` to any exported component functions that mightneed to block.Signed-off-by: Joel Dice * simplify code in `ConcurrentState::check_blocking`Signed-off-by: Joel Dice * make `thread.yield` a no-op in non-blocking contextsPer the proposed spec changes, `thread.yield` should return control to the guestimmediately without allowing any other thread to run. Similarly, when anasync-lifted export or callback returns `CALLBACK_CODE_YIELD`, we should callthe callback again immediately without allowing another thread to run.Signed-off-by: Joel Dice * fix build when `component-model-async` feature disabledSigned-off-by: Joel Dice * fix more test regressionsSigned-off-by: Joel Dice * fix more test regressionsNote that this temporarily updates the `tests/component-model` submodule to thebranch for https://github.com/WebAssembly/component-model/pull/577 until that PRis merged.Signed-off-by: Joel Dice * tweak `Trap::CannotBlockSyncTask` messageThis clarifies that such a task cannot block prior to returning.Signed-off-by: Joel Dice * fix cancel_host_future testSigned-off-by: Joel Dice * trap sync-lowered, guest->guest async calls in sync tasksI somehow forgot to address this earlier. Thanks to Luke for catching this.Note that this commit doesn't include test coverage, but Luke's forthecomingtests in the `component-model` repo will cover it, and we'll pull that in withthe next submodule update.Signed-off-by: Joel Dice * switch back to `main` branch of `component-model` repo...and skip or `should_fail` the tests that won't pass untilhttps://github.com/WebAssembly/component-model/pull/578 is merged.Signed-off-by: Joel Dice * add `trap-if-block-and-sync.wast`We'll remove this again in favor of the upstream version oncehttps://github.com/WebAssembly/component-model/pull/578 has been merged.Signed-off-by: Joel Dice * address review feedback- Assert that `StoreOpaque::suspend` is not called in a non-blocking context except in specific circumstances- Typecheck async-ness for dynamic host functions- Use type parameter instead of value parameter in `call_host[_dynamic]`Signed-off-by: Joel Dice * add explanation comments to `check_blocking` callsSigned-off-by: Joel Dice * fix fuzz test oracle for async functionsSigned-off-by: Joel Dice ---------Signed-off-by: Joel Dice List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/concurrent_disabled.rs

1d738975 - Use `core::convert::Infallible` instead of our own `Uninhabited` type (#12115)

Wed, 03 Dec 2025 21:32:48 +0000

Use `core::convert::Infallible` instead of our own `Uninhabited` type (#12115)* Use `core::convert::Infallible` instead of our own `Uninhabited` typeI didn't realize that the standard library already had an uninhabited typeavailable for us to reuse.* Actually remove the uninhabited module and its re-exports List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/concurrent_disabled.rs

7e39c25e - move `ConcurrentState` from `ComponentInstance` to `Store` (#11796)

Mon, 06 Oct 2025 19:53:10 +0000

move `ConcurrentState` from `ComponentInstance` to `Store` (#11796)* move `ConcurrentState` from `ComponentInstance` to `Store`This has a few benefits:- No need to specify an instance when creating or piping from a stream or future.- No need to track the instance in an `Accessor`.- You may now execute tasks for multiple instances in a single event loop.The main drawback is that, if one of several instances within a single storetraps, it effectively means all instances have trapped, and the store can't beused to create new instances. The way to avoid that is to use separate storesfor instances which must be isolated from others.As a result of this change, a lot of code had to move from e.g. `impl Instance`to e.g. `impl StoreOpaque`, so the diff is pretty huge, but the changesthemselves are almost entirely non-functional.Fixes #11226Signed-off-by: Joel Dice * fix non-component-model-async buildSigned-off-by: Joel Dice * fix outdated doc commentSigned-off-by: Joel Dice * address review feedback- restore `ComponentStoreData` encapsulation- avoid conditional code duplication in `LiftContext::new`Signed-off-by: Joel Dice ---------Signed-off-by: Joel Dice List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/concurrent_disabled.rs

b4475438 - refactor `{Stream,Future}|{Reader,Writer}` APIs and internals (#11325)

Wed, 30 Jul 2025 16:40:41 +0000

refactor `{Stream,Future}|{Reader,Writer}` APIs and internals (#11325)* refactor `{Stream,Future}|{Reader,Writer}` APIs and internalsThis makes a several changes to how `{Stream,Future}|{Reader,Writer}` work tomake them more efficient and, in some ways, more ergonomic:- The background tasks have been removed, allowing reads and writes to complete without task context switching. We now only allocate and use oneshot channels lazily when the other end is not yet ready; this improves real world performance benchmarks (e.g. wasi-http request handling) considerably.- Instances of `{Stream,Future}Reader` can now be lifted and lowered directly; no need for `Host{Stream,Future}` anymore.- The type parameter for `Stream{Reader,Writer}` no longer refers to the buffer type -- just the payload type (i.e. `StreamReader` instead of `StreamReader>`), meaning any buffer type may be used for a given read or write operation. This also means the compiler needs help with type inference less often when calling `Instance::stream`.- Instances of `{Stream,Future}|{Reader,Writer}` now require access to the store in order to be disposed of properly. I've added RAII wrapper structs (`WithAccessor[AndValue]`) to help with this, and also updated `Store::drop` and `Instance::run_concurrent` to ensure the store thread-local is set when dropping futures closing over `&Accessor`s.- In order to ensure that resources containing `{Stream,Future}|{Reader,Writer}` instances are disposed of properly, I've added `LinkerInstance::resource_concurrent` and have updated `wasmtime-wit-bindgen` to use it. This gives resource drop functions access to a `StoreContextMut` via an `Accessor`, allowing the stream and future handles to be disposed of. - In order to make this work, I had to change `Accessor::instance` from a `Instance` to an `Option`, which is awkward but temporary since we're planning to remove `Accessor::instance` entirely once we've moved concurrent state from `ComponentInstance` to `Store`.That problem of disposal is definitely the most awkward part of all this. Insimple cases, it's easy enough to ensure that read and write handles aredisposed of properly, but both `wasmtime-wasi` and `wasmtime-wasi-http` havesome pretty complicated functions where handles are passed between tasks and/orstored inside resources, so it can be tricky to ensure proper disposal on allcode paths. I'm open to ideas for improving this, but I suspect we'll need newRust language features (e.g. linear types) to make it truly ergonomic, robust,and efficient.While testing the above, I discovered an issue with `Instance::poll_until` suchthat it would prematurely give up and return a "deadlock" trap error, believingthat there was no further work to do, even though the future passed to it wasready to resolve the next time it was polled. I've fixed this by polling it onelast time and only trapping if it returns pending.Note that I've moved a few associated functions from `ConcurrentState` to`Instance` (e.g. `guest_drop_writable` and others) since they now need access tothe store; they're unchanged otherwise. Apologies for the diff noise.Finally, I've tweaked how `wasmtime serve` to poll the guest for content beforehanding the response to Hyper, which helps performance by ensuring the firstcontent chunk can be sent with the same TCP packet as the beginning of theresponse.Signed-off-by: Joel Dice fix wasi p3 build and test failuresSigned-off-by: Joel Dice use `ManuallyDrop` instead of `Option` in `Dropper`This allows us to drop its `value` field in-place, i.e. without moving it,thereby upholding the `Pin` guarantee.Signed-off-by: Joel Dice address review comments- Remove `DropWithStoreAndValue` and friends; go back to taking a `fn() -> T` parameter in `Instance::future` instead- Make `DropWithStore::drop[_with]` take `&mut self` instead of `self`- Make `WithAccessor` and `DropWithStore` private - Instead, I've added public `Guarded{Stream,Future}{Reader,Writer}` types for RAII - and also `{Stream,Future}{Reader,Writer}::close[_with]` methods- Use RAII in `FutureReader::read` and `FutureWriter::write` to ensure handles are dropped if the `Future` is droppedSigned-off-by: Joel Dice * lower host stream/future writes in background taskThis avoids unsoundness due to guest realloc calls while there are host embedderframes on the stack.Signed-off-by: Joel Dice * fix `tcp.rs` regressionsSigned-off-by: Joel Dice ---------Signed-off-by: Joel Dice List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/concurrent_disabled.rs

b221fca7 - update `component-model-async` plumbing (#11123)

Thu, 03 Jul 2025 22:03:59 +0000

update `component-model-async` plumbing (#11123)* [DO NOT MERGE] update `component-model-async` plumbingThis pulls in the latest Component Model async ABI code from the`wasip3-prototyping` repo, including various API refactors and spec updates.This includes all the changes to the `wasmtime` crate from `wasip3-prototyping`_except_ that the `concurrent` submodule and child submodules contain onlynon-functional stubs. For that reason, and the fact thate.g. `Func::call_async` is now implemented in terms of `Func::call_concurrent`,most of the component model tests are failing. This commit is not meant to bemerged as-is; a follow-up commit (to be PR'd separately) will contain the real`concurrent` implementation, at which point the tests will pass again. I'msplitting these into separate PRs to make review easier.Signed-off-by: Joel Dice * Undo wit-bindgen changesNo longer necessary after other refactors* Move back to crates.io-based wit-bindgen* Undo upgrade of http-body-util(deferred for future PR)* Add back in arbitrary use of asyncLooks like it may have been lost by accident* Make imports more conventional for Wasmtime* Some minor changes* Privatize a component field* Cut down a bit on #[cfg]* Undo a no-longer-necessary `pub`* add doc comments for `{Future,Stream,ErrorContext}Any`Signed-off-by: Joel Dice * rename `concurrent` stub module to `concurrent_disabled`...and avoid panicking in the stubs.Signed-off-by: Joel Dice * fix test regressionSigned-off-by: Joel Dice * revert `call_async` and `post_return_impl` changesThese will need to wait until the `component-model-async` feature is fullyimplemented.Signed-off-by: Joel Dice * remove unused structSigned-off-by: Joel Dice * add `Options::callback` fieldThis isn't used yet, but will be used when the real `component-model-async`implementation is merged.Signed-off-by: Joel Dice * Remove no-longer-needed feature* Trim reexports from WasmtimeSome of these are no longer needed or can be avoided with small changes.Some deps are likely needed in the next commit but they'll be best addedthere.* Update test expectations* More trimming of Cargo.toml* Defer `*Buffer` traits to next PRNot needed for this PR I believe.* Use conventional Wasmtime imports + remove dummy_waker* Reduce duplication in `*_disabled`* Remove some unncessary bounds* Remove some `for<'a>` bounds where unnecessary* Remove another bound* Defer more functions to the next PR`drop_fibers` is different in the next PR, so defer it to then.* Remove some reexports no longer necessaryBindings generation changed awhile back so these aren't needed, deferthe implementations to the next PR.* Remove unnecessary dropThis was already moved to `run_manual_drop_routines`* Defer a `pub(crate)` to a future PR* Expand comments in traphandlers* Defer some types to the next PR* Update linker documentation* Add `Send`/`Sync` bounds to `ComponentType`This commit is extracted from from review of #11123 and #11127. Whilenot literally present in those PRs it's my own personal conclusion thatit's best to just go ahead and add these bounds at the "base" of thecomponent trait hierarchy. The current implementation in #11123 addsbounds in many locations and this would remove the need to add boundseverywhere and instead have everything inherited through the `Lift` and`Lower` traits.This raises the question of: why? The main conclusion that I've reachedleading to this change is that Wasmtime currently will store `R`, areturn value, on the stack during the lowering process back into linearmemory. This might involve allocation, however, meaning that wasm can beinvoked and a context switch could happen. For Wasmtime's `unsafe impl`of `Send` and `Sync` on fibers to be sound it requires that thisstack-local variable is also `Send` and `Sync` as it's an entirelyuser-provided type. Thus I've concluded that for results it's alwaysrequired for these to be both `Send` and `Sync` (or at the very least,`Send`).Given that I've gone ahead and updated to require both `Send` and `Sync`for both params and results. This is not expected to actually have anyimpact in practice since all primitives are already `Send`/`Sync` (minus`Rc` impls all removed here) and all `bindgen!`-generated types arecompositions of `Send`/`Sync` primitives meaning that they're also`Send` and `Sync`.* Remove some now-unnecessary bounds* Fix build after #11160* Remove some now-unnecessary duplicate bounds* Uncomment test that now works* Undo accidental doc wrap* Clarify comment on `Value` typesDon't leave `TODO` in public-facing documentation ideally* Actually resolve the conflict (forgot to commit)* Avoid returning boxed futures in APIs* Defer making constructors more public to a future PR* Make a method name more conventional* Refactor `linear_lift_into_from_memory`* Drop the `max_count` parameter in favor of slicing the `WasmList` itself. Avoids situations such as what happens if `max_count` is larger than the length of the list.* Don't have the default implementation collect to a vector and then push all that onto a different vector. Instead push each item individually through `extend`.* De-indent a block of code added* Remove unsafety from `prepare_call`Mostly move the parameters themselves to the closure to avoid rawpointers/drop/etc.This will have the consequence of in the future `call_async` is going tonow require `Params: 'static` but that seems more-or-less inevitable atthis point.* Go back to returning box, alas.* Apply same treatment to lift functionMake it a closure and reduce some levels of indirection of the variousfunctions in play.* Refactor `lower_params` to require less context.Relax the bounds on the closure specified since it's immediately calledand then additionally take out parameters/captures that the closure cancarry itself.* Don't pass extraneous `Instance` parameterThis can now be inferred from `Func`.* Clean up some SAFETY comments* Generalize the signature of `lift_results`* Move `lift_results` function to `Func`Also rename the lift/lower helpers to `with_{lift,lower}_context`* Remove parameter from `with_lift_context`Like `with_lower_context` this is fine to capture in the closure passedin.* Simplify the dynamic lifting logicDon't call `with_lift_context` in two locations, only call it once witha dynamic parameter.* Refactor away the `Func::lift_results_sync` helper* Use `with_lift_context` in `call_raw`* Simplify a call to `Func::call_unchecked_raw`* Ungate `with_lift_context` to fix non-cm-async build* Fix compile (bad cherry-pick conflict resolution)* Use `with_lower_context` in `call_raw`Trying to unify the async/concurrent paths as much as possible.* Move params out of `call_raw`Let closures capture the params, no need to thread it through as anunnecessary argument.* Clean up unsafety in `Func::call_raw`* Accurately mark `call_raw` itself as `unsafe`, then document why callers should be safe.* Don't have one large `unsafe` block in `call_raw`, instead split it up with separate safety comments.* Move a one-off type definition closer to its use* Avoid intermediate allocations in dynamic calls* Simplify a future-return site* Deduplicate checking parameter count* Simplify a future invocation with `?`* Simplify a variable declaration* Simplify some function signatures* Remove outdated safety comment* Refactor to not require `Params: 'static` on `call_async`* Remove no-longer-necessary SAFETY comment* Fix typos* Add a fast-path with no `Box` for sync host functionsSpeeds up host calls by ~20% and puts them back on parity with thebeforehand numbers Wasmtime has.* Synchronize signatures of async/concurrent dynamic callsUse slices for both instead of vecs for one and slices for the other.Required some slight rejiggering. Apparently one can solve a closureproblem with another closure, then one surely has no more closureproblems.* Fix non-cm-async build---------Signed-off-by: Joel Dice Co-authored-by: Alex Crichton List of files: /wasmtime-44.0.1/crates/wasmtime/src/runtime/component/concurrent_disabled.rs