T0b1/wasmtime
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Move *nix specific implementation to separate module

Browse Source
This commit is contained in:
Jakub Konka
2019-05-19 14:52:41 +02:00
committed by Dan Gohman
parent 3372e47e5a
commit 7605584691
21 changed files with 3184 additions and 2690 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -1,3 +1,4 @@
/target
Cargo.lock
**/*.rs.bk
.DS_Store

8
Cargo.toml
View File

@@ -14,8 +14,14 @@ wasi-common-cbindgen = { path = "wasi-common-cbindgen" }
cast = "0.2"
failure = "0.1"
libc = "0.2"
nix = "0.13"
rand = "0.6"
cfg-if = "0.1.9"
[target.'cfg(unix)'.dependencies]
nix = "0.13"
[target.'cfg(windows)'.dependencies]
winapi = { version = "0.3", features=["std", "handleapi", "processthreadsapi", "winbase", "ws2def", "fileapi"] }
[lib]
name = "wasi_common"

116
src/ctx.rs
View File

@@ -1,17 +1,17 @@
use crate::fdentry::FdEntry;
use crate::host;
use crate::sys::dev_null;
use crate::sys::fdmap::{FdEntry, FdMap};
use failure::{bail, format_err, Error};
use nix::unistd::dup;
use std::collections::HashMap;
use std::ffi::{CStr, CString};
use std::fs::File;
use std::io::{stderr, stdin, stdout};
use std::os::unix::prelude::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
use std::path::{Path, PathBuf};
pub struct WasiCtxBuilder {
fds: HashMap<host::__wasi_fd_t, FdEntry>,
fds: FdMap,
preopens: HashMap<PathBuf, File>,
args: Vec<CString>,
env: HashMap<CString, CString>,
@@ -20,16 +20,18 @@ pub struct WasiCtxBuilder {
impl WasiCtxBuilder {
/// Builder for a new `WasiCtx`.
pub fn new() -> Self {
let null = dev_null();
WasiCtxBuilder {
fds: HashMap::new(),
let mut builder = Self {
fds: FdMap::new(),
preopens: HashMap::new(),
args: vec![],
env: HashMap::new(),
}
.fd_dup(0, &null)
.fd_dup(1, &null)
.fd_dup(2, &null)
};
builder.fds.insert_fd_entry_at(0, FdEntry::from_file(dev_null()));
builder.fds.insert_fd_entry_at(1, FdEntry::from_file(dev_null()));
builder.fds.insert_fd_entry_at(2, FdEntry::from_file(dev_null()));
builder
}
pub fn args(mut self, args: &[&str]) -> Self {
@@ -59,10 +61,11 @@ impl WasiCtxBuilder {
self
}
pub fn inherit_stdio(self) -> Self {
self.fd_dup(0, &stdin())
.fd_dup(1, &stdout())
.fd_dup(2, &stderr())
pub fn inherit_stdio(mut self) -> Self {
self.fds.insert_fd_entry_at(0, FdEntry::duplicate(&stdin()));
self.fds.insert_fd_entry_at(1, FdEntry::duplicate(&stdout()));
self.fds.insert_fd_entry_at(2, FdEntry::duplicate(&stderr()));
self
}
pub fn inherit_env(mut self) -> Self {
@@ -97,66 +100,21 @@ impl WasiCtxBuilder {
self
}
/// Add an existing file-like object as a file descriptor in the context.
///
/// When the `WasiCtx` is dropped, all of its associated file descriptors are `close`d. If you
/// do not want this to close the existing object, use `WasiCtxBuilder::fd_dup()`.
pub fn fd<F: IntoRawFd>(self, wasm_fd: host::__wasi_fd_t, fd: F) -> Self {
// safe because we're getting a valid RawFd from the F directly
unsafe { self.raw_fd(wasm_fd, fd.into_raw_fd()) }
}
/// Add an existing file-like object as a duplicate file descriptor in the context.
///
/// The underlying file descriptor of this object will be duplicated before being added to the
/// context, so it will not be closed when the `WasiCtx` is dropped.
///
/// TODO: handle `dup` errors
pub fn fd_dup<F: AsRawFd>(self, wasm_fd: host::__wasi_fd_t, fd: &F) -> Self {
// safe because we're getting a valid RawFd from the F directly
unsafe { self.raw_fd(wasm_fd, dup(fd.as_raw_fd()).unwrap()) }
}
/// Add an existing file descriptor to the context.
///
/// When the `WasiCtx` is dropped, this file descriptor will be `close`d. If you do not want to
/// close the existing descriptor, use `WasiCtxBuilder::raw_fd_dup()`.
pub unsafe fn raw_fd(mut self, wasm_fd: host::__wasi_fd_t, fd: RawFd) -> Self {
self.fds.insert(wasm_fd, FdEntry::from_raw_fd(fd));
self
}
/// Add a duplicate of an existing file descriptor to the context.
///
/// The file descriptor will be duplicated before being added to the context, so it will not be
/// closed when the `WasiCtx` is dropped.
///
/// TODO: handle `dup` errors
pub unsafe fn raw_fd_dup(self, wasm_fd: host::__wasi_fd_t, fd: RawFd) -> Self {
self.raw_fd(wasm_fd, dup(fd).unwrap())
}
pub fn preopened_dir<P: AsRef<Path>>(mut self, dir: File, guest_path: P) -> Self {
self.preopens.insert(guest_path.as_ref().to_owned(), dir);
self
}
pub fn build(mut self) -> Result<WasiCtx, Error> {
// startup code starts looking at fd 3 for preopens
let mut preopen_fd = 3;
for (guest_path, dir) in self.preopens {
if !dir.metadata()?.is_dir() {
bail!("preopened file is not a directory");
}
while self.fds.contains_key(&preopen_fd) {
preopen_fd = preopen_fd
.checked_add(1)
.ok_or(format_err!("not enough file handles"))?;
}
let mut fe = FdEntry::from_file(dir);
fe.preopen_path = Some(guest_path);
self.fds.insert(preopen_fd, fe);
preopen_fd += 1;
self.fds
.insert_fd_entry(fe)
.map_err(|_| format_err!("not enough file handles"))?;
}
let env = self
@@ -181,7 +139,7 @@ impl WasiCtxBuilder {
#[derive(Debug)]
pub struct WasiCtx {
pub fds: HashMap<host::__wasi_fd_t, FdEntry>,
pub fds: FdMap,
pub args: Vec<CString>,
pub env: Vec<CString>,
}
@@ -194,7 +152,7 @@ impl WasiCtx {
/// - Environment variables are inherited from the host process.
///
/// To override these behaviors, use `WasiCtxBuilder`.
pub fn new(args: &[&str]) -> WasiCtx {
pub fn new(args: &[&str]) -> Self {
WasiCtxBuilder::new()
.args(args)
.inherit_stdio()
@@ -209,37 +167,13 @@ impl WasiCtx {
rights_base: host::__wasi_rights_t,
rights_inheriting: host::__wasi_rights_t,
) -> Result<&FdEntry, host::__wasi_errno_t> {
if let Some(fe) = self.fds.get(&fd) {
// validate rights
if !fe.rights_base & rights_base != 0 || !fe.rights_inheriting & rights_inheriting != 0
{
Err(host::__WASI_ENOTCAPABLE)
} else {
Ok(fe)
}
} else {
Err(host::__WASI_EBADF)
}
self.fds.get_fd_entry(fd, rights_base, rights_inheriting)
}
pub fn insert_fd_entry(
&mut self,
fe: FdEntry,
) -> Result<host::__wasi_fd_t, host::__wasi_errno_t> {
// never insert where stdio handles usually are
let mut fd = 3;
while self.fds.contains_key(&fd) {
if let Some(next_fd) = fd.checked_add(1) {
fd = next_fd;
} else {
return Err(host::__WASI_EMFILE);
}
}
self.fds.insert(fd, fe);
Ok(fd)
self.fds.insert_fd_entry(fe)
}
}
fn dev_null() -> File {
File::open("/dev/null").expect("failed to open /dev/null")
}

236
src/host.rs
View File

@@ -4,7 +4,6 @@
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
pub type void = ::std::os::raw::c_void;
pub type __wasi_advice_t = u8;
@@ -474,241 +473,6 @@ pub struct __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_fd_
pub fd: __wasi_fd_t,
}
pub fn errno_from_nix(errno: nix::errno::Errno) -> __wasi_errno_t {
match errno {
nix::errno::Errno::EPERM => __WASI_EPERM,
nix::errno::Errno::ENOENT => __WASI_ENOENT,
nix::errno::Errno::ESRCH => __WASI_ESRCH,
nix::errno::Errno::EINTR => __WASI_EINTR,
nix::errno::Errno::EIO => __WASI_EIO,
nix::errno::Errno::ENXIO => __WASI_ENXIO,
nix::errno::Errno::E2BIG => __WASI_E2BIG,
nix::errno::Errno::ENOEXEC => __WASI_ENOEXEC,
nix::errno::Errno::EBADF => __WASI_EBADF,
nix::errno::Errno::ECHILD => __WASI_ECHILD,
nix::errno::Errno::EAGAIN => __WASI_EAGAIN,
nix::errno::Errno::ENOMEM => __WASI_ENOMEM,
nix::errno::Errno::EACCES => __WASI_EACCES,
nix::errno::Errno::EFAULT => __WASI_EFAULT,
nix::errno::Errno::EBUSY => __WASI_EBUSY,
nix::errno::Errno::EEXIST => __WASI_EEXIST,
nix::errno::Errno::EXDEV => __WASI_EXDEV,
nix::errno::Errno::ENODEV => __WASI_ENODEV,
nix::errno::Errno::ENOTDIR => __WASI_ENOTDIR,
nix::errno::Errno::EISDIR => __WASI_EISDIR,
nix::errno::Errno::EINVAL => __WASI_EINVAL,
nix::errno::Errno::ENFILE => __WASI_ENFILE,
nix::errno::Errno::EMFILE => __WASI_EMFILE,
nix::errno::Errno::ENOTTY => __WASI_ENOTTY,
nix::errno::Errno::ETXTBSY => __WASI_ETXTBSY,
nix::errno::Errno::EFBIG => __WASI_EFBIG,
nix::errno::Errno::ENOSPC => __WASI_ENOSPC,
nix::errno::Errno::ESPIPE => __WASI_ESPIPE,
nix::errno::Errno::EROFS => __WASI_EROFS,
nix::errno::Errno::EMLINK => __WASI_EMLINK,
nix::errno::Errno::EPIPE => __WASI_EPIPE,
nix::errno::Errno::EDOM => __WASI_EDOM,
nix::errno::Errno::ERANGE => __WASI_ERANGE,
nix::errno::Errno::EDEADLK => __WASI_EDEADLK,
nix::errno::Errno::ENAMETOOLONG => __WASI_ENAMETOOLONG,
nix::errno::Errno::ENOLCK => __WASI_ENOLCK,
nix::errno::Errno::ENOSYS => __WASI_ENOSYS,
nix::errno::Errno::ENOTEMPTY => __WASI_ENOTEMPTY,
nix::errno::Errno::ELOOP => __WASI_ELOOP,
nix::errno::Errno::ENOMSG => __WASI_ENOMSG,
nix::errno::Errno::EIDRM => __WASI_EIDRM,
nix::errno::Errno::ENOLINK => __WASI_ENOLINK,
nix::errno::Errno::EPROTO => __WASI_EPROTO,
nix::errno::Errno::EMULTIHOP => __WASI_EMULTIHOP,
nix::errno::Errno::EBADMSG => __WASI_EBADMSG,
nix::errno::Errno::EOVERFLOW => __WASI_EOVERFLOW,
nix::errno::Errno::EILSEQ => __WASI_EILSEQ,
nix::errno::Errno::ENOTSOCK => __WASI_ENOTSOCK,
nix::errno::Errno::EDESTADDRREQ => __WASI_EDESTADDRREQ,
nix::errno::Errno::EMSGSIZE => __WASI_EMSGSIZE,
nix::errno::Errno::EPROTOTYPE => __WASI_EPROTOTYPE,
nix::errno::Errno::ENOPROTOOPT => __WASI_ENOPROTOOPT,
nix::errno::Errno::EPROTONOSUPPORT => __WASI_EPROTONOSUPPORT,
nix::errno::Errno::EAFNOSUPPORT => __WASI_EAFNOSUPPORT,
nix::errno::Errno::EADDRINUSE => __WASI_EADDRINUSE,
nix::errno::Errno::EADDRNOTAVAIL => __WASI_EADDRNOTAVAIL,
nix::errno::Errno::ENETDOWN => __WASI_ENETDOWN,
nix::errno::Errno::ENETUNREACH => __WASI_ENETUNREACH,
nix::errno::Errno::ENETRESET => __WASI_ENETRESET,
nix::errno::Errno::ECONNABORTED => __WASI_ECONNABORTED,
nix::errno::Errno::ECONNRESET => __WASI_ECONNRESET,
nix::errno::Errno::ENOBUFS => __WASI_ENOBUFS,
nix::errno::Errno::EISCONN => __WASI_EISCONN,
nix::errno::Errno::ENOTCONN => __WASI_ENOTCONN,
nix::errno::Errno::ETIMEDOUT => __WASI_ETIMEDOUT,
nix::errno::Errno::ECONNREFUSED => __WASI_ECONNREFUSED,
nix::errno::Errno::EHOSTUNREACH => __WASI_EHOSTUNREACH,
nix::errno::Errno::EALREADY => __WASI_EALREADY,
nix::errno::Errno::EINPROGRESS => __WASI_EINPROGRESS,
nix::errno::Errno::ESTALE => __WASI_ESTALE,
nix::errno::Errno::EDQUOT => __WASI_EDQUOT,
nix::errno::Errno::ECANCELED => __WASI_ECANCELED,
nix::errno::Errno::EOWNERDEAD => __WASI_EOWNERDEAD,
nix::errno::Errno::ENOTRECOVERABLE => __WASI_ENOTRECOVERABLE,
_ => __WASI_ENOSYS,
}
}
pub unsafe fn ciovec_to_nix<'a>(ciovec: &'a __wasi_ciovec_t) -> nix::sys::uio::IoVec<&'a [u8]> {
let slice = std::slice::from_raw_parts(ciovec.buf as *const u8, ciovec.buf_len);
nix::sys::uio::IoVec::from_slice(slice)
}
pub unsafe fn ciovec_to_nix_mut<'a>(
ciovec: &'a mut __wasi_ciovec_t,
) -> nix::sys::uio::IoVec<&'a mut [u8]> {
let slice = std::slice::from_raw_parts_mut(ciovec.buf as *mut u8, ciovec.buf_len);
nix::sys::uio::IoVec::from_mut_slice(slice)
}
pub unsafe fn iovec_to_nix<'a>(iovec: &'a __wasi_iovec_t) -> nix::sys::uio::IoVec<&'a [u8]> {
let slice = std::slice::from_raw_parts(iovec.buf as *const u8, iovec.buf_len);
nix::sys::uio::IoVec::from_slice(slice)
}
pub unsafe fn iovec_to_nix_mut<'a>(
iovec: &'a mut __wasi_iovec_t,
) -> nix::sys::uio::IoVec<&'a mut [u8]> {
let slice = std::slice::from_raw_parts_mut(iovec.buf as *mut u8, iovec.buf_len);
nix::sys::uio::IoVec::from_mut_slice(slice)
}
#[cfg(target_os = "linux")]
pub const O_RSYNC: nix::fcntl::OFlag = nix::fcntl::OFlag::O_RSYNC;
#[cfg(not(target_os = "linux"))]
pub const O_RSYNC: nix::fcntl::OFlag = nix::fcntl::OFlag::O_SYNC;
pub fn nix_from_fdflags(fdflags: __wasi_fdflags_t) -> nix::fcntl::OFlag {
use nix::fcntl::OFlag;
let mut nix_flags = OFlag::empty();
if fdflags & __WASI_FDFLAG_APPEND != 0 {
nix_flags.insert(OFlag::O_APPEND);
}
if fdflags & __WASI_FDFLAG_DSYNC != 0 {
nix_flags.insert(OFlag::O_DSYNC);
}
if fdflags & __WASI_FDFLAG_NONBLOCK != 0 {
nix_flags.insert(OFlag::O_NONBLOCK);
}
if fdflags & __WASI_FDFLAG_RSYNC != 0 {
nix_flags.insert(O_RSYNC);
}
if fdflags & __WASI_FDFLAG_SYNC != 0 {
nix_flags.insert(OFlag::O_SYNC);
}
nix_flags
}
pub fn fdflags_from_nix(oflags: nix::fcntl::OFlag) -> __wasi_fdflags_t {
use nix::fcntl::OFlag;
let mut fdflags = 0;
if oflags.contains(OFlag::O_APPEND) {
fdflags |= __WASI_FDFLAG_APPEND;
}
if oflags.contains(OFlag::O_DSYNC) {
fdflags |= __WASI_FDFLAG_DSYNC;
}
if oflags.contains(OFlag::O_NONBLOCK) {
fdflags |= __WASI_FDFLAG_NONBLOCK;
}
if oflags.contains(O_RSYNC) {
fdflags |= __WASI_FDFLAG_RSYNC;
}
if oflags.contains(OFlag::O_SYNC) {
fdflags |= __WASI_FDFLAG_SYNC;
}
fdflags
}
pub fn nix_from_oflags(oflags: __wasi_oflags_t) -> nix::fcntl::OFlag {
use nix::fcntl::OFlag;
let mut nix_flags = OFlag::empty();
if oflags & __WASI_O_CREAT != 0 {
nix_flags.insert(OFlag::O_CREAT);
}
if oflags & __WASI_O_DIRECTORY != 0 {
nix_flags.insert(OFlag::O_DIRECTORY);
}
if oflags & __WASI_O_EXCL != 0 {
nix_flags.insert(OFlag::O_EXCL);
}
if oflags & __WASI_O_TRUNC != 0 {
nix_flags.insert(OFlag::O_TRUNC);
}
nix_flags
}
pub fn filetype_from_nix(sflags: nix::sys::stat::SFlag) -> __wasi_filetype_t {
use nix::sys::stat::SFlag;
if sflags.contains(SFlag::S_IFCHR) {
__WASI_FILETYPE_CHARACTER_DEVICE
} else if sflags.contains(SFlag::S_IFBLK) {
__WASI_FILETYPE_BLOCK_DEVICE
} else if sflags.contains(SFlag::S_IFIFO) | sflags.contains(SFlag::S_IFSOCK) {
__WASI_FILETYPE_SOCKET_STREAM
} else if sflags.contains(SFlag::S_IFDIR) {
__WASI_FILETYPE_DIRECTORY
} else if sflags.contains(SFlag::S_IFREG) {
__WASI_FILETYPE_REGULAR_FILE
} else if sflags.contains(SFlag::S_IFLNK) {
__WASI_FILETYPE_SYMBOLIC_LINK
} else {
__WASI_FILETYPE_UNKNOWN
}
}
pub fn nix_from_filetype(sflags: __wasi_filetype_t) -> nix::sys::stat::SFlag {
use nix::sys::stat::SFlag;
let mut nix_sflags = SFlag::empty();
if sflags & __WASI_FILETYPE_CHARACTER_DEVICE != 0 {
nix_sflags.insert(SFlag::S_IFCHR);
}
if sflags & __WASI_FILETYPE_BLOCK_DEVICE != 0 {
nix_sflags.insert(SFlag::S_IFBLK);
}
if sflags & __WASI_FILETYPE_SOCKET_STREAM != 0 {
nix_sflags.insert(SFlag::S_IFIFO);
nix_sflags.insert(SFlag::S_IFSOCK);
}
if sflags & __WASI_FILETYPE_DIRECTORY != 0 {
nix_sflags.insert(SFlag::S_IFDIR);
}
if sflags & __WASI_FILETYPE_REGULAR_FILE != 0 {
nix_sflags.insert(SFlag::S_IFREG);
}
if sflags & __WASI_FILETYPE_SYMBOLIC_LINK != 0 {
nix_sflags.insert(SFlag::S_IFLNK);
}
nix_sflags
}
pub fn filestat_from_nix(filestat: nix::sys::stat::FileStat) -> __wasi_filestat_t {
use std::convert::TryFrom;
let filetype = nix::sys::stat::SFlag::from_bits_truncate(filestat.st_mode);
let dev = __wasi_device_t::try_from(filestat.st_dev)
.expect("FileStat::st_dev is trivially convertible to __wasi_device_t");
let ino = __wasi_inode_t::try_from(filestat.st_ino)
.expect("FileStat::st_ino is trivially convertible to __wasi_inode_t");
__wasi_filestat_t {
st_dev: dev,
st_ino: ino,
st_nlink: filestat.st_nlink as __wasi_linkcount_t,
st_size: filestat.st_size as __wasi_filesize_t,
st_atim: filestat.st_atime as __wasi_timestamp_t,
st_ctim: filestat.st_ctime as __wasi_timestamp_t,
st_mtim: filestat.st_mtime as __wasi_timestamp_t,
st_filetype: filetype_from_nix(filetype),
}
}
#[cfg(test)]
mod tests {
use super::*;

1132
src/hostcalls/fs.rs
View File

File diff suppressed because it is too large Load Diff

299
src/hostcalls/misc.rs
View File

@@ -1,16 +1,12 @@
#![allow(non_camel_case_types)]
#![allow(unused_unsafe)]
use crate::ctx::WasiCtx;
use crate::memory::*;
use crate::{host, wasm32};
use crate::wasm32;
use crate::sys::hostcalls as hostcalls_impl;
use cast::From as _0;
use nix::convert_ioctl_res;
use nix::libc::{self, c_int};
use std::cmp;
use std::time::SystemTime;
use wasi_common_cbindgen::wasi_common_cbindgen;
#[wasi_common_cbindgen]
@@ -77,75 +73,17 @@ pub fn clock_res_get(
clock_id: wasm32::__wasi_clockid_t,
resolution_ptr: wasm32::uintptr_t,
) -> wasm32::__wasi_errno_t {
// convert the supported clocks to the libc types, or return EINVAL
let clock_id = match dec_clockid(clock_id) {
host::__WASI_CLOCK_REALTIME => libc::CLOCK_REALTIME,
host::__WASI_CLOCK_MONOTONIC => libc::CLOCK_MONOTONIC,
host::__WASI_CLOCK_PROCESS_CPUTIME_ID => libc::CLOCK_PROCESS_CPUTIME_ID,
host::__WASI_CLOCK_THREAD_CPUTIME_ID => libc::CLOCK_THREAD_CPUTIME_ID,
_ => return wasm32::__WASI_EINVAL,
};
// no `nix` wrapper for clock_getres, so we do it ourselves
let mut timespec = unsafe { std::mem::uninitialized::<libc::timespec>() };
let res = unsafe { libc::clock_getres(clock_id, &mut timespec as *mut libc::timespec) };
if res != 0 {
return wasm32::errno_from_nix(nix::errno::Errno::last());
}
// convert to nanoseconds, returning EOVERFLOW in case of overflow; this is freelancing a bit
// from the spec but seems like it'll be an unusual situation to hit
(timespec.tv_sec as host::__wasi_timestamp_t)
.checked_mul(1_000_000_000)
.and_then(|sec_ns| sec_ns.checked_add(timespec.tv_nsec as host::__wasi_timestamp_t))
.map_or(wasm32::__WASI_EOVERFLOW, |resolution| {
// a supported clock can never return zero; this case will probably never get hit, but
// make sure we follow the spec
if resolution == 0 {
wasm32::__WASI_EINVAL
} else {
enc_timestamp_byref(memory, resolution_ptr, resolution)
.map(|_| wasm32::__WASI_ESUCCESS)
.unwrap_or_else(|e| e)
}
})
hostcalls_impl::clock_res_get(memory, clock_id, resolution_ptr)
}
#[wasi_common_cbindgen]
pub fn clock_time_get(
memory: &mut [u8],
clock_id: wasm32::__wasi_clockid_t,
// ignored for now, but will be useful once we put optional limits on precision to reduce side
// channels
_precision: wasm32::__wasi_timestamp_t,
precision: wasm32::__wasi_timestamp_t,
time_ptr: wasm32::uintptr_t,
) -> wasm32::__wasi_errno_t {
// convert the supported clocks to the libc types, or return EINVAL
let clock_id = match dec_clockid(clock_id) {
host::__WASI_CLOCK_REALTIME => libc::CLOCK_REALTIME,
host::__WASI_CLOCK_MONOTONIC => libc::CLOCK_MONOTONIC,
host::__WASI_CLOCK_PROCESS_CPUTIME_ID => libc::CLOCK_PROCESS_CPUTIME_ID,
host::__WASI_CLOCK_THREAD_CPUTIME_ID => libc::CLOCK_THREAD_CPUTIME_ID,
_ => return wasm32::__WASI_EINVAL,
};
// no `nix` wrapper for clock_getres, so we do it ourselves
let mut timespec = unsafe { std::mem::uninitialized::<libc::timespec>() };
let res = unsafe { libc::clock_gettime(clock_id, &mut timespec as *mut libc::timespec) };
if res != 0 {
return wasm32::errno_from_nix(nix::errno::Errno::last());
}
// convert to nanoseconds, returning EOVERFLOW in case of overflow; this is freelancing a bit
// from the spec but seems like it'll be an unusual situation to hit
(timespec.tv_sec as host::__wasi_timestamp_t)
.checked_mul(1_000_000_000)
.and_then(|sec_ns| sec_ns.checked_add(timespec.tv_nsec as host::__wasi_timestamp_t))
.map_or(wasm32::__WASI_EOVERFLOW, |time| {
enc_timestamp_byref(memory, time_ptr, time)
.map(|_| wasm32::__WASI_ESUCCESS)
.unwrap_or_else(|e| e)
})
hostcalls_impl::clock_time_get(memory, clock_id, precision, time_ptr)
}
#[wasi_common_cbindgen]
@@ -214,88 +152,7 @@ pub fn poll_oneoff(
nsubscriptions: wasm32::size_t,
nevents: wasm32::uintptr_t,
) -> wasm32::__wasi_errno_t {
if nsubscriptions as u64 > wasm32::__wasi_filesize_t::max_value() {
return wasm32::__WASI_EINVAL;
}
enc_pointee(memory, nevents, 0).unwrap();
let input_slice =
dec_slice_of::<wasm32::__wasi_subscription_t>(memory, input, nsubscriptions).unwrap();
let input: Vec<_> = input_slice.iter().map(|x| dec_subscription(x)).collect();
let output_slice =
dec_slice_of_mut::<wasm32::__wasi_event_t>(memory, output, nsubscriptions).unwrap();
let timeout = input
.iter()
.filter_map(|event| match event {
Ok(event) if event.type_ == wasm32::__WASI_EVENTTYPE_CLOCK => Some(ClockEventData {
delay: wasi_clock_to_relative_ns_delay(unsafe { event.u.clock }) / 1_000_000,
userdata: event.userdata,
}),
_ => None,
})
.min_by_key(|event| event.delay);
let fd_events: Vec<_> = input
.iter()
.filter_map(|event| match event {
Ok(event)
if event.type_ == wasm32::__WASI_EVENTTYPE_FD_READ
|| event.type_ == wasm32::__WASI_EVENTTYPE_FD_WRITE =>
{
Some(FdEventData {
fd: unsafe { event.u.fd_readwrite.fd } as c_int,
type_: event.type_,
userdata: event.userdata,
})
}
_ => None,
})
.collect();
if fd_events.is_empty() && timeout.is_none() {
return wasm32::__WASI_ESUCCESS;
}
let mut poll_fds: Vec<_> = fd_events
.iter()
.map(|event| {
let mut flags = nix::poll::EventFlags::empty();
match event.type_ {
wasm32::__WASI_EVENTTYPE_FD_READ => flags.insert(nix::poll::EventFlags::POLLIN),
wasm32::__WASI_EVENTTYPE_FD_WRITE => flags.insert(nix::poll::EventFlags::POLLOUT),
// An event on a file descriptor can currently only be of type FD_READ or FD_WRITE
// Nothing else has been defined in the specification, and these are also the only two
// events we filtered before. If we get something else here, the code has a serious bug.
_ => unreachable!(),
};
nix::poll::PollFd::new(event.fd, flags)
})
.collect();
let timeout = timeout.map(|ClockEventData { delay, userdata }| ClockEventData {
delay: cmp::min(delay, c_int::max_value() as u128),
userdata,
});
let poll_timeout = timeout.map_or(-1, |timeout| timeout.delay as c_int);
let ready = loop {
match nix::poll::poll(&mut poll_fds, poll_timeout) {
Err(_) => {
if nix::errno::Errno::last() == nix::errno::Errno::EINTR {
continue;
}
return wasm32::errno_from_nix(nix::errno::Errno::last());
}
Ok(ready) => break ready as usize,
}
};
let events_count = if ready == 0 {
poll_oneoff_handle_timeout_event(output_slice, timeout)
} else {
let events = fd_events.iter().zip(poll_fds.iter()).take(ready);
poll_oneoff_handle_fd_event(output_slice, events)
};
if let Err(e) = enc_pointee(memory, nevents, events_count) {
return enc_errno(e);
}
wasm32::__WASI_ESUCCESS
hostcalls_impl::poll_oneoff(memory, input, output, nsubscriptions, nevents)
}
#[wasi_common_cbindgen]
@@ -314,6 +171,11 @@ pub fn proc_raise(
unimplemented!("proc_raise")
}
#[wasi_common_cbindgen]
pub fn sched_yield() -> wasm32::__wasi_errno_t {
hostcalls_impl::sched_yield()
}
#[wasi_common_cbindgen]
pub fn random_get(
memory: &mut [u8],
@@ -331,140 +193,3 @@ pub fn random_get(
return wasm32::__WASI_ESUCCESS;
}
#[wasi_common_cbindgen]
pub fn sched_yield() -> wasm32::__wasi_errno_t {
unsafe { libc::sched_yield() };
wasm32::__WASI_ESUCCESS
}
// define the `fionread()` function, equivalent to `ioctl(fd, FIONREAD, *bytes)`
nix::ioctl_read_bad!(fionread, nix::libc::FIONREAD, c_int);
fn wasi_clock_to_relative_ns_delay(
wasi_clock: host::__wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_clock_t,
) -> u128 {
if wasi_clock.flags != wasm32::__WASI_SUBSCRIPTION_CLOCK_ABSTIME {
return wasi_clock.timeout as u128;
}
let now: u128 = SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.expect("Current date is before the epoch")
.as_nanos();
let deadline = wasi_clock.timeout as u128;
deadline.saturating_sub(now)
}
#[derive(Debug, Copy, Clone)]
struct ClockEventData {
delay: u128,
userdata: host::__wasi_userdata_t,
}
#[derive(Debug, Copy, Clone)]
struct FdEventData {
fd: c_int,
type_: host::__wasi_eventtype_t,
userdata: host::__wasi_userdata_t,
}
fn poll_oneoff_handle_timeout_event(
output_slice: &mut [wasm32::__wasi_event_t],
timeout: Option<ClockEventData>,
) -> wasm32::size_t {
if let Some(ClockEventData { userdata, .. }) = timeout {
let output_event = host::__wasi_event_t {
userdata,
type_: wasm32::__WASI_EVENTTYPE_CLOCK,
error: wasm32::__WASI_ESUCCESS,
u: host::__wasi_event_t___wasi_event_u {
fd_readwrite: host::__wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t {
nbytes: 0,
flags: 0,
},
},
};
output_slice[0] = enc_event(output_event);
1
} else {
// shouldn't happen
0
}
}
fn poll_oneoff_handle_fd_event<'t>(
output_slice: &mut [wasm32::__wasi_event_t],
events: impl Iterator<Item = (&'t FdEventData, &'t nix::poll::PollFd)>,
) -> wasm32::size_t {
let mut output_slice_cur = output_slice.iter_mut();
let mut revents_count = 0;
for (fd_event, poll_fd) in events {
let revents = match poll_fd.revents() {
Some(revents) => revents,
None => continue,
};
let mut nbytes = 0;
if fd_event.type_ == wasm32::__WASI_EVENTTYPE_FD_READ {
let _ = unsafe { fionread(fd_event.fd, &mut nbytes) };
}
let output_event = if revents.contains(nix::poll::EventFlags::POLLNVAL) {
host::__wasi_event_t {
userdata: fd_event.userdata,
type_: fd_event.type_,
error: wasm32::__WASI_EBADF,
u: host::__wasi_event_t___wasi_event_u {
fd_readwrite:
host::__wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t {
nbytes: 0,
flags: wasm32::__WASI_EVENT_FD_READWRITE_HANGUP,
},
},
}
} else if revents.contains(nix::poll::EventFlags::POLLERR) {
host::__wasi_event_t {
userdata: fd_event.userdata,
type_: fd_event.type_,
error: wasm32::__WASI_EIO,
u: host::__wasi_event_t___wasi_event_u {
fd_readwrite:
host::__wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t {
nbytes: 0,
flags: wasm32::__WASI_EVENT_FD_READWRITE_HANGUP,
},
},
}
} else if revents.contains(nix::poll::EventFlags::POLLHUP) {
host::__wasi_event_t {
userdata: fd_event.userdata,
type_: fd_event.type_,
error: wasm32::__WASI_ESUCCESS,
u: host::__wasi_event_t___wasi_event_u {
fd_readwrite:
host::__wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t {
nbytes: 0,
flags: wasm32::__WASI_EVENT_FD_READWRITE_HANGUP,
},
},
}
} else if revents.contains(nix::poll::EventFlags::POLLIN)
| revents.contains(nix::poll::EventFlags::POLLOUT)
{
host::__wasi_event_t {
userdata: fd_event.userdata,
type_: fd_event.type_,
error: wasm32::__WASI_ESUCCESS,
u: host::__wasi_event_t___wasi_event_u {
fd_readwrite:
host::__wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t {
nbytes: nbytes as host::__wasi_filesize_t,
flags: 0,
},
},
}
} else {
continue;
};
*output_slice_cur.next().unwrap() = enc_event(output_event);
revents_count += 1;
}
revents_count
}

3
src/hostcalls/mod.rs
View File

@@ -1,7 +1,4 @@
//! Hostcalls that implement
//! [WASI](https://github.com/CraneStation/wasmtime-wasi/blob/wasi/docs/WASI-overview.md).
mod fs;
mod fs_helpers;
mod misc;
mod sock;

29
src/hostcalls/sock.rs
View File

@@ -1,9 +1,9 @@
#![allow(non_camel_case_types)]
#![allow(unused_unsafe)]
#![allow(unused)]
use crate::ctx::WasiCtx;
use crate::wasm32;
use crate::sys::hostcalls as hostcalls_impl;
use wasi_common_cbindgen::wasi_common_cbindgen;
#[wasi_common_cbindgen]
@@ -17,7 +17,16 @@ pub fn sock_recv(
ro_datalen: wasm32::uintptr_t,
ro_flags: wasm32::uintptr_t,
) -> wasm32::__wasi_errno_t {
unimplemented!("sock_recv")
hostcalls_impl::sock_recv(
wasi_ctx,
memory,
sock,
ri_data,
ri_data_len,
ri_flags,
ro_datalen,
ro_flags,
)
}
#[wasi_common_cbindgen]
@@ -30,7 +39,15 @@ pub fn sock_send(
si_flags: wasm32::__wasi_siflags_t,
so_datalen: wasm32::uintptr_t,
) -> wasm32::__wasi_errno_t {
unimplemented!("sock_send")
hostcalls_impl::sock_send(
wasi_ctx,
memory,
sock,
si_data,
si_data_len,
si_flags,
so_datalen,
)
}
#[wasi_common_cbindgen]
@@ -40,5 +57,5 @@ pub fn sock_shutdown(
sock: wasm32::__wasi_fd_t,
how: wasm32::__wasi_sdflags_t,
) -> wasm32::__wasi_errno_t {
unimplemented!("sock_shutdown")
hostcalls_impl::sock_shutdown(wasi_ctx, memory, sock, how)
}

7
src/lib.rs
View File

@@ -20,11 +20,12 @@
)
)]
pub mod ctx;
pub mod fdentry;
mod ctx;
mod sys;
pub mod memory;
pub mod host;
pub mod hostcalls;
pub mod memory;
pub mod wasm32;
pub use ctx::{WasiCtx, WasiCtxBuilder};

41
src/memory.rs
View File

@@ -1,15 +1,6 @@
//! Functions to go back and forth between WASI types in host and wasm32 representations.
//!
//! This module is an adaptation of the `wasmtime-wasi` module
//! [`translate.rs`](https://github.com/CraneStation/wasmtime-wasi/blob/1a6ecf3a0378d71f3fc1ba25ce76a2b43e4166b8/lib/wasi/src/translate.rs);
//! its license file `LICENSE.wasmtime-wasi` is included in this project.
//!
//! Any of these functions that take a `Vmctx` argument are only meant to be called from within a
//! hostcall.
//!
//! This sort of manual encoding will hopefully be obsolete once the IDL is developed.
use crate::{host, wasm32};
pub use crate::sys::memory::*;
use cast;
use cast::From as _0;
@@ -587,33 +578,3 @@ dec_enc_scalar!(
enc_dircookie,
enc_dircookie_byref
);
#[cfg(target_os = "linux")]
pub fn dirent_from_host(
host_entry: &nix::libc::dirent,
) -> Result<wasm32::__wasi_dirent_t, host::__wasi_errno_t> {
let mut entry = unsafe { std::mem::zeroed::<wasm32::__wasi_dirent_t>() };
let d_namlen = unsafe { std::ffi::CStr::from_ptr(host_entry.d_name.as_ptr()) }
.to_bytes()
.len();
if d_namlen > u32::max_value() as usize {
return Err(host::__WASI_EIO);
}
entry.d_ino = enc_inode(host_entry.d_ino);
entry.d_next = enc_dircookie(host_entry.d_off as u64);
entry.d_namlen = enc_u32(d_namlen as u32);
entry.d_type = enc_filetype(host_entry.d_type);
Ok(entry)
}
#[cfg(not(target_os = "linux"))]
pub fn dirent_from_host(
host_entry: &nix::libc::dirent,
) -> Result<wasm32::__wasi_dirent_t, host::__wasi_errno_t> {
let mut entry = unsafe { std::mem::zeroed::<wasm32::__wasi_dirent_t>() };
entry.d_ino = enc_inode(host_entry.d_ino);
entry.d_next = enc_dircookie(host_entry.d_seekoff);
entry.d_namlen = enc_u32(u32::from(host_entry.d_namlen));
entry.d_type = enc_filetype(host_entry.d_type);
Ok(entry)
}

13
src/sys/mod.rs Normal file
View File

@@ -0,0 +1,13 @@
use cfg_if::cfg_if;
cfg_if! {
if #[cfg(unix)] {
mod unix;
pub use self::unix::*;
} else if #[cfg(windows)] {
mod windows;
pub use self::windows::*;
} else {
compile_error!("wasi-common doesn't compile for this platform yet");
}
}

103
src/fdentry.rs → src/sys/unix/fdmap.rs
View File

@@ -1,7 +1,17 @@
use crate::host;
use std::fs::File;
use std::os::unix::prelude::{FileTypeExt, FromRawFd, IntoRawFd, RawFd};
use std::os::unix::prelude::{FileTypeExt, FromRawFd, IntoRawFd, RawFd, AsRawFd};
use std::path::PathBuf;
use std::collections::HashMap;
#[derive(Clone, Debug)]
pub struct FdObject {
pub ty: host::__wasi_filetype_t,
pub rawfd: RawFd,
pub needs_close: bool,
// TODO: directories
}
#[derive(Clone, Debug)]
pub struct FdEntry {
@@ -11,15 +21,32 @@ pub struct FdEntry {
pub preopen_path: Option<PathBuf>,
}
#[derive(Debug)]
pub struct FdMap {
entries: HashMap<host::__wasi_fd_t, FdEntry>,
}
impl Drop for FdObject {
fn drop(&mut self) {
if self.needs_close {
nix::unistd::close(self.rawfd).unwrap_or_else(|e| eprintln!("FdObject::drop(): {}", e));
}
}
}
impl FdEntry {
pub fn from_file(file: File) -> FdEntry {
unsafe { FdEntry::from_raw_fd(file.into_raw_fd()) }
pub fn from_file(file: File) -> Self {
unsafe { Self::from_raw_fd(file.into_raw_fd()) }
}
pub fn duplicate<F: AsRawFd>(fd: &F) -> Self {
unsafe { Self::from_raw_fd(nix::unistd::dup(fd.as_raw_fd()).unwrap()) }
}
}
impl FromRawFd for FdEntry {
// TODO: make this a different function with error handling, rather than using the trait method
unsafe fn from_raw_fd(rawfd: RawFd) -> FdEntry {
unsafe fn from_raw_fd(rawfd: RawFd) -> Self {
let (ty, mut rights_base, rights_inheriting) =
determine_type_rights(rawfd).expect("can determine file rights");
@@ -33,7 +60,7 @@ impl FromRawFd for FdEntry {
rights_base &= !host::__WASI_RIGHT_FD_READ;
}
FdEntry {
Self {
fd_object: FdObject {
ty: ty,
rawfd,
@@ -122,18 +149,62 @@ pub unsafe fn determine_type_rights(
Ok((ty, rights_base, rights_inheriting))
}
#[derive(Clone, Debug)]
pub struct FdObject {
pub ty: host::__wasi_filetype_t,
pub rawfd: RawFd,
pub needs_close: bool,
// TODO: directories
}
impl FdMap {
pub fn new() -> Self {
Self {
entries: HashMap::new()
}
}
impl Drop for FdObject {
fn drop(&mut self) {
if self.needs_close {
nix::unistd::close(self.rawfd).unwrap_or_else(|e| eprintln!("FdObject::drop(): {}", e));
pub(crate) fn insert_fd_entry_at(&mut self, fd: host::__wasi_fd_t, fe: FdEntry) {
self.entries.insert(fd, fe);
}
pub(crate) fn get(&self, fd: &host::__wasi_fd_t) -> Option<&FdEntry> {
self.entries.get(fd)
}
pub(crate) fn get_mut(&mut self, fd: &host::__wasi_fd_t) -> Option<&mut FdEntry> {
self.entries.get_mut(fd)
}
pub(crate) fn remove(&mut self, fd: &host::__wasi_fd_t) -> Option<FdEntry> {
self.entries.remove(fd)
}
pub fn get_fd_entry(
&self,
fd: host::__wasi_fd_t,
rights_base: host::__wasi_rights_t,
rights_inheriting: host::__wasi_rights_t,
) -> Result<&FdEntry, host::__wasi_errno_t> {
if let Some(fe) = self.entries.get(&fd) {
// validate rights
if !fe.rights_base & rights_base != 0 || !fe.rights_inheriting & rights_inheriting != 0
{
Err(host::__WASI_ENOTCAPABLE)
} else {
Ok(fe)
}
} else {
Err(host::__WASI_EBADF)
}
}
pub fn insert_fd_entry(
&mut self,
fe: FdEntry,
) -> Result<host::__wasi_fd_t, host::__wasi_errno_t> {
// never insert where stdio handles usually are
let mut fd = 3;
while self.entries.contains_key(&fd) {
if let Some(next_fd) = fd.checked_add(1) {
fd = next_fd;
} else {
return Err(host::__WASI_EMFILE);
}
}
self.entries.insert(fd, fe);
Ok(fd)
}
}

240
src/sys/unix/host.rs Normal file
View File

@@ -0,0 +1,240 @@
//! WASI host types specific to *nix host.
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(dead_code)]
use crate::host;
pub fn errno_from_nix(errno: nix::errno::Errno) -> host::__wasi_errno_t {
match errno {
nix::errno::Errno::EPERM => host::__WASI_EPERM,
nix::errno::Errno::ENOENT => host::__WASI_ENOENT,
nix::errno::Errno::ESRCH => host::__WASI_ESRCH,
nix::errno::Errno::EINTR => host::__WASI_EINTR,
nix::errno::Errno::EIO => host::__WASI_EIO,
nix::errno::Errno::ENXIO => host::__WASI_ENXIO,
nix::errno::Errno::E2BIG => host::__WASI_E2BIG,
nix::errno::Errno::ENOEXEC => host::__WASI_ENOEXEC,
nix::errno::Errno::EBADF => host::__WASI_EBADF,
nix::errno::Errno::ECHILD => host::__WASI_ECHILD,
nix::errno::Errno::EAGAIN => host::__WASI_EAGAIN,
nix::errno::Errno::ENOMEM => host::__WASI_ENOMEM,
nix::errno::Errno::EACCES => host::__WASI_EACCES,
nix::errno::Errno::EFAULT => host::__WASI_EFAULT,
nix::errno::Errno::EBUSY => host::__WASI_EBUSY,
nix::errno::Errno::EEXIST => host::__WASI_EEXIST,
nix::errno::Errno::EXDEV => host::__WASI_EXDEV,
nix::errno::Errno::ENODEV => host::__WASI_ENODEV,
nix::errno::Errno::ENOTDIR => host::__WASI_ENOTDIR,
nix::errno::Errno::EISDIR => host::__WASI_EISDIR,
nix::errno::Errno::EINVAL => host::__WASI_EINVAL,
nix::errno::Errno::ENFILE => host::__WASI_ENFILE,
nix::errno::Errno::EMFILE => host::__WASI_EMFILE,
nix::errno::Errno::ENOTTY => host::__WASI_ENOTTY,
nix::errno::Errno::ETXTBSY => host::__WASI_ETXTBSY,
nix::errno::Errno::EFBIG => host::__WASI_EFBIG,
nix::errno::Errno::ENOSPC => host::__WASI_ENOSPC,
nix::errno::Errno::ESPIPE => host::__WASI_ESPIPE,
nix::errno::Errno::EROFS => host::__WASI_EROFS,
nix::errno::Errno::EMLINK => host::__WASI_EMLINK,
nix::errno::Errno::EPIPE => host::__WASI_EPIPE,
nix::errno::Errno::EDOM => host::__WASI_EDOM,
nix::errno::Errno::ERANGE => host::__WASI_ERANGE,
nix::errno::Errno::EDEADLK => host::__WASI_EDEADLK,
nix::errno::Errno::ENAMETOOLONG => host::__WASI_ENAMETOOLONG,
nix::errno::Errno::ENOLCK => host::__WASI_ENOLCK,
nix::errno::Errno::ENOSYS => host::__WASI_ENOSYS,
nix::errno::Errno::ENOTEMPTY => host::__WASI_ENOTEMPTY,
nix::errno::Errno::ELOOP => host::__WASI_ELOOP,
nix::errno::Errno::ENOMSG => host::__WASI_ENOMSG,
nix::errno::Errno::EIDRM => host::__WASI_EIDRM,
nix::errno::Errno::ENOLINK => host::__WASI_ENOLINK,
nix::errno::Errno::EPROTO => host::__WASI_EPROTO,
nix::errno::Errno::EMULTIHOP => host::__WASI_EMULTIHOP,
nix::errno::Errno::EBADMSG => host::__WASI_EBADMSG,
nix::errno::Errno::EOVERFLOW => host::__WASI_EOVERFLOW,
nix::errno::Errno::EILSEQ => host::__WASI_EILSEQ,
nix::errno::Errno::ENOTSOCK => host::__WASI_ENOTSOCK,
nix::errno::Errno::EDESTADDRREQ => host::__WASI_EDESTADDRREQ,
nix::errno::Errno::EMSGSIZE => host::__WASI_EMSGSIZE,
nix::errno::Errno::EPROTOTYPE => host::__WASI_EPROTOTYPE,
nix::errno::Errno::ENOPROTOOPT => host::__WASI_ENOPROTOOPT,
nix::errno::Errno::EPROTONOSUPPORT => host::__WASI_EPROTONOSUPPORT,
nix::errno::Errno::EAFNOSUPPORT => host::__WASI_EAFNOSUPPORT,
nix::errno::Errno::EADDRINUSE => host::__WASI_EADDRINUSE,
nix::errno::Errno::EADDRNOTAVAIL => host::__WASI_EADDRNOTAVAIL,
nix::errno::Errno::ENETDOWN => host::__WASI_ENETDOWN,
nix::errno::Errno::ENETUNREACH => host::__WASI_ENETUNREACH,
nix::errno::Errno::ENETRESET => host::__WASI_ENETRESET,
nix::errno::Errno::ECONNABORTED => host::__WASI_ECONNABORTED,
nix::errno::Errno::ECONNRESET => host::__WASI_ECONNRESET,
nix::errno::Errno::ENOBUFS => host::__WASI_ENOBUFS,
nix::errno::Errno::EISCONN => host::__WASI_EISCONN,
nix::errno::Errno::ENOTCONN => host::__WASI_ENOTCONN,
nix::errno::Errno::ETIMEDOUT => host::__WASI_ETIMEDOUT,
nix::errno::Errno::ECONNREFUSED => host::__WASI_ECONNREFUSED,
nix::errno::Errno::EHOSTUNREACH => host::__WASI_EHOSTUNREACH,
nix::errno::Errno::EALREADY => host::__WASI_EALREADY,
nix::errno::Errno::EINPROGRESS => host::__WASI_EINPROGRESS,
nix::errno::Errno::ESTALE => host::__WASI_ESTALE,
nix::errno::Errno::EDQUOT => host::__WASI_EDQUOT,
nix::errno::Errno::ECANCELED => host::__WASI_ECANCELED,
nix::errno::Errno::EOWNERDEAD => host::__WASI_EOWNERDEAD,
nix::errno::Errno::ENOTRECOVERABLE => host::__WASI_ENOTRECOVERABLE,
_ => host::__WASI_ENOSYS,
}
}
pub unsafe fn ciovec_to_nix<'a>(ciovec: &'a host::__wasi_ciovec_t) -> nix::sys::uio::IoVec<&'a [u8]> {
let slice = std::slice::from_raw_parts(ciovec.buf as *const u8, ciovec.buf_len);
nix::sys::uio::IoVec::from_slice(slice)
}
pub unsafe fn ciovec_to_nix_mut<'a>(
ciovec: &'a mut host::__wasi_ciovec_t,
) -> nix::sys::uio::IoVec<&'a mut [u8]> {
let slice = std::slice::from_raw_parts_mut(ciovec.buf as *mut u8, ciovec.buf_len);
nix::sys::uio::IoVec::from_mut_slice(slice)
}
pub unsafe fn iovec_to_nix<'a>(iovec: &'a host::__wasi_iovec_t) -> nix::sys::uio::IoVec<&'a [u8]> {
let slice = std::slice::from_raw_parts(iovec.buf as *const u8, iovec.buf_len);
nix::sys::uio::IoVec::from_slice(slice)
}
pub unsafe fn iovec_to_nix_mut<'a>(
iovec: &'a mut host::__wasi_iovec_t,
) -> nix::sys::uio::IoVec<&'a mut [u8]> {
let slice = std::slice::from_raw_parts_mut(iovec.buf as *mut u8, iovec.buf_len);
nix::sys::uio::IoVec::from_mut_slice(slice)
}
#[cfg(target_os = "linux")]
pub const O_RSYNC: nix::fcntl::OFlag = nix::fcntl::OFlag::O_RSYNC;
#[cfg(not(target_os = "linux"))]
pub const O_RSYNC: nix::fcntl::OFlag = nix::fcntl::OFlag::O_SYNC;
pub fn nix_from_fdflags(fdflags: host::__wasi_fdflags_t) -> nix::fcntl::OFlag {
use nix::fcntl::OFlag;
let mut nix_flags = OFlag::empty();
if fdflags & host::__WASI_FDFLAG_APPEND != 0 {
nix_flags.insert(OFlag::O_APPEND);
}
if fdflags & host::__WASI_FDFLAG_DSYNC != 0 {
nix_flags.insert(OFlag::O_DSYNC);
}
if fdflags & host::__WASI_FDFLAG_NONBLOCK != 0 {
nix_flags.insert(OFlag::O_NONBLOCK);
}
if fdflags & host::__WASI_FDFLAG_RSYNC != 0 {
nix_flags.insert(O_RSYNC);
}
if fdflags & host::__WASI_FDFLAG_SYNC != 0 {
nix_flags.insert(OFlag::O_SYNC);
}
nix_flags
}
pub fn fdflags_from_nix(oflags: nix::fcntl::OFlag) -> host::__wasi_fdflags_t {
use nix::fcntl::OFlag;
let mut fdflags = 0;
if oflags.contains(OFlag::O_APPEND) {
fdflags |= host::__WASI_FDFLAG_APPEND;
}
if oflags.contains(OFlag::O_DSYNC) {
fdflags |= host::__WASI_FDFLAG_DSYNC;
}
if oflags.contains(OFlag::O_NONBLOCK) {
fdflags |= host::__WASI_FDFLAG_NONBLOCK;
}
if oflags.contains(O_RSYNC) {
fdflags |= host::__WASI_FDFLAG_RSYNC;
}
if oflags.contains(OFlag::O_SYNC) {
fdflags |= host::__WASI_FDFLAG_SYNC;
}
fdflags
}
pub fn nix_from_oflags(oflags: host::__wasi_oflags_t) -> nix::fcntl::OFlag {
use nix::fcntl::OFlag;
let mut nix_flags = OFlag::empty();
if oflags & host::__WASI_O_CREAT != 0 {
nix_flags.insert(OFlag::O_CREAT);
}
if oflags & host::__WASI_O_DIRECTORY != 0 {
nix_flags.insert(OFlag::O_DIRECTORY);
}
if oflags & host::__WASI_O_EXCL != 0 {
nix_flags.insert(OFlag::O_EXCL);
}
if oflags & host::__WASI_O_TRUNC != 0 {
nix_flags.insert(OFlag::O_TRUNC);
}
nix_flags
}
pub fn filetype_from_nix(sflags: nix::sys::stat::SFlag) -> host::__wasi_filetype_t {
use nix::sys::stat::SFlag;
if sflags.contains(SFlag::S_IFCHR) {
host::__WASI_FILETYPE_CHARACTER_DEVICE
} else if sflags.contains(SFlag::S_IFBLK) {
host::__WASI_FILETYPE_BLOCK_DEVICE
} else if sflags.contains(SFlag::S_IFIFO) | sflags.contains(SFlag::S_IFSOCK) {
host::__WASI_FILETYPE_SOCKET_STREAM
} else if sflags.contains(SFlag::S_IFDIR) {
host::__WASI_FILETYPE_DIRECTORY
} else if sflags.contains(SFlag::S_IFREG) {
host::__WASI_FILETYPE_REGULAR_FILE
} else if sflags.contains(SFlag::S_IFLNK) {
host::__WASI_FILETYPE_SYMBOLIC_LINK
} else {
host::__WASI_FILETYPE_UNKNOWN
}
}
pub fn nix_from_filetype(sflags: host::__wasi_filetype_t) -> nix::sys::stat::SFlag {
use nix::sys::stat::SFlag;
let mut nix_sflags = SFlag::empty();
if sflags & host::__WASI_FILETYPE_CHARACTER_DEVICE != 0 {
nix_sflags.insert(SFlag::S_IFCHR);
}
if sflags & host::__WASI_FILETYPE_BLOCK_DEVICE != 0 {
nix_sflags.insert(SFlag::S_IFBLK);
}
if sflags & host::__WASI_FILETYPE_SOCKET_STREAM != 0 {
nix_sflags.insert(SFlag::S_IFIFO);
nix_sflags.insert(SFlag::S_IFSOCK);
}
if sflags & host::__WASI_FILETYPE_DIRECTORY != 0 {
nix_sflags.insert(SFlag::S_IFDIR);
}
if sflags & host::__WASI_FILETYPE_REGULAR_FILE != 0 {
nix_sflags.insert(SFlag::S_IFREG);
}
if sflags & host::__WASI_FILETYPE_SYMBOLIC_LINK != 0 {
nix_sflags.insert(SFlag::S_IFLNK);
}
nix_sflags
}
pub fn filestat_from_nix(filestat: nix::sys::stat::FileStat) -> host::__wasi_filestat_t {
use std::convert::TryFrom;
let filetype = nix::sys::stat::SFlag::from_bits_truncate(filestat.st_mode);
let dev = host::__wasi_device_t::try_from(filestat.st_dev)
.expect("FileStat::st_dev is trivially convertible to __wasi_device_t");
let ino = host::__wasi_inode_t::try_from(filestat.st_ino)
.expect("FileStat::st_ino is trivially convertible to __wasi_inode_t");
host::__wasi_filestat_t {
st_dev: dev,
st_ino: ino,
st_nlink: filestat.st_nlink as host::__wasi_linkcount_t,
st_size: filestat.st_size as host::__wasi_filesize_t,
st_atim: filestat.st_atime as host::__wasi_timestamp_t,
st_ctim: filestat.st_ctime as host::__wasi_timestamp_t,
st_mtim: filestat.st_mtime as host::__wasi_timestamp_t,
st_filetype: filetype_from_nix(filetype),
}
}

1347
src/sys/unix/hostcalls/fs.rs Normal file
View File

File diff suppressed because it is too large Load Diff

7
src/hostcalls/fs_helpers.rs → src/sys/unix/hostcalls/fs_helpers.rs
View File

@@ -3,6 +3,7 @@
use crate::ctx::WasiCtx;
use crate::host;
use crate::sys::host as host_impl;
use nix::libc::{self, c_long};
use std::ffi::{OsStr, OsString};
@@ -191,7 +192,7 @@ pub fn path_get<P: AsRef<OsStr>>(
Err(e) => {
return ret_error(
&mut dir_stack,
host::errno_from_nix(e.as_errno().unwrap()),
host_impl::errno_from_nix(e.as_errno().unwrap()),
);
}
}
@@ -199,7 +200,7 @@ pub fn path_get<P: AsRef<OsStr>>(
Err(e) => {
return ret_error(
&mut dir_stack,
host::errno_from_nix(e.as_errno().unwrap()),
host_impl::errno_from_nix(e.as_errno().unwrap()),
);
}
}
@@ -237,7 +238,7 @@ pub fn path_get<P: AsRef<OsStr>>(
let errno = e.as_errno().unwrap();
if errno != Errno::EINVAL && errno != Errno::ENOENT {
// only return an error if this path is not actually a symlink
return ret_error(&mut dir_stack, host::errno_from_nix(errno));
return ret_error(&mut dir_stack, host_impl::errno_from_nix(errno));
}
}
}

313
src/sys/unix/hostcalls/misc.rs Normal file
View File

@@ -0,0 +1,313 @@
#![allow(non_camel_case_types)]
#![allow(unused_unsafe)]
use crate::memory::*;
use crate::{host, wasm32};
use crate::sys::host as host_impl;
use nix::convert_ioctl_res;
use nix::libc::{self, c_int};
use std::cmp;
use std::time::SystemTime;
pub fn clock_res_get(
memory: &mut [u8],
clock_id: wasm32::__wasi_clockid_t,
resolution_ptr: wasm32::uintptr_t,
) -> wasm32::__wasi_errno_t {
// convert the supported clocks to the libc types, or return EINVAL
let clock_id = match dec_clockid(clock_id) {
host::__WASI_CLOCK_REALTIME => libc::CLOCK_REALTIME,
host::__WASI_CLOCK_MONOTONIC => libc::CLOCK_MONOTONIC,
host::__WASI_CLOCK_PROCESS_CPUTIME_ID => libc::CLOCK_PROCESS_CPUTIME_ID,
host::__WASI_CLOCK_THREAD_CPUTIME_ID => libc::CLOCK_THREAD_CPUTIME_ID,
_ => return wasm32::__WASI_EINVAL,
};
// no `nix` wrapper for clock_getres, so we do it ourselves
let mut timespec = unsafe { std::mem::uninitialized::<libc::timespec>() };
let res = unsafe { libc::clock_getres(clock_id, &mut timespec as *mut libc::timespec) };
if res != 0 {
return host_impl::errno_from_nix(nix::errno::Errno::last());
}
// convert to nanoseconds, returning EOVERFLOW in case of overflow; this is freelancing a bit
// from the spec but seems like it'll be an unusual situation to hit
(timespec.tv_sec as host::__wasi_timestamp_t)
.checked_mul(1_000_000_000)
.and_then(|sec_ns| sec_ns.checked_add(timespec.tv_nsec as host::__wasi_timestamp_t))
.map_or(wasm32::__WASI_EOVERFLOW, |resolution| {
// a supported clock can never return zero; this case will probably never get hit, but
// make sure we follow the spec
if resolution == 0 {
wasm32::__WASI_EINVAL
} else {
enc_timestamp_byref(memory, resolution_ptr, resolution)
.map(|_| wasm32::__WASI_ESUCCESS)
.unwrap_or_else(|e| e)
}
})
}
pub fn clock_time_get(
memory: &mut [u8],
clock_id: wasm32::__wasi_clockid_t,
// ignored for now, but will be useful once we put optional limits on precision to reduce side
// channels
_precision: wasm32::__wasi_timestamp_t,
time_ptr: wasm32::uintptr_t,
) -> wasm32::__wasi_errno_t {
// convert the supported clocks to the libc types, or return EINVAL
let clock_id = match dec_clockid(clock_id) {
host::__WASI_CLOCK_REALTIME => libc::CLOCK_REALTIME,
host::__WASI_CLOCK_MONOTONIC => libc::CLOCK_MONOTONIC,
host::__WASI_CLOCK_PROCESS_CPUTIME_ID => libc::CLOCK_PROCESS_CPUTIME_ID,
host::__WASI_CLOCK_THREAD_CPUTIME_ID => libc::CLOCK_THREAD_CPUTIME_ID,
_ => return wasm32::__WASI_EINVAL,
};
// no `nix` wrapper for clock_getres, so we do it ourselves
let mut timespec = unsafe { std::mem::uninitialized::<libc::timespec>() };
let res = unsafe { libc::clock_gettime(clock_id, &mut timespec as *mut libc::timespec) };
if res != 0 {
return host_impl::errno_from_nix(nix::errno::Errno::last());
}
// convert to nanoseconds, returning EOVERFLOW in case of overflow; this is freelancing a bit
// from the spec but seems like it'll be an unusual situation to hit
(timespec.tv_sec as host::__wasi_timestamp_t)
.checked_mul(1_000_000_000)
.and_then(|sec_ns| sec_ns.checked_add(timespec.tv_nsec as host::__wasi_timestamp_t))
.map_or(wasm32::__WASI_EOVERFLOW, |time| {
enc_timestamp_byref(memory, time_ptr, time)
.map(|_| wasm32::__WASI_ESUCCESS)
.unwrap_or_else(|e| e)
})
}
pub fn poll_oneoff(
memory: &mut [u8],
input: wasm32::uintptr_t,
output: wasm32::uintptr_t,
nsubscriptions: wasm32::size_t,
nevents: wasm32::uintptr_t,
) -> wasm32::__wasi_errno_t {
if nsubscriptions as u64 > wasm32::__wasi_filesize_t::max_value() {
return wasm32::__WASI_EINVAL;
}
enc_pointee(memory, nevents, 0).unwrap();
let input_slice =
dec_slice_of::<wasm32::__wasi_subscription_t>(memory, input, nsubscriptions).unwrap();
let input: Vec<_> = input_slice.iter().map(|x| dec_subscription(x)).collect();
let output_slice =
dec_slice_of_mut::<wasm32::__wasi_event_t>(memory, output, nsubscriptions).unwrap();
let timeout = input
.iter()
.filter_map(|event| match event {
Ok(event) if event.type_ == wasm32::__WASI_EVENTTYPE_CLOCK => Some(ClockEventData {
delay: wasi_clock_to_relative_ns_delay(unsafe { event.u.clock }) / 1_000_000,
userdata: event.userdata,
}),
_ => None,
})
.min_by_key(|event| event.delay);
let fd_events: Vec<_> = input
.iter()
.filter_map(|event| match event {
Ok(event)
if event.type_ == wasm32::__WASI_EVENTTYPE_FD_READ
|| event.type_ == wasm32::__WASI_EVENTTYPE_FD_WRITE =>
{
Some(FdEventData {
fd: unsafe { event.u.fd_readwrite.fd } as c_int,
type_: event.type_,
userdata: event.userdata,
})
}
_ => None,
})
.collect();
if fd_events.is_empty() && timeout.is_none() {
return wasm32::__WASI_ESUCCESS;
}
let mut poll_fds: Vec<_> = fd_events
.iter()
.map(|event| {
let mut flags = nix::poll::EventFlags::empty();
match event.type_ {
wasm32::__WASI_EVENTTYPE_FD_READ => flags.insert(nix::poll::EventFlags::POLLIN),
wasm32::__WASI_EVENTTYPE_FD_WRITE => flags.insert(nix::poll::EventFlags::POLLOUT),
// An event on a file descriptor can currently only be of type FD_READ or FD_WRITE
// Nothing else has been defined in the specification, and these are also the only two
// events we filtered before. If we get something else here, the code has a serious bug.
_ => unreachable!(),
};
nix::poll::PollFd::new(event.fd, flags)
})
.collect();
let timeout = timeout.map(|ClockEventData { delay, userdata }| ClockEventData {
delay: cmp::min(delay, c_int::max_value() as u128),
userdata,
});
let poll_timeout = timeout.map_or(-1, |timeout| timeout.delay as c_int);
let ready = loop {
match nix::poll::poll(&mut poll_fds, poll_timeout) {
Err(_) => {
if nix::errno::Errno::last() == nix::errno::Errno::EINTR {
continue;
}
return host_impl::errno_from_nix(nix::errno::Errno::last());
}
Ok(ready) => break ready as usize,
}
};
let events_count = if ready == 0 {
poll_oneoff_handle_timeout_event(output_slice, timeout)
} else {
let events = fd_events.iter().zip(poll_fds.iter()).take(ready);
poll_oneoff_handle_fd_event(output_slice, events)
};
if let Err(e) = enc_pointee(memory, nevents, events_count) {
return enc_errno(e);
}
wasm32::__WASI_ESUCCESS
}
pub fn sched_yield() -> wasm32::__wasi_errno_t {
unsafe { libc::sched_yield() };
wasm32::__WASI_ESUCCESS
}
// define the `fionread()` function, equivalent to `ioctl(fd, FIONREAD, *bytes)`
nix::ioctl_read_bad!(fionread, nix::libc::FIONREAD, c_int);
fn wasi_clock_to_relative_ns_delay(
wasi_clock: host::__wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_clock_t,
) -> u128 {
if wasi_clock.flags != wasm32::__WASI_SUBSCRIPTION_CLOCK_ABSTIME {
return wasi_clock.timeout as u128;
}
let now: u128 = SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.expect("Current date is before the epoch")
.as_nanos();
let deadline = wasi_clock.timeout as u128;
deadline.saturating_sub(now)
}
#[derive(Debug, Copy, Clone)]
struct ClockEventData {
delay: u128,
userdata: host::__wasi_userdata_t,
}
#[derive(Debug, Copy, Clone)]
struct FdEventData {
fd: c_int,
type_: host::__wasi_eventtype_t,
userdata: host::__wasi_userdata_t,
}
fn poll_oneoff_handle_timeout_event(
output_slice: &mut [wasm32::__wasi_event_t],
timeout: Option<ClockEventData>,
) -> wasm32::size_t {
if let Some(ClockEventData { userdata, .. }) = timeout {
let output_event = host::__wasi_event_t {
userdata,
type_: wasm32::__WASI_EVENTTYPE_CLOCK,
error: wasm32::__WASI_ESUCCESS,
u: host::__wasi_event_t___wasi_event_u {
fd_readwrite: host::__wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t {
nbytes: 0,
flags: 0,
},
},
};
output_slice[0] = enc_event(output_event);
1
} else {
// shouldn't happen
0
}
}
fn poll_oneoff_handle_fd_event<'t>(
output_slice: &mut [wasm32::__wasi_event_t],
events: impl Iterator<Item = (&'t FdEventData, &'t nix::poll::PollFd)>,
) -> wasm32::size_t {
let mut output_slice_cur = output_slice.iter_mut();
let mut revents_count = 0;
for (fd_event, poll_fd) in events {
let revents = match poll_fd.revents() {
Some(revents) => revents,
None => continue,
};
let mut nbytes = 0;
if fd_event.type_ == wasm32::__WASI_EVENTTYPE_FD_READ {
let _ = unsafe { fionread(fd_event.fd, &mut nbytes) };
}
let output_event = if revents.contains(nix::poll::EventFlags::POLLNVAL) {
host::__wasi_event_t {
userdata: fd_event.userdata,
type_: fd_event.type_,
error: wasm32::__WASI_EBADF,
u: host::__wasi_event_t___wasi_event_u {
fd_readwrite:
host::__wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t {
nbytes: 0,
flags: wasm32::__WASI_EVENT_FD_READWRITE_HANGUP,
},
},
}
} else if revents.contains(nix::poll::EventFlags::POLLERR) {
host::__wasi_event_t {
userdata: fd_event.userdata,
type_: fd_event.type_,
error: wasm32::__WASI_EIO,
u: host::__wasi_event_t___wasi_event_u {
fd_readwrite:
host::__wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t {
nbytes: 0,
flags: wasm32::__WASI_EVENT_FD_READWRITE_HANGUP,
},
},
}
} else if revents.contains(nix::poll::EventFlags::POLLHUP) {
host::__wasi_event_t {
userdata: fd_event.userdata,
type_: fd_event.type_,
error: wasm32::__WASI_ESUCCESS,
u: host::__wasi_event_t___wasi_event_u {
fd_readwrite:
host::__wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t {
nbytes: 0,
flags: wasm32::__WASI_EVENT_FD_READWRITE_HANGUP,
},
},
}
} else if revents.contains(nix::poll::EventFlags::POLLIN)
| revents.contains(nix::poll::EventFlags::POLLOUT)
{
host::__wasi_event_t {
userdata: fd_event.userdata,
type_: fd_event.type_,
error: wasm32::__WASI_ESUCCESS,
u: host::__wasi_event_t___wasi_event_u {
fd_readwrite:
host::__wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t {
nbytes: nbytes as host::__wasi_filesize_t,
flags: 0,
},
},
}
} else {
continue;
};
*output_slice_cur.next().unwrap() = enc_event(output_event);
revents_count += 1;
}
revents_count
}

10
src/sys/unix/hostcalls/mod.rs Normal file
View File

@@ -0,0 +1,10 @@
//! Hostcalls that implement
//! [WASI](https://github.com/CraneStation/wasmtime-wasi/blob/wasi/docs/WASI-overview.md).
mod fs;
mod fs_helpers;
mod misc;
mod sock;
pub use self::fs::*;
pub use self::misc::*;
pub use self::sock::*;

41
src/sys/unix/hostcalls/sock.rs Normal file
View File

@@ -0,0 +1,41 @@
#![allow(non_camel_case_types)]
#![allow(unused_unsafe)]
#![allow(unused)]
use crate::ctx::WasiCtx;
use crate::wasm32;
use wasi_common_cbindgen::wasi_common_cbindgen;
pub fn sock_recv(
wasi_ctx: &WasiCtx,
memory: &mut [u8],
sock: wasm32::__wasi_fd_t,
ri_data: wasm32::uintptr_t,
ri_data_len: wasm32::size_t,
ri_flags: wasm32::__wasi_riflags_t,
ro_datalen: wasm32::uintptr_t,
ro_flags: wasm32::uintptr_t,
) -> wasm32::__wasi_errno_t {
unimplemented!("sock_recv")
}
pub fn sock_send(
wasi_ctx: &WasiCtx,
memory: &mut [u8],
sock: wasm32::__wasi_fd_t,
si_data: wasm32::uintptr_t,
si_data_len: wasm32::size_t,
si_flags: wasm32::__wasi_siflags_t,
so_datalen: wasm32::uintptr_t,
) -> wasm32::__wasi_errno_t {
unimplemented!("sock_send")
}
pub fn sock_shutdown(
wasi_ctx: &WasiCtx,
memory: &mut [u8],
sock: wasm32::__wasi_fd_t,
how: wasm32::__wasi_sdflags_t,
) -> wasm32::__wasi_errno_t {
unimplemented!("sock_shutdown")
}

42
src/sys/unix/mod.rs Normal file
View File

@@ -0,0 +1,42 @@
pub mod host;
pub mod hostcalls;
pub mod fdmap;
pub mod memory {
use crate::{host, wasm32};
use crate::memory::*;
#[cfg(target_os = "linux")]
pub fn dirent_from_host(
host_entry: &nix::libc::dirent,
) -> Result<wasm32::__wasi_dirent_t, host::__wasi_errno_t> {
let mut entry = unsafe { std::mem::zeroed::<wasm32::__wasi_dirent_t>() };
let d_namlen = unsafe { std::ffi::CStr::from_ptr(host_entry.d_name.as_ptr()) }
.to_bytes()
.len();
if d_namlen > u32::max_value() as usize {
return Err(host::__WASI_EIO);
}
entry.d_ino = enc_inode(host_entry.d_ino);
entry.d_next = enc_dircookie(host_entry.d_off as u64);
entry.d_namlen = enc_u32(d_namlen as u32);
entry.d_type = enc_filetype(host_entry.d_type);
Ok(entry)
}
#[cfg(not(target_os = "linux"))]
pub fn dirent_from_host(
host_entry: &nix::libc::dirent,
) -> Result<wasm32::__wasi_dirent_t, host::__wasi_errno_t> {
let mut entry = unsafe { std::mem::zeroed::<wasm32::__wasi_dirent_t>() };
entry.d_ino = enc_inode(host_entry.d_ino);
entry.d_next = enc_dircookie(host_entry.d_seekoff);
entry.d_namlen = enc_u32(u32::from(host_entry.d_namlen));
entry.d_type = enc_filetype(host_entry.d_type);
Ok(entry)
}
}
pub fn dev_null() -> std::fs::File {
std::fs::File::open("/dev/null").expect("failed to open /dev/null")
}

0
src/sys/windows/mod.rs Normal file
View File

1878
src/wasm32.rs
View File

File diff suppressed because it is too large Load Diff