kobako 0.29.0 → 0.30.0

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

@@ -6,10 +6,10 @@
 //! 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.
+//! 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 args;
-mod beneath;
 mod errno;
 mod fd;
 mod memory;
@@ -21,441 +21,492 @@ mod sock;
 mod differential;
 #[cfg(test)]
 mod mount_view;
+#[cfg(test)]
+mod testsuite;
 
-use wasmtime::{Caller, Extern, Linker};
+use wasmtime::Linker;
+use wiggle::GuestPtr;
 
 use crate::descriptors::Descriptors;
 use crate::invocation::Invocation;
-use errno::{Answer, Failure};
+use errno::Answer;
 use memory::GuestMemory;
-use path::OpenFlags;
-
-const MODULE: &str = "wasi_snapshot_preview1";
-
-/// Run one call against the calling instance's memory and invocation,
-/// answering its `errno`, or the trap that ends the invocation.
-fn answer(
-    caller: &mut Caller<'_, Invocation>,
-    call: impl FnOnce(&mut GuestMemory, &mut Invocation) -> Answer,
-) -> wasmtime::Result<i32> {
-    let memory = caller
-        .get_export("memory")
-        .and_then(Extern::into_memory)
-        .ok_or_else(|| wasmtime::Error::msg("a preview1 call needs the guest's `memory` export"))?;
-    let (bytes, invocation) = memory.data_and_store_mut(caller);
-    let answer = call(&mut GuestMemory::new(bytes), invocation);
-    if let Some(trap) = invocation.abandonment() {
-        return Err(trap);
-    }
-    match answer {
-        Ok(()) => Ok(0),
-        Err(Failure::Errno(errno)) => Ok(errno as i32),
-        Err(Failure::Trap(trap)) => Err(trap),
+
+// 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 },
+        });
     }
 }
 
-fn table(invocation: &mut Invocation) -> &mut Descriptors {
-    invocation.wasi_mut().descriptors_mut()
+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);
-    shadow_fd(linker)?;
-    shadow_path(linker)?;
-    shadow_poll_and_sock(linker)?;
+    witx::glue::add_wasi_snapshot_preview1_to_linker(linker, |invocation: &mut Invocation| {
+        invocation
+    })?;
     linker.allow_shadowing(false);
     Ok(())
 }
 
-fn shadow_fd(linker: &mut Linker<Invocation>) -> wasmtime::Result<()> {
-    type C<'a> = Caller<'a, Invocation>;
-    linker.func_wrap(
-        MODULE,
-        "fd_advise",
-        |mut c: C, fd: i32, offset: i64, len: i64, advice: i32| {
-            answer(&mut c, |_, inv| {
-                fd::advise(
-                    table(inv),
-                    fd as u32,
-                    offset as u64,
-                    len as u64,
-                    advice as u32,
-                )
-            })
-        },
-    )?;
-    linker.func_wrap(
-        MODULE,
-        "fd_allocate",
-        |mut c: C, fd: i32, _: i64, _: i64| {
-            answer(&mut c, |_, inv| fd::allocate(table(inv), fd as u32))
-        },
-    )?;
-    linker.func_wrap(MODULE, "fd_close", |mut c: C, fd: i32| {
-        answer(&mut c, |_, inv| fd::close(table(inv), fd as u32))
-    })?;
-    // A Filesystem makes what was written durable in one step, so data
-    // and metadata sync alike.
-    for name in ["fd_datasync", "fd_sync"] {
-        linker.func_wrap(MODULE, name, |mut c: C, fd: i32| {
-            answer(&mut c, |_, inv| fd::sync(table(inv), fd as u32))
-        })?;
-    }
-    linker.func_wrap(MODULE, "fd_fdstat_get", |mut c: C, fd: i32, out: i32| {
-        answer(&mut c, |mem, inv| {
-            fd::fdstat_get(table(inv), mem, fd as u32, out as u32)
+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)
         })
-    })?;
-    linker.func_wrap(
-        MODULE,
-        "fd_fdstat_set_flags",
-        |mut c: C, fd: i32, flags: i32| {
-            answer(&mut c, |_, inv| {
-                fd::fdstat_set_flags(table(inv), fd as u32, flags as u32)
-            })
-        },
-    )?;
-    linker.func_wrap(
-        MODULE,
-        "fd_fdstat_set_rights",
-        |mut c: C, fd: i32, base: i64, inheriting: i64| {
-            answer(&mut c, |_, inv| {
-                fd::fdstat_set_rights(table(inv), fd as u32, base as u64, inheriting as u64)
-            })
-        },
-    )?;
-    linker.func_wrap(MODULE, "fd_filestat_get", |mut c: C, fd: i32, out: i32| {
-        answer(&mut c, |mem, inv| {
-            fd::filestat_get(table(inv), mem, fd as u32, out as u32)
+    }
+
+    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)
         })
