kobako 0.29.0 → 0.30.0

data/crates/kobako-wasmtime/src/preview1/poll.rs

@@ -10,67 +10,51 @@
 use std::thread;
 use std::time::{Duration, Instant};
 
-use super::errno::{Answer, Errno, Failure};
+use kobako_runtime::vfs::PollMask;
+use wiggle::{GuestPtr, GuestType};
+
+use super::errno::{Answer, Errno};
+use super::fd::file;
 use super::memory::GuestMemory;
-use crate::descriptors::Descriptor;
+use super::types::{self, Clockid, Eventrwflags, Eventtype, Subclockflags, SubscriptionU};
 use crate::invocation::Invocation;
 use crate::trap::TimeoutTrap;
 
-const SUBSCRIPTION_SIZE: u32 = 48;
-const EVENT_SIZE: u32 = 32;
-
-const TAG_CLOCK: u8 = 0;
-const TAG_FD_READ: u8 = 1;
-const TAG_FD_WRITE: u8 = 2;
-
-const CLOCK_REALTIME: u32 = 0;
-const CLOCK_MONOTONIC: u32 = 1;
-/// The highest `clockid` variant.
-const CLOCK_MAX: u32 = 3;
-const SUBCLOCKFLAGS_ABSTIME: u16 = 1;
-
-/// One subscription as the guest wrote it.
+/// One subscription as the guest wrote it, and the error its event reports.
 struct Subscription {
     userdata: u64,
     kind: Kind,
+    error: Errno,
 }
 
 enum Kind {
     /// A clock, as the nanoseconds left before it fires.
     Clock(u64),
-    /// A descriptor to read; `hangup` when a file has nothing left past
-    /// its position.
-    FdRead {
-        hangup: bool,
-    },
+    FdRead,
     FdWrite,
 }
 
