wasmtime 21.0.1 → 23.0.2

data/ext/cargo-vendor/wasi-common-21.0.1/src/string_array.rs

@@ -1,74 +0,0 @@
-use crate::{Error, ErrorExt};
-use wiggle::GuestPtr;
-
-pub struct StringArray {
-    elems: Vec<String>,
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum StringArrayError {
-    #[error("Number of elements exceeds 2^32")]
-    NumberElements,
-    #[error("Element size exceeds 2^32")]
-    ElementSize,
-    #[error("Cumulative size exceeds 2^32")]
-    CumulativeSize,
-}
-
-impl StringArray {
-    pub fn new() -> Self {
-        StringArray { elems: Vec::new() }
-    }
-
-    pub fn push(&mut self, elem: String) -> Result<(), StringArrayError> {
-        if self.elems.len() + 1 > std::u32::MAX as usize {
-            return Err(StringArrayError::NumberElements);
-        }
-        if elem.as_bytes().len() + 1 > std::u32::MAX as usize {
-            return Err(StringArrayError::ElementSize);
-        }
-        if self.cumulative_size() as usize + elem.as_bytes().len() + 1 > std::u32::MAX as usize {
-            return Err(StringArrayError::CumulativeSize);
-        }
-        self.elems.push(elem);
-        Ok(())
-    }
-
-    pub fn number_elements(&self) -> u32 {
-        self.elems.len() as u32
-    }
-
-    pub fn cumulative_size(&self) -> u32 {
-        self.elems
-            .iter()
-            .map(|e| e.as_bytes().len() + 1)
-            .sum::<usize>() as u32
-    }
-
-    pub fn write_to_guest<'a>(
-        &self,
-        buffer: &GuestPtr<'a, u8>,
-        element_heads: &GuestPtr<'a, GuestPtr<'a, u8>>,
-    ) -> Result<(), Error> {
-        let element_heads = element_heads.as_array(self.number_elements());
-        let buffer = buffer.as_array(self.cumulative_size());
-        let mut cursor = 0;
-        for (elem, head) in self.elems.iter().zip(element_heads.iter()) {
-            let bytes = elem.as_bytes();
-            let len = bytes.len() as u32;
-            {
-                let elem_buffer = buffer
-                    .get_range(cursor..(cursor + len))
-                    .ok_or(Error::invalid_argument())?; // Elements don't fit in buffer provided
-                elem_buffer.copy_from_slice(bytes)?;
-            }
-            buffer
-                .get(cursor + len)
-                .ok_or(Error::invalid_argument())?
-                .write(0)?; // 0 terminate
-            head?.write(buffer.get(cursor).expect("already validated"))?;
-            cursor += len + 1;
-        }
-        Ok(())
-    }
-}

data/ext/cargo-vendor/wasi-common-21.0.1/src/sync/sched/windows.rs

