Mirror WASIp{2,3} clocks implementations (#11377)

This is an implementation of #11362 but for the `wasi:clocks`
implementation of WASIp2. The goal here is to have the impls be
implemented and look roughly the same across WASIp2 and WASIp3, namely
the target of the implementation of now `WasiClocksCtxView` instead of
`WasiCtxView`. This makes the trait implementations a bit more flexible
as it means embedders aren't required to, for example, provide a full
WASI context for clocks but just clock-related context.

Author: alexcrichton

crates/wasi/src/clocks.rs

@@ -1,6 +1,13 @@
 use cap_std::time::{Duration, Instant, SystemClock};
 use cap_std::{AmbientAuthority, ambient_authority};
 use cap_time_ext::{MonotonicClockExt as _, SystemClockExt as _};
+use wasmtime::component::{HasData, ResourceTable};
+
+pub(crate) struct WasiClocks;
+
+impl HasData for WasiClocks {
+    type Data<'a> = WasiClocksCtxView<'a>;
+}
 
 pub struct WasiClocksCtx {
     pub wall_clock: Box<dyn HostWallClock + Send>,
@@ -17,13 +24,12 @@ impl Default for WasiClocksCtx {
 }
 
 pub trait WasiClocksView: Send {
-    fn clocks(&mut self) -> &mut WasiClocksCtx;
+    fn clocks(&mut self) -> WasiClocksCtxView<'_>;
 }
 
-impl WasiClocksView for WasiClocksCtx {
-    fn clocks(&mut self) -> &mut WasiClocksCtx {
-        self
-    }
+pub struct WasiClocksCtxView<'a> {
+    pub ctx: &'a mut WasiClocksCtx,
+    pub table: &'a mut ResourceTable,
 }
 
 pub trait HostWallClock: Send {

crates/wasi/src/p2/host/clocks.rs

@@ -1,8 +1,9 @@
+use crate::clocks::WasiClocksCtxView;
+use crate::p2::DynPollable;
 use crate::p2::bindings::{
     clocks::monotonic_clock::{self, Duration as WasiDuration, Instant},
     clocks::wall_clock::{self, Datetime},
 };
-use crate::p2::{DynPollable, WasiCtxView};
 use cap_std::time::SystemTime;
 use std::time::Duration;
 use wasmtime::component::Resource;
@@ -22,17 +23,17 @@ impl TryFrom<SystemTime> for Datetime {
     }
 }
 
-impl wall_clock::Host for WasiCtxView<'_> {
+impl wall_clock::Host for WasiClocksCtxView<'_> {
     fn now(&mut self) -> anyhow::Result<Datetime> {
-        let now = self.ctx.clocks.wall_clock.now();
+        let now = self.ctx.wall_clock.now();
         Ok(Datetime {
             seconds: now.as_secs(),
             nanoseconds: now.subsec_nanos(),
         })
     }
 
     fn resolution(&mut self) -> anyhow::Result<Datetime> {
-        let res = self.ctx.clocks.wall_clock.resolution();
+        let res = self.ctx.wall_clock.resolution();
         Ok(Datetime {
             seconds: res.as_secs(),
             nanoseconds: res.subsec_nanos(),
@@ -59,17 +60,17 @@ fn subscribe_to_duration(
     subscribe(table, sleep)
 }
 
-impl monotonic_clock::Host for WasiCtxView<'_> {
+impl monotonic_clock::Host for WasiClocksCtxView<'_> {
     fn now(&mut self) -> anyhow::Result<Instant> {
-        Ok(self.ctx.clocks.monotonic_clock.now())
+        Ok(self.ctx.monotonic_clock.now())
     }
 
     fn resolution(&mut self) -> anyhow::Result<Instant> {
-        Ok(self.ctx.clocks.monotonic_clock.resolution())
+        Ok(self.ctx.monotonic_clock.resolution())
     }
 
     fn subscribe_instant(&mut self, when: Instant) -> anyhow::Result<Resource<DynPollable>> {
-        let clock_now = self.ctx.clocks.monotonic_clock.now();
+        let clock_now = self.ctx.monotonic_clock.now();
         let duration = if when > clock_now {
             Duration::from_nanos(when - clock_now)
         } else {

crates/wasi/src/p2/mod.rs

@@ -222,6 +222,7 @@
 //! [`ResourceTable`]: wasmtime::component::ResourceTable
 
 use crate::cli::{WasiCli, WasiCliView};
+use crate::clocks::{WasiClocks, WasiClocksView};
 use crate::random::WasiRandom;
 use crate::{WasiCtxView, WasiView};
 use wasmtime::component::{HasData, Linker, ResourceTable};
@@ -339,8 +340,8 @@ where
     use crate::p2::bindings::{cli, clocks, filesystem, random, sockets};
 
     let l = linker;
-    clocks::wall_clock::add_to_linker::<T, HasWasi>(l, T::ctx)?;
-    clocks::monotonic_clock::add_to_linker::<T, HasWasi>(l, T::ctx)?;
+    clocks::wall_clock::add_to_linker::<T, WasiClocks>(l, T::clocks)?;
+    clocks::monotonic_clock::add_to_linker::<T, WasiClocks>(l, T::clocks)?;
     filesystem::preopens::add_to_linker::<T, HasWasi>(l, T::ctx)?;
     random::random::add_to_linker::<T, WasiRandom>(l, |t| &mut t.ctx().ctx.random)?;
     random::insecure::add_to_linker::<T, WasiRandom>(l, |t| &mut t.ctx().ctx.random)?;
@@ -386,8 +387,8 @@ fn add_proxy_interfaces_nonblocking<T: WasiView>(linker: &mut Linker<T>) -> anyh
     use crate::p2::bindings::{cli, clocks, random};
 
     let l = linker;
-    clocks::wall_clock::add_to_linker::<T, HasWasi>(l, T::ctx)?;
-    clocks::monotonic_clock::add_to_linker::<T, HasWasi>(l, T::ctx)?;
+    clocks::wall_clock::add_to_linker::<T, WasiClocks>(l, T::clocks)?;
+    clocks::monotonic_clock::add_to_linker::<T, WasiClocks>(l, T::clocks)?;
     random::random::add_to_linker::<T, WasiRandom>(l, |t| &mut t.ctx().ctx.random)?;
     cli::stdin::add_to_linker::<T, WasiCli>(l, T::cli)?;
     cli::stdout::add_to_linker::<T, WasiCli>(l, T::cli)?;

crates/wasi/src/p3/clocks/host.rs

@@ -1,13 +1,11 @@
-use core::time::Duration;
-
+use crate::clocks::WasiClocksCtxView;
+use crate::p3::bindings::clocks::{monotonic_clock, wall_clock};
+use crate::p3::clocks::WasiClocks;
 use cap_std::time::SystemTime;
+use core::time::Duration;
 use tokio::time::sleep;
 use wasmtime::component::Accessor;
 
-use crate::clocks::WasiClocksCtx;
-use crate::p3::bindings::clocks::{monotonic_clock, wall_clock};
-use crate::p3::clocks::WasiClocks;
-
 impl TryFrom<SystemTime> for wall_clock::Datetime {
     type Error = wasmtime::Error;
 
@@ -22,17 +20,17 @@ impl TryFrom<SystemTime> for wall_clock::Datetime {
     }
 }
 
-impl wall_clock::Host for WasiClocksCtx {
+impl wall_clock::Host for WasiClocksCtxView<'_> {
     fn now(&mut self) -> wasmtime::Result<wall_clock::Datetime> {
-        let now = self.wall_clock.now();
+        let now = self.ctx.wall_clock.now();
         Ok(wall_clock::Datetime {
             seconds: now.as_secs(),
             nanoseconds: now.subsec_nanos(),
         })
     }
 
     fn resolution(&mut self) -> wasmtime::Result<wall_clock::Datetime> {
-        let res = self.wall_clock.resolution();
+        let res = self.ctx.wall_clock.resolution();
         Ok(wall_clock::Datetime {
             seconds: res.as_secs(),
             nanoseconds: res.subsec_nanos(),
@@ -45,7 +43,7 @@ impl monotonic_clock::HostWithStore for WasiClocks {
         store: &Accessor<U, Self>,
         when: monotonic_clock::Instant,
     ) -> wasmtime::Result<()> {
-        let clock_now = store.with(|mut view| view.get().monotonic_clock.now());
+        let clock_now = store.with(|mut view| view.get().ctx.monotonic_clock.now());
         if when > clock_now {
             sleep(Duration::from_nanos(when - clock_now)).await;
         };
@@ -63,12 +61,12 @@ impl monotonic_clock::HostWithStore for WasiClocks {
     }
 }
 
-impl monotonic_clock::Host for WasiClocksCtx {
+impl monotonic_clock::Host for WasiClocksCtxView<'_> {
     fn now(&mut self) -> wasmtime::Result<monotonic_clock::Instant> {
-        Ok(self.monotonic_clock.now())
+        Ok(self.ctx.monotonic_clock.now())
     }
 
     fn resolution(&mut self) -> wasmtime::Result<monotonic_clock::Instant> {
-        Ok(self.monotonic_clock.resolution())
+        Ok(self.ctx.monotonic_clock.resolution())
     }
 }

crates/wasi/src/p3/clocks/mod.rs

@@ -1,8 +1,8 @@
 mod host;
 
-use crate::clocks::{WasiClocksCtx, WasiClocksView};
+use crate::clocks::{WasiClocks, WasiClocksView};
 use crate::p3::bindings::clocks;
-use wasmtime::component::{HasData, Linker};
+use wasmtime::component::Linker;
 
 /// Add all WASI interfaces from this module into the `linker` provided.
 ///
@@ -18,8 +18,8 @@ use wasmtime::component::{HasData, Linker};
 ///
 /// ```
 /// use wasmtime::{Engine, Result, Store, Config};
-/// use wasmtime::component::Linker;
-/// use wasmtime_wasi::clocks::{WasiClocksView, WasiClocksCtx};
+/// use wasmtime::component::{Linker, ResourceTable};
+/// use wasmtime_wasi::clocks::{WasiClocksView, WasiClocksCtxView, WasiClocksCtx};
 ///
 /// fn main() -> Result<()> {
 ///     let mut config = Config::new();
@@ -33,22 +33,24 @@ use wasmtime::component::{HasData, Linker};
 ///
 ///     let mut store = Store::new(
 ///         &engine,
-///         MyState {
-///             clocks: WasiClocksCtx::default(),
-///         },
+///         MyState::default(),
 ///     );
 ///
 ///     // ... use `linker` to instantiate within `store` ...
 ///
 ///     Ok(())
 /// }
 ///
+/// #[derive(Default)]
 /// struct MyState {
 ///     clocks: WasiClocksCtx,
+///     table: ResourceTable,
 /// }
 ///
 /// impl WasiClocksView for MyState {
-///     fn clocks(&mut self) -> &mut WasiClocksCtx { &mut self.clocks }
+///     fn clocks(&mut self) -> WasiClocksCtxView {
+///         WasiClocksCtxView { ctx: &mut self.clocks, table: &mut self.table }
+///     }
 /// }
 /// ```
 pub fn add_to_linker<T>(linker: &mut Linker<T>) -> wasmtime::Result<()>
@@ -59,9 +61,3 @@ where
     clocks::wall_clock::add_to_linker::<_, WasiClocks>(linker, T::clocks)?;
     Ok(())
 }
-
-struct WasiClocks;
-
-impl HasData for WasiClocks {
-    type Data<'a> = &'a mut WasiClocksCtx;
-}

crates/wasi/src/preview1.rs

@@ -64,6 +64,7 @@
 //! ```
 
 use crate::cli::WasiCliView;
+use crate::clocks::WasiClocksView;
 use crate::p2::bindings::{
     cli::{
         stderr::Host as _, stdin::Host as _, stdout::Host as _, terminal_input, terminal_output,
@@ -1232,15 +1233,13 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiP1Ctx {
         id: types::Clockid,
     ) -> Result<types::Timestamp, types::Error> {
         let res = match id {
-            types::Clockid::Realtime => wall_clock::Host::resolution(&mut self.as_wasi_impl())
+            types::Clockid::Realtime => wall_clock::Host::resolution(&mut self.clocks())
                 .context("failed to call `wall_clock::resolution`")
                 .map_err(types::Error::trap)?
                 .try_into()?,
-            types::Clockid::Monotonic => {
-                monotonic_clock::Host::resolution(&mut self.as_wasi_impl())
-                    .context("failed to call `monotonic_clock::resolution`")
-                    .map_err(types::Error::trap)?
-            }
+            types::Clockid::Monotonic => monotonic_clock::Host::resolution(&mut self.clocks())
+                .context("failed to call `monotonic_clock::resolution`")
+                .map_err(types::Error::trap)?,
             types::Clockid::ProcessCputimeId | types::Clockid::ThreadCputimeId => {
                 return Err(types::Errno::Badf.into());
             }
@@ -1256,11 +1255,11 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiP1Ctx {
         _precision: types::Timestamp,
     ) -> Result<types::Timestamp, types::Error> {
         let now = match id {
-            types::Clockid::Realtime => wall_clock::Host::now(&mut self.as_wasi_impl())
+            types::Clockid::Realtime => wall_clock::Host::now(&mut self.clocks())
                 .context("failed to call `wall_clock::now`")
                 .map_err(types::Error::trap)?
                 .try_into()?,
-            types::Clockid::Monotonic => monotonic_clock::Host::now(&mut self.as_wasi_impl())
+            types::Clockid::Monotonic => monotonic_clock::Host::now(&mut self.clocks())
                 .context("failed to call `monotonic_clock::now`")
                 .map_err(types::Error::trap)?,
             types::Clockid::ProcessCputimeId | types::Clockid::ThreadCputimeId => {
@@ -2320,7 +2319,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiP1Ctx {
                         types::Clockid::Monotonic => (timeout, absolute),
                         types::Clockid::Realtime if !absolute => (timeout, false),
                         types::Clockid::Realtime => {
-                            let now = wall_clock::Host::now(&mut self.as_wasi_impl())
+                            let now = wall_clock::Host::now(&mut self.clocks())
                                 .context("failed to call `wall_clock::now`")
                                 .map_err(types::Error::trap)?;
 
@@ -2343,11 +2342,11 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiP1Ctx {
                         _ => return Err(types::Errno::Inval.into()),
                     };
                     if absolute {
-                        monotonic_clock::Host::subscribe_instant(&mut self.as_wasi_impl(), timeout)
+                        monotonic_clock::Host::subscribe_instant(&mut self.clocks(), timeout)
                             .context("failed to call `monotonic_clock::subscribe_instant`")
                             .map_err(types::Error::trap)?
                     } else {
-                        monotonic_clock::Host::subscribe_duration(&mut self.as_wasi_impl(), timeout)
+                        monotonic_clock::Host::subscribe_duration(&mut self.clocks(), timeout)
                             .context("failed to call `monotonic_clock::subscribe_duration`")
                             .map_err(types::Error::trap)?
                     }

crates/wasi/src/view.rs

@@ -59,8 +59,12 @@ impl<T: WasiView> crate::sockets::WasiSocketsView for T {
 }
 
 impl<T: WasiView> crate::clocks::WasiClocksView for T {
-    fn clocks(&mut self) -> &mut crate::clocks::WasiClocksCtx {
-        &mut self.ctx().ctx.clocks
+    fn clocks(&mut self) -> crate::clocks::WasiClocksCtxView<'_> {
+        let WasiCtxView { ctx, table } = self.ctx();
+        crate::clocks::WasiClocksCtxView {
+            ctx: &mut ctx.clocks,
+            table,
+        }
     }
 }