-    })?;
-    linker.func_wrap(
-        MODULE,
-        "fd_filestat_set_size",
-        |mut c: C, fd: i32, size: i64| {
-            answer(&mut c, |_, inv| {
-                fd::filestat_set_size(table(inv), fd as u32, size as u64)
-            })
-        },
-    )?;
-    linker.func_wrap(
-        MODULE,
-        "fd_filestat_set_times",
-        |mut c: C, fd: i32, _: i64, _: i64, fst_flags: i32| {
-            answer(&mut c, |_, inv| {
-                fd::filestat_set_times(table(inv), fd as u32, fst_flags as u32)
-            })
-        },
-    )?;
-    linker.func_wrap(
-        MODULE,
-        "fd_pread",
-        |mut c: C, fd: i32, iovs: i32, iovs_len: i32, offset: i64, nread: i32| {
-            answer(&mut c, |mem, inv| {
-                let iovs = (iovs as u32, iovs_len as u32);
-                fd::pread(
-                    table(inv),
-                    mem,
-                    fd as u32,
-                    iovs,
-                    offset as u64,
-                    nread as u32,
-                )
-            })
-        },
-    )?;
-    linker.func_wrap(MODULE, "fd_prestat_get", |mut c: C, fd: i32, out: i32| {
-        answer(&mut c, |mem, inv| {
-            fd::prestat_get(table(inv), mem, fd as u32, out as u32)
+    }
+
+    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)
         })
-    })?;
-    linker.func_wrap(
-        MODULE,
-        "fd_prestat_dir_name",
-        |mut c: C, fd: i32, path: i32, path_len: i32| {
-            answer(&mut c, |mem, inv| {
-                fd::prestat_dir_name(table(inv), mem, fd as u32, path as u32, path_len as u32)
-            })
-        },
-    )?;
-    linker.func_wrap(
-        MODULE,
-        "fd_pwrite",
-        |mut c: C, fd: i32, ciovs: i32, ciovs_len: i32, offset: i64, nwritten: i32| {
-            answer(&mut c, |mem, inv| {
-                let ciovs = (ciovs as u32, ciovs_len as u32);
-                fd::pwrite(
-                    table(inv),
-                    mem,
-                    fd as u32,
-                    ciovs,
-                    offset as u64,
-                    nwritten as u32,
-                )
-            })
-        },
-    )?;
-    linker.func_wrap(
-        MODULE,
-        "fd_read",
-        |mut c: C, fd: i32, iovs: i32, iovs_len: i32, nread: i32| {
-            answer(&mut c, |mem, inv| {
-                let iovs = (iovs as u32, iovs_len as u32);
-                fd::read(table(inv), mem, fd as u32, iovs, nread as u32)
-            })
-        },
-    )?;
-    linker.func_wrap(
-        MODULE,
-        "fd_readdir",
-        |mut c: C, fd: i32, buf: i32, buf_len: i32, cookie: i64, bufused: i32| {
-            answer(&mut c, |mem, inv| {
-                let buf = (buf as u32, buf_len as u32);
-                fd::readdir(
-                    table(inv),
-                    mem,
-                    fd as u32,
-                    buf,
-                    cookie as u64,
-                    bufused as u32,
-                )
-            })
-        },
-    )?;
-    linker.func_wrap(MODULE, "fd_renumber", |mut c: C, from: i32, to: i32| {
-        answer(&mut c, |_, inv| {
-            fd::renumber(table(inv), from as u32, to as u32)
+    }
+
+    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())
         })