@@ -1,221 +0,0 @@
-// The windows scheduler is unmaintained and due for a rewrite.
-//
-// Rather than use a polling mechanism for file read/write readiness,
-// it checks readiness just once, before sleeping for any timer subscriptions.
-// Checking stdin readiness uses a worker thread which, once started, lives for the
-// lifetime of the process.
-//
-// We suspect there are bugs in this scheduler, however, we have not
-// taken the time to improve it. See bug #2880.
-
-use crate::sched::subscription::{RwEventFlags, Subscription};
-use crate::{file::WasiFile, sched::Poll, Error, ErrorExt};
-use once_cell::sync::Lazy;
-use std::sync::mpsc::{self, Receiver, RecvTimeoutError, Sender, TryRecvError};
-use std::sync::Mutex;
-use std::thread;
-use std::time::Duration;
-
-pub async fn poll_oneoff<'a>(poll: &mut Poll<'a>) -> Result<(), Error> {
-    poll_oneoff_(poll, wasi_file_is_stdin).await
-}
-
-pub async fn poll_oneoff_<'a>(
-    poll: &mut Poll<'a>,
-    file_is_stdin: impl Fn(&dyn WasiFile) -> bool,
-) -> Result<(), Error> {
-    if poll.is_empty() {
-        return Ok(());
-    }
-
-    let mut ready = false;
-    let waitmode = if let Some(t) = poll.earliest_clock_deadline() {
-        if let Some(duration) = t.duration_until() {
-            WaitMode::Timeout(duration)
-        } else {
-            WaitMode::Immediate
-        }
-    } else {
-        if ready {
-            WaitMode::Immediate
-        } else {
-            WaitMode::Infinite
-        }
-    };
-
-    let mut stdin_read_subs = Vec::new();
-    let mut immediate_reads = Vec::new();
-    let mut immediate_writes = Vec::new();
-    for s in poll.rw_subscriptions() {
-        match s {
-            Subscription::Read(r) => {
-                if file_is_stdin(r.file) {
-                    stdin_read_subs.push(r);
-                } else if r.file.pollable().is_some() {
-                    immediate_reads.push(r);
-                } else {
-                    return Err(Error::invalid_argument().context("file is not pollable"));
-                }
-            }
-            Subscription::Write(w) => {
-                if w.file.pollable().is_some() {
-                    immediate_writes.push(w);
-                } else {
-                    return Err(Error::invalid_argument().context("file is not pollable"));
-                }
-            }
-            Subscription::MonotonicClock { .. } => unreachable!(),
-        }
-    }
-
-    if !stdin_read_subs.is_empty() {
-        let state = STDIN_POLL
-            .lock()
-            .map_err(|_| Error::trap(anyhow::Error::msg("failed to take lock of STDIN_POLL")))?
-            .poll(waitmode)?;
-        for readsub in stdin_read_subs.into_iter() {
-            match state {
-                PollState::Ready => {
-                    readsub.complete(1, RwEventFlags::empty());
-                    ready = true;
-                }
-                PollState::NotReady | PollState::TimedOut => {}
-                PollState::Error(ref e) => {
-                    // Unfortunately, we need to deliver the Error to each of the
-                    // subscriptions, but there is no Clone on std::io::Error. So, we convert it to the
-                    // kind, and then back to std::io::Error, and finally to anyhow::Error.
-                    // When its time to turn this into an errno elsewhere, the error kind will
-                    // be inspected.
-                    let ekind = e.kind();
-                    let ioerror = std::io::Error::from(ekind);
-                    readsub.error(ioerror.into());
-                    ready = true;
-                }
-            }
-        }
-    }
-    for r in immediate_reads {
-        match r.file.num_ready_bytes() {
-            Ok(ready_bytes) => {
-                r.complete(ready_bytes, RwEventFlags::empty());
-                ready = true;
-            }
-            Err(e) => {
-                r.error(e);
-                ready = true;
-            }
-        }
-    }
-    for w in immediate_writes {
-        // Everything is always ready for writing, apparently?
-        w.complete(0, RwEventFlags::empty());
-        ready = true;
-    }
-
-    if !ready {
-        if let WaitMode::Timeout(duration) = waitmode {
-            thread::sleep(duration);
-        }
-    }
-
-    Ok(())
-}
-
-pub fn wasi_file_is_stdin(f: &dyn WasiFile) -> bool {
-    f.as_any().is::<crate::sync::stdio::Stdin>()
-}
-
-enum PollState {
-    Ready,
-    NotReady, // Not ready, but did not wait
-    TimedOut, // Not ready, waited until timeout
-    Error(std::io::Error),
-}
-
-#[derive(Copy, Clone)]
-enum WaitMode {
-    Timeout(Duration),
-    Infinite,
-    Immediate,
-}
-
-struct StdinPoll {
-    request_tx: Sender<()>,
-    notify_rx: Receiver<PollState>,
-}
-
-static STDIN_POLL: Lazy<Mutex<StdinPoll>> = Lazy::new(StdinPoll::new);
-
-impl StdinPoll {
-    pub fn new() -> Mutex<Self> {
-        let (request_tx, request_rx) = mpsc::channel();
-        let (notify_tx, notify_rx) = mpsc::channel();
-        thread::spawn(move || Self::event_loop(request_rx, notify_tx));
-        Mutex::new(StdinPoll {
-            request_tx,
-            notify_rx,
-        })
-    }
-
-    // This function should not be used directly.
-    // Correctness of this function crucially depends on the fact that
-    // mpsc::Receiver is !Sync.
-    fn poll(&self, wait_mode: WaitMode) -> Result<PollState, Error> {
-        match self.notify_rx.try_recv() {
-            // Clean up possibly unread result from previous poll.
-            Ok(_) | Err(TryRecvError::Empty) => {}
-            Err(TryRecvError::Disconnected) => {
-                return Err(Error::trap(anyhow::Error::msg(
-                    "StdinPoll notify_rx channel closed",
-                )))
-            }
-        }
-
-        // Notify the worker thread to poll stdin
-        self.request_tx
-            .send(())
-            .map_err(|_| Error::trap(anyhow::Error::msg("request_tx channel closed")))?;
-
-        // Wait for the worker thread to send a readiness notification
-        match wait_mode {
-            WaitMode::Timeout(timeout) => match self.notify_rx.recv_timeout(timeout) {
-                Ok(r) => Ok(r),
-                Err(RecvTimeoutError::Timeout) => Ok(PollState::TimedOut),
-                Err(RecvTimeoutError::Disconnected) => Err(Error::trap(anyhow::Error::msg(
-                    "StdinPoll notify_rx channel closed",
-                ))),
-            },
-            WaitMode::Infinite => self
-                .notify_rx
-                .recv()
-                .map_err(|_| Error::trap(anyhow::Error::msg("StdinPoll notify_rx channel closed"))),
-            WaitMode::Immediate => match self.notify_rx.try_recv() {
-                Ok(r) => Ok(r),
-                Err(TryRecvError::Empty) => Ok(PollState::NotReady),
-                Err(TryRecvError::Disconnected) => Err(Error::trap(anyhow::Error::msg(
-                    "StdinPoll notify_rx channel closed",
-                ))),
-            },
-        }
-    }
-
-    fn event_loop(request_rx: Receiver<()>, notify_tx: Sender<PollState>) -> ! {
-        use std::io::BufRead;
-        loop {
-            // Wait on a request:
-            request_rx.recv().expect("request_rx channel");
-            // Wait for data to appear in stdin. If fill_buf returns any slice, it means
-            // that either:
-            // (a) there is some data in stdin, if non-empty,
-            // (b) EOF was recieved, if its empty
-            // Linux returns `POLLIN` in both cases, so we imitate this behavior.
-            let resp = match std::io::stdin().lock().fill_buf() {
-                Ok(_) => PollState::Ready,
-                Err(e) => PollState::Error(e),
-            };
-            // Notify about data in stdin. If the read on this channel has timed out, the
-            // next poller will have to clean the channel.
-            notify_tx.send(resp).expect("notify_tx channel");
-        }
-    }
-}

