Skip to content

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.rs
index 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.rs
index 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.rs
index 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.wit
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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> {
where
T: 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> {
) where
T: 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.rs
index 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,