kobako 0.28.0 → 0.30.0

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:?}"
+    );
+}

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

@@ -0,0 +1,512 @@
+//! kobako's own answers to the 36 preview1 imports that read the
+//! descriptor table: `fd_*`, `path_*`, `sock_*`, and `poll_oneoff`.
+//!
+//! wasmtime-wasi keeps its table private, so a descriptor kobako places
+//! there would stay invisible to its calls. Answering every call that reads
+//! a descriptor keeps the guest on one table, `crate::descriptors`, where
+//! each Mount is a preopen. The other ten imports — arguments,
+//! environment, clocks, process, scheduling, and randomness — stay
+//! wasmtime-wasi's, so `witx/` declares only these 36. wiggle generates their
+//! glue as it generates wasmtime-wasi's, so a value outside what the witx
+//! defines traps there before a call starts.
+
+mod errno;
+mod fd;
+mod memory;
+mod path;
+mod poll;
+mod sock;
+
+#[cfg(test)]
+mod differential;
+#[cfg(test)]
+mod mount_view;
+#[cfg(test)]
+mod testsuite;
+
+use wasmtime::Linker;
+use wiggle::GuestPtr;
+
+use crate::descriptors::Descriptors;
+use crate::invocation::Invocation;
+use errno::Answer;
+use memory::GuestMemory;
+
+// wiggle gives each generated call one parameter per witx argument, and no
+// generated signature can be shrunk to fit the lint.
+#[allow(clippy::too_many_arguments)]
+mod witx {
+    wiggle::from_witx!({
+        witx: ["witx/wasi_snapshot_preview1.witx"],
+        tracing: false,
+        errors: { errno => trappable Error },
+    });
+
+    pub(super) mod glue {
+        wiggle::wasmtime_integration!({
+            witx: ["witx/wasi_snapshot_preview1.witx"],
+            target: super,
+            tracing: false,
+            errors: { errno => trappable Error },
+        });
+    }
+}
+
+use witx::{types, wasi_snapshot_preview1};
+
+impl wiggle::GuestErrorType for types::Errno {
+    fn success() -> Self {
+        Self::Success
+    }
+}
+
+/// Define kobako's answers over wasmtime-wasi's for the same names.
+pub(crate) fn shadow(linker: &mut Linker<Invocation>) -> wasmtime::Result<()> {
+    linker.allow_shadowing(true);
+    witx::glue::add_wasi_snapshot_preview1_to_linker(linker, |invocation: &mut Invocation| {
+        invocation
+    })?;
+    linker.allow_shadowing(false);
+    Ok(())
+}
+
+fn table(invocation: &mut Invocation) -> &mut Descriptors {
+    invocation.wasi_mut().descriptors_mut()
+}
+
+impl Invocation {
+    /// Run one call against the calling instance's memory, answering what it
+    /// answers unless its host has given the invocation up by then.
+    fn answer<T>(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        call: impl FnOnce(&mut GuestMemory<'_, '_>, &mut Invocation) -> Answer<T>,
+    ) -> Answer<T> {
+        let fuel = self.hostcall_fuel();
+        let answer = call(&mut GuestMemory::new(memory, fuel), self);
+        match self.abandonment() {
+            Some(trap) => Err(types::Error::trap(trap)),
+            None => answer,
+        }
+    }
+}
+
+impl wasi_snapshot_preview1::WasiSnapshotPreview1 for Invocation {
+    fn set_hostcall_fuel(&mut self, fuel: usize) {
+        Invocation::set_hostcall_fuel(self, fuel);
+    }
+
+    fn fd_advise(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        offset: types::Filesize,
+        len: types::Filesize,
+        _advice: types::Advice,
+    ) -> Answer {
+        self.answer(memory, |_, inv| {
+            fd::advise(table(inv), fd.into(), offset, len)
+        })
+    }
+
+    fn fd_allocate(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        offset: types::Filesize,
+        len: types::Filesize,
+    ) -> Answer {
+        self.answer(memory, |_, inv| {
+            fd::allocate(table(inv), fd.into(), offset, len)
+        })
+    }
+
+    fn fd_close(&mut self, memory: &mut wiggle::GuestMemory<'_>, fd: types::Fd) -> Answer {
+        self.answer(memory, |_, inv| fd::close(table(inv), fd.into()))
+    }
+
+    fn fd_datasync(&mut self, memory: &mut wiggle::GuestMemory<'_>, fd: types::Fd) -> Answer {
+        self.answer(memory, |_, inv| fd::sync(table(inv), fd.into(), true))
+    }
+
+    fn fd_fdstat_get(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Answer<types::Fdstat> {
+        self.answer(memory, |_, inv| fd::fdstat_get(table(inv), fd.into()))
+    }
+
+    fn fd_fdstat_set_flags(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        flags: types::Fdflags,
+    ) -> Answer {
+        self.answer(memory, |_, inv| {
+            fd::fdstat_set_flags(table(inv), fd.into(), flags)
+        })
+    }
+
+    fn fd_fdstat_set_rights(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        _fs_rights_base: types::Rights,
+        _fs_rights_inheriting: types::Rights,
+    ) -> Answer {
+        self.answer(memory, |_, inv| {
+            fd::fdstat_set_rights(table(inv), fd.into())
+        })
+    }
+
+    fn fd_filestat_get(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Answer<types::Filestat> {
+        self.answer(memory, |_, inv| fd::filestat_get(table(inv), fd.into()))
+    }
+
+    fn fd_filestat_set_size(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        size: types::Filesize,
+    ) -> Answer {
+        self.answer(memory, |_, inv| {
+            fd::filestat_set_size(table(inv), fd.into(), size)
+        })
+    }
+
+    fn fd_filestat_set_times(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        atim: types::Timestamp,
+        mtim: types::Timestamp,
+        fst_flags: types::Fstflags,
+    ) -> Answer {
+        self.answer(memory, |_, inv| {
+            fd::utimensat(atim, mtim, fst_flags, |times| {
+                fd::filestat_set_times(table(inv), fd.into(), times)
+            })
+        })
+    }
+
+    fn fd_pread(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        iovs: types::IovecArray,
+        offset: types::Filesize,
+    ) -> Answer<types::Size> {
+        self.answer(memory, |mem, inv| {
+            fd::pread(table(inv), mem, fd.into(), iovs, offset)
+        })
+    }
+
+    fn fd_prestat_get(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Answer<types::Prestat> {
+        self.answer(memory, |_, inv| fd::prestat_get(table(inv), fd.into()))
+    }
+
+    fn fd_prestat_dir_name(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        path: GuestPtr<u8>,
+        path_max_len: types::Size,
+    ) -> Answer {
+        self.answer(memory, |mem, inv| {
+            fd::prestat_dir_name(table(inv), mem, fd.into(), path, path_max_len)
+        })
+    }
+
+    fn fd_pwrite(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        ciovs: types::CiovecArray,
+        offset: types::Filesize,
+    ) -> Answer<types::Size> {
+        self.answer(memory, |mem, inv| {
+            fd::pwrite(table(inv), mem, fd.into(), ciovs, offset)
+        })
+    }
+
+    fn fd_read(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        iovs: types::IovecArray,
+    ) -> Answer<types::Size> {
+        self.answer(memory, |mem, inv| {
+            fd::read(table(inv), mem, fd.into(), iovs)
+        })
+    }
+
+    fn fd_readdir(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        buf: GuestPtr<u8>,
+        buf_len: types::Size,
+        cookie: types::Dircookie,
+    ) -> Answer<types::Size> {
+        self.answer(memory, |mem, inv| {
+            fd::readdir(table(inv), mem, fd.into(), buf, buf_len, cookie)
+        })
+    }
+
+    fn fd_renumber(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        from: types::Fd,
+        to: types::Fd,
+    ) -> Answer {
+        self.answer(memory, |_, inv| {
+            fd::renumber(table(inv), from.into(), to.into())
+        })
+    }
+
+    fn fd_seek(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        offset: types::Filedelta,
+        whence: types::Whence,
+    ) -> Answer<types::Filesize> {
+        self.answer(memory, |_, inv| {
+            fd::seek(table(inv), fd.into(), offset, whence)
+        })
+    }
+
+    fn fd_sync(&mut self, memory: &mut wiggle::GuestMemory<'_>, fd: types::Fd) -> Answer {
+        self.answer(memory, |_, inv| fd::sync(table(inv), fd.into(), false))
+    }
+
+    fn fd_tell(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Answer<types::Filesize> {
+        self.answer(memory, |_, inv| fd::tell(table(inv), fd.into()))
+    }
+
+    fn fd_write(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        ciovs: types::CiovecArray,
+    ) -> Answer<types::Size> {
+        self.answer(memory, |mem, inv| {
+            fd::write(table(inv), mem, fd.into(), ciovs)
+        })
+    }
+
+    fn path_create_directory(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        path: GuestPtr<str>,
+    ) -> Answer {
+        self.answer(memory, |mem, inv| {
+            path::create_directory(table(inv), mem, fd.into(), path)
+        })
+    }
+
+    fn path_filestat_get(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        flags: types::Lookupflags,
+        path: GuestPtr<str>,
+    ) -> Answer<types::Filestat> {
+        self.answer(memory, |mem, inv| {
+            path::filestat_get(table(inv), mem, fd.into(), flags, path)
+        })
+    }
+
+    fn path_filestat_set_times(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        flags: types::Lookupflags,
+        path: GuestPtr<str>,
+        atim: types::Timestamp,
+        mtim: types::Timestamp,
+        fst_flags: types::Fstflags,
+    ) -> Answer {
+        self.answer(memory, |mem, inv| {
+            fd::utimensat(atim, mtim, fst_flags, |times| {
+                path::filestat_set_times(table(inv), mem, fd.into(), flags, path, times)
+            })
+        })
+    }
+
+    fn path_link(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        old_fd: types::Fd,
+        old_flags: types::Lookupflags,
+        old_path: GuestPtr<str>,
+        new_fd: types::Fd,
+        new_path: GuestPtr<str>,
+    ) -> Answer {
+        self.answer(memory, |mem, inv| {
+            path::link(
+                table(inv),
+                mem,
+                (old_fd.into(), old_path),
+                (new_fd.into(), new_path),
+                old_flags,
+            )
+        })
+    }
+
+    fn path_open(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        dirflags: types::Lookupflags,
+        path: GuestPtr<str>,
+        oflags: types::Oflags,
+        fs_rights_base: types::Rights,
+        _fs_rights_inheriting: types::Rights,
+        fdflags: types::Fdflags,
+    ) -> Answer<types::Fd> {
+        self.answer(memory, |mem, inv| {
+            path::open(
+                table(inv),
+                mem,
+                fd.into(),
+                path,
+                &path::PathOpen {
+                    dirflags,
+                    oflags,
+                    rights_base: fs_rights_base,
+                    fdflags,
+                },
+            )
+        })
+    }
+
+    fn path_readlink(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        path: GuestPtr<str>,
+        buf: GuestPtr<u8>,
+        buf_len: types::Size,
+    ) -> Answer<types::Size> {
+        self.answer(memory, |mem, inv| {
+            path::readlink(table(inv), mem, fd.into(), path, buf, buf_len)
+        })
+    }
+
+    fn path_remove_directory(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        path: GuestPtr<str>,
+    ) -> Answer {
+        self.answer(memory, |mem, inv| {
+            path::remove_directory(table(inv), mem, fd.into(), path)
+        })
+    }
+
+    fn path_rename(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        old_fd: types::Fd,
+        old_path: GuestPtr<str>,
+        new_fd: types::Fd,
+        new_path: GuestPtr<str>,
+    ) -> Answer {
+        self.answer(memory, |mem, inv| {
+            path::rename(
+                table(inv),
+                mem,
+                (old_fd.into(), old_path),
+                (new_fd.into(), new_path),
+            )
+        })
+    }
+
+    fn path_symlink(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        old_path: GuestPtr<str>,
+        fd: types::Fd,
+        new_path: GuestPtr<str>,
+    ) -> Answer {
+        self.answer(memory, |mem, inv| {
+            path::symlink(table(inv), mem, old_path, fd.into(), new_path)
+        })
+    }
+
+    fn path_unlink_file(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        path: GuestPtr<str>,
+    ) -> Answer {
+        self.answer(memory, |mem, inv| {
+            path::unlink_file(table(inv), mem, fd.into(), path)
+        })
+    }
+
+    fn poll_oneoff(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        subs: GuestPtr<types::Subscription>,
+        events: GuestPtr<types::Event>,
+        count: types::Size,
+    ) -> Answer<types::Size> {
+        self.answer(memory, |mem, inv| {
+            poll::poll_oneoff(inv, mem, subs, events, count)
+        })
+    }
+
+    fn sock_accept(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        _flags: types::Fdflags,
+    ) -> Answer<types::Fd> {
+        self.answer(memory, |_, inv| sock::socket(table(inv), fd.into()))
+    }
+
+    fn sock_recv(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        _ri_data: types::IovecArray,
+        _ri_flags: types::Riflags,
+    ) -> Answer<(types::Size, types::Roflags)> {
+        self.answer(memory, |_, inv| sock::socket(table(inv), fd.into()))
+    }
+
+    fn sock_send(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        _si_data: types::CiovecArray,
+        _si_flags: types::Siflags,
+    ) -> Answer<types::Size> {
+        self.answer(memory, |_, inv| sock::socket(table(inv), fd.into()))
+    }
+
+    fn sock_shutdown(
+        &mut self,
+        memory: &mut wiggle::GuestMemory<'_>,
+        fd: types::Fd,
+        _how: types::Sdflags,
+    ) -> Answer {
+        self.answer(memory, |_, inv| sock::socket(table(inv), fd.into()))
+    }
+}