-    })?;
-    linker.func_wrap(
-        MODULE,
-        "fd_seek",
-        |mut c: C, fd: i32, offset: i64, whence: i32, out: i32| {
-            answer(&mut c, |mem, inv| {
-                fd::seek(
-                    table(inv),
-                    mem,
-                    fd as u32,
-                    offset,
-                    whence as u32,
-                    out as u32,
-                )
-            })
-        },
-    )?;
-    linker.func_wrap(MODULE, "fd_tell", |mut c: C, fd: i32, out: i32| {
-        answer(&mut c, |mem, inv| {
-            fd::tell(table(inv), mem, fd as u32, out as u32)
+    }
+
+    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)
         })
-    })?;
-    linker.func_wrap(
-        MODULE,
-        "fd_write",
-        |mut c: C, fd: i32, ciovs: i32, ciovs_len: i32, nwritten: i32| {
-            answer(&mut c, |mem, inv| {
-                let ciovs = (ciovs as u32, ciovs_len as u32);
-                fd::write(table(inv), mem, fd as u32, ciovs, nwritten as u32)
-            })
-        },
-    )?;
-    Ok(())
-}
+    }
 
-fn shadow_path(linker: &mut Linker<Invocation>) -> wasmtime::Result<()> {
-    type C<'a> = Caller<'a, Invocation>;
-    linker.func_wrap(
-        MODULE,
-        "path_create_directory",
-        |mut c: C, fd: i32, path: i32, len: i32| {
-            answer(&mut c, |mem, inv| {
-                path::create_directory(table(inv), mem, fd as u32, (path as u32, len as u32))
-            })
-        },
-    )?;
-    linker.func_wrap(
-        MODULE,
-        "path_filestat_get",
-        |mut c: C, fd: i32, flags: i32, path: i32, len: i32, out: i32| {
-            answer(&mut c, |mem, inv| {
-                let path = (path as u32, len as u32);
-                path::filestat_get(table(inv), mem, fd as u32, flags as u32, path, out as u32)
-            })
-        },
-    )?;
-    linker.func_wrap(
-        MODULE,
-        "path_filestat_set_times",
-        |mut c: C, fd: i32, flags: i32, path: i32, len: i32, _: i64, _: i64, fst_flags: i32| {
-            answer(&mut c, |mem, inv| {
-                let path = (path as u32, len as u32);
-                path::filestat_set_times(
-                    table(inv),
-                    mem,
-                    fd as u32,
-                    flags as u32,
-                    path,
-                    fst_flags as u32,
-                )
-            })
-        },
-    )?;
-    linker.func_wrap(
-        MODULE,
-        "path_link",
-        |mut c: C,
-         old_fd: i32,
-         old_flags: i32,
-         old_path: i32,
-         old_len: i32,
-         new_fd: i32,
-         new_path: i32,
-         new_len: i32| {
-            answer(&mut c, |mem, inv| {
-                path::link(
-                    table(inv),
-                    mem,
-                    old_fd as u32,
-                    old_flags as u32,
-                    (old_path as u32, old_len as u32),
-                    new_fd as u32,
-                    (new_path as u32, new_len as u32),
-                )
-            })
-        },
-    )?;
-    linker.func_wrap(
-        MODULE,
-        "path_open",
-        |mut c: C,
-         fd: i32,
-         dirflags: i32,
-         path: i32,
-         path_len: i32,
-         oflags: i32,
-         rights_base: i64,
-         rights_inheriting: i64,
-         fdflags: i32,
-         out: i32| {
-            let flags = OpenFlags {
-                dirflags: dirflags as u32,
-                oflags: oflags as u32,
-                rights_base: rights_base as u64,
-                rights_inheriting: rights_inheriting as u64,
-                fdflags: fdflags as u32,
-            };
-            answer(&mut c, |mem, inv| {
-                let path = (path as u32, path_len as u32);
-                path::open(table(inv), mem, fd as u32, path, &flags, out as u32)
-            })
-        },
-    )?;
-    linker.func_wrap(
-        MODULE,
-        "path_readlink",
-        |mut c: C, fd: i32, path: i32, len: i32, _: i32, _: i32, _: i32| {
-            answer(&mut c, |mem, inv| {
-                path::readlink(table(inv), mem, fd as u32, (path as u32, len as u32))
-            })
-        },
-    )?;
-    linker.func_wrap(
-        MODULE,
-        "path_remove_directory",
-        |mut c: C, fd: i32, path: i32, len: i32| {
-            answer(&mut c, |mem, inv| {
-                path::remove_directory(table(inv), mem, fd as u32, (path as u32, len as u32))
-            })
-        },
-    )?;
-    linker.func_wrap(
-        MODULE,
-        "path_rename",
-        |mut c: C, fd: i32, old: i32, old_len: i32, new_fd: i32, new: i32, new_len: i32| {
-            answer(&mut c, |mem, inv| {
-                path::rename(
-                    table(inv),
-                    mem,
-                    (fd as u32, (old as u32, old_len as u32)),
-                    (new_fd as u32, (new as u32, new_len as u32)),
-                )
-            })
-        },
-    )?;
-    linker.func_wrap(
-        MODULE,
-        "path_symlink",
-        |mut c: C, old: i32, old_len: i32, fd: i32, new: i32, new_len: i32| {
-            answer(&mut c, |mem, inv| {
-                path::symlink(
-                    table(inv),
-                    mem,
-                    (old as u32, old_len as u32),
-                    fd as u32,
-                    (new as u32, new_len as u32),
-                )
+    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)
             })
-        },
-    )?;
-    linker.func_wrap(
-        MODULE,
-        "path_unlink_file",
-        |mut c: C, fd: i32, path: i32, len: i32| {
-            answer(&mut c, |mem, inv| {
-                path::unlink_file(table(inv), mem, fd as u32, (path as u32, len as u32))
-            })
-        },
-    )?;
-    Ok(())
-}
+        })
+    }
 