-const EVENTRWFLAGS_HANGUP: u16 = 1;
-
 pub(crate) fn poll_oneoff(
     invocation: &Invocation,
-    mem: &mut GuestMemory,
-    subs: u32,
-    events: u32,
+    mem: &mut GuestMemory<'_, '_>,
+    subs: GuestPtr<types::Subscription>,
+    events: GuestPtr<types::Event>,
     count: u32,
-    nevents: u32,
-) -> Answer {
+) -> Answer<types::Size> {
     if count == 0 {
         return Err(Errno::Inval.into());
     }
-    mem.consume(count, SUBSCRIPTION_SIZE)?;
-    mem.consume(count, EVENT_SIZE)?;
-    let subscriptions = (0..count)
-        .map(|index| {
-            let sub = GuestMemory::element(subs, index, SUBSCRIPTION_SIZE)?;
-            read_subscription(invocation, mem, sub)
-        })
+    mem.consume(count, types::Subscription::guest_size())?;
+    mem.consume(count, types::Event::guest_size())?;
+    let subscriptions = subs
+        .as_array(count)
+        .iter()
+        .map(|sub| read_subscription(invocation, mem, sub?))
         .collect::<Answer<Vec<_>>>()?;
 
     let clocks = subscriptions.iter().filter_map(|sub| match sub.kind {
         Kind::Clock(left) => Some(left),
-        Kind::FdRead { .. } | Kind::FdWrite => None,
+        Kind::FdRead | Kind::FdWrite => None,
     });
     let waited = if clocks.clone().count() == subscriptions.len() {
         let soonest = clocks.min().unwrap_or(0);
@@ -84,71 +68,77 @@ pub(crate) fn poll_oneoff(
     for sub in &subscriptions {
         let (ready, nbytes) = match sub.kind {
             Kind::Clock(left) => (left <= waited, 0),
-            Kind::FdRead { .. } | Kind::FdWrite => (true, 1),
+            Kind::FdRead | Kind::FdWrite => (true, u64::from(sub.error == Errno::Success)),
         };
         if ready {
-            let event = GuestMemory::element(events, written, EVENT_SIZE)?;
-            write_event(mem, event, sub, nbytes)?;
+            mem.write(events.add(written)?, to_event(sub, nbytes))?;
             written += 1;
         }
     }
-    mem.write_u32(nevents, written)
+    Ok(written)
 }
 
-fn read_subscription(invocation: &Invocation, mem: &GuestMemory, sub: u32) -> Answer<Subscription> {
-    let userdata = mem.read_u64(sub)?;
-    let kind = match mem.read_u8(GuestMemory::field(sub, 8)?)? {
-        TAG_CLOCK => read_clock(invocation, mem, sub)?,
-        TAG_FD_READ => match descriptor(invocation, mem, sub)? {
-            Descriptor::Stdin(_) => Kind::FdRead { hangup: false },
-            Descriptor::File(file) => Kind::FdRead {
-                hangup: file.file.metadata()?.len <= file.position,
-            },
-            Descriptor::Channel(_) | Descriptor::Directory(_) => return Err(Errno::Badf.into()),
-        },
-        TAG_FD_WRITE => match descriptor(invocation, mem, sub)? {
-            Descriptor::Channel(_) => Kind::FdWrite,
-            Descriptor::File(file) if file.mount.allows_writes() => Kind::FdWrite,
-            Descriptor::File(_) => return Err(Errno::Perm.into()),
-            Descriptor::Stdin(_) | Descriptor::Directory(_) => return Err(Errno::Badf.into()),
-        },
-        _ => return Err(Errno::Inval.into()),
+fn read_subscription(
+    invocation: &Invocation,
+    mem: &GuestMemory<'_, '_>,
+    sub: GuestPtr<types::Subscription>,
+) -> Answer<Subscription> {
+    let sub = mem.read(sub)?;
+    let (kind, error) = match sub.u {
+        SubscriptionU::Clock(clock) => (read_clock(invocation, &clock)?, Errno::Success),
+        SubscriptionU::FdRead(subscribed) => (
+            Kind::FdRead,
+            poll_descriptor(invocation, subscribed, PollMask::IN)?,
+        ),
+        SubscriptionU::FdWrite(subscribed) => (
+            Kind::FdWrite,
+            poll_descriptor(invocation, subscribed, PollMask::OUT)?,
+        ),
     };
-    Ok(Subscription { userdata, kind })
+    Ok(Subscription {
+        userdata: sub.userdata,
+        kind,
+        error,
+    })
 }
 
-fn descriptor<'a>(
-    invocation: &'a Invocation,
-    mem: &GuestMemory,
-    sub: u32,
-) -> Answer<&'a Descriptor> {
-    let fd = mem.read_u32(GuestMemory::field(sub, 16)?)?;
-    invocation
-        .wasi()
-        .descriptors()
-        .get(fd)
-        .ok_or_else(|| Errno::Badf.into())
+/// Hold a subscription to what its descriptor would find ready, answering the
+/// error its event reports. A number no descriptor holds, or one standing only
+/// for its path, is reported in its event, as Linux's `do_pollfd` marks it
+/// `POLLNVAL` when `fdget` refuses it and the wait goes on. A
+/// pipe's end is never ready for what the other end does, and nothing here
+/// would wake a wait on it, so that is `BADF` rather than a wait that never
+/// ends.
+fn poll_descriptor(
+    invocation: &Invocation,
+    subscribed: types::SubscriptionFdReadwrite,
+    event: PollMask,
+) -> Answer<Errno> {
+    let descriptors = invocation.wasi().descriptors();
+    let Ok(file) = file(descriptors, subscribed.file_descriptor.into()) else {
+        return Ok(Errno::Badf);
+    };
+    match file.poll().contains(event) {
+        true => Ok(Errno::Success),
+        false => Err(Errno::Badf.into()),
+    }
 }
 
 /// A clock, read against the guest's own clocks. Only the realtime and
 /// monotonic clocks can be waited on, alone or among other
 /// subscriptions, as in wasmtime-wasi.
-fn read_clock(invocation: &Invocation, mem: &GuestMemory, sub: u32) -> Answer<Kind> {
-    let id = mem.read_u32(GuestMemory::field(sub, 16)?)?;
-    let timeout = mem.read_u64(GuestMemory::field(sub, 24)?)?;
-    let flags = mem.read_u16(GuestMemory::field(sub, 40)?)?;
-    if id > CLOCK_MAX || flags & !SUBCLOCKFLAGS_ABSTIME != 0 {
-        return Err(Errno::Inval.into());
-    }
-    let absolute = flags & SUBCLOCKFLAGS_ABSTIME != 0;
+fn read_clock(invocation: &Invocation, clock: &types::SubscriptionClock) -> Answer<Kind> {
+    let absolute = clock
+        .flags
+        .contains(Subclockflags::SUBSCRIPTION_CLOCK_ABSTIME);
     let clocks = invocation.wasi().clocks();
-    let now = match (id, absolute) {
-        (CLOCK_REALTIME | CLOCK_MONOTONIC, false) => 0,
-        (CLOCK_MONOTONIC, true) => clocks.monotonic_now(),
-        (CLOCK_REALTIME, true) => clocks.wall_now(),
+    let now = match (clock.id, absolute) {
+        (Clockid::Realtime | Clockid::Monotonic, false) => 0,
+        (Clockid::Monotonic, true) => clocks.monotonic_now(),
+        (Clockid::Realtime, true) => clocks.wall_now(),
         _ => return Err(Errno::Inval.into()),
     };
-    Ok(Kind::Clock(timeout.saturating_sub(now)))
+    Ok(Kind::Clock(clock.timeout.saturating_sub(now)))
 }
 
 /// Wait `nanos` of the guest's time: none on frozen clocks, and on live
@@ -163,24 +153,27 @@ fn wait(invocation: &Invocation, nanos: u64) -> Answer {
         let left = deadline.saturating_duration_since(Instant::now());
         if wanted >= left {
             thread::sleep(left);
-            return Err(Failure::Trap(wasmtime::Error::new(TimeoutTrap)));
+            return Err(types::Error::trap(wasmtime::Error::new(TimeoutTrap)));
         }
     }
     thread::sleep(wanted);
     Ok(())
 }
 
-fn write_event(mem: &mut GuestMemory, event: u32, sub: &Subscription, nbytes: u64) -> Answer {
-    let (kind, flags) = match sub.kind {
-        Kind::Clock(_) => (TAG_CLOCK, 0),
-        Kind::FdRead { hangup } => (TAG_FD_READ, if hangup { EVENTRWFLAGS_HANGUP } else { 0 }),
-        Kind::FdWrite => (TAG_FD_WRITE, 0),
-    };
-    mem.write_u64(event, sub.userdata)?;
-    mem.write_u16(GuestMemory::field(event, 8)?, 0)?;
-    mem.write_u8(GuestMemory::field(event, 10)?, kind)?;
-    mem.write_u64(GuestMemory::field(event, 16)?, nbytes)?;
-    mem.write_u16(GuestMemory::field(event, 24)?, flags)
+fn to_event(sub: &Subscription, nbytes: u64) -> types::Event {
+    types::Event {
+        userdata: sub.userdata,
+        error: sub.error,
+        type_: match sub.kind {
+            Kind::Clock(_) => Eventtype::Clock,
+            Kind::FdRead => Eventtype::FdRead,
+            Kind::FdWrite => Eventtype::FdWrite,
+        },
+        fd_readwrite: types::EventFdReadwrite {
+            nbytes,
+            flags: Eventrwflags::empty(),
+        },
+    }
 }
 
 #[cfg(test)]
@@ -192,7 +185,7 @@ mod tests {
 
     use wasmtime::{Module, Store};
 
-    use crate::cache::shared_engine;
+    use crate::cache::load_engine;
     use crate::config::Config;
     use crate::imports;
     use crate::invocation::Invocation;
@@ -221,7 +214,7 @@ mod tests {
         profile: Profile,
         deadline: Option<Duration>,
     ) -> (wasmtime::Result<i32>, Duration) {
-        let engine = shared_engine().expect("shared engine must be constructible");
+        let engine = load_engine().expect("shared engine must be constructible");
         let config = Config {
             timeout: None,
             setup_timeout: None,
@@ -230,8 +223,9 @@ mod tests {
             stderr_limit: None,
             open_file_limit: None,
             profile,
+            security: Vec::new(),
         };
-        let wasi = Wasi::for_invocation(&config, &[], &[]).expect("WASI context must build");
+        let wasi = Wasi::for_invocation(&config, Vec::new(), &[]).expect("WASI context must build");
         let mut store = Store::new(engine, Invocation::new(None, wasi));
         store.set_epoch_deadline(NO_TIMEOUT_EPOCH_DELTA);
         let linker = imports::linker().expect("host imports must link");
@@ -277,7 +271,7 @@ mod tests {
                 (i32.store (i32.const 16) (local.get $id))
                 (call $poll (i32.const 0) (i32.const 64) (i32.const 1) (i32.const 96))))
         "#;
-        let engine = shared_engine().expect("shared engine must be constructible");
+        let engine = load_engine().expect("shared engine must be constructible");
         let config = Config {
             timeout: None,
             setup_timeout: None,
@@ -286,8 +280,9 @@ mod tests {
             stderr_limit: None,
             open_file_limit: None,
             profile: Profile::Hermetic,
+            security: Vec::new(),
         };
-        let wasi = Wasi::for_invocation(&config, &[], &[]).expect("WASI context must build");
+        let wasi = Wasi::for_invocation(&config, Vec::new(), &[]).expect("WASI context must build");
         let mut store = Store::new(engine, Invocation::new(None, wasi));
         store.set_epoch_deadline(NO_TIMEOUT_EPOCH_DELTA);
         let linker = imports::linker().expect("host imports must link");
@@ -314,6 +309,59 @@ mod tests {
 
     const ERRNO_INVAL: i32 = 28;
 
+    /// What a lone wait on standard output answers for event `tag`, 1 to read
+    /// and 2 to write.
+    fn wait_on_stdout(tag: i32) -> i32 {
+        const WAIT_ON_FD_WAT: &str = r#"
+            (module
+              (import "wasi_snapshot_preview1" "poll_oneoff"
+                (func $poll (param i32 i32 i32 i32) (result i32)))
+              (memory (export "memory") 1)
+              (func (export "wait_on") (param $tag i32) (result i32)
+                (i32.store8 (i32.const 8) (local.get $tag))
+                (i32.store (i32.const 16) (i32.const 1))
+                (call $poll (i32.const 0) (i32.const 64) (i32.const 1) (i32.const 96))))
+        "#;
+        let engine = load_engine().expect("shared engine must be constructible");
+        let config = Config {
+            timeout: None,
+            setup_timeout: None,
+            memory_limit: None,
+            stdout_limit: None,
+            stderr_limit: None,
+            open_file_limit: None,
+            profile: Profile::Hermetic,
+            security: Vec::new(),
+        };
+        let wasi = Wasi::for_invocation(&config, Vec::new(), &[]).expect("WASI context must build");
+        let mut store = Store::new(engine, Invocation::new(None, wasi));
+        store.set_epoch_deadline(NO_TIMEOUT_EPOCH_DELTA);
+        let linker = imports::linker().expect("host imports must link");
+        let module = Module::new(engine, WAIT_ON_FD_WAT).expect("wait module must compile");
+        linker
+            .instantiate(&mut store, &module)
+            .expect("wait module must instantiate")
+            .get_typed_func::<i32, i32>(&mut store, "wait_on")
+            .expect("wait export must resolve")
+            .call(&mut store, tag)
+            .expect("the wait must not trap")
+    }
+
+    const ERRNO_BADF: i32 = 8;
+
+    // Nothing ever makes standard output ready to read, so without the refusal
+    // the wait would only end with the invocation.
+    // @behavior RT-285
+    #[test]
+    fn a_wait_on_what_a_descriptor_never_does_answers_ebadf() {
+        assert_eq!(
+            [1, 2].map(wait_on_stdout),
+            [ERRNO_BADF, 0],
+            "poll_oneoff on standard output must answer EBADF waiting to read and be ready to \
+             write"
+        );
+    }
+
     // @behavior RT-074
     #[test]
     fn a_permissive_wait_ends_at_the_deadline_as_a_timeout() {

data/crates/kobako-wasmtime/src/preview1/sock.rs

@@ -1,30 +1,13 @@
 //! The 4 `sock_*` calls. The table holds no socket, so every open
-//! descriptor answers `NOTSOCK`, as wasmtime-wasi's preview1 does.
+//! descriptor answers `NOTSOCK`, as wasmtime-wasi's preview1 does, and one
+//! standing only for its path `BADF`, as Linux's socket calls take theirs
+//! through `fdget`.
 
-use super::args;
 use super::errno::{Answer, Errno};
+use super::fd::file;
 use crate::descriptors::Descriptors;
 
-fn socket(table: &Descriptors, fd: u32) -> Answer {
-    table.get(fd).ok_or(Errno::Badf)?;
+pub(crate) fn socket<T>(table: &Descriptors, fd: u32) -> Answer<T> {
+    file(table, fd)?;
     Err(Errno::Notsock.into())
 }
-
-pub(crate) fn accept(table: &Descriptors, fd: u32, flags: u32) -> Answer {
-    args::flags(flags, args::FDFLAGS)?;
-    socket(table, fd)
-}
-
-pub(crate) fn recv(table: &Descriptors, fd: u32, ri_flags: u32) -> Answer {
-    args::flags(ri_flags, args::RIFLAGS)?;
-    socket(table, fd)
-}
-
-pub(crate) fn send(table: &Descriptors, fd: u32) -> Answer {
-    socket(table, fd)
-}
-
-pub(crate) fn shutdown(table: &Descriptors, fd: u32, how: u32) -> Answer {
-    args::flags(how, args::SDFLAGS)?;
-    socket(table, fd)
-}

data/crates/kobako-wasmtime/src/preview1/testsuite-expected.txt

@@ -0,0 +1,6 @@
+nofollow_errors   # no built-in Filesystem makes a link
+path_exists       # no built-in Filesystem makes a link
+path_link         # no built-in Filesystem makes a link
+readlink          # no built-in Filesystem makes a link
+symlink_create    # no built-in Filesystem makes a link
+symlink_filestat  # no built-in Filesystem makes a link

data/crates/kobako-wasmtime/src/preview1/testsuite.rs

@@ -0,0 +1,157 @@
+//! Runs wasi-testsuite's prebuilt preview1 tests against kobako's linker, over a
+//! Bind of each test's own copy of the directory it is handed. The suite is
+//! the second of what decides a preview1 answer, after the witx, so only the
+//! calls kobako deliberately refuses may fail, and `testsuite-expected.txt`
+//! names them.
+//!
+//! The suite is fetched by `rake crates:testsuite`, which pins its version, so
+//! no gate reaches the network.
+
+use std::collections::BTreeMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::time::Duration;
+
+use kobako_runtime::filesystem::Bind;
+use kobako_runtime::filesystem::Filesystem;
+use kobako_runtime::grant::Grant;
+use kobako_runtime::mount::{Access, Mount};
+use kobako_runtime::profile::Profile;
+use wasmtime::{Module, Store};
+use wasmtime_wasi::I32Exit;
+
+use crate::cache::load_engine;
+use crate::config::Config;
+use crate::imports;
+use crate::invocation::Invocation;
+use crate::trap::arm_deadline;
+use crate::wasi::Wasi;
+
+const SUITE: &str = concat!(
+    env!("CARGO_MANIFEST_DIR"),
+    "/../../tmp/wasi-testsuite/tests/rust/testsuite/wasm32-wasip1"
+);
+
+/// What may fail, one test per line, with why after a `#`.
+const EXPECTED: &str = include_str!("testsuite-expected.txt");
+
+fn copy_tree(from: &Path, to: &Path) {
+    fs::create_dir_all(to).expect("the copy must make its directory");
+    for entry in fs::read_dir(from).expect("the suite's directory must list") {
+        let entry = entry.expect("the suite's directory must list");
+        let target = to.join(entry.file_name());
+        match entry.file_type().expect("an entry has a type").is_dir() {
+            true => copy_tree(&entry.path(), &target),
+            false => {
+                fs::copy(entry.path(), target).expect("the suite's file must copy");
+            }
+        }
+    }
+}
+
+/// What the test at `wasm` ended with: its exit code, or why it never reached
+/// one.
+fn run(wasm: &Path, root: &Path) -> Result<i32, String> {
+    let engine = load_engine().map_err(|err| err.to_string())?;
+    let bind = Bind::new(root).map_err(|err| err.to_string())?;
+    let filesystem = Filesystem::new(Arc::new(bind)).map_err(|err| format!("{err:?}"))?;
+    let mount = Mount::new("/", filesystem, Access::ReadWrite).map_err(|err| err.to_string())?;
+    let config = Config {
+        timeout: None,
+        setup_timeout: None,
+        memory_limit: None,
+        stdout_limit: None,
+        stderr_limit: None,
+        open_file_limit: None,
+        profile: Profile::Permissive,
+        security: Vec::new(),
+    };
+    let wasi = Wasi::for_invocation(&config, Vec::new(), &[Grant::Mount(mount)])
+        .map_err(|err| err.to_string())?;
+    let mut store = Store::new(engine, Invocation::new(None, wasi));
+    arm_deadline(&mut store, Some(Duration::from_secs(30)));
+    let module = Module::from_file(engine, wasm).map_err(|err| err.to_string())?;
+    let instance = imports::linker()
+        .map_err(|err| err.to_string())?
+        .instantiate(&mut store, &module)
+        .map_err(|err| err.to_string())?;
+    let start = instance
+        .get_typed_func::<(), ()>(&mut store, "_start")
+        .map_err(|err| err.to_string())?;
+    match start.call(&mut store, ()) {
+        Ok(()) => Ok(0),
+        Err(err) => match err.downcast_ref::<I32Exit>() {
+            Some(exit) => Ok(exit.0),
+            // A test aborts on its first failed assertion, which it wrote to
+            // stderr, so that says what the call answered.
+            None => Err(String::from_utf8_lossy(&store.data().wasi().stderr_bytes()).to_string()),
+        },
+    }
+}
+
+fn expected_failures() -> BTreeMap<String, String> {
+    EXPECTED
+        .lines()
+        .filter(|line| !line.trim().is_empty())
+        .map(|line| {
+            let (name, why) = line.split_once('#').unwrap_or((line, ""));
+            (name.trim().to_string(), why.trim().to_string())
+        })
+        .collect()
+}
+
+// @behavior RT-192
+#[test]
+#[ignore = "run through `rake crates:testsuite`, which fetches the suite"]
+fn only_what_kobako_refuses_fails_wasi_testsuite() {
+    let suite = PathBuf::from(SUITE);
+    assert!(
+        suite.exists(),
+        "wasi-testsuite is not at {SUITE}; run `rake crates:testsuite`"
+    );
+    let scratch = std::env::temp_dir().join(format!("kobako-testsuite-{}", std::process::id()));
+    let mut wasms: Vec<PathBuf> = fs::read_dir(&suite)
+        .expect("the suite must list")
+        .map(|entry| entry.expect("the suite must list").path())
+        .filter(|path| path.extension().is_some_and(|ext| ext == "wasm"))
+        .collect();
+    wasms.sort();
+
+    let mut failed = BTreeMap::new();
+    for wasm in &wasms {
+        let name = wasm
+            .file_stem()
+            .expect("a test has a name")
+            .to_string_lossy()
+            .to_string();
+        let root = scratch.join(&name);
+        copy_tree(&suite.join("fs-tests.dir"), &root);
+        match run(wasm, &root) {
+            Ok(0) => {}
+            Ok(code) => {
+                failed.insert(name, format!("exit {code}"));
+            }
+            Err(why) => {
+                failed.insert(name, why);
+            }
+        }
+    }
+    let _ = fs::remove_dir_all(&scratch);
+
+    let expected = expected_failures();
+    let unexpected: Vec<_> = failed
+        .iter()
+        .filter(|(name, _)| !expected.contains_key(*name))
+        .collect();
+    let passing: Vec<_> = expected
+        .keys()
+        .filter(|name| !failed.contains_key(*name))
+        .collect();
+    assert!(
+        unexpected.is_empty() && passing.is_empty(),
+        "wasi-testsuite through kobako's preview1 imports must fail only what \
+         testsuite-expected.txt names; unexpected failures: {unexpected:#?}; now passing: \
+         {passing:?}"
+    );
+}