kobako 0.29.0 → 0.30.0

data/crates/kobako-wasmtime/witx/wasi_snapshot_preview1.witx

@@ -0,0 +1,441 @@
+;; WASI Preview. This is an evolution of the API that WASI initially
+;; launched with.
+;;
+;; Some content here is derived from [CloudABI](https://github.com/NuxiNL/cloudabi).
+;;
+;; This is a `witx` file. See [here](https://github.com/WebAssembly/WASI/blob/main/legacy/tools/witx-docs.md)
+;; for an explanation of what that means.
+
+(use "typenames.witx")
+
+(module $wasi_snapshot_preview1
+  ;;; Linear memory to be accessed by WASI functions that need it.
+  (import "memory" (memory))
+
+
+
+
+  ;;; Provide file advisory information on a file descriptor.
+  ;;; Note: This is similar to `posix_fadvise` in POSIX.
+  (@interface func (export "fd_advise")
+    (param $fd $fd)
+    ;;; The offset within the file to which the advisory applies.
+    (param $offset $filesize)
+    ;;; The length of the region to which the advisory applies.
+    (param $len $filesize)
+    ;;; The advice.
+    (param $advice $advice)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Force the allocation of space in a file.
+  ;;; Note: This is similar to `posix_fallocate` in POSIX.
+  (@interface func (export "fd_allocate")
+    (param $fd $fd)
+    ;;; The offset at which to start the allocation.
+    (param $offset $filesize)
+    ;;; The length of the area that is allocated.
+    (param $len $filesize)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Close a file descriptor.
+  ;;; Note: This is similar to `close` in POSIX.
+  (@interface func (export "fd_close")
+    (param $fd $fd)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Synchronize the data of a file to disk.
+  ;;; Note: This is similar to `fdatasync` in POSIX.
+  (@interface func (export "fd_datasync")
+    (param $fd $fd)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Get the attributes of a file descriptor.
+  ;;; Note: This returns similar flags to `fsync(fd, F_GETFL)` in POSIX, as well as additional fields.
+  (@interface func (export "fd_fdstat_get")
+    (param $fd $fd)
+    ;;; The buffer where the file descriptor's attributes are stored.
+    (result $error (expected $fdstat (error $errno)))
+  )
+
+  ;;; Adjust the flags associated with a file descriptor.
+  ;;; Note: This is similar to `fcntl(fd, F_SETFL, flags)` in POSIX.
+  (@interface func (export "fd_fdstat_set_flags")
+    (param $fd $fd)
+    ;;; The desired values of the file descriptor flags.
+    (param $flags $fdflags)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Adjust the rights associated with a file descriptor.
+  ;;; This can only be used to remove rights, and returns `errno::notcapable` if called in a way that would attempt to add rights
+  (@interface func (export "fd_fdstat_set_rights")
+    (param $fd $fd)
+    ;;; The desired rights of the file descriptor.
+    (param $fs_rights_base $rights)
+    (param $fs_rights_inheriting $rights)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Return the attributes of an open file.
+  (@interface func (export "fd_filestat_get")
+    (param $fd $fd)
+    ;;; The buffer where the file's attributes are stored.
+    (result $error (expected $filestat (error $errno)))
+  )
+
+  ;;; Adjust the size of an open file. If this increases the file's size, the extra bytes are filled with zeros.
+  ;;; Note: This is similar to `ftruncate` in POSIX.
+  (@interface func (export "fd_filestat_set_size")
+    (param $fd $fd)
+    ;;; The desired file size.
+    (param $size $filesize)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Adjust the timestamps of an open file or directory.
+  ;;; Note: This is similar to `futimens` in POSIX.
+  (@interface func (export "fd_filestat_set_times")
+    (param $fd $fd)
+    ;;; The desired values of the data access timestamp.
+    (param $atim $timestamp)
+    ;;; The desired values of the data modification timestamp.
+    (param $mtim $timestamp)
+    ;;; A bitmask indicating which timestamps to adjust.
+    (param $fst_flags $fstflags)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Read from a file descriptor, without using and updating the file descriptor's offset.
+  ;;; Note: This is similar to `preadv` in POSIX.
+  (@interface func (export "fd_pread")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors in which to store data.
+    (param $iovs $iovec_array)
+    ;;; The offset within the file at which to read.
+    (param $offset $filesize)
+    ;;; The number of bytes read.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Return a description of the given preopened file descriptor.
+  (@interface func (export "fd_prestat_get")
+    (param $fd $fd)
+    ;;; The buffer where the description is stored.
+    (result $error (expected $prestat (error $errno)))
+  )
+
+  ;;; Return a description of the given preopened file descriptor.
+  (@interface func (export "fd_prestat_dir_name")
+    (param $fd $fd)
+    ;;; A buffer into which to write the preopened directory name.
+    (param $path (@witx pointer u8))
+    (param $path_len $size)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Write to a file descriptor, without using and updating the file descriptor's offset.
+  ;;; Note: This is similar to `pwritev` in POSIX.
+  (@interface func (export "fd_pwrite")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors from which to retrieve data.
+    (param $iovs $ciovec_array)
+    ;;; The offset within the file at which to write.
+    (param $offset $filesize)
+    ;;; The number of bytes written.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Read from a file descriptor.
+  ;;; Note: This is similar to `readv` in POSIX.
+  (@interface func (export "fd_read")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors to which to store data.
+    (param $iovs $iovec_array)
+    ;;; The number of bytes read.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Read directory entries from a directory.
+  ;;; When successful, the contents of the output buffer consist of a sequence of
+  ;;; directory entries. Each directory entry consists of a `dirent` object,
+  ;;; followed by `dirent::d_namlen` bytes holding the name of the directory
+  ;;; entry.
+  ;;
+  ;;; This function fills the output buffer as much as possible, potentially
+  ;;; truncating the last directory entry. This allows the caller to grow its
+  ;;; read buffer size in case it's too small to fit a single large directory
+  ;;; entry, or skip the oversized directory entry.
+  (@interface func (export "fd_readdir")
+    (param $fd $fd)
+    ;;; The buffer where directory entries are stored
+    (param $buf (@witx pointer u8))
+    (param $buf_len $size)
+    ;;; The location within the directory to start reading
+    (param $cookie $dircookie)
+    ;;; The number of bytes stored in the read buffer. If less than the size of the read buffer, the end of the directory has been reached.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Atomically replace a file descriptor by renumbering another file descriptor.
+  ;;
+  ;;; Due to the strong focus on thread safety, this environment does not provide
+  ;;; a mechanism to duplicate or renumber a file descriptor to an arbitrary
+  ;;; number, like `dup2()`. This would be prone to race conditions, as an actual
+  ;;; file descriptor with the same number could be allocated by a different
+  ;;; thread at the same time.
+  ;;
+  ;;; This function provides a way to atomically renumber file descriptors, which
+  ;;; would disappear if `dup2()` were to be removed entirely.
+  (@interface func (export "fd_renumber")
+    (param $fd $fd)
+    ;;; The file descriptor to overwrite.
+    (param $to $fd)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Move the offset of a file descriptor.
+  ;;; Note: This is similar to `lseek` in POSIX.
+  (@interface func (export "fd_seek")
+    (param $fd $fd)
+    ;;; The number of bytes to move.
+    (param $offset $filedelta)
+    ;;; The base from which the offset is relative.
+    (param $whence $whence)
+    ;;; The new offset of the file descriptor, relative to the start of the file.
+    (result $error (expected $filesize (error $errno)))
+  )
+
+  ;;; Synchronize the data and metadata of a file to disk.
+  ;;; Note: This is similar to `fsync` in POSIX.
+  (@interface func (export "fd_sync")
+    (param $fd $fd)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Return the current offset of a file descriptor.
+  ;;; Note: This is similar to `lseek(fd, 0, SEEK_CUR)` in POSIX.
+  (@interface func (export "fd_tell")
+    (param $fd $fd)
+    ;;; The current offset of the file descriptor, relative to the start of the file.
+    (result $error (expected $filesize (error $errno)))
+  )
+
+  ;;; Write to a file descriptor.
+  ;;; Note: This is similar to `writev` in POSIX.
+  (@interface func (export "fd_write")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors from which to retrieve data.
+    (param $iovs $ciovec_array)
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Create a directory.
+  ;;; Note: This is similar to `mkdirat` in POSIX.
+  (@interface func (export "path_create_directory")
+    (param $fd $fd)
+    ;;; The path at which to create the directory.
+    (param $path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Return the attributes of a file or directory.
+  ;;; Note: This is similar to `stat` in POSIX.
+  (@interface func (export "path_filestat_get")
+    (param $fd $fd)
+    ;;; Flags determining the method of how the path is resolved.
+    (param $flags $lookupflags)
+    ;;; The path of the file or directory to inspect.
+    (param $path string)
+    ;;; The buffer where the file's attributes are stored.
+    (result $error (expected $filestat (error $errno)))
+  )
+
+  ;;; Adjust the timestamps of a file or directory.
+  ;;; Note: This is similar to `utimensat` in POSIX.
+  (@interface func (export "path_filestat_set_times")
+    (param $fd $fd)
+    ;;; Flags determining the method of how the path is resolved.
+    (param $flags $lookupflags)
+    ;;; The path of the file or directory to operate on.
+    (param $path string)
+    ;;; The desired values of the data access timestamp.
+    (param $atim $timestamp)
+    ;;; The desired values of the data modification timestamp.
+    (param $mtim $timestamp)
+    ;;; A bitmask indicating which timestamps to adjust.
+    (param $fst_flags $fstflags)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Create a hard link.
+  ;;; Note: This is similar to `linkat` in POSIX.
+  (@interface func (export "path_link")
+    (param $old_fd $fd)
+    ;;; Flags determining the method of how the path is resolved.
+    (param $old_flags $lookupflags)
+    ;;; The source path from which to link.
+    (param $old_path string)
+    ;;; The working directory at which the resolution of the new path starts.
+    (param $new_fd $fd)
+    ;;; The destination path at which to create the hard link.
+    (param $new_path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Open a file or directory.
+  ;;
+  ;;; The returned file descriptor is not guaranteed to be the lowest-numbered
+  ;;; file descriptor not currently open; it is randomized to prevent
+  ;;; applications from depending on making assumptions about indexes, since this
+  ;;; is error-prone in multi-threaded contexts. The returned file descriptor is
+  ;;; guaranteed to be less than 2**31.
+  ;;
+  ;;; Note: This is similar to `openat` in POSIX.
+  (@interface func (export "path_open")
+    (param $fd $fd)
+    ;;; Flags determining the method of how the path is resolved.
+    (param $dirflags $lookupflags)
+    ;;; The relative path of the file or directory to open, relative to the
+    ;;; `path_open::fd` directory.
+    (param $path string)
+    ;;; The method by which to open the file.
+    (param $oflags $oflags)
+    ;;; The initial rights of the newly created file descriptor. The
+    ;;; implementation is allowed to return a file descriptor with fewer rights
+    ;;; than specified, if and only if those rights do not apply to the type of
+    ;;; file being opened.
+    ;;
+    ;;; The *base* rights are rights that will apply to operations using the file
+    ;;; descriptor itself, while the *inheriting* rights are rights that apply to
+    ;;; file descriptors derived from it.
+    (param $fs_rights_base $rights)
+    (param $fs_rights_inheriting $rights)
+    (param $fdflags $fdflags)
+    ;;; The file descriptor of the file that has been opened.
+    (result $error (expected $fd (error $errno)))
+  )
+
+  ;;; Read the contents of a symbolic link.
+  ;;; Note: This is similar to `readlinkat` in POSIX.
+  (@interface func (export "path_readlink")
+    (param $fd $fd)
+    ;;; The path of the symbolic link from which to read.
+    (param $path string)
+    ;;; The buffer to which to write the contents of the symbolic link.
+    (param $buf (@witx pointer u8))
+    (param $buf_len $size)
+    ;;; The number of bytes placed in the buffer.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Remove a directory.
+  ;;; Return `errno::notempty` if the directory is not empty.
+  ;;; Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX.
+  (@interface func (export "path_remove_directory")
+    (param $fd $fd)
+    ;;; The path to a directory to remove.
+    (param $path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Rename a file or directory.
+  ;;; Note: This is similar to `renameat` in POSIX.
+  (@interface func (export "path_rename")
+    (param $fd $fd)
+    ;;; The source path of the file or directory to rename.
+    (param $old_path string)
+    ;;; The working directory at which the resolution of the new path starts.
+    (param $new_fd $fd)
+    ;;; The destination path to which to rename the file or directory.
+    (param $new_path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Create a symbolic link.
+  ;;; Note: This is similar to `symlinkat` in POSIX.
+  (@interface func (export "path_symlink")
+    ;;; The contents of the symbolic link.
+    (param $old_path string)
+    (param $fd $fd)
+    ;;; The destination path at which to create the symbolic link.
+    (param $new_path string)
+    (result $error (expected (error $errno)))
+  )
+
+
+  ;;; Unlink a file.
+  ;;; Return `errno::isdir` if the path refers to a directory.
+  ;;; Note: This is similar to `unlinkat(fd, path, 0)` in POSIX.
+  (@interface func (export "path_unlink_file")
+    (param $fd $fd)
+    ;;; The path to a file to unlink.
+    (param $path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Concurrently poll for the occurrence of a set of events.
+  (@interface func (export "poll_oneoff")
+    ;;; The events to which to subscribe.
+    (param $in (@witx const_pointer $subscription))
+    ;;; The events that have occurred.
+    (param $out (@witx pointer $event))
+    ;;; Both the number of subscriptions and events.
+    (param $nsubscriptions $size)
+    ;;; The number of events stored.
+    (result $error (expected $size (error $errno)))
+  )
+
+
+
+
+
+  ;;; Accept a new incoming connection.
+  ;;; Note: This is similar to `accept` in POSIX.
+  (@interface func (export "sock_accept")
+    ;;; The listening socket.
+    (param $fd $fd)
+    ;;; The desired values of the file descriptor flags.
+    (param $flags $fdflags)
+    ;;; New socket connection
+    (result $error (expected $fd (error $errno)))
+  )
+
+  ;;; Receive a message from a socket.
+  ;;; Note: This is similar to `recv` in POSIX, though it also supports reading
+  ;;; the data into multiple buffers in the manner of `readv`.
+  (@interface func (export "sock_recv")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors to which to store data.
+    (param $ri_data $iovec_array)
+    ;;; Message flags.
+    (param $ri_flags $riflags)
+    ;;; Number of bytes stored in ri_data and message flags.
+    (result $error (expected (tuple $size $roflags) (error $errno)))
+  )
+
+  ;;; Send a message on a socket.
+  ;;; Note: This is similar to `send` in POSIX, though it also supports writing
+  ;;; the data from multiple buffers in the manner of `writev`.
+  (@interface func (export "sock_send")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors to which to retrieve data
+    (param $si_data $ciovec_array)
+    ;;; Message flags.
+    (param $si_flags $siflags)
+    ;;; Number of bytes transmitted.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Shut down socket send and receive channels.
+  ;;; Note: This is similar to `shutdown` in POSIX.
+  (@interface func (export "sock_shutdown")
+    (param $fd $fd)
+    ;;; Which channels on the socket to shut down.
+    (param $how $sdflags)
+    (result $error (expected (error $errno)))
+  )
+)

data/ext/kobako/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kobako"
-version = "0.29.0"
+version = "0.30.0"
 edition = "2021"
 authors = ["Aotokitsuruya <contact@aotoki.me>"]
 license = "Apache-2.0"

data/ext/kobako/src/runtime/bridge.rs

@@ -21,7 +21,7 @@ use kobako_transport::envelope::{Call, Fault, FaultKind, Reply, Target, YieldRep
 
 /// The names each side of this seam branches on — one per Reply and
 /// Yield Reply arm. Neutral Symbols rather than the envelope's tag bytes,
-/// the same way `Snapshot#outcome` names its arms: the core envelope is
+/// the same way `Snapshot#outcome` names its arms: the Envelope is
 /// this side's to read, so no byte value of it reaches Ruby.
 const ARM_OK: &str = "ok";
 const ARM_FAULT: &str = "fault";

data/ext/kobako/src/runtime/errors.rs

@@ -58,7 +58,7 @@ pub(super) fn trap_class(ruby: &Ruby, trap: &Trap) -> ExceptionClass {
     }
 }
 
-/// The verb prefix is left to `Kobako::Context#invoke!`.
+/// The verb prefix is left to `Kobako::Context#invoke`.
 pub(super) fn trap_to_magnus(ruby: &Ruby, trap: Trap) -> MagnusError {
     MagnusError::new(trap_class(ruby, &trap), trap.to_string())
 }

data/ext/kobako/src/runtime/escape.rs

@@ -1,8 +1,8 @@
 //! What a Host App's callback raises that is not a `StandardError`:
-//! `Interrupt`, `exit`, `throw`, `Timeout`. These belong to the host, so
-//! the callback holds one here instead of answering the guest with it,
-//! the invocation ends at its next host call, and the run raises it again
-//! once control is back in Ruby.
+//! `Interrupt`, `exit`, `throw`, `Timeout`, and any interrupt delivered to the
+//! Thread while a run gives up the GVL. These belong to the host, so one is held
+//! here instead of answering the guest with it, the invocation ends at its next
+//! host call, and the run raises it again once control is back in Ruby.
 //!
 //! The slot is per thread, as each invocation runs on its caller's
 //! thread. A nested invocation takes what its own run held before the
@@ -14,39 +14,53 @@ use magnus::value::BoxValue;
 use magnus::{Error as MagnusError, Ruby, Value};
 
 thread_local! {
-    static HELD: RefCell<Option<Held>> = const { RefCell::new(None) };
+    static ESCAPE: RefCell<Option<Escape>> = const { RefCell::new(None) };
 }
 
 /// The error and, when it carries one, its exception kept rooted while
 /// the guest finishes unwinding.
-struct Held {
+struct Escape {
     error: MagnusError,
     _rooted: Option<BoxValue<Value>>,
 }
 
 /// Hold `error` unless it is a `StandardError`, which comes back for the
-/// callback to answer the guest with; the first one held wins.
+/// callback to answer the guest with.
 pub(super) fn hold(ruby: &Ruby, error: MagnusError) -> Result<(), MagnusError> {
     if error.is_kind_of(ruby.exception_standard_error()) {
         return Err(error);
     }
-    HELD.with(|held| {
-        held.borrow_mut().get_or_insert_with(|| Held {
+    keep(error);
+    Ok(())
+}
+
+/// Run what is pending on this Thread, holding what it raises, whatever its
+/// class: no callback asked for it, so no guest is answered with it.
+pub(super) fn hold_interrupts() {
+    let ruby = Ruby::get().expect("a Thread that was not given up holds the GVL");
+    if let Err(error) = ruby.thread_check_ints() {
+        keep(error);
+    }
+}
+
+/// Keep `error` for the host; the first one kept wins.
+fn keep(error: MagnusError) {
+    ESCAPE.with(|held| {
+        held.borrow_mut().get_or_insert_with(|| Escape {
             _rooted: error.value().map(BoxValue::new),
             error,
         });
     });
-    Ok(())
 }
 
-/// Whether a callback on this thread holds an error for the host.
+/// Whether this thread holds an error for the host.
 pub(super) fn pending() -> bool {
-    HELD.with(|held| held.borrow().is_some())
+    ESCAPE.with(|held| held.borrow().is_some())
 }
 
-/// Raise what a callback held, once the run is back in Ruby.
+/// Raise what was held, once the run is back in Ruby.
 pub(super) fn resume() -> Result<(), MagnusError> {
-    match HELD.with(|held| held.borrow_mut().take()) {
+    match ESCAPE.with(|held| held.borrow_mut().take()) {
         Some(held) => Err(held.error),
         None => Ok(()),
     }

data/ext/kobako/src/runtime/filesystem/grants.rs

@@ -5,13 +5,12 @@
 use std::sync::Arc;
 
 use magnus::value::{Opaque, ReprValue};
-use magnus::{prelude::*, Error as MagnusError, RArray, RString, Ruby, Value};
+use magnus::{prelude::*, Error as MagnusError, RArray, RString, Ruby, Symbol, Value};
 
-use kobako_runtime::filesystem::Access;
 use kobako_runtime::grant::Grant;
-use kobako_runtime::mount::{Mount, Policy};
+use kobako_runtime::mount::{Access, Mount, Policy};
 
-use super::{to_access, to_filesystem};
+use super::to_filesystem;
 use crate::runtime::pinned_value::PinnedValue;
 use crate::runtime::{escape, gvl};
 
@@ -35,7 +34,24 @@ fn to_mount(at: Value, access: Value, filesystem: Value) -> Result<Mount, Magnus
         .map_err(|err| MagnusError::new(ruby.exception_arg_error(), err.to_string()))
 }
 
-/// A mount's block, asked in its access's place. A block raising a
+fn to_access(access: Value) -> Result<Access, MagnusError> {
+    let name = Symbol::from_value(access)
+        .map(|symbol| symbol.name())
+        .transpose()?;
+    match name.as_deref() {
+        Some("read") => Ok(Access::Read),
+        Some("read_write") => Ok(Access::ReadWrite),
+        _ => Err(MagnusError::new(
+            Ruby::get().expect("Ruby thread").exception_arg_error(),
+            format!(
+                "access must be :read or :read_write, got {}",
+                access.inspect()
+            ),
+        )),
+    }
+}
+
+/// A mount's block, asked what its access allows. A block raising a
 /// StandardError refuses, so the guest's open fails and its script goes
 /// on; anything else it raises is held for the host.
 struct RubyPolicy {