data/ext/cargo-vendor/wasi-common-21.0.1/src/tokio/file.rs

@@ -1,247 +0,0 @@
-use crate::tokio::block_on_dummy_executor;
-use crate::{
-    file::{Advice, FdFlags, FileType, Filestat, WasiFile},
-    Error,
-};
-#[cfg(windows)]
-use io_extras::os::windows::{AsRawHandleOrSocket, RawHandleOrSocket};
-#[cfg(not(windows))]
-use io_lifetimes::AsFd;
-use std::any::Any;
-use std::borrow::Borrow;
-use std::io;
-
-pub struct File(crate::sync::file::File);
-
-impl File {
-    pub(crate) fn from_inner(file: crate::sync::file::File) -> Self {
-        File(file)
-    }
-    pub fn from_cap_std(file: cap_std::fs::File) -> Self {
-        Self::from_inner(crate::sync::file::File::from_cap_std(file))
-    }
-}
-
-pub struct TcpListener(crate::sync::net::TcpListener);
-
-impl TcpListener {
-    pub(crate) fn from_inner(listener: crate::sync::net::TcpListener) -> Self {
-        TcpListener(listener)
-    }
-    pub fn from_cap_std(listener: cap_std::net::TcpListener) -> Self {
-        Self::from_inner(crate::sync::net::TcpListener::from_cap_std(listener))
-    }
-}
-
-pub struct TcpStream(crate::sync::net::TcpStream);
-
-impl TcpStream {
-    pub(crate) fn from_inner(stream: crate::sync::net::TcpStream) -> Self {
-        TcpStream(stream)
-    }
-    pub fn from_cap_std(stream: cap_std::net::TcpStream) -> Self {
-        Self::from_inner(crate::sync::net::TcpStream::from_cap_std(stream))
-    }
-}
-
-#[cfg(unix)]
-pub struct UnixListener(crate::sync::net::UnixListener);
-
-#[cfg(unix)]
-impl UnixListener {
-    pub(crate) fn from_inner(listener: crate::sync::net::UnixListener) -> Self {
-        UnixListener(listener)
-    }
-    pub fn from_cap_std(listener: cap_std::os::unix::net::UnixListener) -> Self {
-        Self::from_inner(crate::sync::net::UnixListener::from_cap_std(listener))
-    }
-}
-
-#[cfg(unix)]
-pub struct UnixStream(crate::sync::net::UnixStream);
-
-#[cfg(unix)]
-impl UnixStream {
-    fn from_inner(stream: crate::sync::net::UnixStream) -> Self {
-        UnixStream(stream)
-    }
-    pub fn from_cap_std(stream: cap_std::os::unix::net::UnixStream) -> Self {
-        Self::from_inner(crate::sync::net::UnixStream::from_cap_std(stream))
-    }
-}
-
-pub struct Stdin(crate::sync::stdio::Stdin);
-
-pub fn stdin() -> Stdin {
-    Stdin(crate::sync::stdio::stdin())
-}
-
-pub struct Stdout(crate::sync::stdio::Stdout);
-
-pub fn stdout() -> Stdout {
-    Stdout(crate::sync::stdio::stdout())
-}
-
-pub struct Stderr(crate::sync::stdio::Stderr);
-
-pub fn stderr() -> Stderr {
-    Stderr(crate::sync::stdio::stderr())
-}
-
-macro_rules! wasi_file_impl {
-    ($ty:ty) => {
-        #[wiggle::async_trait]
-        impl WasiFile for $ty {
-            fn as_any(&self) -> &dyn Any {
-                self
-            }
-            #[cfg(unix)]
-            fn pollable(&self) -> Option<rustix::fd::BorrowedFd> {
-                Some(self.0.as_fd())
-            }
-            #[cfg(windows)]
-            fn pollable(&self) -> Option<io_extras::os::windows::RawHandleOrSocket> {
-                Some(self.0.as_raw_handle_or_socket())
-            }
-            async fn datasync(&self) -> Result<(), Error> {
-                block_on_dummy_executor(|| self.0.datasync())
-            }
-            async fn sync(&self) -> Result<(), Error> {
-                block_on_dummy_executor(|| self.0.sync())
-            }
-            async fn get_filetype(&self) -> Result<FileType, Error> {
-                block_on_dummy_executor(|| self.0.get_filetype())
-            }
-            async fn get_fdflags(&self) -> Result<FdFlags, Error> {
-                block_on_dummy_executor(|| self.0.get_fdflags())
-            }
-            async fn set_fdflags(&mut self, fdflags: FdFlags) -> Result<(), Error> {
-                block_on_dummy_executor(|| self.0.set_fdflags(fdflags))
-            }
-            async fn get_filestat(&self) -> Result<Filestat, Error> {
-                block_on_dummy_executor(|| self.0.get_filestat())
-            }
-            async fn set_filestat_size(&self, size: u64) -> Result<(), Error> {
-                block_on_dummy_executor(move || self.0.set_filestat_size(size))
-            }
-            async fn advise(&self, offset: u64, len: u64, advice: Advice) -> Result<(), Error> {
-                block_on_dummy_executor(move || self.0.advise(offset, len, advice))
-            }
-            async fn read_vectored<'a>(
-                &self,
-                bufs: &mut [io::IoSliceMut<'a>],
-            ) -> Result<u64, Error> {
-                block_on_dummy_executor(move || self.0.read_vectored(bufs))
-            }
-            async fn read_vectored_at<'a>(
-                &self,
-                bufs: &mut [io::IoSliceMut<'a>],
-                offset: u64,
-            ) -> Result<u64, Error> {
-                block_on_dummy_executor(move || self.0.read_vectored_at(bufs, offset))
-            }
-            async fn write_vectored<'a>(&self, bufs: &[io::IoSlice<'a>]) -> Result<u64, Error> {
-                block_on_dummy_executor(move || self.0.write_vectored(bufs))
-            }
-            async fn write_vectored_at<'a>(
-                &self,
-                bufs: &[io::IoSlice<'a>],
-                offset: u64,
-            ) -> Result<u64, Error> {
-                if bufs.iter().map(|i| i.len()).sum::<usize>() == 0 {
-                    return Ok(0);
-                }
-                block_on_dummy_executor(move || self.0.write_vectored_at(bufs, offset))
-            }
-            async fn seek(&self, pos: std::io::SeekFrom) -> Result<u64, Error> {
-                block_on_dummy_executor(move || self.0.seek(pos))
-            }
-            async fn peek(&self, buf: &mut [u8]) -> Result<u64, Error> {
-                block_on_dummy_executor(move || self.0.peek(buf))
-            }
-            async fn set_times(
-                &self,
-                atime: Option<crate::SystemTimeSpec>,
-                mtime: Option<crate::SystemTimeSpec>,
-            ) -> Result<(), Error> {
-                block_on_dummy_executor(move || self.0.set_times(atime, mtime))
-            }
-            fn num_ready_bytes(&self) -> Result<u64, Error> {
-                self.0.num_ready_bytes()
-            }
-            fn isatty(&self) -> bool {
-                self.0.isatty()
-            }
-
-            #[cfg(not(windows))]
-            async fn readable(&self) -> Result<(), Error> {
-                // The Inner impls OwnsRaw, which asserts exclusive use of the handle by the owned object.
-                // AsyncFd needs to wrap an owned `impl std::os::unix::io::AsRawFd`. Rather than introduce
-                // mutability to let it own the `Inner`, we are depending on the `&mut self` bound on this
-                // async method to ensure this is the only Future which can access the RawFd during the
-                // lifetime of the AsyncFd.
-                use std::os::unix::io::AsRawFd;
-                use tokio::io::{unix::AsyncFd, Interest};
-                let rawfd = self.0.borrow().as_fd().as_raw_fd();
-                match AsyncFd::with_interest(rawfd, Interest::READABLE) {
-                    Ok(asyncfd) => {
-                        let _ = asyncfd.readable().await?;
-                        Ok(())
-                    }
-                    Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => {
-                        // if e is EPERM, this file isnt supported by epoll because it is immediately
-                        // available for reading:
-                        Ok(())
-                    }
-                    Err(e) => Err(e.into()),
-                }
-            }
-
-            #[cfg(not(windows))]
-            async fn writable(&self) -> Result<(), Error> {
-                // The Inner impls OwnsRaw, which asserts exclusive use of the handle by the owned object.
-                // AsyncFd needs to wrap an owned `impl std::os::unix::io::AsRawFd`. Rather than introduce
-                // mutability to let it own the `Inner`, we are depending on the `&mut self` bound on this
-                // async method to ensure this is the only Future which can access the RawFd during the
-                // lifetime of the AsyncFd.
-                use std::os::unix::io::AsRawFd;
-                use tokio::io::{unix::AsyncFd, Interest};
-                let rawfd = self.0.borrow().as_fd().as_raw_fd();
-                match AsyncFd::with_interest(rawfd, Interest::WRITABLE) {
-                    Ok(asyncfd) => {
-                        let _ = asyncfd.writable().await?;
-                        Ok(())
-                    }
-                    Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => {
-                        // if e is EPERM, this file isnt supported by epoll because it is immediately
-                        // available for writing:
-                        Ok(())
-                    }
-                    Err(e) => Err(e.into()),
-                }
-            }
-
-            async fn sock_accept(&self, fdflags: FdFlags) -> Result<Box<dyn WasiFile>, Error> {
-                block_on_dummy_executor(|| self.0.sock_accept(fdflags))
-            }
-        }
-        #[cfg(windows)]
-        impl AsRawHandleOrSocket for $ty {
-            #[inline]
-            fn as_raw_handle_or_socket(&self) -> RawHandleOrSocket {
-                self.0.borrow().as_raw_handle_or_socket()
-            }
-        }
-    };
-}
-
-wasi_file_impl!(File);
-wasi_file_impl!(TcpListener);
-wasi_file_impl!(TcpStream);
-#[cfg(unix)]
-wasi_file_impl!(UnixListener);
-#[cfg(unix)]
-wasi_file_impl!(UnixStream);
-wasi_file_impl!(Stdin);
-wasi_file_impl!(Stdout);
-wasi_file_impl!(Stderr);

