wasmtime 21.0.1 → 22.0.0

data/ext/cargo-vendor/wasmtime-wasi-22.0.0/src/filesystem.rs

@@ -0,0 +1,446 @@
+use crate::bindings::filesystem::types;
+use crate::runtime::{spawn_blocking, AbortOnDropJoinHandle};
+use crate::{HostOutputStream, StreamError, Subscribe, TrappableError};
+use anyhow::anyhow;
+use bytes::{Bytes, BytesMut};
+use std::io;
+use std::mem;
+use std::sync::Arc;
+
+pub type FsResult<T> = Result<T, FsError>;
+
+pub type FsError = TrappableError<types::ErrorCode>;
+
+impl From<wasmtime::component::ResourceTableError> for FsError {
+    fn from(error: wasmtime::component::ResourceTableError) -> Self {
+        Self::trap(error)
+    }
+}
+
+impl From<io::Error> for FsError {
+    fn from(error: io::Error) -> Self {
+        types::ErrorCode::from(error).into()
+    }
+}
+
+pub enum Descriptor {
+    File(File),
+    Dir(Dir),
+}
+
+impl Descriptor {
+    pub fn file(&self) -> Result<&File, types::ErrorCode> {
+        match self {
+            Descriptor::File(f) => Ok(f),
+            Descriptor::Dir(_) => Err(types::ErrorCode::BadDescriptor),
+        }
+    }
+
+    pub fn dir(&self) -> Result<&Dir, types::ErrorCode> {
+        match self {
+            Descriptor::Dir(d) => Ok(d),
+            Descriptor::File(_) => Err(types::ErrorCode::NotDirectory),
+        }
+    }
+
+    pub fn is_file(&self) -> bool {
+        match self {
+            Descriptor::File(_) => true,
+            Descriptor::Dir(_) => false,
+        }
+    }
+
+    pub fn is_dir(&self) -> bool {
+        match self {
+            Descriptor::File(_) => false,
+            Descriptor::Dir(_) => true,
+        }
+    }
+}
+
+bitflags::bitflags! {
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    pub struct FilePerms: usize {
+        const READ = 0b1;
+        const WRITE = 0b10;
+    }
+}
+
+bitflags::bitflags! {
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    pub struct OpenMode: usize {
+        const READ = 0b1;
+        const WRITE = 0b10;
+    }
+}
+
+#[derive(Clone)]
+pub struct File {
+    /// The operating system File this struct is mediating access to.
+    ///
+    /// Wrapped in an Arc because the same underlying file is used for
+    /// implementing the stream types. A copy is also needed for
+    /// [`spawn_blocking`].
+    ///
+    /// [`spawn_blocking`]: Self::spawn_blocking
+    pub file: Arc<cap_std::fs::File>,
+    /// Permissions to enforce on access to the file. These permissions are
+    /// specified by a user of the `crate::WasiCtxBuilder`, and are
+    /// enforced prior to any enforced by the underlying operating system.
+    pub perms: FilePerms,
+    /// The mode the file was opened under: bits for reading, and writing.
+    /// Required to correctly report the DescriptorFlags, because cap-std
+    /// doesn't presently provide a cross-platform equivalent of reading the
+    /// oflags back out using fcntl.
+    pub open_mode: OpenMode,
+
+    allow_blocking_current_thread: bool,
+}
+
+impl File {
+    pub fn new(
+        file: cap_std::fs::File,
+        perms: FilePerms,
+        open_mode: OpenMode,
+        allow_blocking_current_thread: bool,
+    ) -> Self {
+        Self {
+            file: Arc::new(file),
+            perms,
+            open_mode,
+            allow_blocking_current_thread,
+        }
+    }
+
+    /// Spawn a task on tokio's blocking thread for performing blocking
+    /// syscalls on the underlying [`cap_std::fs::File`].
+    pub(crate) async fn spawn_blocking<F, R>(&self, body: F) -> R
+    where
+        F: FnOnce(&cap_std::fs::File) -> R + Send + 'static,
+        R: Send + 'static,
+    {
+        match self._spawn_blocking(body) {
+            SpawnBlocking::Done(result) => result,
+            SpawnBlocking::Spawned(task) => task.await,
+        }
+    }
+
+    /// Returns `Some` when the current thread is allowed to block in filesystem
+    /// operations, and otherwise returns `None` to indicate that
+    /// `spawn_blocking` must be used.
+    pub(crate) fn as_blocking_file(&self) -> Option<&cap_std::fs::File> {
+        if self.allow_blocking_current_thread {
+            Some(&self.file)
+        } else {
+            None
+        }
+    }
+
+    fn _spawn_blocking<F, R>(&self, body: F) -> SpawnBlocking<R>
+    where
+        F: FnOnce(&cap_std::fs::File) -> R + Send + 'static,
+        R: Send + 'static,
+    {
+        match self.as_blocking_file() {
+            Some(file) => SpawnBlocking::Done(body(file)),
+            None => {
+                let f = self.file.clone();
+                SpawnBlocking::Spawned(spawn_blocking(move || body(&f)))
+            }
+        }
+    }
+}
+
+enum SpawnBlocking<T> {
+    Done(T),
+    Spawned(AbortOnDropJoinHandle<T>),
+}
+
+bitflags::bitflags! {
+    /// Permission bits for operating on a directory.
+    ///
+    /// Directories can be limited to being readonly. This will restrict what
+    /// can be done with them, for example preventing creation of new files.
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    pub struct DirPerms: usize {
+        /// This directory can be read, for example its entries can be iterated
+        /// over and files can be opened.
+        const READ = 0b1;
+
+        /// This directory can be mutated, for example by creating new files
+        /// within it.
+        const MUTATE = 0b10;
+    }
+}
+
+#[derive(Clone)]
+pub struct Dir {
+    /// The operating system file descriptor this struct is mediating access
+    /// to.
+    ///
+    /// Wrapped in an Arc because a copy is needed for [`spawn_blocking`].
+    ///
+    /// [`spawn_blocking`]: Self::spawn_blocking
+    pub dir: Arc<cap_std::fs::Dir>,
+    /// Permissions to enforce on access to this directory. These permissions
+    /// are specified by a user of the `crate::WasiCtxBuilder`, and
+    /// are enforced prior to any enforced by the underlying operating system.
+    ///
+    /// These permissions are also enforced on any directories opened under
+    /// this directory.
+    pub perms: DirPerms,
+    /// Permissions to enforce on any files opened under this directory.
+    pub file_perms: FilePerms,
+    /// The mode the directory was opened under: bits for reading, and writing.
+    /// Required to correctly report the DescriptorFlags, because cap-std
+    /// doesn't presently provide a cross-platform equivalent of reading the
+    /// oflags back out using fcntl.
+    pub open_mode: OpenMode,
+
+    allow_blocking_current_thread: bool,
+}
+
+impl Dir {
+    pub fn new(
+        dir: cap_std::fs::Dir,
+        perms: DirPerms,
+        file_perms: FilePerms,
+        open_mode: OpenMode,
+        allow_blocking_current_thread: bool,
+    ) -> Self {
+        Dir {
+            dir: Arc::new(dir),
+            perms,
+            file_perms,
+            open_mode,
+            allow_blocking_current_thread,
+        }
+    }
+
+    /// Spawn a task on tokio's blocking thread for performing blocking
+    /// syscalls on the underlying [`cap_std::fs::Dir`].
+    pub(crate) async fn spawn_blocking<F, R>(&self, body: F) -> R
+    where
+        F: FnOnce(&cap_std::fs::Dir) -> R + Send + 'static,
+        R: Send + 'static,
+    {
+        if self.allow_blocking_current_thread {
+            body(&self.dir)
+        } else {
+            let d = self.dir.clone();
+            spawn_blocking(move || body(&d)).await
+        }
+    }
+}
+
+pub struct FileInputStream {
+    file: File,
+    position: u64,
+}
+impl FileInputStream {
+    pub fn new(file: &File, position: u64) -> Self {
+        Self {
+            file: file.clone(),
+            position,
+        }
+    }
+
+    pub async fn read(&mut self, size: usize) -> Result<Bytes, StreamError> {
+        use system_interface::fs::FileIoExt;
+        let p = self.position;
+
+        let (r, mut buf) = self
+            .file
+            .spawn_blocking(move |f| {
+                let mut buf = BytesMut::zeroed(size);
+                let r = f.read_at(&mut buf, p);
+                (r, buf)
+            })
+            .await;
+        let n = read_result(r, size)?;
+        buf.truncate(n);
+        self.position += n as u64;
+        Ok(buf.freeze())
+    }
+
+    pub async fn skip(&mut self, nelem: usize) -> Result<usize, StreamError> {
+        let bs = self.read(nelem).await?;
+        Ok(bs.len())
+    }
+}
+
+fn read_result(r: io::Result<usize>, size: usize) -> Result<usize, StreamError> {
+    match r {
+        Ok(0) if size > 0 => Err(StreamError::Closed),
+        Ok(n) => Ok(n),
+        Err(e) if e.kind() == std::io::ErrorKind::Interrupted => Ok(0),
+        Err(e) => Err(StreamError::LastOperationFailed(e.into())),
+    }
+}
+
+#[derive(Clone, Copy)]
+pub(crate) enum FileOutputMode {
+    Position(u64),
+    Append,
+}
+
+pub(crate) struct FileOutputStream {
+    file: File,
+    mode: FileOutputMode,
+    state: OutputState,
+}
+
+enum OutputState {
+    Ready,
+    /// Allows join future to be awaited in a cancellable manner. Gone variant indicates
+    /// no task is currently outstanding.
+    Waiting(AbortOnDropJoinHandle<io::Result<usize>>),
+    /// The last I/O operation failed with this error.
+    Error(io::Error),
+    Closed,
+}
+
+impl FileOutputStream {
+    pub fn write_at(file: &File, position: u64) -> Self {
+        Self {
+            file: file.clone(),
+            mode: FileOutputMode::Position(position),
+            state: OutputState::Ready,
+        }
+    }
+
+    pub fn append(file: &File) -> Self {
+        Self {
+            file: file.clone(),
+            mode: FileOutputMode::Append,
+            state: OutputState::Ready,
+        }
+    }
+}
+
+// FIXME: configurable? determine from how much space left in file?
+const FILE_WRITE_CAPACITY: usize = 1024 * 1024;
+
+impl HostOutputStream for FileOutputStream {
+    fn write(&mut self, buf: Bytes) -> Result<(), StreamError> {
+        use system_interface::fs::FileIoExt;
+        match self.state {
+            OutputState::Ready => {}
+            OutputState::Closed => return Err(StreamError::Closed),
+            OutputState::Waiting(_) | OutputState::Error(_) => {
+                // a write is pending - this call was not permitted
+                return Err(StreamError::Trap(anyhow!(
+                    "write not permitted: check_write not called first"
+                )));
+            }
+        }
+
+        if buf.is_empty() {
+            return Ok(());
+        }
+
+        let m = self.mode;
+        let result = self.file._spawn_blocking(move |f| {
+            match m {
+                FileOutputMode::Position(mut p) => {
+                    let mut total = 0;
+                    let mut buf = buf;
+                    while !buf.is_empty() {
+                        let nwritten = f.write_at(buf.as_ref(), p)?;
+                        // afterwards buf contains [nwritten, len):
+                        let _ = buf.split_to(nwritten);
+                        p += nwritten as u64;
+                        total += nwritten;
+                    }
+                    Ok(total)
+                }
+                FileOutputMode::Append => {
+                    let mut total = 0;
+                    let mut buf = buf;
+                    while !buf.is_empty() {
+                        let nwritten = f.append(buf.as_ref())?;
+                        let _ = buf.split_to(nwritten);
+                        total += nwritten;
+                    }
+                    Ok(total)
+                }
+            }
+        });
+        self.state = match result {
+            SpawnBlocking::Done(Ok(nwritten)) => {
+                if let FileOutputMode::Position(ref mut p) = &mut self.mode {
+                    *p += nwritten as u64;
+                }
+                OutputState::Ready
+            }
+            SpawnBlocking::Done(Err(e)) => OutputState::Error(e),
+            SpawnBlocking::Spawned(task) => OutputState::Waiting(task),
+        };
+        Ok(())
+    }
+    fn flush(&mut self) -> Result<(), StreamError> {
+        match self.state {
+            // Only userland buffering of file writes is in the blocking task,
+            // so there's nothing extra that needs to be done to request a
+            // flush.
+            OutputState::Ready | OutputState::Waiting(_) => Ok(()),
+            OutputState::Closed => Err(StreamError::Closed),
+            OutputState::Error(_) => match mem::replace(&mut self.state, OutputState::Closed) {
+                OutputState::Error(e) => Err(StreamError::LastOperationFailed(e.into())),
+                _ => unreachable!(),
+            },
+        }
+    }
+    fn check_write(&mut self) -> Result<usize, StreamError> {
+        match self.state {
+            OutputState::Ready => Ok(FILE_WRITE_CAPACITY),
+            OutputState::Closed => Err(StreamError::Closed),
+            OutputState::Error(_) => match mem::replace(&mut self.state, OutputState::Closed) {
+                OutputState::Error(e) => Err(StreamError::LastOperationFailed(e.into())),
+                _ => unreachable!(),
+            },
+            OutputState::Waiting(_) => Ok(0),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl Subscribe for FileOutputStream {
+    async fn ready(&mut self) {
+        if let OutputState::Waiting(task) = &mut self.state {
+            self.state = match task.await {
+                Ok(nwritten) => {
+                    if let FileOutputMode::Position(ref mut p) = &mut self.mode {
+                        *p += nwritten as u64;
+                    }
+                    OutputState::Ready
+                }
+                Err(e) => OutputState::Error(e),
+            };
+        }
+    }
+}
+
+pub struct ReaddirIterator(
+    std::sync::Mutex<Box<dyn Iterator<Item = FsResult<types::DirectoryEntry>> + Send + 'static>>,
+);
+
+impl ReaddirIterator {
+    pub(crate) fn new(
+        i: impl Iterator<Item = FsResult<types::DirectoryEntry>> + Send + 'static,
+    ) -> Self {
+        ReaddirIterator(std::sync::Mutex::new(Box::new(i)))
+    }
+    pub(crate) fn next(&self) -> FsResult<Option<types::DirectoryEntry>> {
+        self.0.lock().unwrap().next().transpose()
+    }
+}
+
+impl IntoIterator for ReaddirIterator {
+    type Item = FsResult<types::DirectoryEntry>;
+    type IntoIter = Box<dyn Iterator<Item = Self::Item> + Send>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_inner().unwrap()
+    }
+}

data/ext/cargo-vendor/wasmtime-wasi-22.0.0/src/host/clocks.rs

@@ -0,0 +1,109 @@
+#![allow(unused_variables)]
+
+use crate::bindings::{
+    clocks::monotonic_clock::{self, Duration as WasiDuration, Instant},
+    clocks::wall_clock::{self, Datetime},
+};
+use crate::poll::{subscribe, Subscribe};
+use crate::{Pollable, WasiImpl, WasiView};
+use cap_std::time::SystemTime;
+use std::time::Duration;
+use wasmtime::component::Resource;
+
+impl TryFrom<SystemTime> for Datetime {
+    type Error = anyhow::Error;
+
+    fn try_from(time: SystemTime) -> Result<Self, Self::Error> {
+        let duration =
+            time.duration_since(SystemTime::from_std(std::time::SystemTime::UNIX_EPOCH))?;
+
+        Ok(Datetime {
+            seconds: duration.as_secs(),
+            nanoseconds: duration.subsec_nanos(),
+        })
+    }
+}
+
+impl<T> wall_clock::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn now(&mut self) -> anyhow::Result<Datetime> {
+        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().wall_clock.resolution();
+        Ok(Datetime {
+            seconds: res.as_secs(),
+            nanoseconds: res.subsec_nanos(),
+        })
+    }
+}
+
+fn subscribe_to_duration(
+    table: &mut wasmtime::component::ResourceTable,
+    duration: tokio::time::Duration,
+) -> anyhow::Result<Resource<Pollable>> {
+    let sleep = if duration.is_zero() {
+        table.push(Deadline::Past)?
+    } else if let Some(deadline) = tokio::time::Instant::now().checked_add(duration) {
+        // NB: this resource created here is not actually exposed to wasm, it's
+        // only an internal implementation detail used to match the signature
+        // expected by `subscribe`.
+        table.push(Deadline::Instant(deadline))?
+    } else {
+        // If the user specifies a time so far in the future we can't
+        // represent it, wait forever rather than trap.
+        table.push(Deadline::Never)?
+    };
+    subscribe(table, sleep)
+}
+
+impl<T> monotonic_clock::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn now(&mut self) -> anyhow::Result<Instant> {
+        Ok(self.ctx().monotonic_clock.now())
+    }
+
+    fn resolution(&mut self) -> anyhow::Result<Instant> {
+        Ok(self.ctx().monotonic_clock.resolution())
+    }
+
+    fn subscribe_instant(&mut self, when: Instant) -> anyhow::Result<Resource<Pollable>> {
+        let clock_now = self.ctx().monotonic_clock.now();
+        let duration = if when > clock_now {
+            Duration::from_nanos(when - clock_now)
+        } else {
+            Duration::from_nanos(0)
+        };
+        subscribe_to_duration(&mut self.table(), duration)
+    }
+
+    fn subscribe_duration(&mut self, duration: WasiDuration) -> anyhow::Result<Resource<Pollable>> {
+        subscribe_to_duration(&mut self.table(), Duration::from_nanos(duration))
+    }
+}
+
+enum Deadline {
+    Past,
+    Instant(tokio::time::Instant),
+    Never,
+}
+
+#[async_trait::async_trait]
+impl Subscribe for Deadline {
+    async fn ready(&mut self) {
+        match self {
+            Deadline::Past => {}
+            Deadline::Instant(instant) => tokio::time::sleep_until(*instant).await,
+            Deadline::Never => std::future::pending().await,
+        }
+    }
+}

data/ext/cargo-vendor/wasmtime-wasi-22.0.0/src/host/env.rs

@@ -0,0 +1,18 @@
+use crate::bindings::cli::environment;
+use crate::{WasiImpl, WasiView};
+
+impl<T> environment::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn get_environment(&mut self) -> anyhow::Result<Vec<(String, String)>> {
+        Ok(self.ctx().env.clone())
+    }
+    fn get_arguments(&mut self) -> anyhow::Result<Vec<String>> {
+        Ok(self.ctx().args.clone())
+    }
+    fn initial_cwd(&mut self) -> anyhow::Result<Option<String>> {
+        // FIXME: expose cwd in builder and save in ctx
+        Ok(None)
+    }
+}

data/ext/cargo-vendor/wasmtime-wasi-22.0.0/src/host/exit.rs

@@ -0,0 +1,14 @@
+use crate::{bindings::cli::exit, I32Exit, WasiImpl, WasiView};
+
+impl<T> exit::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn exit(&mut self, status: Result<(), ()>) -> anyhow::Result<()> {
+        let status = match status {
+            Ok(()) => 0,
+            Err(()) => 1,
+        };
+        Err(anyhow::anyhow!(I32Exit(status)))
+    }
+}