A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
support non-async `{stream,future}.cancel-{read,write}` (#11625)
Joel Dice066ff8bebbab
diff --git a/crates/misc/component-async-tests/src/util.rs b/crates/misc/component-async-tests/src/util.rsindex 70be467885..0d9ddcc9fe 100644--- a/crates/misc/component-async-tests/src/util.rs+++ b/crates/misc/component-async-tests/src/util.rs@@ -9,7 +9,7 @@ use std::{use wasmtime::{StoreContextMut,component::{- Accessor, Destination, FutureConsumer, FutureProducer, Lift, Lower, Source, StreamConsumer,+ Destination, FutureConsumer, FutureProducer, Lift, Lower, Source, StreamConsumer,StreamProducer, StreamResult,},};@@ -139,24 +139,41 @@ impl<T> OneshotProducer<T> {impl<D, T: Send + 'static> FutureProducer<D> for OneshotProducer<T> {type Item = T;- async fn produce(self, _: &Accessor<D>) -> Result<T> {- Ok(self.0.await?)+ fn poll_produce(+ self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ _: StoreContextMut<D>,+ finish: bool,+ ) -> Poll<Result<Option<T>>> {+ match Pin::new(&mut self.get_mut().0).poll(cx) {+ Poll::Pending if finish => Poll::Ready(Ok(None)),+ Poll::Pending => Poll::Pending,+ Poll::Ready(result) => Poll::Ready(Ok(Some(result?))),+ }}}-pub struct OneshotConsumer<T>(oneshot::Sender<T>);+pub struct OneshotConsumer<T>(Option<oneshot::Sender<T>>);impl<T> OneshotConsumer<T> {pub fn new(tx: oneshot::Sender<T>) -> Self {- Self(tx)+ Self(Some(tx))}}-impl<D, T: Send + 'static> FutureConsumer<D> for OneshotConsumer<T> {+impl<D, T: Lift + Send + 'static> FutureConsumer<D> for OneshotConsumer<T> {type Item = T;- async fn consume(self, _: &Accessor<D>, value: T) -> Result<()> {- _ = self.0.send(value);- Ok(())+ fn poll_consume(+ self: Pin<&mut Self>,+ _: &mut Context<'_>,+ store: StoreContextMut<D>,+ mut source: Source<'_, T>,+ _: bool,+ ) -> Poll<Result<()>> {+ let value = &mut None;+ source.read(store, value)?;+ _ = self.get_mut().0.take().unwrap().send(value.take().unwrap());+ Poll::Ready(Ok(()))}}diff --git a/crates/misc/component-async-tests/tests/scenario/transmit.rs b/crates/misc/component-async-tests/tests/scenario/transmit.rsindex 77a0cfc98f..e6e4b2cc66 100644--- a/crates/misc/component-async-tests/tests/scenario/transmit.rs+++ b/crates/misc/component-async-tests/tests/scenario/transmit.rs@@ -1,7 +1,7 @@use std::future::{self, Future};use std::pin::Pin;use std::sync::{Arc, Mutex};-use std::task::{Context, Poll};+use std::task::{self, Context, Poll};use std::time::Duration;use super::util::{config, make_component, test_run, test_run_with_count};@@ -16,106 +16,321 @@ use futures::{stream::FuturesUnordered,};use wasmtime::component::{- Accessor, Component, Destination, FutureReader, HasSelf, Instance, Linker, ResourceTable,- Source, StreamConsumer, StreamProducer, StreamReader, StreamResult, Val,+ Accessor, Component, Destination, FutureConsumer, FutureProducer, FutureReader, HasSelf,+ Instance, Linker, ResourceTable, Source, StreamConsumer, StreamProducer, StreamReader,+ StreamResult, Val,};use wasmtime::{AsContextMut, Engine, Store, StoreContextMut, Trap};use wasmtime_wasi::WasiCtxBuilder;-mod readiness {- wasmtime::component::bindgen!({- path: "wit",- world: "readiness-guest"- });-}--struct ReadinessProducer {+struct BufferStreamProducer {buffer: Vec<u8>,- sleep: Pin<Box<dyn Future<Output = ()> + Send>>,}-impl<D> StreamProducer<D> for ReadinessProducer {+impl<D> StreamProducer<D> for BufferStreamProducer {type Item = u8;type Buffer = Option<u8>;fn poll_produce<'a>(self: Pin<&mut Self>,- cx: &mut Context<'_>,+ _: &mut Context<'_>,mut store: StoreContextMut<'a, D>,destination: Destination<'a, Self::Item, Self::Buffer>,- finish: bool,+ _: bool,) -> Poll<Result<StreamResult>> {let me = self.get_mut();-- match me.sleep.as_mut().poll(cx) {- Poll::Pending => {- if finish {- Poll::Ready(Ok(StreamResult::Cancelled))- } else {- Poll::Pending- }- }- Poll::Ready(()) => {- me.sleep = async {}.boxed();- let capacity = destination.remaining(store.as_context_mut());- if capacity == Some(0) {- Poll::Ready(Ok(StreamResult::Completed))- } else {- assert_eq!(capacity, Some(me.buffer.len()));- let mut destination = destination.as_direct(store, me.buffer.len());- destination.remaining().copy_from_slice(&me.buffer);- destination.mark_written(me.buffer.len());-- Poll::Ready(Ok(StreamResult::Dropped))- }- }+ let capacity = destination.remaining(store.as_context_mut());+ if capacity == Some(0) {+ Poll::Ready(Ok(StreamResult::Completed))+ } else {+ assert_eq!(capacity, Some(me.buffer.len()));+ let mut destination = destination.as_direct(store, me.buffer.len());+ destination.remaining().copy_from_slice(&me.buffer);+ destination.mark_written(me.buffer.len());++ Poll::Ready(Ok(StreamResult::Dropped))}}}-struct ReadinessConsumer {+struct BufferStreamConsumer {expected: Vec<u8>,- sleep: Pin<Box<dyn Future<Output = ()> + Send>>,}-impl<D> StreamConsumer<D> for ReadinessConsumer {+impl<D> StreamConsumer<D> for BufferStreamConsumer {type Item = u8;fn poll_consume(self: Pin<&mut Self>,- cx: &mut Context<'_>,+ _: &mut Context<'_>,mut store: StoreContextMut<D>,source: Source<Self::Item>,- finish: bool,+ _: bool,) -> Poll<Result<StreamResult>> {let me = self.get_mut();+ let available = source.remaining(store.as_context_mut());+ if available == 0 {+ Poll::Ready(Ok(StreamResult::Completed))+ } else {+ assert_eq!(available, me.expected.len());+ let mut source = source.as_direct(store);+ assert_eq!(&me.expected, source.remaining());+ source.mark_read(me.expected.len());++ Poll::Ready(Ok(StreamResult::Dropped))+ }+ }+}- match me.sleep.as_mut().poll(cx) {- Poll::Pending => {- if finish {- Poll::Ready(Ok(StreamResult::Cancelled))- } else {- Poll::Pending- }- }- Poll::Ready(()) => {- me.sleep = async {}.boxed();- let available = source.remaining(store.as_context_mut());- if available == 0 {- Poll::Ready(Ok(StreamResult::Completed))- } else {- assert_eq!(available, me.expected.len());- let mut source = source.as_direct(store);- assert_eq!(&me.expected, source.remaining());- source.mark_read(me.expected.len());-- Poll::Ready(Ok(StreamResult::Dropped))- }- }+struct ValueFutureProducer {+ value: u8,+}++impl<D> FutureProducer<D> for ValueFutureProducer {+ type Item = u8;++ fn poll_produce<'a>(+ self: Pin<&mut Self>,+ _: &mut Context<'_>,+ _: StoreContextMut<'a, D>,+ _: bool,+ ) -> Poll<Result<Option<Self::Item>>> {+ Poll::Ready(Ok(Some(self.value)))+ }+}++struct ValueFutureConsumer {+ expected: u8,+}++impl<D> FutureConsumer<D> for ValueFutureConsumer {+ type Item = u8;++ fn poll_consume(+ self: Pin<&mut Self>,+ _: &mut Context<'_>,+ store: StoreContextMut<D>,+ mut source: Source<'_, Self::Item>,+ _: bool,+ ) -> Poll<Result<()>> {+ let value = &mut None;+ source.read(store, value)?;+ assert_eq!(value.take(), Some(self.expected));+ Poll::Ready(Ok(()))+ }+}++struct DelayedStreamProducer<P> {+ inner: P,+ sleep: Pin<Box<dyn Future<Output = ()> + Send>>,+}++impl<D, P: StreamProducer<D>> StreamProducer<D> for DelayedStreamProducer<P> {+ type Item = P::Item;+ type Buffer = P::Buffer;++ fn poll_produce<'a>(+ mut self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ store: StoreContextMut<'a, D>,+ destination: Destination<'a, Self::Item, Self::Buffer>,+ finish: bool,+ ) -> Poll<Result<StreamResult>> {+ // SAFETY: We never move out of `self`.+ let sleep = unsafe { &mut self.as_mut().get_unchecked_mut().sleep };+ task::ready!(sleep.as_mut().poll(cx));+ *sleep = async {}.boxed();++ // SAFETY: This is a standard pin-projection, and we never move out+ // of `self`.+ let inner = unsafe { self.map_unchecked_mut(|v| &mut v.inner) };+ inner.poll_produce(cx, store, destination, finish)+ }+}++struct DelayedStreamConsumer<C> {+ inner: C,+ sleep: Pin<Box<dyn Future<Output = ()> + Send>>,+}++impl<D, C: StreamConsumer<D>> StreamConsumer<D> for DelayedStreamConsumer<C> {+ type Item = C::Item;++ fn poll_consume(+ mut self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ store: StoreContextMut<D>,+ source: Source<Self::Item>,+ finish: bool,+ ) -> Poll<Result<StreamResult>> {+ // SAFETY: We never move out of `self`.+ let sleep = unsafe { &mut self.as_mut().get_unchecked_mut().sleep };+ task::ready!(sleep.as_mut().poll(cx));+ *sleep = async {}.boxed();++ // SAFETY: This is a standard pin-projection, and we never move out+ // of `self`.+ let inner = unsafe { self.map_unchecked_mut(|v| &mut v.inner) };+ inner.poll_consume(cx, store, source, finish)+ }+}++struct DelayedFutureProducer<P> {+ inner: P,+ sleep: Pin<Box<dyn Future<Output = ()> + Send>>,+}++impl<D, P: FutureProducer<D>> FutureProducer<D> for DelayedFutureProducer<P> {+ type Item = P::Item;++ fn poll_produce<'a>(+ mut self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ store: StoreContextMut<'a, D>,+ finish: bool,+ ) -> Poll<Result<Option<Self::Item>>> {+ // SAFETY: We never move out of `self`.+ let sleep = unsafe { &mut self.as_mut().get_unchecked_mut().sleep };+ task::ready!(sleep.as_mut().poll(cx));+ *sleep = async {}.boxed();++ // SAFETY: This is a standard pin-projection, and we never move out+ // of `self`.+ let inner = unsafe { self.map_unchecked_mut(|v| &mut v.inner) };+ inner.poll_produce(cx, store, finish)+ }+}++struct DelayedFutureConsumer<C> {+ inner: C,+ sleep: Pin<Box<dyn Future<Output = ()> + Send>>,+}++impl<D, C: FutureConsumer<D>> FutureConsumer<D> for DelayedFutureConsumer<C> {+ type Item = C::Item;++ fn poll_consume(+ mut self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ store: StoreContextMut<D>,+ source: Source<'_, Self::Item>,+ finish: bool,+ ) -> Poll<Result<()>> {+ // SAFETY: We never move out of `self`.+ let sleep = unsafe { &mut self.as_mut().get_unchecked_mut().sleep };+ task::ready!(sleep.as_mut().poll(cx));+ *sleep = async {}.boxed();++ // SAFETY: This is a standard pin-projection, and we never move out+ // of `self`.+ let inner = unsafe { self.map_unchecked_mut(|v| &mut v.inner) };+ inner.poll_consume(cx, store, source, finish)+ }+}++struct ProcrastinatingStreamProducer<P>(P);++impl<D, P: StreamProducer<D>> StreamProducer<D> for ProcrastinatingStreamProducer<P> {+ type Item = P::Item;+ type Buffer = P::Buffer;++ fn poll_produce<'a>(+ self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ store: StoreContextMut<'a, D>,+ destination: Destination<'a, Self::Item, Self::Buffer>,+ finish: bool,+ ) -> Poll<Result<StreamResult>> {+ if finish {+ // SAFETY: This is a standard pin-projection, and we never move out+ // of `self`.+ let producer = unsafe { self.map_unchecked_mut(|v| &mut v.0) };+ producer.poll_produce(cx, store, destination, true)+ } else {+ Poll::Pending}}}+struct ProcrastinatingStreamConsumer<C>(C);++impl<D, C: StreamConsumer<D>> StreamConsumer<D> for ProcrastinatingStreamConsumer<C> {+ type Item = C::Item;++ fn poll_consume(+ self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ store: StoreContextMut<D>,+ source: Source<'_, Self::Item>,+ finish: bool,+ ) -> Poll<Result<StreamResult>> {+ if finish {+ // SAFETY: This is a standard pin-projection, and we never move out+ // of `self`.+ let consumer = unsafe { self.map_unchecked_mut(|v| &mut v.0) };+ consumer.poll_consume(cx, store, source, true)+ } else {+ Poll::Pending+ }+ }+}++struct ProcrastinatingFutureProducer<P>(P);++impl<D, P: FutureProducer<D>> FutureProducer<D> for ProcrastinatingFutureProducer<P> {+ type Item = P::Item;++ fn poll_produce<'a>(+ self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ store: StoreContextMut<'a, D>,+ finish: bool,+ ) -> Poll<Result<Option<Self::Item>>> {+ if finish {+ // SAFETY: This is a standard pin-projection, and we never move out+ // of `self`.+ let producer = unsafe { self.map_unchecked_mut(|v| &mut v.0) };+ producer.poll_produce(cx, store, true)+ } else {+ Poll::Pending+ }+ }+}++struct ProcrastinatingFutureConsumer<C>(C);++impl<D, C: FutureConsumer<D>> FutureConsumer<D> for ProcrastinatingFutureConsumer<C> {+ type Item = C::Item;++ fn poll_consume(+ self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ store: StoreContextMut<D>,+ source: Source<'_, Self::Item>,+ finish: bool,+ ) -> Poll<Result<()>> {+ if finish {+ // SAFETY: This is a standard pin-projection, and we never move out+ // of `self`.+ let consumer = unsafe { self.map_unchecked_mut(|v| &mut v.0) };+ consumer.poll_consume(cx, store, source, true)+ } else {+ Poll::Pending+ }+ }+}++fn sleep() -> Pin<Box<dyn Future<Output = ()> + Send>> {+ component_async_tests::util::sleep(Duration::from_millis(delay_millis())).boxed()+}++mod readiness {+ wasmtime::component::bindgen!({+ path: "wit",+ world: "readiness-guest"+ });+}+#[tokio::test]pub async fn async_readiness() -> Result<()> {let component = test_programs_artifacts::ASYNC_READINESS_COMPONENT;@@ -144,10 +359,11 @@ pub async fn async_readiness() -> Result<()> {let rx = StreamReader::new(instance,&mut store,- ReadinessProducer {- buffer: expected.clone(),- sleep: component_async_tests::util::sleep(Duration::from_millis(delay_millis()))- .boxed(),+ DelayedStreamProducer {+ inner: BufferStreamProducer {+ buffer: expected.clone(),+ },+ sleep: sleep(),},);let result = instance@@ -160,12 +376,9 @@ pub async fn async_readiness() -> Result<()> {accessor.with(|access| {rx.pipe(access,- ReadinessConsumer {- expected,- sleep: component_async_tests::util::sleep(Duration::from_millis(- delay_millis(),- ))- .boxed(),+ DelayedStreamConsumer {+ inner: BufferStreamConsumer { expected },+ sleep: sleep(),},)});@@ -508,25 +721,21 @@ async fn test_transmit(component: &str) -> Result<()> {async fn test_transmit_with<Test: TransmitTest + 'static>(component: &str) -> Result<()> {let engine = Engine::new(&config())?;- let make_store = || {- Store::new(- &engine,- Ctx {- wasi: WasiCtxBuilder::new().inherit_stdio().build(),- table: ResourceTable::default(),- continue_: false,- wakers: Arc::new(Mutex::new(None)),- },- )- };-let component = make_component(&engine, &[component]).await?;let mut linker = Linker::new(&engine);wasmtime_wasi::p2::add_to_linker_async(&mut linker)?;- let mut store = make_store();+ let mut store = Store::new(+ &engine,+ Ctx {+ wasi: WasiCtxBuilder::new().inherit_stdio().build(),+ table: ResourceTable::default(),+ continue_: false,+ wakers: Arc::new(Mutex::new(None)),+ },+ );let (test, instance) = Test::instantiate(&mut store, &component, &linker).await?;@@ -693,3 +902,102 @@ async fn test_transmit_with<Test: TransmitTest + 'static>(component: &str) -> Re.await??;Ok(())}++mod cancel_transmit {+ wasmtime::component::bindgen!({+ path: "wit",+ world: "cancel-transmit-guest"+ });+}++#[tokio::test]+pub async fn async_cancel_transmit() -> Result<()> {+ let engine = Engine::new(&config())?;++ let component = make_component(+ &engine,+ &[test_programs_artifacts::ASYNC_CANCEL_TRANSMIT_COMPONENT],+ )+ .await?;++ let mut linker = Linker::new(&engine);++ wasmtime_wasi::p2::add_to_linker_async(&mut linker)?;++ let mut store = Store::new(+ &engine,+ Ctx {+ wasi: WasiCtxBuilder::new().inherit_stdio().build(),+ table: ResourceTable::default(),+ continue_: false,+ wakers: Arc::new(Mutex::new(None)),+ },+ );++ let instance = linker.instantiate_async(&mut store, &component).await?;+ let guest = cancel_transmit::CancelTransmitGuest::new(&mut store, &instance)?;+ let stream_expected = vec![2u8, 4, 6, 8, 9];+ let stream = StreamReader::new(+ instance,+ &mut store,+ ProcrastinatingStreamProducer(DelayedStreamProducer {+ inner: BufferStreamProducer {+ buffer: stream_expected.clone(),+ },+ sleep: sleep(),+ }),+ );+ let future_expected = 10;+ let future = FutureReader::new(+ instance,+ &mut store,+ ProcrastinatingFutureProducer(DelayedFutureProducer {+ inner: ValueFutureProducer {+ value: future_expected,+ },+ sleep: sleep(),+ }),+ );+ let result = instance+ .run_concurrent(&mut store, async move |accessor| {+ let (stream, stream_expected, future, future_expected) = guest+ .local_local_cancel_transmit()+ .call_start(accessor, stream, stream_expected, future, future_expected)+ .await?;++ accessor.with(|mut access| {+ stream.pipe(+ &mut access,+ ProcrastinatingStreamConsumer(DelayedStreamConsumer {+ inner: BufferStreamConsumer {+ expected: stream_expected,+ },+ sleep: sleep(),+ }),+ );+ future.pipe(+ access,+ ProcrastinatingFutureConsumer(DelayedFutureConsumer {+ inner: ValueFutureConsumer {+ expected: future_expected,+ },+ sleep: sleep(),+ }),+ );+ });++ future::pending::<Result<()>>().await+ })+ .await;++ // As of this writing, passing a future which never resolves to+ // `Instance::run_concurrent` and expecting a `Trap::AsyncDeadlock` is+ // the only way to join all tasks for the `Instance`, so that's what we+ // do:+ assert!(matches!(+ result.unwrap_err().downcast::<Trap>(),+ Ok(Trap::AsyncDeadlock)+ ));++ Ok(())+}diff --git a/crates/misc/component-async-tests/tests/test_all.rs b/crates/misc/component-async-tests/tests/test_all.rsindex 54ddbba338..91cdf6873e 100644--- a/crates/misc/component-async-tests/tests/test_all.rs+++ b/crates/misc/component-async-tests/tests/test_all.rs@@ -29,8 +29,9 @@ use scenario::round_trip_many::{};use scenario::streams::async_closed_streams;use scenario::transmit::{- async_cancel_callee, async_cancel_caller, async_intertask_communication, async_poll_stackless,- async_poll_synchronous, async_readiness, async_transmit_callee, async_transmit_caller,+ async_cancel_callee, async_cancel_caller, async_cancel_transmit, async_intertask_communication,+ async_poll_stackless, async_poll_synchronous, async_readiness, async_transmit_callee,+ async_transmit_caller,};use scenario::unit_stream::{async_unit_stream_callee, async_unit_stream_caller};use scenario::yield_::{diff --git a/crates/misc/component-async-tests/wit/test.wit b/crates/misc/component-async-tests/wit/test.witindex 9a602834ec..7445cde7a4 100644--- a/crates/misc/component-async-tests/wit/test.wit+++ b/crates/misc/component-async-tests/wit/test.wit@@ -166,6 +166,10 @@ interface readiness {start: async func(s: stream<u8>, expected: list<u8>) -> tuple<stream<u8>, list<u8>>;}+interface cancel-transmit {+ start: async func(s: stream<u8>, s-expected: list<u8>, f: future<u8>, f-expected: u8) -> tuple<stream<u8>, list<u8>, future<u8>, u8>;+}+world yield-caller {import continue;import ready;@@ -315,3 +319,7 @@ world intertask-communication {world readiness-guest {export readiness;}++world cancel-transmit-guest {+ export cancel-transmit;+}diff --git a/crates/test-programs/src/bin/async_cancel_transmit.rs b/crates/test-programs/src/bin/async_cancel_transmit.rsnew file mode 100644index 0000000000..5d30e3eb88--- /dev/null+++ b/crates/test-programs/src/bin/async_cancel_transmit.rs@@ -0,0 +1,360 @@+mod bindings {+ wit_bindgen::generate!({+ path: "../misc/component-async-tests/wit",+ world: "cancel-transmit-guest",+ });+}++use {+ std::{+ mem::{self, ManuallyDrop},+ slice,+ },+ test_programs::async_::{+ BLOCKED, CALLBACK_CODE_EXIT, CALLBACK_CODE_YIELD, COMPLETED, DROPPED, EVENT_NONE,+ context_get, context_set,+ },+};++#[cfg(target_arch = "wasm32")]+#[link(wasm_import_module = "[export]local:local/cancel-transmit")]+unsafe extern "C" {+ #[link_name = "[task-return][async]start"]+ fn task_return_start(_: u32, _: *const u8, _: usize, _: u32, _: u8);+}+#[cfg(not(target_arch = "wasm32"))]+unsafe extern "C" fn task_return_start(_: u32, _: *const u8, _: usize, _: u32, _: u8) {+ unreachable!()+}++#[cfg(target_arch = "wasm32")]+#[link(wasm_import_module = "[export]local:local/cancel-transmit")]+unsafe extern "C" {+ #[link_name = "[stream-new-0][async]start"]+ fn stream_new() -> u64;+}+#[cfg(not(target_arch = "wasm32"))]+unsafe extern "C" fn stream_new() -> u64 {+ unreachable!()+}++#[cfg(target_arch = "wasm32")]+#[link(wasm_import_module = "[export]local:local/cancel-transmit")]+unsafe extern "C" {+ #[link_name = "[async-lower][stream-write-0][async]start"]+ fn stream_write(_: u32, _: *const u8, _: usize) -> u32;+}+#[cfg(not(target_arch = "wasm32"))]+unsafe extern "C" fn stream_write(_: u32, _: *const u8, _: usize) -> u32 {+ unreachable!()+}++#[cfg(target_arch = "wasm32")]+#[link(wasm_import_module = "[export]local:local/cancel-transmit")]+unsafe extern "C" {+ #[link_name = "[async-lower][stream-read-0][async]start"]+ fn stream_read(_: u32, _: *mut u8, _: usize) -> u32;+}+#[cfg(not(target_arch = "wasm32"))]+unsafe extern "C" fn stream_read(_: u32, _: *mut u8, _: usize) -> u32 {+ unreachable!()+}++#[cfg(target_arch = "wasm32")]+#[link(wasm_import_module = "[export]local:local/cancel-transmit")]+unsafe extern "C" {+ #[link_name = "[stream-cancel-write-0][async]start"]+ fn stream_cancel_write(_: u32) -> u32;+}+#[cfg(not(target_arch = "wasm32"))]+unsafe extern "C" fn stream_cancel_write(_: u32) -> u32 {+ unreachable!()+}++#[cfg(target_arch = "wasm32")]+#[link(wasm_import_module = "[export]local:local/cancel-transmit")]+unsafe extern "C" {+ #[link_name = "[stream-cancel-read-0][async]start"]+ fn stream_cancel_read(_: u32) -> u32;+}+#[cfg(not(target_arch = "wasm32"))]+unsafe extern "C" fn stream_cancel_read(_: u32) -> u32 {+ unreachable!()+}++#[cfg(target_arch = "wasm32")]+#[link(wasm_import_module = "[export]local:local/cancel-transmit")]+unsafe extern "C" {+ #[link_name = "[stream-drop-readable-0][async]start"]+ fn stream_drop_readable(_: u32);+}+#[cfg(not(target_arch = "wasm32"))]+unsafe extern "C" fn stream_drop_readable(_: u32) {+ unreachable!()+}++#[cfg(target_arch = "wasm32")]+#[link(wasm_import_module = "[export]local:local/cancel-transmit")]+unsafe extern "C" {+ #[link_name = "[stream-drop-writable-0][async]start"]+ fn stream_drop_writable(_: u32);+}+#[cfg(not(target_arch = "wasm32"))]+unsafe extern "C" fn stream_drop_writable(_: u32) {+ unreachable!()+}++#[cfg(target_arch = "wasm32")]+#[link(wasm_import_module = "[export]local:local/cancel-transmit")]+unsafe extern "C" {+ #[link_name = "[future-new-1][async]start"]+ fn future_new() -> u64;+}+#[cfg(not(target_arch = "wasm32"))]+unsafe extern "C" fn future_new() -> u64 {+ unreachable!()+}++#[cfg(target_arch = "wasm32")]+#[link(wasm_import_module = "[export]local:local/cancel-transmit")]+unsafe extern "C" {+ #[link_name = "[async-lower][future-write-1][async]start"]+ fn future_write(_: u32, _: *const u8) -> u32;+}+#[cfg(not(target_arch = "wasm32"))]+unsafe extern "C" fn future_write(_: u32, _: *const u8) -> u32 {+ unreachable!()+}++#[cfg(target_arch = "wasm32")]+#[link(wasm_import_module = "[export]local:local/cancel-transmit")]+unsafe extern "C" {+ #[link_name = "[async-lower][future-read-1][async]start"]+ fn future_read(_: u32, _: *mut u8) -> u32;+}+#[cfg(not(target_arch = "wasm32"))]+unsafe extern "C" fn future_read(_: u32, _: *mut u8) -> u32 {+ unreachable!()+}++#[cfg(target_arch = "wasm32")]+#[link(wasm_import_module = "[export]local:local/cancel-transmit")]+unsafe extern "C" {+ #[link_name = "[future-cancel-write-1][async]start"]+ fn future_cancel_write(_: u32) -> u32;+}+#[cfg(not(target_arch = "wasm32"))]+unsafe extern "C" fn future_cancel_write(_: u32) -> u32 {+ unreachable!()+}++#[cfg(target_arch = "wasm32")]+#[link(wasm_import_module = "[export]local:local/cancel-transmit")]+unsafe extern "C" {+ #[link_name = "[future-cancel-read-1][async]start"]+ fn future_cancel_read(_: u32) -> u32;+}+#[cfg(not(target_arch = "wasm32"))]+unsafe extern "C" fn future_cancel_read(_: u32) -> u32 {+ unreachable!()+}++#[cfg(target_arch = "wasm32")]+#[link(wasm_import_module = "[export]local:local/cancel-transmit")]+unsafe extern "C" {+ #[link_name = "[future-drop-readable-1][async]start"]+ fn future_drop_readable(_: u32);+}+#[cfg(not(target_arch = "wasm32"))]+unsafe extern "C" fn future_drop_readable(_: u32) {+ unreachable!()+}++#[cfg(target_arch = "wasm32")]+#[link(wasm_import_module = "[export]local:local/cancel-transmit")]+unsafe extern "C" {+ #[link_name = "[future-drop-writable-1][async]start"]+ fn future_drop_writable(_: u32);+}+#[cfg(not(target_arch = "wasm32"))]+unsafe extern "C" fn future_drop_writable(_: u32) {+ unreachable!()+}++static STREAM_BYTES_TO_WRITE: &[u8] = &[1, 3, 5, 7, 11];+static FUTURE_BYTE_TO_WRITE: u8 = 13;++enum State {+ S0 {+ stream: u32,+ stream_expected: Vec<u8>,+ future: u32,+ future_expected: u8,+ },+ S1 {+ stream_read_buffer: *mut u8,+ stream_tx: u32,+ stream: u32,+ stream_expected: Vec<u8>,+ future_read_buffer: *mut u8,+ future_tx: u32,+ future: u32,+ future_expected: u8,+ },+}++#[unsafe(export_name = "[async-lift]local:local/cancel-transmit#[async]start")]+unsafe extern "C" fn export_start(+ stream: u32,+ stream_expected: u32,+ stream_expected_len: u32,+ future: u32,+ future_expected: u8,+) -> u32 {+ let stream_expected_len = usize::try_from(stream_expected_len).unwrap();++ unsafe {+ context_set(+ u32::try_from(Box::into_raw(Box::new(State::S0 {+ stream,+ stream_expected: Vec::from_raw_parts(+ stream_expected as usize as *mut u8,+ stream_expected_len,+ stream_expected_len,+ ),+ future,+ future_expected,+ })) as usize)+ .unwrap(),+ );++ callback_start(EVENT_NONE, 0, 0)+ }+}++#[unsafe(export_name = "[callback][async-lift]local:local/cancel-transmit#[async]start")]+unsafe extern "C" fn callback_start(event0: u32, _event1: u32, _event2: u32) -> u32 {+ unsafe {+ let state = &mut *(usize::try_from(context_get()).unwrap() as *mut State);+ match state {+ &mut State::S0 {+ stream,+ ref mut stream_expected,+ future,+ future_expected,+ } => {+ assert_eq!(event0, EVENT_NONE);++ // Here we assume specific behavior from the writers, namely:+ //+ // - They will not send us anything until after we cancel the+ // reads, and even then there will be a delay.+ //+ // - When they _do_ send, they will send us all the bytes it+ // told us to expect at once.+ let stream_read_buffer =+ ManuallyDrop::new(vec![0_u8; stream_expected.len()]).as_mut_ptr();+ let status = stream_read(stream, stream_read_buffer, stream_expected.len());+ assert_eq!(status, BLOCKED);++ let future_read_buffer = Box::into_raw(Box::new(0_u8));+ let status = future_read(future, future_read_buffer);+ assert_eq!(status, BLOCKED);++ let pair = stream_new();+ let stream_tx = u32::try_from(pair >> 32).unwrap();+ let stream_rx = u32::try_from(pair & 0xFFFFFFFF_u64).unwrap();++ let pair = future_new();+ let future_tx = u32::try_from(pair >> 32).unwrap();+ let future_rx = u32::try_from(pair & 0xFFFFFFFF_u64).unwrap();++ task_return_start(+ stream_rx,+ STREAM_BYTES_TO_WRITE.as_ptr(),+ STREAM_BYTES_TO_WRITE.len(),+ future_rx,+ FUTURE_BYTE_TO_WRITE,+ );++ // Here we assume specific behavior from the readers, namely:+ //+ // - They will not read anything until after we cancel the+ // write, and even then there will be a delay.+ //+ // - When they _do_ read, they will accept all the bytes we told+ // it to expect at once.+ let status = stream_write(+ stream_tx,+ STREAM_BYTES_TO_WRITE.as_ptr(),+ STREAM_BYTES_TO_WRITE.len(),+ );+ assert_eq!(status, BLOCKED);++ let status = future_write(future_tx, &FUTURE_BYTE_TO_WRITE);+ assert_eq!(status, BLOCKED);++ *state = State::S1 {+ stream_read_buffer,+ stream_tx,+ stream,+ stream_expected: mem::take(stream_expected),+ future_read_buffer,+ future_tx,+ future,+ future_expected,+ };++ CALLBACK_CODE_YIELD+ }++ &mut State::S1 {+ stream_read_buffer,+ stream_tx,+ stream,+ ref mut stream_expected,+ future_read_buffer,+ future_tx,+ future,+ future_expected,+ } => {+ // Now we synchronously cancel everything and expect that the+ // reads and writes complete.++ let status = stream_cancel_read(stream);+ assert_eq!(+ status,+ DROPPED | u32::try_from(stream_expected.len() << 4).unwrap()+ );+ let received = Box::from_raw(slice::from_raw_parts_mut(+ stream_read_buffer,+ stream_expected.len(),+ ));+ assert_eq!(&received[..], stream_expected);+ stream_drop_readable(stream);++ let status = stream_cancel_write(stream_tx);+ assert_eq!(+ status,+ DROPPED | u32::try_from(STREAM_BYTES_TO_WRITE.len() << 4).unwrap()+ );+ stream_drop_writable(stream_tx);++ let status = future_cancel_read(future);+ assert_eq!(status, COMPLETED);+ let received = Box::from_raw(future_read_buffer);+ assert_eq!(*received, future_expected);+ future_drop_readable(future);++ let status = future_cancel_write(future_tx);+ assert_eq!(status, COMPLETED);+ future_drop_writable(future_tx);++ CALLBACK_CODE_EXIT+ }+ }+ }+}++// Unused function; required since this file is built as a `bin`:+fn main() {}diff --git a/crates/wasi-http/src/p3/body.rs b/crates/wasi-http/src/p3/body.rsindex 7a568e5172..7ea96eaffd 100644--- a/crates/wasi-http/src/p3/body.rs+++ b/crates/wasi-http/src/p3/body.rs@@ -1,5 +1,5 @@+use crate::p3::WasiHttpCtxView;use crate::p3::bindings::http::types::{ErrorCode, Trailers};-use crate::p3::{WasiHttp, WasiHttpCtxView};use anyhow::Context as _;use bytes::Bytes;use core::pin::Pin;@@ -10,8 +10,7 @@ use std::sync::Arc;use tokio::sync::{mpsc, oneshot};use tokio_util::sync::PollSender;use wasmtime::component::{- Accessor, FutureConsumer, FutureReader, Resource, Source, StreamConsumer, StreamReader,- StreamResult,+ FutureConsumer, FutureReader, Resource, Source, StreamConsumer, StreamReader, StreamResult,};use wasmtime::{AsContextMut, StoreContextMut};@@ -87,7 +86,7 @@ impl GuestBody {trailers_rx.pipe(&mut store,GuestTrailerConsumer {- tx: trailers_http_tx,+ tx: Some(trailers_http_tx),getter,},);@@ -184,7 +183,7 @@ impl http_body::Body for ConsumedBody {}pub(crate) struct GuestTrailerConsumer<T> {- pub(crate) tx: oneshot::Sender<Result<Option<Arc<HeaderMap>>, ErrorCode>>,+ pub(crate) tx: Option<oneshot::Sender<Result<Option<Arc<HeaderMap>>, ErrorCode>>>,pub(crate) getter: for<'a> fn(&'a mut T) -> WasiHttpCtxView<'a>,}@@ -194,27 +193,33 @@ where{type Item = Result<Option<Resource<Trailers>>, ErrorCode>;- async fn consume(self, store: &Accessor<D>, res: Self::Item) -> wasmtime::Result<()> {+ fn poll_consume(+ self: Pin<&mut Self>,+ _: &mut Context<'_>,+ mut store: StoreContextMut<D>,+ mut source: Source<'_, Self::Item>,+ _: bool,+ ) -> Poll<wasmtime::Result<()>> {+ let value = &mut None;+ source.read(store.as_context_mut(), value)?;+ let res = value.take().unwrap();+ let me = self.get_mut();match res {- Ok(Some(trailers)) => store- .with_getter::<WasiHttp>(self.getter)- .with(|mut store| {- let WasiHttpCtxView { table, .. } = store.get();- let trailers = table- .delete(trailers)- .context("failed to delete trailers")?;- _ = self.tx.send(Ok(Some(Arc::from(trailers))));- Ok(())- }),+ Ok(Some(trailers)) => {+ let WasiHttpCtxView { table, .. } = (me.getter)(store.data_mut());+ let trailers = table+ .delete(trailers)+ .context("failed to delete trailers")?;+ _ = me.tx.take().unwrap().send(Ok(Some(Arc::from(trailers))));+ }Ok(None) => {- _ = self.tx.send(Ok(None));- Ok(())+ _ = me.tx.take().unwrap().send(Ok(None));}Err(err) => {- _ = self.tx.send(Err(err));- Ok(())+ _ = me.tx.take().unwrap().send(Err(err));}}+ Poll::Ready(Ok(()))}}diff --git a/crates/wasi-http/src/p3/host/types.rs b/crates/wasi-http/src/p3/host/types.rsindex 533bec0287..5e76d3633b 100644--- a/crates/wasi-http/src/p3/host/types.rs+++ b/crates/wasi-http/src/p3/host/types.rs@@ -81,17 +81,34 @@ fn parse_header_value(}struct GuestBodyResultProducer(- oneshot::Receiver<Box<dyn Future<Output = Result<(), ErrorCode>> + Send>>,+ Pin<Box<dyn Future<Output = wasmtime::Result<Result<(), ErrorCode>>> + Send>>,);+impl GuestBodyResultProducer {+ fn new(rx: oneshot::Receiver<Box<dyn Future<Output = Result<(), ErrorCode>> + Send>>) -> Self {+ Self(Box::pin(async move {+ let Ok(fut) = rx.await else {+ return Ok(Ok(()));+ };+ Ok(Box::into_pin(fut).await)+ }))+ }+}+impl<D> FutureProducer<D> for GuestBodyResultProducer {type Item = Result<(), ErrorCode>;- async fn produce(self, _: &Accessor<D>) -> wasmtime::Result<Self::Item> {- let Ok(fut) = self.0.await else {- return Ok(Ok(()));- };- Ok(Box::into_pin(fut).await)+ fn poll_produce(+ self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ _: StoreContextMut<D>,+ finish: bool,+ ) -> Poll<wasmtime::Result<Option<Self::Item>>> {+ match Pin::new(&mut self.get_mut().0).poll(cx) {+ Poll::Pending if finish => Poll::Ready(Ok(None)),+ Poll::Pending => Poll::Pending,+ Poll::Ready(result) => Poll::Ready(Ok(Some(result?))),+ }}}@@ -384,7 +401,11 @@ impl HostRequestWithStore for WasiHttp {let req = push_request(table, req)?;Ok((req,- FutureReader::new(instance, &mut store, GuestBodyResultProducer(result_rx)),+ FutureReader::new(+ instance,+ &mut store,+ GuestBodyResultProducer::new(result_rx),+ ),))})}@@ -704,7 +725,11 @@ impl HostResponseWithStore for WasiHttp {let res = push_response(table, res)?;Ok((res,- FutureReader::new(instance, &mut store, GuestBodyResultProducer(result_rx)),+ FutureReader::new(+ instance,+ &mut store,+ GuestBodyResultProducer::new(result_rx),+ ),))})}diff --git a/crates/wasi/src/p3/filesystem/host.rs b/crates/wasi/src/p3/filesystem/host.rsindex 6faad51d6d..6bba67ab56 100644--- a/crates/wasi/src/p3/filesystem/host.rs+++ b/crates/wasi/src/p3/filesystem/host.rs@@ -502,7 +502,7 @@ impl types::HostDescriptorWithStore for WasiFilesystem {FutureReader::new(instance,&mut store,- FutureReadyProducer(Err(ErrorCode::NotPermitted)),+ FutureReadyProducer(Some(Err(ErrorCode::NotPermitted))),),));}@@ -648,7 +648,7 @@ impl types::HostDescriptorWithStore for WasiFilesystem {FutureReader::new(instance,&mut store,- FutureReadyProducer(Err(ErrorCode::NotPermitted)),+ FutureReadyProducer(Some(Err(ErrorCode::NotPermitted))),),));}diff --git a/crates/wasi/src/p3/mod.rs b/crates/wasi/src/p3/mod.rsindex 2283e887da..d9764c7038 100644--- a/crates/wasi/src/p3/mod.rs+++ b/crates/wasi/src/p3/mod.rs@@ -24,7 +24,7 @@ use core::task::{Context, Poll};use tokio::sync::oneshot;use wasmtime::StoreContextMut;use wasmtime::component::{- Accessor, Destination, FutureProducer, Linker, StreamProducer, StreamResult, VecBuffer,+ Destination, FutureProducer, Linker, StreamProducer, StreamResult, VecBuffer,};// Default buffer capacity to use for reads of byte-sized values.@@ -53,16 +53,21 @@ impl<T: Send + Sync + 'static, D> StreamProducer<D> for StreamEmptyProducer<T> {}}-struct FutureReadyProducer<T>(T);+struct FutureReadyProducer<T>(Option<T>);impl<T, D> FutureProducer<D> for FutureReadyProducer<T>where- T: Send + 'static,+ T: Send + Unpin + 'static,{type Item = T;- async fn produce(self, _: &Accessor<D>) -> wasmtime::Result<T> {- Ok(self.0)+ fn poll_produce(+ self: Pin<&mut Self>,+ _: &mut Context<'_>,+ _: StoreContextMut<D>,+ _: bool,+ ) -> Poll<wasmtime::Result<Option<T>>> {+ Poll::Ready(Ok(Some(self.get_mut().0.take().unwrap())))}}@@ -80,8 +85,17 @@ where{type Item = T;- async fn produce(self, _: &Accessor<D>) -> wasmtime::Result<T> {- self.0.await.context("oneshot sender dropped")+ fn poll_produce(+ self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ _: StoreContextMut<D>,+ finish: bool,+ ) -> Poll<wasmtime::Result<Option<T>>> {+ match Pin::new(&mut self.get_mut().0).poll(cx) {+ Poll::Pending if finish => Poll::Ready(Ok(None)),+ Poll::Pending => Poll::Pending,+ Poll::Ready(result) => Poll::Ready(Ok(Some(result.context("oneshot sender dropped")?))),+ }}}diff --git a/crates/wasi/src/p3/sockets/host/types/tcp.rs b/crates/wasi/src/p3/sockets/host/types/tcp.rsindex f982b75144..abd6fa3ae4 100644--- a/crates/wasi/src/p3/sockets/host/types/tcp.rs+++ b/crates/wasi/src/p3/sockets/host/types/tcp.rs@@ -359,7 +359,7 @@ impl HostTcpSocketWithStore for WasiSockets {FutureReader::new(instance,&mut store,- FutureReadyProducer(Err(ErrorCode::InvalidState)),+ FutureReadyProducer(Some(Err(ErrorCode::InvalidState))),),)),}diff --git a/crates/wasmtime/src/runtime/component/concurrent.rs b/crates/wasmtime/src/runtime/component/concurrent.rsindex 1a62147258..d4c5202340 100644--- a/crates/wasmtime/src/runtime/component/concurrent.rs+++ b/crates/wasmtime/src/runtime/component/concurrent.rs@@ -2936,14 +2936,7 @@ impl Instance {if async_ {return Ok(BLOCKED);} else {- let waitable = Waitable::Guest(guest_task);- let old_set = waitable.common(concurrent_state)?.set;- let set = concurrent_state.get_mut(caller)?.sync_call_set;- waitable.join(concurrent_state, Some(set))?;-- self.suspend(store, SuspendReason::Waiting { set, task: caller })?;-- waitable.join(self.concurrent_state_mut(store), old_set)?;+ self.wait_for_event(store, Waitable::Guest(guest_task))?;}}}@@ -2960,6 +2953,17 @@ impl Instance {}}+ fn wait_for_event(self, store: &mut dyn VMStore, waitable: Waitable) -> Result<()> {+ let state = self.concurrent_state_mut(store);+ let caller = state.guest_task.unwrap();+ let old_set = waitable.common(state)?.set;+ let set = state.get_mut(caller)?.sync_call_set;+ waitable.join(state, Some(set))?;+ self.suspend(store, SuspendReason::Waiting { set, task: caller })?;+ let state = self.concurrent_state_mut(store);+ waitable.join(state, old_set)+ }+/// Configures TLS state so `store` will be available via `tls::get` within/// the closure `f` provided.///diff --git a/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rs b/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rsindex 9bc43d25fe..d5f0f92ea7 100644--- a/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rs+++ b/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rs@@ -1,6 +1,6 @@use super::table::{TableDebug, TableId};use super::{Event, GlobalErrorContextRefCount, Waitable, WaitableCommon};-use crate::component::concurrent::{Accessor, ConcurrentState, WorkItem, tls};+use crate::component::concurrent::{ConcurrentState, WorkItem, tls};use crate::component::func::{self, LiftContext, LowerContext, Options};use crate::component::matching::InstanceType;use crate::component::values::{ErrorContextAny, FutureAny, StreamAny};@@ -23,7 +23,7 @@ use std::mem::{self, MaybeUninit};use std::pin::Pin;use std::string::{String, ToString};use std::sync::{Arc, Mutex};-use std::task::{Context, Poll, Waker};+use std::task::{self, Context, Poll, Waker};use std::vec::Vec;use wasmtime_environ::component::{CanonicalAbiInfo, ComponentTypes, InterfaceType, OptionsIndex,@@ -223,6 +223,17 @@ pub struct Destination<'a, T, B> {}impl<'a, T, B> Destination<'a, T, B> {+ /// Reborrow `self` so it can be used again later.+ pub fn reborrow(&mut self) -> Destination<'_, T, B> {+ Destination {+ instance: self.instance,+ id: self.id,+ buffer: &mut *self.buffer,+ host_buffer: self.host_buffer.as_deref_mut(),+ _phantom: PhantomData,+ }+ }+/// Take the buffer out of `self`, leaving a default-initialized one in its/// place.///@@ -505,7 +516,16 @@ pub struct Source<'a, T> {host_buffer: Option<&'a mut dyn WriteBuffer<T>>,}-impl<T> Source<'_, T> {+impl<'a, T> Source<'a, T> {+ /// Reborrow `self` so it can be used again later.+ pub fn reborrow(&mut self) -> Source<'_, T> {+ Source {+ instance: self.instance,+ id: self.id,+ host_buffer: self.host_buffer.as_deref_mut(),+ }+ }+/// Accept zero or more items from the writer.pub fn read<B, S: AsContextMut>(&mut self, mut store: S, buffer: &mut B) -> Result<()>where@@ -782,7 +802,20 @@ pub trait FutureProducer<D>: Send + 'static {type Item;/// Handle a host- or guest-initiated read by producing a value.- fn produce(self, accessor: &Accessor<D>) -> impl Future<Output = Result<Self::Item>> + Send;+ ///+ /// This is equivalent to `StreamProducer::poll_produce`, but with a+ /// simplified interface for futures.+ ///+ /// If `finish` is true, the implementation may return+ /// `Poll::Ready(Ok(None))` to indicate the operation was canceled before it+ /// could produce a value. Otherwise, it must either return+ /// `Poll::Ready(Ok(Some(_)))`, `Poll::Ready(Err(_))`, or `Poll::Pending`.+ fn poll_produce(+ self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ store: StoreContextMut<D>,+ finish: bool,+ ) -> Poll<Result<Option<Self::Item>>>;}/// Represents a host-owned read end of a future.@@ -791,11 +824,23 @@ pub trait FutureConsumer<D>: Send + 'static {type Item;/// Handle a host- or guest-initiated write by consuming a value.- fn consume(- self,- accessor: &Accessor<D>,- value: Self::Item,- ) -> impl Future<Output = Result<()>> + Send;+ ///+ /// This is equivalent to `StreamProducer::poll_produce`, but with a+ /// simplified interface for futures.+ ///+ /// If `finish` is true, the implementation may return `Poll::Ready(Ok(()))`+ /// without taking the item from `source`, which indicates the operation was+ /// canceled before it could consume the value. Otherwise, it must either+ /// take the item from `source` and return `Poll::Ready(Ok(()))`, or else+ /// return `Poll::Ready(Err(_))` or `Poll::Pending` (with or without taking+ /// the item).+ fn poll_consume(+ self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ store: StoreContextMut<D>,+ source: Source<'_, Self::Item>,+ finish: bool,+ ) -> Poll<Result<()>>;}/// Represents the readable end of a Component Model `future`.@@ -820,13 +865,13 @@ impl<T> FutureReader<T> {whereT: func::Lower + func::Lift + Send + Sync + 'static,{- struct Producer<F>(F);+ struct Producer<P>(P);- impl<D, T: func::Lower + 'static, F: Future<Output = Result<T>> + Send + 'static>- StreamProducer<D> for Producer<F>+ impl<D, T: func::Lower + 'static, P: FutureProducer<D, Item = T>> StreamProducer<D>+ for Producer<P>{- type Item = T;- type Buffer = Option<T>;+ type Item = P::Item;+ type Buffer = Option<P::Item>;fn poll_produce<'a>(self: Pin<&mut Self>,@@ -837,18 +882,11 @@ impl<T> FutureReader<T> {) -> Poll<Result<StreamResult>> {// SAFETY: This is a standard pin-projection, and we never move// out of `self`.- let future = unsafe { self.map_unchecked_mut(|v| &mut v.0) };-- match tls::set(store.0, || future.poll(cx)) {- Poll::Pending => {- if finish {- Poll::Ready(Ok(StreamResult::Cancelled))- } else {- Poll::Pending- }- }- Poll::Ready(value) => {- destination.set_buffer(Some(value?));+ let producer = unsafe { self.map_unchecked_mut(|v| &mut v.0) };++ Poll::Ready(Ok(+ if let Some(value) = task::ready!(producer.poll_produce(cx, store, finish))? {+ destination.set_buffer(Some(value));// Here we return `StreamResult::Completed` even though// we've produced the last item we'll ever produce.@@ -856,23 +894,19 @@ impl<T> FutureReader<T> {// `ReturnCode::Completed(1)` rather than// `ReturnCode::Dropped(1)`. In any case, we won't be// called again since the future will have resolved.- Poll::Ready(Ok(StreamResult::Completed))- }- }+ StreamResult::Completed+ } else {+ StreamResult::Cancelled+ },+ ))}}- let mut store = store.as_context_mut();- let token = StoreToken::new(store.as_context_mut());Self::new_(instance.new_transmit(- store,+ store.as_context_mut(),TransmitKind::Future,- Producer(async move {- producer- .produce(&Accessor::new(token, Some(instance)))- .await- }),+ Producer(producer),),instance,)@@ -894,14 +928,10 @@ impl<T> FutureReader<T> {) whereT: func::Lift + 'static,{- enum Consumer<C> {- Start(C, Instance),- Poll(Pin<Box<dyn Future<Output = Result<()>> + Send>>),- Invalid,- }+ struct Consumer<C>(C);- impl<D: 'static, T: func::Lift + 'static, C: FutureConsumer<D, Item = T> + Unpin>- StreamConsumer<D> for Consumer<C>+ impl<D: 'static, T: func::Lift + 'static, C: FutureConsumer<D, Item = T>> StreamConsumer<D>+ for Consumer<C>{type Item = T;@@ -912,53 +942,32 @@ impl<T> FutureReader<T> {mut source: Source<Self::Item>,finish: bool,) -> Poll<Result<StreamResult>> {- let me = self.get_mut();-- if let Consumer::Start(consumer, instance) = mem::replace(me, Consumer::Invalid) {- let token = StoreToken::new(store.as_context_mut());- let value = &mut None;- source.read(store.as_context_mut(), value)?;- let value = value.take().unwrap();- *me = Consumer::Poll(Box::pin(async move {- consumer- .consume(&Accessor::new(token, Some(instance)), value)- .await- }));- }-- let Consumer::Poll(future) = me else {- unreachable!();- };-- match tls::set(store.0, || future.as_mut().poll(cx)) {- Poll::Pending => {- if finish {- Poll::Ready(Ok(StreamResult::Cancelled))- } else {- Poll::Pending- }- }- Poll::Ready(result) => {- result?;+ // SAFETY: This is a standard pin-projection, and we never move+ // out of `self`.+ let consumer = unsafe { self.map_unchecked_mut(|v| &mut v.0) };- // Here we return `StreamResult::Completed` even though- // we've consumed the last item we'll ever consume.- // That's because the ABI expects- // `ReturnCode::Completed(1)` rather than- // `ReturnCode::Dropped(1)`. In any case, we won't be- // called again since the future will have resolved.- Poll::Ready(Ok(StreamResult::Completed))- }- }+ task::ready!(consumer.poll_consume(+ cx,+ store.as_context_mut(),+ source.reborrow(),+ finish+ ))?;++ Poll::Ready(Ok(if source.remaining(store) == 0 {+ // Here we return `StreamResult::Completed` even though+ // we've consumed the last item we'll ever consume. That's+ // because the ABI expects `ReturnCode::Completed(1)` rather+ // than `ReturnCode::Dropped(1)`. In any case, we won't be+ // called again since the future will have resolved.+ StreamResult::Completed+ } else {+ StreamResult::Cancelled+ }))}}- self.instance.set_consumer(- store,- self.id,- TransmitKind::Future,- Consumer::Start(consumer, self.instance),- );+ self.instance+ .set_consumer(store, self.id, TransmitKind::Future, Consumer(consumer));}/// Convert this `FutureReader` into a [`Val`].@@ -1653,6 +1662,10 @@ impl TableDebug for TransmitState {}}+type PollStream = Box<+ dyn Fn() -> Pin<Box<dyn Future<Output = Result<StreamResult>> + Send + 'static>> + Send + Sync,+>;+/// Represents the state of the write end of a stream or future.enum WriteState {/// The write end is open, but no write is pending.@@ -1668,11 +1681,7 @@ enum WriteState {},/// The write end is owned by the host, which is ready to produce items.HostReady {- produce: Box<- dyn Fn() -> Pin<Box<dyn Future<Output = Result<StreamResult>> + Send + 'static>>- + Send- + Sync,- >,+ produce: PollStream,guest_offset: usize,cancel: bool,cancel_waker: Option<Waker>,@@ -1707,11 +1716,7 @@ enum ReadState {},/// The read end is owned by a host task, and it is ready to consume items.HostReady {- consume: Box<- dyn Fn() -> Pin<Box<dyn Future<Output = Result<StreamResult>> + Send + 'static>>- + Send- + Sync,- >,+ consume: PollStream,guest_offset: usize,cancel: bool,cancel_waker: Option<Waker>,@@ -1829,7 +1834,7 @@ impl Instance {unreachable!();};- if let Poll::Pending = &poll {+ if poll.is_pending() {if !buffer.remaining().is_empty()|| *guest_offset > 0|| host_offset > 0@@ -1839,7 +1844,6 @@ impl Instance {after producing at least one item")));}-*cancel_waker = Some(cx.waker().clone());} else {*cancel_waker = None;@@ -1961,7 +1965,7 @@ impl Instance {..} = &mut self.concurrent_state_mut(store).get_mut(id).unwrap().read{- if let Poll::Pending = &poll {+ if poll.is_pending() {*cancel_waker = Some(cx.waker().clone());} else {*cancel_waker = None;@@ -2004,6 +2008,12 @@ impl Instance {without consuming any items");}++ if let TransmitKind::Future = kind {+ tls::get(|store| {+ self.concurrent_state_mut(store).get_mut(id).unwrap().done = true;+ });+ }}StreamResult::Cancelled => {if !cancelled {@@ -2046,7 +2056,7 @@ impl Instance {cancel: false,cancel_waker: None,};- self.pipe_from_guest(store, kind, id, future);+ self.pipe_from_guest(store.0, kind, id, future);}WriteState::HostReady { .. } => {let WriteState::HostReady { produce, .. } = mem::replace(@@ -2262,7 +2272,7 @@ impl Instance {fn pipe_from_guest(self,- mut store: impl AsContextMut,+ store: &mut dyn VMStore,kind: TransmitKind,id: TableId<TransmitState>,future: Pin<Box<dyn Future<Output = Result<StreamResult>> + Send + 'static>>,@@ -2300,13 +2310,12 @@ impl Instance {})};- self.concurrent_state_mut(store.as_context_mut().0)- .push_future(future.boxed());+ self.concurrent_state_mut(store).push_future(future.boxed());}fn pipe_to_guest(self,- mut store: impl AsContextMut,+ store: &mut dyn VMStore,kind: TransmitKind,id: TableId<TransmitState>,future: Pin<Box<dyn Future<Output = Result<StreamResult>> + Send + 'static>>,@@ -2344,8 +2353,7 @@ impl Instance {})};- self.concurrent_state_mut(store.as_context_mut().0)- .push_future(future.boxed());+ self.concurrent_state_mut(store).push_future(future.boxed());}/// Drop the read end of a stream or future read from the host.@@ -2907,40 +2915,8 @@ impl Instance {transmit.done = true;}- let mut future = consume();- transmit.read = ReadState::HostReady {- consume,- guest_offset: 0,- cancel: false,- cancel_waker: None,- };set_guest_ready(concurrent_state)?;- let poll = self.set_tls(store.0, || {- future- .as_mut()- .poll(&mut Context::from_waker(&Waker::noop()))- });-- match poll {- Poll::Ready(state) => {- let transmit = self.concurrent_state_mut(store.0).get_mut(transmit_id)?;- let ReadState::HostReady { guest_offset, .. } = &mut transmit.read else {- unreachable!();- };- let code = return_code(ty.kind(), state?, mem::replace(guest_offset, 0));- transmit.write = WriteState::Open;- code- }- Poll::Pending => {- self.pipe_from_guest(- store.as_context_mut(),- ty.kind(),- transmit_id,- future,- );- ReturnCode::Blocked- }- }+ self.consume(store.0, ty.kind(), transmit_id, consume, 0, false)?}ReadState::HostToHost { .. } => unreachable!(),@@ -2972,6 +2948,47 @@ impl Instance {Ok(result)}+ /// Handle a host- or guest-initiated write by delivering the item(s) to the+ /// `StreamConsumer` for the specified stream or future.+ fn consume(+ self,+ store: &mut dyn VMStore,+ kind: TransmitKind,+ transmit_id: TableId<TransmitState>,+ consume: PollStream,+ guest_offset: usize,+ cancel: bool,+ ) -> Result<ReturnCode> {+ let mut future = consume();+ self.concurrent_state_mut(store).get_mut(transmit_id)?.read = ReadState::HostReady {+ consume,+ guest_offset,+ cancel,+ cancel_waker: None,+ };+ let poll = self.set_tls(store, || {+ future+ .as_mut()+ .poll(&mut Context::from_waker(&Waker::noop()))+ });++ Ok(match poll {+ Poll::Ready(state) => {+ let transmit = self.concurrent_state_mut(store).get_mut(transmit_id)?;+ let ReadState::HostReady { guest_offset, .. } = &mut transmit.read else {+ unreachable!();+ };+ let code = return_code(kind, state?, mem::replace(guest_offset, 0));+ transmit.write = WriteState::Open;+ code+ }+ Poll::Pending => {+ self.pipe_from_guest(store, kind, transmit_id, future);+ ReturnCode::Blocked+ }+ })+ }+/// Read from the specified stream or future from the guest.pub(super) fn guest_read<T: 'static>(self,@@ -3136,35 +3153,9 @@ impl Instance {transmit.done = true;}- let mut future = produce();- transmit.write = WriteState::HostReady {- produce,- guest_offset: 0,- cancel: false,- cancel_waker: None,- };set_guest_ready(concurrent_state)?;- let poll = self.set_tls(store.0, || {- future- .as_mut()- .poll(&mut Context::from_waker(&Waker::noop()))- });- match poll {- Poll::Ready(state) => {- let transmit = self.concurrent_state_mut(store.0).get_mut(transmit_id)?;- let WriteState::HostReady { guest_offset, .. } = &mut transmit.write else {- unreachable!();- };- let code = return_code(ty.kind(), state?, mem::replace(guest_offset, 0));- transmit.read = ReadState::Open;- code- }- Poll::Pending => {- self.pipe_to_guest(store.as_context_mut(), ty.kind(), transmit_id, future);- ReturnCode::Blocked- }- }+ self.produce(store.0, ty.kind(), transmit_id, produce, 0, false)?}WriteState::Open => {@@ -3188,6 +3179,273 @@ impl Instance {Ok(result)}+ /// Handle a host- or guest-initiated read by polling the `StreamProducer`+ /// for the specified stream or future for items.+ fn produce(+ self,+ store: &mut dyn VMStore,+ kind: TransmitKind,+ transmit_id: TableId<TransmitState>,+ produce: PollStream,+ guest_offset: usize,+ cancel: bool,+ ) -> Result<ReturnCode> {+ let mut future = produce();+ self.concurrent_state_mut(store).get_mut(transmit_id)?.write = WriteState::HostReady {+ produce,+ guest_offset,+ cancel,+ cancel_waker: None,+ };+ let poll = self.set_tls(store, || {+ future+ .as_mut()+ .poll(&mut Context::from_waker(&Waker::noop()))+ });++ Ok(match poll {+ Poll::Ready(state) => {+ let transmit = self.concurrent_state_mut(store).get_mut(transmit_id)?;+ let WriteState::HostReady { guest_offset, .. } = &mut transmit.write else {+ unreachable!();+ };+ let code = return_code(kind, state?, mem::replace(guest_offset, 0));+ transmit.read = ReadState::Open;+ code+ }+ Poll::Pending => {+ self.pipe_to_guest(store, kind, transmit_id, future);+ ReturnCode::Blocked+ }+ })+ }++ /// Cancel a pending stream or future write.+ fn cancel_write(+ self,+ store: &mut dyn VMStore,+ transmit_id: TableId<TransmitState>,+ async_: bool,+ ) -> Result<ReturnCode> {+ let state = self.concurrent_state_mut(store);+ let transmit = state.get_mut(transmit_id)?;+ log::trace!(+ "host_cancel_write state {transmit_id:?}; write state {:?} read state {:?}",+ transmit.read,+ transmit.write+ );++ let code = if let Some(event) =+ Waitable::Transmit(transmit.write_handle).take_event(state)?+ {+ let (Event::FutureWrite { code, .. } | Event::StreamWrite { code, .. }) = event else {+ unreachable!();+ };+ match (code, event) {+ (ReturnCode::Completed(count), Event::StreamWrite { .. }) => {+ ReturnCode::Cancelled(count)+ }+ (ReturnCode::Dropped(_) | ReturnCode::Completed(_), _) => code,+ _ => unreachable!(),+ }+ } else if let ReadState::HostReady {+ cancel,+ cancel_waker,+ ..+ } = &mut state.get_mut(transmit_id)?.read+ {+ *cancel = true;+ if let Some(waker) = cancel_waker.take() {+ waker.wake();+ }++ if async_ {+ ReturnCode::Blocked+ } else {+ let waitable = Waitable::Transmit(+ self.concurrent_state_mut(store)+ .get_mut(transmit_id)?+ .write_handle,+ );+ self.wait_for_event(store, waitable)?;+ let event = waitable.take_event(self.concurrent_state_mut(store))?;+ if let Some(+ event @ (Event::StreamWrite { code, .. } | Event::FutureWrite { code, .. }),+ ) = event+ {+ waitable.on_delivery(self.id().get_mut(store), event);+ code+ } else {+ unreachable!()+ }+ }+ } else {+ ReturnCode::Cancelled(0)+ };++ let transmit = self.concurrent_state_mut(store).get_mut(transmit_id)?;++ match &transmit.write {+ WriteState::GuestReady { .. } => {+ transmit.write = WriteState::Open;+ }+ WriteState::HostReady { .. } => todo!("support host write cancellation"),+ WriteState::Open | WriteState::Dropped => {}+ }++ log::trace!("cancelled write {transmit_id:?}: {code:?}");++ Ok(code)+ }++ /// Cancel a pending stream or future read.+ fn cancel_read(+ self,+ store: &mut dyn VMStore,+ transmit_id: TableId<TransmitState>,+ async_: bool,+ ) -> Result<ReturnCode> {+ let state = self.concurrent_state_mut(store);+ let transmit = state.get_mut(transmit_id)?;+ log::trace!(+ "host_cancel_read state {transmit_id:?}; read state {:?} write state {:?}",+ transmit.read,+ transmit.write+ );++ let code = if let Some(event) =+ Waitable::Transmit(transmit.read_handle).take_event(state)?+ {+ let (Event::FutureRead { code, .. } | Event::StreamRead { code, .. }) = event else {+ unreachable!();+ };+ match (code, event) {+ (ReturnCode::Completed(count), Event::StreamRead { .. }) => {+ ReturnCode::Cancelled(count)+ }+ (ReturnCode::Dropped(_) | ReturnCode::Completed(_), _) => code,+ _ => unreachable!(),+ }+ } else if let WriteState::HostReady {+ cancel,+ cancel_waker,+ ..+ } = &mut state.get_mut(transmit_id)?.write+ {+ *cancel = true;+ if let Some(waker) = cancel_waker.take() {+ waker.wake();+ }++ if async_ {+ ReturnCode::Blocked+ } else {+ let waitable = Waitable::Transmit(+ self.concurrent_state_mut(store)+ .get_mut(transmit_id)?+ .read_handle,+ );+ self.wait_for_event(store, waitable)?;+ let event = waitable.take_event(self.concurrent_state_mut(store))?;+ if let Some(+ event @ (Event::StreamRead { code, .. } | Event::FutureRead { code, .. }),+ ) = event+ {+ waitable.on_delivery(self.id().get_mut(store), event);+ code+ } else {+ unreachable!()+ }+ }+ } else {+ ReturnCode::Cancelled(0)+ };++ let transmit = self.concurrent_state_mut(store).get_mut(transmit_id)?;++ match &transmit.read {+ ReadState::GuestReady { .. } => {+ transmit.read = ReadState::Open;+ }+ ReadState::HostReady { .. } | ReadState::HostToHost { .. } => {+ todo!("support host read cancellation")+ }+ ReadState::Open | ReadState::Dropped => {}+ }++ log::trace!("cancelled read {transmit_id:?}: {code:?}");++ Ok(code)+ }++ /// Cancel a pending write for the specified stream or future from the guest.+ fn guest_cancel_write(+ self,+ store: &mut dyn VMStore,+ ty: TransmitIndex,+ async_: bool,+ writer: u32,+ ) -> Result<ReturnCode> {+ let (rep, state) =+ get_mut_by_index_from(self.id().get_mut(store).table_for_transmit(ty), ty, writer)?;+ let id = TableId::<TransmitHandle>::new(rep);+ log::trace!("guest cancel write {id:?} (handle {writer})");+ match state {+ TransmitLocalState::Write { .. } => {+ bail!("stream or future write cancelled when no write is pending")+ }+ TransmitLocalState::Read { .. } => {+ bail!("passed read end to `{{stream|future}}.cancel-write`")+ }+ TransmitLocalState::Busy => {}+ }+ let transmit_id = self.concurrent_state_mut(store).get_mut(id)?.state;+ let code = self.cancel_write(store, transmit_id, async_)?;+ if !matches!(code, ReturnCode::Blocked) {+ let state =+ get_mut_by_index_from(self.id().get_mut(store).table_for_transmit(ty), ty, writer)?+ .1;+ if let TransmitLocalState::Busy = state {+ *state = TransmitLocalState::Write { done: false };+ }+ }+ Ok(code)+ }++ /// Cancel a pending read for the specified stream or future from the guest.+ fn guest_cancel_read(+ self,+ store: &mut dyn VMStore,+ ty: TransmitIndex,+ async_: bool,+ reader: u32,+ ) -> Result<ReturnCode> {+ let (rep, state) =+ get_mut_by_index_from(self.id().get_mut(store).table_for_transmit(ty), ty, reader)?;+ let id = TableId::<TransmitHandle>::new(rep);+ log::trace!("guest cancel read {id:?} (handle {reader})");+ match state {+ TransmitLocalState::Read { .. } => {+ bail!("stream or future read cancelled when no read is pending")+ }+ TransmitLocalState::Write { .. } => {+ bail!("passed write end to `{{stream|future}}.cancel-read`")+ }+ TransmitLocalState::Busy => {}+ }+ let transmit_id = self.concurrent_state_mut(store).get_mut(id)?.state;+ let code = self.cancel_read(store, transmit_id, async_)?;+ if !matches!(code, ReturnCode::Blocked) {+ let state =+ get_mut_by_index_from(self.id().get_mut(store).table_for_transmit(ty), ty, reader)?+ .1;+ if let TransmitLocalState::Busy = state {+ *state = TransmitLocalState::Read { done: false };+ }+ }+ Ok(code)+ }+/// Drop the readable end of the specified stream or future from the guest.fn guest_drop_readable(self,@@ -3301,6 +3559,54 @@ impl Instance {Ok(())}+ /// Implements the `future.cancel-read` intrinsic.+ pub(crate) fn future_cancel_read(+ self,+ store: &mut dyn VMStore,+ ty: TypeFutureTableIndex,+ async_: bool,+ reader: u32,+ ) -> Result<u32> {+ self.guest_cancel_read(store, TransmitIndex::Future(ty), async_, reader)+ .map(|v| v.encode())+ }++ /// Implements the `future.cancel-write` intrinsic.+ pub(crate) fn future_cancel_write(+ self,+ store: &mut dyn VMStore,+ ty: TypeFutureTableIndex,+ async_: bool,+ writer: u32,+ ) -> Result<u32> {+ self.guest_cancel_write(store, TransmitIndex::Future(ty), async_, writer)+ .map(|v| v.encode())+ }++ /// Implements the `stream.cancel-read` intrinsic.+ pub(crate) fn stream_cancel_read(+ self,+ store: &mut dyn VMStore,+ ty: TypeStreamTableIndex,+ async_: bool,+ reader: u32,+ ) -> Result<u32> {+ self.guest_cancel_read(store, TransmitIndex::Stream(ty), async_, reader)+ .map(|v| v.encode())+ }++ /// Implements the `stream.cancel-write` intrinsic.+ pub(crate) fn stream_cancel_write(+ self,+ store: &mut dyn VMStore,+ ty: TypeStreamTableIndex,+ async_: bool,+ writer: u32,+ ) -> Result<u32> {+ self.guest_cancel_write(store, TransmitIndex::Stream(ty), async_, writer)+ .map(|v| v.encode())+ }+/// Implements the `future.drop-readable` intrinsic.pub(crate) fn future_drop_readable(self,@@ -3377,58 +3683,6 @@ impl ComponentInstance {})}- /// Cancel a pending write for the specified stream or future from the guest.- fn guest_cancel_write(- mut self: Pin<&mut Self>,- ty: TransmitIndex,- writer: u32,- _async_: bool,- ) -> Result<ReturnCode> {- let (rep, state) = get_mut_by_index_from(self.as_mut().table_for_transmit(ty), ty, writer)?;- let id = TableId::<TransmitHandle>::new(rep);- log::trace!("guest cancel write {id:?} (handle {writer})");- match state {- TransmitLocalState::Write { .. } => {- bail!("stream or future write cancelled when no write is pending")- }- TransmitLocalState::Read { .. } => {- bail!("passed read end to `{{stream|future}}.cancel-write`")- }- TransmitLocalState::Busy => {- *state = TransmitLocalState::Write { done: false };- }- }- let state = self.concurrent_state_mut();- let rep = state.get_mut(id)?.state.rep();- state.host_cancel_write(rep)- }-- /// Cancel a pending read for the specified stream or future from the guest.- fn guest_cancel_read(- mut self: Pin<&mut Self>,- ty: TransmitIndex,- reader: u32,- _async_: bool,- ) -> Result<ReturnCode> {- let (rep, state) = get_mut_by_index_from(self.as_mut().table_for_transmit(ty), ty, reader)?;- let id = TableId::<TransmitHandle>::new(rep);- log::trace!("guest cancel read {id:?} (handle {reader})");- match state {- TransmitLocalState::Read { .. } => {- bail!("stream or future read cancelled when no read is pending")- }- TransmitLocalState::Write { .. } => {- bail!("passed write end to `{{stream|future}}.cancel-read`")- }- TransmitLocalState::Busy => {- *state = TransmitLocalState::Read { done: false };- }- }- let state = self.concurrent_state_mut();- let rep = state.get_mut(id)?.state.rep();- state.host_cancel_read(rep)- }-/// Drop the specified error context.pub(crate) fn error_context_drop(mut self: Pin<&mut Self>,@@ -3499,28 +3753,6 @@ impl ComponentInstance {self.guest_new(TransmitIndex::Future(ty))}- /// Implements the `future.cancel-write` intrinsic.- pub(crate) fn future_cancel_write(- self: Pin<&mut Self>,- ty: TypeFutureTableIndex,- async_: bool,- writer: u32,- ) -> Result<u32> {- self.guest_cancel_write(TransmitIndex::Future(ty), writer, async_)- .map(|result| result.encode())- }-- /// Implements the `future.cancel-read` intrinsic.- pub(crate) fn future_cancel_read(- self: Pin<&mut Self>,- ty: TypeFutureTableIndex,- async_: bool,- reader: u32,- ) -> Result<u32> {- self.guest_cancel_read(TransmitIndex::Future(ty), reader, async_)- .map(|result| result.encode())- }-/// Implements the `stream.new` intrinsic.pub(crate) fn stream_new(self: Pin<&mut Self>,@@ -3529,28 +3761,6 @@ impl ComponentInstance {self.guest_new(TransmitIndex::Stream(ty))}- /// Implements the `stream.cancel-write` intrinsic.- pub(crate) fn stream_cancel_write(- self: Pin<&mut Self>,- ty: TypeStreamTableIndex,- async_: bool,- writer: u32,- ) -> Result<u32> {- self.guest_cancel_write(TransmitIndex::Stream(ty), writer, async_)- .map(|result| result.encode())- }-- /// Implements the `stream.cancel-read` intrinsic.- pub(crate) fn stream_cancel_read(- self: Pin<&mut Self>,- ty: TypeStreamTableIndex,- async_: bool,- reader: u32,- ) -> Result<u32> {- self.guest_cancel_read(TransmitIndex::Stream(ty), reader, async_)- .map(|result| result.encode())- }-/// Transfer ownership of the specified future read end from one guest to/// another.pub(crate) fn future_transfer(@@ -3755,120 +3965,6 @@ impl ConcurrentState {Ok(())}-- /// Cancel a pending stream or future write from the host.- ///- /// # Arguments- ///- /// * `rep` - The `TransmitState` rep for the stream or future.- fn host_cancel_write(&mut self, rep: u32) -> Result<ReturnCode> {- let transmit_id = TableId::<TransmitState>::new(rep);- let transmit = self.get_mut(transmit_id)?;- log::trace!(- "host_cancel_write state {transmit_id:?}; write state {:?} read state {:?}",- transmit.read,- transmit.write- );-- let code = if let Some(event) =- Waitable::Transmit(transmit.write_handle).take_event(self)?- {- let (Event::FutureWrite { code, .. } | Event::StreamWrite { code, .. }) = event else {- unreachable!();- };- match (code, event) {- (ReturnCode::Completed(count), Event::StreamWrite { .. }) => {- ReturnCode::Cancelled(count)- }- (ReturnCode::Dropped(_) | ReturnCode::Completed(_), _) => code,- _ => unreachable!(),- }- } else if let ReadState::HostReady {- cancel,- cancel_waker,- ..- } = &mut self.get_mut(transmit_id)?.read- {- *cancel = true;- if let Some(waker) = cancel_waker.take() {- waker.wake()- }- ReturnCode::Blocked- } else {- ReturnCode::Cancelled(0)- };-- let transmit = self.get_mut(transmit_id)?;-- match &transmit.write {- WriteState::GuestReady { .. } => {- transmit.write = WriteState::Open;- }- WriteState::HostReady { .. } => todo!("support host write cancellation"),- WriteState::Open | WriteState::Dropped => {}- }-- log::trace!("cancelled write {transmit_id:?}");-- Ok(code)- }-- /// Cancel a pending stream or future read from the host.- ///- /// # Arguments- ///- /// * `rep` - The `TransmitState` rep for the stream or future.- fn host_cancel_read(&mut self, rep: u32) -> Result<ReturnCode> {- let transmit_id = TableId::<TransmitState>::new(rep);- let transmit = self.get_mut(transmit_id)?;- log::trace!(- "host_cancel_read state {transmit_id:?}; read state {:?} write state {:?}",- transmit.read,- transmit.write- );-- let code = if let Some(event) = Waitable::Transmit(transmit.read_handle).take_event(self)? {- let (Event::FutureRead { code, .. } | Event::StreamRead { code, .. }) = event else {- unreachable!();- };- match (code, event) {- (ReturnCode::Completed(count), Event::StreamRead { .. }) => {- ReturnCode::Cancelled(count)- }- (ReturnCode::Dropped(_) | ReturnCode::Completed(_), _) => code,- _ => unreachable!(),- }- } else if let WriteState::HostReady {- cancel,- cancel_waker,- ..- } = &mut self.get_mut(transmit_id)?.write- {- *cancel = true;- if let Some(waker) = cancel_waker.take() {- waker.wake()- }- ReturnCode::Blocked- } else {- ReturnCode::Cancelled(0)- };-- let transmit = self.get_mut(transmit_id)?;-- match &transmit.read {- ReadState::GuestReady { .. } => {- transmit.read = ReadState::Open;- }- ReadState::HostReady { .. } | ReadState::HostToHost { .. } => {- todo!("support host read cancellation")- }- ReadState::Open | ReadState::Dropped => {}- }-- log::trace!("cancelled read {transmit_id:?}");-- Ok(code)- }}pub(crate) struct ResourcePair {diff --git a/crates/wasmtime/src/runtime/vm/component/libcalls.rs b/crates/wasmtime/src/runtime/vm/component/libcalls.rsindex 30fd688bc8..e40e9acf81 100644--- a/crates/wasmtime/src/runtime/vm/component/libcalls.rs+++ b/crates/wasmtime/src/runtime/vm/component/libcalls.rs@@ -978,7 +978,8 @@ fn future_cancel_write(async_: u8,writer: u32,) -> Result<u32> {- instance.id().get_mut(store).future_cancel_write(+ instance.future_cancel_write(+ store,TypeFutureTableIndex::from_u32(ty),async_ != 0,writer,@@ -993,7 +994,8 @@ fn future_cancel_read(async_: u8,reader: u32,) -> Result<u32> {- instance.id().get_mut(store).future_cancel_read(+ instance.future_cancel_read(+ store,TypeFutureTableIndex::from_u32(ty),async_ != 0,reader,@@ -1080,7 +1082,8 @@ fn stream_cancel_write(async_: u8,writer: u32,) -> Result<u32> {- instance.id().get_mut(store).stream_cancel_write(+ instance.stream_cancel_write(+ store,TypeStreamTableIndex::from_u32(ty),async_ != 0,writer,@@ -1095,7 +1098,8 @@ fn stream_cancel_read(async_: u8,reader: u32,) -> Result<u32> {- instance.id().get_mut(store).stream_cancel_read(+ instance.stream_cancel_read(+ store,TypeStreamTableIndex::from_u32(ty),async_ != 0,reader,