-fn shadow_poll_and_sock(linker: &mut Linker<Invocation>) -> wasmtime::Result<()> {
-    type C<'a> = Caller<'a, Invocation>;
-    linker.func_wrap(
-        MODULE,
-        "poll_oneoff",
-        |mut c: C, subs: i32, events: i32, count: i32, nevents: i32| {
-            answer(&mut c, |mem, inv| {
-                poll::poll_oneoff(
-                    inv,
-                    mem,
-                    subs as u32,
-                    events as u32,
-                    count as u32,
-                    nevents as u32,
-                )
-            })
-        },
-    )?;
-    linker.func_wrap(
-        MODULE,
-        "sock_accept",
-        |mut c: C, fd: i32, flags: i32, _: i32| {
-            answer(&mut c, |_, inv| {
-                sock::accept(table(inv), fd as u32, flags as u32)
-            })
-        },
-    )?;
-    linker.func_wrap(
-        MODULE,
-        "sock_recv",
-        |mut c: C, fd: i32, _: i32, _: i32, ri_flags: i32, _: i32, _: i32| {
-            answer(&mut c, |_, inv| {
-                sock::recv(table(inv), fd as u32, ri_flags as u32)
+    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)
             })
-        },
-    )?;
-    linker.func_wrap(
-        MODULE,
-        "sock_send",
-        |mut c: C, fd: i32, _: i32, _: i32, _: i32, _: i32| {
-            answer(&mut c, |_, inv| sock::send(table(inv), fd as u32))
-        },
-    )?;
-    linker.func_wrap(MODULE, "sock_shutdown", |mut c: C, fd: i32, how: i32| {
-        answer(&mut c, |_, inv| {
-            sock::shutdown(table(inv), fd as u32, how as u32)
         })
-    })?;
-    Ok(())
+    }
+
+    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()))
+    }
 }