data/ext/cargo-vendor/wasi-common-21.0.1/src/tokio/mod.rs

@@ -1,137 +0,0 @@
-#![cfg_attr(io_lifetimes_use_std, feature(io_safety))]
-
-mod dir;
-mod file;
-pub mod net;
-pub mod sched;
-pub mod stdio;
-
-use self::sched::sched_ctx;
-use crate::sync::net::Socket;
-pub use crate::sync::{clocks_ctx, random_ctx};
-use crate::{file::FileAccessMode, Error, Table, WasiCtx, WasiFile};
-pub use dir::Dir;
-pub use file::File;
-pub use net::*;
-use std::future::Future;
-use std::mem;
-use std::path::Path;
-
-pub struct WasiCtxBuilder {
-    ctx: WasiCtx,
-    built: bool,
-}
-
-impl WasiCtxBuilder {
-    pub fn new() -> Self {
-        WasiCtxBuilder {
-            ctx: WasiCtx::new(random_ctx(), clocks_ctx(), sched_ctx(), Table::new()),
-            built: false,
-        }
-    }
-    pub fn env(&mut self, var: &str, value: &str) -> Result<&mut Self, crate::StringArrayError> {
-        self.ctx.push_env(var, value)?;
-        Ok(self)
-    }
-    pub fn envs(&mut self, env: &[(String, String)]) -> Result<&mut Self, crate::StringArrayError> {
-        for (k, v) in env {
-            self.ctx.push_env(k, v)?;
-        }
-        Ok(self)
-    }
-    pub fn inherit_env(&mut self) -> Result<&mut Self, crate::StringArrayError> {
-        for (key, value) in std::env::vars() {
-            self.ctx.push_env(&key, &value)?;
-        }
-        Ok(self)
-    }
-    pub fn arg(&mut self, arg: &str) -> Result<&mut Self, crate::StringArrayError> {
-        self.ctx.push_arg(arg)?;
-        Ok(self)
-    }
-    pub fn args(&mut self, arg: &[String]) -> Result<&mut Self, crate::StringArrayError> {
-        for a in arg {
-            self.ctx.push_arg(&a)?;
-        }
-        Ok(self)
-    }
-    pub fn inherit_args(&mut self) -> Result<&mut Self, crate::StringArrayError> {
-        for arg in std::env::args() {
-            self.ctx.push_arg(&arg)?;
-        }
-        Ok(self)
-    }
-    pub fn stdin(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
-        self.ctx.set_stdin(f);
-        self
-    }
-    pub fn stdout(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
-        self.ctx.set_stdout(f);
-        self
-    }
-    pub fn stderr(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
-        self.ctx.set_stderr(f);
-        self
-    }
-    pub fn inherit_stdin(&mut self) -> &mut Self {
-        self.stdin(Box::new(crate::tokio::stdio::stdin()))
-    }
-    pub fn inherit_stdout(&mut self) -> &mut Self {
-        self.stdout(Box::new(crate::tokio::stdio::stdout()))
-    }
-    pub fn inherit_stderr(&mut self) -> &mut Self {
-        self.stderr(Box::new(crate::tokio::stdio::stderr()))
-    }
-    pub fn inherit_stdio(&mut self) -> &mut Self {
-        self.inherit_stdin().inherit_stdout().inherit_stderr()
-    }
-    pub fn preopened_dir(
-        &mut self,
-        dir: cap_std::fs::Dir,
-        guest_path: impl AsRef<Path>,
-    ) -> Result<&mut Self, Error> {
-        let dir = Box::new(crate::tokio::dir::Dir::from_cap_std(dir));
-        self.ctx.push_preopened_dir(dir, guest_path)?;
-        Ok(self)
-    }
-    pub fn preopened_socket(
-        &mut self,
-        fd: u32,
-        socket: impl Into<Socket>,
-    ) -> Result<&mut Self, Error> {
-        let socket: Socket = socket.into();
-        let file: Box<dyn WasiFile> = socket.into();
-        self.ctx
-            .insert_file(fd, file, FileAccessMode::READ | FileAccessMode::WRITE);
-        Ok(self)
-    }
-
-    pub fn build(&mut self) -> WasiCtx {
-        assert!(!self.built);
-        let WasiCtxBuilder { ctx, .. } = mem::replace(self, Self::new());
-        self.built = true;
-        ctx
-    }
-}
-
-// Much of this mod is implemented in terms of `async` methods from the
-// wasmtime_wasi::sync module. These methods may be async in signature, however,
-// they are synchronous in implementation (always Poll::Ready on first poll)
-// and perform blocking syscalls.
-//
-// This function takes this blocking code and executes it using a dummy executor
-// to assert its immediate readiness. We tell tokio this is a blocking operation
-// with the block_in_place function.
-pub(crate) fn block_on_dummy_executor<'a, F, Fut, T>(f: F) -> Result<T, Error>
-where
-    F: FnOnce() -> Fut + Send + 'a,
-    Fut: Future<Output = Result<T, Error>>,
-    T: Send + 'static,
-{
-    tokio::task::block_in_place(move || {
-        wiggle::run_in_dummy_executor(f()).expect("wrapped operation should be synchronous")
-    })
-}
-
-#[cfg(feature = "wasmtime")]
-super::define_wasi!(async T: Send);