wasi-common: use &self instead of &mut self

After #5236, it is now easier to modify the `wasi-common`
implementations (both `preview0` and `preview1`) to use `&self` instead
of `&mut self` in their function signatures. This makes it possible to
access and use a `WasiCtx` from an `Arc<Host>` (the top-level Wasmtime
CLI structure holding the WASI implementations). An `Arc<Host>` will
only give out immutable access to the WASI implementations it contains.
This relies on #5428 to configure Wiggle to emit `&self`-receiving
traits.

This change also wraps `wasi-common`'s source of randomness in `WasiCtx`
with a `Mutex` to enable this `&mut self` to `&self` refactoring.

One remaining issue to figure out with this change is the interaction
with the `async` side of wiggle. E.g., `cargo build --all-features -p
wasmtime-wasi` will fail due to the `tokyo` feature being enabled. The
errors have to do with incorrect `Send` and `Sync` bounds on various
parts of the Wiggle-generated API. We had previously discussed turning
off these `async` parts when the `wasi-threads` feature is enabled, or
at least prevent these features from being enabled at the same time,
since as-is even `cargo test --all` is affected.

Author: abrown

crates/wasi-common/src/ctx.rs

@@ -7,12 +7,12 @@ use crate::table::Table;
 use crate::Error;
 use cap_rand::RngCore;
 use std::path::{Path, PathBuf};
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 
 pub struct WasiCtx {
     pub args: StringArray,
     pub env: StringArray,
-    pub random: Box<dyn RngCore + Send + Sync>,
+    pub random: Mutex<Box<dyn RngCore + Send + Sync>>,
     pub clocks: WasiClocks,
     pub sched: Box<dyn WasiSched>,
     pub table: Table,
@@ -28,7 +28,7 @@ impl WasiCtx {
         let s = WasiCtx {
             args: StringArray::new(),
             env: StringArray::new(),
-            random,
+            random: Mutex::new(random),
             clocks,
             sched,
             table,

crates/wasi-common/src/snapshots/preview_0.rs

@@ -19,6 +19,7 @@ wiggle::from_witx!({
     errors: { errno => trappable Error },
     async: *,
     wasmtime: false,
+    mutable: false,
 });
 
 use types::Error;
@@ -390,40 +391,40 @@ convert_flags_bidirectional!(
 #[wiggle::async_trait]
 impl wasi_unstable::WasiUnstable for WasiCtx {
     async fn args_get<'a>(
-        &mut self,
+        &self,
         argv: &GuestPtr<'a, GuestPtr<'a, u8>>,
         argv_buf: &GuestPtr<'a, u8>,
     ) -> Result<(), Error> {
         Snapshot1::args_get(self, argv, argv_buf).await?;
         Ok(())
     }
 
-    async fn args_sizes_get(&mut self) -> Result<(types::Size, types::Size), Error> {
+    async fn args_sizes_get(&self) -> Result<(types::Size, types::Size), Error> {
         let s = Snapshot1::args_sizes_get(self).await?;
         Ok(s)
     }
 
     async fn environ_get<'a>(
-        &mut self,
+        &self,
         environ: &GuestPtr<'a, GuestPtr<'a, u8>>,
         environ_buf: &GuestPtr<'a, u8>,
     ) -> Result<(), Error> {
         Snapshot1::environ_get(self, environ, environ_buf).await?;
         Ok(())
     }
 
-    async fn environ_sizes_get(&mut self) -> Result<(types::Size, types::Size), Error> {
+    async fn environ_sizes_get(&self) -> Result<(types::Size, types::Size), Error> {
         let s = Snapshot1::environ_sizes_get(self).await?;
         Ok(s)
     }
 
-    async fn clock_res_get(&mut self, id: types::Clockid) -> Result<types::Timestamp, Error> {
+    async fn clock_res_get(&self, id: types::Clockid) -> Result<types::Timestamp, Error> {
         let t = Snapshot1::clock_res_get(self, id.into()).await?;
         Ok(t)
     }
 
     async fn clock_time_get(
-        &mut self,
+        &self,
         id: types::Clockid,
         precision: types::Timestamp,
     ) -> Result<types::Timestamp, Error> {
@@ -432,7 +433,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     }
 
     async fn fd_advise(
-        &mut self,
+        &self,
         fd: types::Fd,
         offset: types::Filesize,
         len: types::Filesize,
@@ -443,7 +444,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     }
 
     async fn fd_allocate(
-        &mut self,
+        &self,
         fd: types::Fd,
         offset: types::Filesize,
         len: types::Filesize,
@@ -452,31 +453,27 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
         Ok(())
     }
 
-    async fn fd_close(&mut self, fd: types::Fd) -> Result<(), Error> {
+    async fn fd_close(&self, fd: types::Fd) -> Result<(), Error> {
         Snapshot1::fd_close(self, fd.into()).await?;
         Ok(())
     }
 
-    async fn fd_datasync(&mut self, fd: types::Fd) -> Result<(), Error> {
+    async fn fd_datasync(&self, fd: types::Fd) -> Result<(), Error> {
         Snapshot1::fd_datasync(self, fd.into()).await?;
         Ok(())
     }
 
-    async fn fd_fdstat_get(&mut self, fd: types::Fd) -> Result<types::Fdstat, Error> {
+    async fn fd_fdstat_get(&self, fd: types::Fd) -> Result<types::Fdstat, Error> {
         Ok(Snapshot1::fd_fdstat_get(self, fd.into()).await?.into())
     }
 
-    async fn fd_fdstat_set_flags(
-        &mut self,
-        fd: types::Fd,
-        flags: types::Fdflags,
-    ) -> Result<(), Error> {
+    async fn fd_fdstat_set_flags(&self, fd: types::Fd, flags: types::Fdflags) -> Result<(), Error> {
         Snapshot1::fd_fdstat_set_flags(self, fd.into(), flags.into()).await?;
         Ok(())
     }
 
     async fn fd_fdstat_set_rights(
-        &mut self,
+        &self,
         fd: types::Fd,
         fs_rights_base: types::Rights,
         fs_rights_inheriting: types::Rights,
@@ -491,12 +488,12 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
         Ok(())
     }
 
-    async fn fd_filestat_get(&mut self, fd: types::Fd) -> Result<types::Filestat, Error> {
+    async fn fd_filestat_get(&self, fd: types::Fd) -> Result<types::Filestat, Error> {
         Ok(Snapshot1::fd_filestat_get(self, fd.into()).await?.into())
     }
 
     async fn fd_filestat_set_size(
-        &mut self,
+        &self,
         fd: types::Fd,
         size: types::Filesize,
     ) -> Result<(), Error> {
@@ -505,7 +502,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     }
 
     async fn fd_filestat_set_times(
-        &mut self,
+        &self,
         fd: types::Fd,
         atim: types::Timestamp,
         mtim: types::Timestamp,
@@ -524,7 +521,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     // representation to a std::io::IoSlice(Mut) representation.
 
     async fn fd_read<'a>(
-        &mut self,
+        &self,
         fd: types::Fd,
         iovs: &types::IovecArray<'a>,
     ) -> Result<types::Size, Error> {
@@ -598,7 +595,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     }
 
     async fn fd_pread<'a>(
-        &mut self,
+        &self,
         fd: types::Fd,
         iovs: &types::IovecArray<'a>,
         offset: types::Filesize,
@@ -675,7 +672,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     }
 
     async fn fd_write<'a>(
-        &mut self,
+        &self,
         fd: types::Fd,
         ciovs: &types::CiovecArray<'a>,
     ) -> Result<types::Size, Error> {
@@ -701,7 +698,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     }
 
     async fn fd_pwrite<'a>(
-        &mut self,
+        &self,
         fd: types::Fd,
         ciovs: &types::CiovecArray<'a>,
         offset: types::Filesize,
@@ -727,12 +724,12 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
         Ok(types::Size::try_from(bytes_written)?)
     }
 
-    async fn fd_prestat_get(&mut self, fd: types::Fd) -> Result<types::Prestat, Error> {
+    async fn fd_prestat_get(&self, fd: types::Fd) -> Result<types::Prestat, Error> {
         Ok(Snapshot1::fd_prestat_get(self, fd.into()).await?.into())
     }
 
     async fn fd_prestat_dir_name<'a>(
-        &mut self,
+        &self,
         fd: types::Fd,
         path: &GuestPtr<'a, u8>,
         path_max_len: types::Size,
@@ -741,31 +738,31 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
         Ok(())
     }
 
-    async fn fd_renumber(&mut self, from: types::Fd, to: types::Fd) -> Result<(), Error> {
+    async fn fd_renumber(&self, from: types::Fd, to: types::Fd) -> Result<(), Error> {
         Snapshot1::fd_renumber(self, from.into(), to.into()).await?;
         Ok(())
     }
 
     async fn fd_seek(
-        &mut self,
+        &self,
         fd: types::Fd,
         offset: types::Filedelta,
         whence: types::Whence,
     ) -> Result<types::Filesize, Error> {
         Ok(Snapshot1::fd_seek(self, fd.into(), offset, whence.into()).await?)
     }
 
-    async fn fd_sync(&mut self, fd: types::Fd) -> Result<(), Error> {
+    async fn fd_sync(&self, fd: types::Fd) -> Result<(), Error> {
         Snapshot1::fd_sync(self, fd.into()).await?;
         Ok(())
     }
 
-    async fn fd_tell(&mut self, fd: types::Fd) -> Result<types::Filesize, Error> {
+    async fn fd_tell(&self, fd: types::Fd) -> Result<types::Filesize, Error> {
         Ok(Snapshot1::fd_tell(self, fd.into()).await?)
     }
 
     async fn fd_readdir<'a>(
-        &mut self,
+        &self,
         fd: types::Fd,
         buf: &GuestPtr<'a, u8>,
         buf_len: types::Size,
@@ -775,7 +772,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     }
 
     async fn path_create_directory<'a>(
-        &mut self,
+        &self,
         dirfd: types::Fd,
         path: &GuestPtr<'a, str>,
     ) -> Result<(), Error> {
@@ -784,7 +781,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     }
 
     async fn path_filestat_get<'a>(
-        &mut self,
+        &self,
         dirfd: types::Fd,
         flags: types::Lookupflags,
         path: &GuestPtr<'a, str>,
@@ -797,7 +794,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     }
 
     async fn path_filestat_set_times<'a>(
-        &mut self,
+        &self,
         dirfd: types::Fd,
         flags: types::Lookupflags,
         path: &GuestPtr<'a, str>,
@@ -819,7 +816,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     }
 
     async fn path_link<'a>(
-        &mut self,
+        &self,
         src_fd: types::Fd,
         src_flags: types::Lookupflags,
         src_path: &GuestPtr<'a, str>,
@@ -839,7 +836,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     }
 
     async fn path_open<'a>(
-        &mut self,
+        &self,
         dirfd: types::Fd,
         dirflags: types::Lookupflags,
         path: &GuestPtr<'a, str>,
@@ -863,7 +860,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     }
 
     async fn path_readlink<'a>(
-        &mut self,
+        &self,
         dirfd: types::Fd,
         path: &GuestPtr<'a, str>,
         buf: &GuestPtr<'a, u8>,
@@ -873,7 +870,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     }
 
     async fn path_remove_directory<'a>(
-        &mut self,
+        &self,
         dirfd: types::Fd,
         path: &GuestPtr<'a, str>,
     ) -> Result<(), Error> {
@@ -882,7 +879,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     }
 
     async fn path_rename<'a>(
-        &mut self,
+        &self,
         src_fd: types::Fd,
         src_path: &GuestPtr<'a, str>,
         dest_fd: types::Fd,
@@ -893,7 +890,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     }
 
     async fn path_symlink<'a>(
-        &mut self,
+        &self,
         src_path: &GuestPtr<'a, str>,
         dirfd: types::Fd,
         dest_path: &GuestPtr<'a, str>,
@@ -903,7 +900,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     }
 
     async fn path_unlink_file<'a>(
-        &mut self,
+        &self,
         dirfd: types::Fd,
         path: &GuestPtr<'a, str>,
     ) -> Result<(), Error> {
@@ -919,7 +916,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     // The bodies of these functions is mostly about converting the GuestPtr and types::-based
     // representation to use the Poll abstraction.
     async fn poll_oneoff<'a>(
-        &mut self,
+        &self,
         subs: &GuestPtr<'a, types::Subscription>,
         events: &GuestPtr<'a, types::Event>,
         nsubscriptions: types::Size,
@@ -1098,21 +1095,21 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
         Ok(num_results.try_into().expect("results fit into memory"))
     }
 
