A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
Refactor how concurrency support is enabled in a `Store` (#12416)
Alex Crichton21797bb5ec19
diff --git a/crates/cli-flags/src/lib.rs b/crates/cli-flags/src/lib.rsindex 6cc61e6cfb..aad803fe72 100644--- a/crates/cli-flags/src/lib.rs+++ b/crates/cli-flags/src/lib.rs@@ -412,6 +412,9 @@ wasmtime_option_group! {/// Component model support for fixed-length lists: this corresponds/// to the 🔧 emoji in the component model specificationpub component_model_fixed_length_lists: Option<bool>,+ /// Whether or not any concurrency infrastructure in Wasmtime is+ /// enabled or not.+ pub concurrency_support: Option<bool>,}enum Wasm {@@ -1006,6 +1009,10 @@ impl CommonOptions {config.gc_support(enable);}+ if let Some(enable) = self.wasm.concurrency_support {+ config.concurrency_support(enable);+ }+if let Some(enable) = self.wasm.shared_memory {config.shared_memory(enable);}diff --git a/crates/cranelift/src/compiler/component.rs b/crates/cranelift/src/compiler/component.rsindex 6a6c5b8224..93795cd6da 100644--- a/crates/cranelift/src/compiler/component.rs+++ b/crates/cranelift/src/compiler/component.rs@@ -1220,7 +1220,7 @@ impl<'a> TrampolineCompiler<'a> {.ins().trapz(masked, TRAP_CANNOT_LEAVE_COMPONENT);- if self.compiler.tunables.component_model_concurrency {+ if self.compiler.tunables.concurrency_support {// Stash the old value of `may_block` and then set it to false.let old_may_block = self.builder.ins().load(ir::types::I32,diff --git a/crates/environ/src/fact/trampoline.rs b/crates/environ/src/fact/trampoline.rsindex 160949ae06..79cf0a49eb 100644--- a/crates/environ/src/fact/trampoline.rs+++ b/crates/environ/src/fact/trampoline.rs@@ -180,7 +180,7 @@ pub(super) fn compile(module: &mut Module<'_>, adapter: &AdapterData) {compiler.compile_sync_to_sync_adapter(adapter, &lower_sig, &lift_sig)}(true, true) => {- assert!(module.tunables.component_model_concurrency);+ assert!(module.tunables.concurrency_support);// In the async->async case, we must compile a couple of helper functions://@@ -209,7 +209,7 @@ pub(super) fn compile(module: &mut Module<'_>, adapter: &AdapterData) {);}(false, true) => {- assert!(module.tunables.component_model_concurrency);+ assert!(module.tunables.concurrency_support);// Like the async->async case above, for the sync->async case we// also need `async-start` and `async-return` helper functions to@@ -235,7 +235,7 @@ pub(super) fn compile(module: &mut Module<'_>, adapter: &AdapterData) {);}(true, false) => {- assert!(module.tunables.component_model_concurrency);+ assert!(module.tunables.concurrency_support);// As with the async->async and sync->async cases above, for the// async->sync case we use `async-start` and `async-return` helper@@ -759,7 +759,7 @@ impl<'a, 'b> Compiler<'a, 'b> {Trap::CannotLeaveComponent,);- let old_task_may_block = if self.module.tunables.component_model_concurrency {+ let old_task_may_block = if self.module.tunables.concurrency_support {// Save, clear, and later restore the `may_block` field.let task_may_block = self.module.import_task_may_block();let old_task_may_block = if self.types[adapter.lift.ty].async_ {@@ -871,7 +871,7 @@ impl<'a, 'b> Compiler<'a, 'b> {self.instruction(Call(exit.as_u32()));}- if self.module.tunables.component_model_concurrency {+ if self.module.tunables.concurrency_support {// Pop the task we pushed earlier off of the current task stack.//// FIXME: Apply the optimizations described in #12311.diff --git a/crates/environ/src/tunables.rs b/crates/environ/src/tunables.rsindex 5a958a313a..fc9b4c3ce1 100644--- a/crates/environ/src/tunables.rs+++ b/crates/environ/src/tunables.rs@@ -143,7 +143,7 @@ define_tunables! {/// Whether any component model feature related to concurrency is/// enabled.- pub component_model_concurrency: bool,+ pub concurrency_support: bool,}pub struct ConfigTunables {@@ -219,7 +219,7 @@ impl Tunables {inlining_small_callee_size: 50,inlining_sum_size_threshold: 2000,debug_guest: false,- component_model_concurrency: true,+ concurrency_support: true,}}diff --git a/crates/wasmtime/src/config.rs b/crates/wasmtime/src/config.rsindex d500ed9c37..45d01e007e 100644--- a/crates/wasmtime/src/config.rs+++ b/crates/wasmtime/src/config.rs@@ -2358,6 +2358,10 @@ impl Config {let mut tunables = Tunables::default_for_target(&self.compiler_target())?;+ // By default this is enabled with the Cargo feature, and if the feature+ // is missing this is disabled.+ tunables.concurrency_support = cfg!(feature = "component-model-async");+// If no target is explicitly specified then further refine `tunables`// for the configuration of this host depending on what platform// features were found available at compile time. This means that anyone@@ -2430,9 +2434,23 @@ impl Config {);}- #[cfg(feature = "component-model")]- {- tunables.component_model_concurrency = self.cm_concurrency_enabled();+ // Concurrency support is required for some component model features.+ let requires_concurrency = WasmFeatures::CM_ASYNC+ | WasmFeatures::CM_ASYNC_BUILTINS+ | WasmFeatures::CM_ASYNC_STACKFUL+ | WasmFeatures::CM_THREADING+ | WasmFeatures::CM_ERROR_CONTEXT;+ if tunables.concurrency_support && !cfg!(feature = "component-model-async") {+ bail!(+ "concurrency support was requested but was not \+ compiled into this build of Wasmtime"+ )+ }+ if !tunables.concurrency_support && features.intersects(requires_concurrency) {+ bail!(+ "concurrency support must be enabled to use the component \+ model async or threading features"+ )}Ok((tunables, features))@@ -2923,17 +2941,41 @@ impl Config {self}- #[cfg(feature = "component-model")]- #[inline]- pub(crate) fn cm_concurrency_enabled(&self) -> bool {- cfg!(feature = "component-model-async")- && self.enabled_features.intersects(- WasmFeatures::CM_ASYNC- | WasmFeatures::CM_ASYNC_BUILTINS- | WasmFeatures::CM_ASYNC_STACKFUL- | WasmFeatures::CM_THREADING- | WasmFeatures::CM_ERROR_CONTEXT,- )+ /// Specifies whether support for concurrent execution of WebAssembly is+ /// supported within this store.+ ///+ /// This configuration option affects whether runtime data structures are+ /// initialized within a `Store` on creation to support concurrent execution+ /// of WebAssembly guests. This is primarily applicable to the+ /// [`Config::wasm_component_model_async`] configuration which is the first+ /// time Wasmtime has supported concurrent execution of guests. This+ /// configuration option, for example, enables usage of+ /// [`Store::run_concurrent`], [`Func::call_concurrent`], [`StreamReader`],+ /// etc.+ ///+ /// This configuration option can be manually disabled to avoid initializing+ /// data structures in the [`Store`] related to concurrent execution. When+ /// this option is disabled then APIs related to concurrency will all fail+ /// with a panic. For example [`Store::run_concurrent`] will panic, creating+ /// a [`StreamReader`] will panic, etc.+ ///+ /// The value of this option additionally affects whether a [`Config`] is+ /// valid and the default set of enabled WebAssembly features. If this+ /// option is disabled then component-model features related to concurrency+ /// will all be disabled. If this option is enabled, then the options will+ /// retain their normal defaults. It is not valid to create a [`Config`]+ /// with component-model-async explicitly enabled and this option explicitly+ /// disabled, however.+ ///+ /// This option defaults to `true`.+ ///+ /// [`Store`]: crate::Store+ /// [`Store::run_concurrent`]: crate::Store::run_concurrent+ /// [`Func::call_concurrent`]: crate::component::Func::call_concurrent+ /// [`StreamReader`]: crate::component::StreamReader+ pub fn concurrency_support(&mut self, enable: bool) -> &mut Self {+ self.tunables.concurrency_support = Some(enable);+ self}}diff --git a/crates/wasmtime/src/engine/serialization.rs b/crates/wasmtime/src/engine/serialization.rsindex 1901839712..c014cb8611 100644--- a/crates/wasmtime/src/engine/serialization.rs+++ b/crates/wasmtime/src/engine/serialization.rs@@ -285,7 +285,7 @@ impl Metadata<'_> {inlining_intra_module,inlining_small_callee_size,inlining_sum_size_threshold,- component_model_concurrency,+ concurrency_support,// This doesn't affect compilation, it's just a runtime setting.memory_reservation_for_growth: _,@@ -367,9 +367,9 @@ impl Metadata<'_> {"function inlining sum-size threshold",)?;Self::check_bool(- component_model_concurrency,- other.component_model_concurrency,- "component model concurrency",+ concurrency_support,+ other.concurrency_support,+ "concurrency support",)?;Self::check_intra_module_inlining(inlining_intra_module, other.inlining_intra_module)?;diff --git a/crates/wasmtime/src/runtime/component/concurrent.rs b/crates/wasmtime/src/runtime/component/concurrent.rsindex fcff9d5965..395b967d37 100644--- a/crates/wasmtime/src/runtime/component/concurrent.rs+++ b/crates/wasmtime/src/runtime/component/concurrent.rs@@ -886,8 +886,8 @@ impl<T> Store<T> {T: Send + 'static,{ensure!(- self.as_context().0.cm_concurrency_enabled(),- "cannot use `run_concurrent` without enabling component-model async"+ self.as_context().0.concurrency_support(),+ "cannot use `run_concurrent` when Config::concurrency_support disabled",);self.as_context_mut().run_concurrent(fun).await}@@ -983,6 +983,11 @@ impl<T> StoreContextMut<'_, T> {/// This function can be used to invoke [`Func::call_concurrent`] for/// example within the async closure provided here.///+ /// This function will unconditionally return an error if+ /// [`Config::concurrency_support`] is disabled.+ ///+ /// [`Config::concurrency_support`]: crate::Config::concurrency_support+ ////// # Store-blocking behavior////// At this time there are certain situations in which the `Future` returned@@ -1056,8 +1061,8 @@ impl<T> StoreContextMut<'_, T> {T: Send + 'static,{ensure!(- self.0.cm_concurrency_enabled(),- "cannot use `run_concurrent` without enabling component-model async"+ self.0.concurrency_support(),+ "cannot use `run_concurrent` when Config::concurrency_support disabled",);self.do_run_concurrent(fun, false).await}@@ -1080,7 +1085,7 @@ impl<T> StoreContextMut<'_, T> {whereT: Send + 'static,{- debug_assert!(self.0.cm_concurrency_enabled());+ debug_assert!(self.0.concurrency_support());check_recursive_run();let token = StoreToken::new(self.as_context_mut());@@ -1513,8 +1518,10 @@ impl StoreOpaque {/// - The top-level instance is not already on the current task's call stack./// - The instance is not in need of a post-return function call./// - `self` has not been poisoned due to a trap.- pub(crate) fn may_enter_concurrent(&mut self, instance: RuntimeInstance) -> bool {- debug_assert!(self.cm_concurrency_enabled());+ pub(crate) fn may_enter(&mut self, instance: RuntimeInstance) -> bool {+ if !self.concurrency_support() {+ return self.may_enter_at_all(instance);+ }let state = self.concurrent_state_mut();if let Some(caller) = state.guest_thread {instance != state.get_mut(caller.task).unwrap().instance@@ -1524,23 +1531,6 @@ impl StoreOpaque {}}- /// Returns `false` if the specified instance may not be entered, regardless- /// of what's on a task's call stack.- ///- /// If this returns `true`, the instance may be entered as long as it isn't- /// on the task's call stack, if applicable.- fn may_enter_at_all(&self, instance: RuntimeInstance) -> bool {- if self.trapped() {- return false;- }-- let flags = self- .component_instance(instance.instance)- .instance_flags(instance.index);-- unsafe { !flags.needs_post_return() }- }-/// Variation of `may_enter` which takes a `TableId<GuestTask>` representing/// the callee.fn may_enter_task(&mut self, task: TableId<GuestTask>) -> bool {@@ -1641,8 +1631,10 @@ impl StoreOpaque {.set_task_may_block(may_block)}- pub(crate) fn check_blocking_concurrent(&mut self) -> Result<()> {- debug_assert!(self.cm_concurrency_enabled());+ pub(crate) fn check_blocking(&mut self) -> Result<()> {+ if !self.concurrency_support() {+ return Ok(());+ }let state = self.concurrent_state_mut();let task = state.guest_thread.unwrap().task;let instance = state.get_mut(task).unwrap().instance.instance;diff --git a/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rs b/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rsindex a352e89f80..82c7ab3370 100644--- a/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rs+++ b/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rs@@ -1116,6 +1116,12 @@ pub struct FutureReader<T> {impl<T> FutureReader<T> {/// Create a new future with the specified producer.+ ///+ /// # Panics+ ///+ /// Panics if [`Config::concurrency_support`] is not enabled.+ ///+ /// [`Config::concurrency_support`]: crate::Config::concurrency_supportpub fn new<S: AsContextMut>(mut store: S,producer: impl FutureProducer<S::Data, Item = T>,@@ -1123,7 +1129,7 @@ impl<T> FutureReader<T> {whereT: func::Lower + func::Lift + Send + Sync + 'static,{- assert!(store.as_context().0.cm_concurrency_enabled());+ assert!(store.as_context().0.concurrency_support());struct Producer<P>(P);@@ -1451,11 +1457,17 @@ whereA: AsAccessor,{/// Create a new `GuardedFutureReader` with the specified `accessor` and `reader`.+ ///+ /// # Panics+ ///+ /// Panics if [`Config::concurrency_support`] is not enabled.+ ///+ /// [`Config::concurrency_support`]: crate::Config::concurrency_supportpub fn new(accessor: A, reader: FutureReader<T>) -> Self {assert!(accessor.as_accessor()- .with(|a| a.as_context().0.cm_concurrency_enabled())+ .with(|a| a.as_context().0.concurrency_support()));Self {reader: Some(reader),@@ -1503,6 +1515,12 @@ pub struct StreamReader<T> {impl<T> StreamReader<T> {/// Create a new stream with the specified producer.+ ///+ /// # Panics+ ///+ /// Panics if [`Config::concurrency_support`] is not enabled.+ ///+ /// [`Config::concurrency_support`]: crate::Config::concurrency_supportpub fn new<S: AsContextMut>(mut store: S,producer: impl StreamProducer<S::Data, Item = T>,@@ -1510,7 +1528,7 @@ impl<T> StreamReader<T> {whereT: func::Lower + func::Lift + Send + Sync + 'static,{- assert!(store.as_context().0.cm_concurrency_enabled());+ assert!(store.as_context().0.concurrency_support());Self::new_(store.as_context_mut()@@ -1785,11 +1803,17 @@ where{/// Create a new `GuardedStreamReader` with the specified `accessor` and/// `reader`.+ ///+ /// # Panics+ ///+ /// Panics if [`Config::concurrency_support`] is not enabled.+ ///+ /// [`Config::concurrency_support`]: crate::Config::concurrency_supportpub fn new(accessor: A, reader: StreamReader<T>) -> Self {assert!(accessor.as_accessor()- .with(|a| a.as_context().0.cm_concurrency_enabled())+ .with(|a| a.as_context().0.concurrency_support()));Self {reader: Some(reader),diff --git a/crates/wasmtime/src/runtime/component/concurrent_disabled.rs b/crates/wasmtime/src/runtime/component/concurrent_disabled.rsindex fa8ea16708..5bfd79f762 100644--- a/crates/wasmtime/src/runtime/component/concurrent_disabled.rs+++ b/crates/wasmtime/src/runtime/component/concurrent_disabled.rs@@ -7,8 +7,7 @@ use core::convert::Infallible;use core::mem::MaybeUninit;use wasmtime_environ::component::{CanonicalAbiInfo, InterfaceType};-#[derive(Default)]-pub struct ConcurrentState;+pub enum ConcurrentState {}fn should_have_failed_validation<T>(what: &str) -> Result<T> {// This should be unreachable; if we trap here, it indicates a@@ -168,4 +167,12 @@ impl StoreOpaque {// See comment in `enter_sync_call`unreachable!()}++ pub(crate) fn check_blocking(&mut self) -> crate::Result<()> {+ Ok(())+ }++ pub(crate) fn may_enter(&mut self, instance: RuntimeInstance) -> bool {+ self.may_enter_at_all(instance)+ }}diff --git a/crates/wasmtime/src/runtime/component/func.rs b/crates/wasmtime/src/runtime/component/func.rsindex e56d933ab0..4bfad04bbc 100644--- a/crates/wasmtime/src/runtime/component/func.rs+++ b/crates/wasmtime/src/runtime/component/func.rs@@ -258,7 +258,7 @@ impl Func {let store = store.as_context_mut();#[cfg(feature = "component-model-async")]- if store.0.cm_concurrency_enabled() {+ if store.0.concurrency_support() {return store.run_concurrent_trap_on_idle(async |store| {self.call_concurrent_dynamic(store, params, results, false)@@ -353,6 +353,10 @@ impl Func {/// but the task will still progress and invoke callbacks and such until/// completion.///+ /// This function will return an error if [`Config::concurrency_support`] is+ /// disabled.+ ///+ /// [`Config::concurrency_support`]: crate::Config::concurrency_support/// [`run_concurrent`]: crate::Store::run_concurrent/// [#11833]: https://github.com/bytecodealliance/wasmtime/issues/11833/// [`Accessor`]: crate::component::Accessor@@ -610,7 +614,7 @@ impl Func {bail!(crate::Trap::CannotEnterComponent);}- if store.engine().config().cm_concurrency_enabled() {+ if store.0.concurrency_support() {let async_type = self.abi_async(store.0);store.0.enter_sync_call(None, async_type, instance)?;}@@ -812,7 +816,7 @@ impl Func {}.exit_call()?;- if !async_ && store.engine().config().cm_concurrency_enabled() {+ if !async_ && store.0.concurrency_support() {store.0.exit_sync_call(false)?;}}diff --git a/crates/wasmtime/src/runtime/component/func/typed.rs b/crates/wasmtime/src/runtime/component/func/typed.rsindex ed9b8a703a..bc81692c38 100644--- a/crates/wasmtime/src/runtime/component/func/typed.rs+++ b/crates/wasmtime/src/runtime/component/func/typed.rs@@ -181,7 +181,7 @@ wherelet mut store = store.as_context_mut();#[cfg(feature = "component-model-async")]- if store.0.cm_concurrency_enabled() {+ if store.0.concurrency_support() {use crate::component::concurrent::TaskId;use crate::runtime::vm::SendSyncPtr;use core::ptr::NonNull;@@ -258,6 +258,11 @@ where/// representing the completion of the guest task and any transitive/// subtasks it might create.///+ /// This function will return an error if [`Config::concurrency_support`] is+ /// disabled.+ ///+ /// [`Config::concurrency_support`]: crate::Config::concurrency_support+ ////// # Progress and Cancellation////// For more information about how to make progress on the wasm task or how@@ -313,7 +318,10 @@ where{let result = accessor.as_accessor().with(|mut store| {let mut store = store.as_context_mut();- assert!(store.0.cm_concurrency_enabled());+ ensure!(+ store.0.concurrency_support(),+ "cannot use `call_concurrent` Config::concurrency_support disabled",+ );let prepared =self.prepare_call(store.as_context_mut(), false, true, move |cx, ty, dst| {@@ -368,7 +376,7 @@ whereReturn: 'static,{use crate::component::storage::slice_to_storage;- debug_assert!(store.0.cm_concurrency_enabled());+ debug_assert!(store.0.concurrency_support());let param_count = if Params::flatten_count() <= MAX_FLAT_PARAMS {Params::flatten_count()diff --git a/crates/wasmtime/src/runtime/component/instance.rs b/crates/wasmtime/src/runtime/component/instance.rsindex 887313e788..271a4d2f56 100644--- a/crates/wasmtime/src/runtime/component/instance.rs+++ b/crates/wasmtime/src/runtime/component/instance.rs@@ -869,10 +869,9 @@ impl<'a> Instantiator<'a> {}};- let exit = if let (&Some(component_instance), true) = (- component_instance,- store.engine().config().cm_concurrency_enabled(),- ) {+ let exit = if let Some(component_instance) = *component_instance+ && store.0.concurrency_support()+ {store.0.enter_sync_call(None,false,diff --git a/crates/wasmtime/src/runtime/component/linker.rs b/crates/wasmtime/src/runtime/component/linker.rsindex 5ef3820d71..9e3cf42c2f 100644--- a/crates/wasmtime/src/runtime/component/linker.rs+++ b/crates/wasmtime/src/runtime/component/linker.rs@@ -531,6 +531,9 @@ impl<T: 'static> LinkerInstance<'_, T> {Params: ComponentNamedList + Lift + 'static,Return: ComponentNamedList + Lower + 'static,{+ if !self.engine.tunables().concurrency_support {+ bail!("concurrent host functions require `Config::concurrency_support`");+ }self.insert(name, Definition::Func(HostFunc::func_wrap_concurrent(f)))?;Ok(())}@@ -690,6 +693,9 @@ impl<T: 'static> LinkerInstance<'_, T> {+ Sync+ 'static,{+ if !self.engine.tunables().concurrency_support {+ bail!("concurrent host functions require `Config::concurrency_support`");+ }self.insert(name, Definition::Func(HostFunc::func_new_concurrent(f)))?;Ok(())}@@ -768,6 +774,9 @@ impl<T: 'static> LinkerInstance<'_, T> {+ Sync+ 'static,{+ if !self.engine.tunables().concurrency_support {+ bail!("concurrent host functions require `Config::concurrency_support`");+ }// TODO: This isn't really concurrent -- it requires exclusive access to// the store for the duration of the call, preventing guest code from// running until it completes. We should make it concurrent and cleandiff --git a/crates/wasmtime/src/runtime/component/mod.rs b/crates/wasmtime/src/runtime/component/mod.rsindex b06907125b..16d93b12ee 100644--- a/crates/wasmtime/src/runtime/component/mod.rs+++ b/crates/wasmtime/src/runtime/component/mod.rs@@ -764,38 +764,3 @@ pub(crate) mod concurrent_disabled;#[cfg(not(feature = "component-model-async"))]pub(crate) use concurrent_disabled as concurrent;--impl crate::runtime::store::StoreOpaque {- #[cfg(feature = "component-model-async")]- pub(crate) fn cm_concurrency_enabled(&self) -> bool {- let enabled = self.concurrent_state().is_some();- debug_assert_eq!(enabled, self.engine().config().cm_concurrency_enabled());- enabled- }-- pub(crate) fn check_blocking(&mut self) -> crate::Result<()> {- #[cfg(feature = "component-model-async")]- if self.cm_concurrency_enabled() {- return self.check_blocking_concurrent();- }-- Ok(())- }-- pub(crate) fn may_enter(&mut self, instance: RuntimeInstance) -> bool {- #[cfg(feature = "component-model-async")]- if self.cm_concurrency_enabled() {- return self.may_enter_concurrent(instance);- }-- if self.trapped() {- return false;- }-- let flags = self- .component_instance(instance.instance)- .instance_flags(instance.index);-- unsafe { !flags.needs_post_return() }- }-}diff --git a/crates/wasmtime/src/runtime/component/resources/any.rs b/crates/wasmtime/src/runtime/component/resources/any.rsindex 78c417b672..27cb760c9e 100644--- a/crates/wasmtime/src/runtime/component/resources/any.rs+++ b/crates/wasmtime/src/runtime/component/resources/any.rs@@ -197,10 +197,9 @@ impl ResourceAny {};let mut args = [ValRaw::u32(rep)];- let exit = if let (Some(instance), true) = (- slot.instance,- store.engine().config().cm_concurrency_enabled(),- ) {+ let exit = if let Some(instance) = slot.instance+ && store.0.concurrency_support()+ {store.0.enter_sync_call(None, false, instance)?;true} else {diff --git a/crates/wasmtime/src/runtime/component/store.rs b/crates/wasmtime/src/runtime/component/store.rsindex 0b2d571aa5..9402c209e1 100644--- a/crates/wasmtime/src/runtime/component/store.rs+++ b/crates/wasmtime/src/runtime/component/store.rs@@ -34,6 +34,23 @@ impl StoreOpaque {pub(crate) fn set_trapped(&mut self) {self.store_data_mut().components.trapped = true;}++ /// Returns `false` if the specified instance may not be entered, regardless+ /// of what's on a task's call stack.+ ///+ /// If this returns `true`, the instance may be entered as long as it isn't+ /// on the task's call stack, if applicable.+ pub(crate) fn may_enter_at_all(&mut self, instance: RuntimeInstance) -> bool {+ if self.trapped() {+ return false;+ }++ let flags = self+ .component_instance(instance.instance)+ .instance_flags(instance.index);++ unsafe { !flags.needs_post_return() }+ }}impl StoreData {diff --git a/crates/wasmtime/src/runtime/store.rs b/crates/wasmtime/src/runtime/store.rsindex bfdb069e57..8b9bd3d008 100644--- a/crates/wasmtime/src/runtime/store.rs+++ b/crates/wasmtime/src/runtime/store.rs@@ -775,8 +775,15 @@ impl<T> Store<T> {host_resource_data: Default::default(),executor: Executor::new(engine),#[cfg(feature = "component-model")]- concurrent_state: if engine.config().cm_concurrency_enabled() {- Some(Default::default())+ concurrent_state: if engine.tunables().concurrency_support {+ #[cfg(feature = "component-model-async")]+ {+ Some(Default::default())+ }+ #[cfg(not(feature = "component-model-async"))]+ {+ unreachable!()+ }} else {None},@@ -2595,17 +2602,20 @@ at https://bytecodealliance.org/security.&mut self.async_state}- #[cfg(feature = "component-model-async")]- pub(crate) fn concurrent_state(&self) -> Option<&concurrent::ConcurrentState> {- self.concurrent_state.as_ref()- }-#[cfg(feature = "component-model-async")]pub(crate) fn concurrent_state_mut(&mut self) -> &mut concurrent::ConcurrentState {- debug_assert!(self.engine().config().cm_concurrency_enabled());+ debug_assert!(self.concurrency_support());self.concurrent_state.as_mut().unwrap()}+ #[inline]+ #[cfg(feature = "component-model")]+ pub(crate) fn concurrency_support(&self) -> bool {+ let support = self.concurrent_state.is_some();+ debug_assert_eq!(support, self.engine().tunables().concurrency_support);+ support+ }+#[cfg(feature = "async")]pub(crate) fn has_pkey(&self) -> bool {self.pkey.is_some()diff --git a/src/commands/run.rs b/src/commands/run.rsindex edcca310ff..e3ce0e9a0a 100644--- a/src/commands/run.rs+++ b/src/commands/run.rs@@ -633,7 +633,7 @@ impl RunCommand {results: &mut Vec<wasmtime::component::Val>,) -> Result<(), Error> {#[cfg(feature = "component-model-async")]- if self.run.common.wasm.component_model_async.unwrap_or(false) {+ if self.run.common.wasm.concurrency_support.unwrap_or(true) {store.run_concurrent(async |store| {let task = func.call_concurrent(store, params, results).await?;diff --git a/src/commands/serve.rs b/src/commands/serve.rsindex 4d7ca7ff59..4b87cb8930 100644--- a/src/commands/serve.rs+++ b/src/commands/serve.rs@@ -403,7 +403,6 @@ impl ServeCommand {.common.config(use_pooling_allocator_by_default().unwrap_or(None))?;config.wasm_component_model(true);- config.wasm_component_model_async(true);if self.run.common.wasm.timeout.is_some() {config.epoch_interruption(true);diff --git a/tests/all/component_model/async.rs b/tests/all/component_model/async.rsindex da6cde8b4c..7e71ccd38e 100644--- a/tests/all/component_model/async.rs+++ b/tests/all/component_model/async.rs@@ -832,3 +832,48 @@ async fn run_wasm_in_call_async() -> Result<()> {run.call_async(&mut store, ()).await?;Ok(())}++#[tokio::test]+#[cfg_attr(miri, ignore)]+async fn require_concurrency_support() -> Result<()> {+ let mut config = Config::new();+ config.concurrency_support(false);+ let engine = Engine::new(&config)?;++ let mut store = Store::new(&engine, ());++ assert!(+ store+ .run_concurrent(async |_| wasmtime::error::Ok(()))+ .await+ .is_err()+ );++ let ok = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {+ StreamReader::<u32>::new(&mut store, Vec::new());+ }));+ assert!(ok.is_err());++ let ok = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {+ FutureReader::new(&mut store, async { wasmtime::error::Ok(0) })+ }));+ assert!(ok.is_err());++ let mut linker = Linker::<()>::new(&engine);+ let mut root = linker.root();++ assert!(+ root.func_wrap_concurrent::<(), (), _>("f1", |_, _| { todo!() })+ .is_err()+ );+ assert!(+ root.func_new_concurrent("f2", |_, _, _, _| { todo!() })+ .is_err()+ );+ assert!(+ root.resource_concurrent("f3", ResourceType::host::<u32>(), |_, _| { todo!() })+ .is_err()+ );++ Ok(())+}diff --git a/tests/all/component_model/resources.rs b/tests/all/component_model/resources.rsindex 821553fca4..f40ab07f25 100644--- a/tests/all/component_model/resources.rs+++ b/tests/all/component_model/resources.rs@@ -233,7 +233,7 @@ fn mismatch_intrinsics() -> Result<()> {let ctor = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "ctor")?;assert_eq!(ctor.call(&mut store, (100,)).unwrap_err().to_string(),- "handle index 1 used with the wrong type, expected guest-defined \+ "handle index 2 used with the wrong type, expected guest-defined \resource but found a different guest-defined resource",);@@ -1411,8 +1411,8 @@ fn guest_different_host_same() -> Result<()> {(func (export "f") (param i32 i32);; different types, but everything goes into the same;; handle index namespace- (if (i32.ne (local.get 0) (i32.const 1)) (then (unreachable)))- (if (i32.ne (local.get 1) (i32.const 2)) (then (unreachable)))+ (if (i32.ne (local.get 0) (i32.const 2)) (then (unreachable)))+ (if (i32.ne (local.get 1) (i32.const 3)) (then (unreachable)));; host should end up getting the same resource(call $f (local.get 0) (local.get 1))diff --git a/tests/disas/component-model/direct-adapter-calls-inlining.wat b/tests/disas/component-model/direct-adapter-calls-inlining.watindex 82c1aae8b1..41bfa66c1d 100644--- a/tests/disas/component-model/direct-adapter-calls-inlining.wat+++ b/tests/disas/component-model/direct-adapter-calls-inlining.wat@@ -1,7 +1,7 @@;;! target = "x86_64";;! test = "optimize";;! filter = "wasm[1]--function"-;;! flags = "-C inlining=y"+;;! flags = "-C inlining=y -Wconcurrency-support=n";; Same as `direct-adapter-calls.wat`, except we have enabled function inlining;; so all the direct calls should get inlined.diff --git a/tests/disas/component-model/direct-adapter-calls-x64.wat b/tests/disas/component-model/direct-adapter-calls-x64.watindex 4d5bece740..984198c73b 100644--- a/tests/disas/component-model/direct-adapter-calls-x64.wat+++ b/tests/disas/component-model/direct-adapter-calls-x64.wat@@ -1,7 +1,7 @@;;! target = "x86_64";;! test = 'compile';;! filter = "function"-;;! flags = "-C inlining=n"+;;! flags = "-C inlining=n -Wconcurrency-support=n";; Same as `direct-adapter-calls.wat` but shows full compilation down to x86_64;; so that we can exercise our linker's ability to resolve relocations fordiff --git a/tests/disas/component-model/direct-adapter-calls.wat b/tests/disas/component-model/direct-adapter-calls.watindex f8e71a7d98..8f935101d4 100644--- a/tests/disas/component-model/direct-adapter-calls.wat+++ b/tests/disas/component-model/direct-adapter-calls.wat@@ -1,7 +1,7 @@;;! target = "x86_64";;! test = "optimize";;! filter = "function"-;;! flags = "-C inlining=n"+;;! flags = "-C inlining=n -Wconcurrency-support=n";; The following component links two sub-components together and each are only;; instantiated the once, so we statically know what their core modules'