-    async fn proc_exit(&mut self, status: types::Exitcode) -> anyhow::Error {
+    async fn proc_exit(&self, status: types::Exitcode) -> anyhow::Error {
         Snapshot1::proc_exit(self, status).await
     }
 
-    async fn proc_raise(&mut self, _sig: types::Signal) -> Result<(), Error> {
+    async fn proc_raise(&self, _sig: types::Signal) -> Result<(), Error> {
         Err(Error::trap(anyhow::Error::msg("proc_raise unsupported")))
     }
 
-    async fn sched_yield(&mut self) -> Result<(), Error> {
+    async fn sched_yield(&self) -> Result<(), Error> {
         Snapshot1::sched_yield(self).await?;
         Ok(())
     }
 
     async fn random_get<'a>(
-        &mut self,
+        &self,
         buf: &GuestPtr<'a, u8>,
         buf_len: types::Size,
     ) -> Result<(), Error> {
@@ -1121,7 +1118,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     }
 
     async fn sock_recv<'a>(
-        &mut self,
+        &self,
         _fd: types::Fd,
         _ri_data: &types::IovecArray<'a>,
         _ri_flags: types::Riflags,
@@ -1130,15 +1127,15 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     }
 
     async fn sock_send<'a>(
-        &mut self,
+        &self,
         _fd: types::Fd,
         _si_data: &types::CiovecArray<'a>,
         _si_flags: types::Siflags,
     ) -> Result<types::Size, Error> {
         Err(Error::trap(anyhow::Error::msg("sock_send unsupported")))
     }
 
-    async fn sock_shutdown(&mut self, _fd: types::Fd, _how: types::Sdflags) -> Result<(), Error> {
+    async fn sock_shutdown(&self, _fd: types::Fd, _how: types::Sdflags) -> Result<(), Error> {
         Err(Error::trap(anyhow::Error::msg("sock_shutdown unsupported")))
     }
 }