diff --git a/Cargo.toml b/Cargo.toml index 4fe49bfcb2..ba49f3d1cc 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,9 +14,6 @@ libc = "0.2" nix = "0.13" rand = "0.6" -[build-dependencies] -bindgen = "0.49.0" - [lib] name = "wasi_common" crate-type = ["rlib", "staticlib", "cdylib"] diff --git a/build.rs b/build.rs deleted file mode 100644 index 0e39fb4899..0000000000 --- a/build.rs +++ /dev/null @@ -1,96 +0,0 @@ -use std::env; -use std::fs::File; -use std::path::{Path, PathBuf}; -use std::process::{Command, Stdio}; - -fn wasi_sdk() -> PathBuf { - Path::new(&env::var("WASI_SDK").unwrap_or("/opt/wasi-sdk".to_owned())).to_path_buf() -} - -fn wasi_sysroot() -> PathBuf { - match env::var("WASI_SYSROOT") { - Ok(wasi_sysroot) => Path::new(&wasi_sysroot).to_path_buf(), - Err(_) => { - let mut path = wasi_sdk(); - path.push("share"); - path.push("sysroot"); - path - } - } -} - -fn wasm_clang_root() -> PathBuf { - match env::var("CLANG_ROOT") { - Ok(clang) => Path::new(&clang).to_path_buf(), - Err(_) => { - let mut path = wasi_sdk(); - path.push("lib"); - path.push("clang"); - path.push("8.0.0"); - path - } - } -} - -fn main() { - let wasi_sysroot = wasi_sysroot(); - let wasm_clang_root = wasm_clang_root(); - assert!( - wasi_sysroot.exists(), - "wasi-sysroot not present at {:?}", - wasi_sysroot - ); - assert!( - wasm_clang_root.exists(), - "clang-root not present at {:?}", - wasm_clang_root - ); - - let wasi_sysroot_core_h = wasi_sysroot.join("include/wasi/core.h"); - - assert!( - wasi_sysroot_core_h.exists(), - "wasi-sysroot core.h not present at {:?}", - wasi_sysroot_core_h - ); - - println!("cargo:rerun-if-changed={}", wasi_sysroot_core_h.display()); - - let out_path = PathBuf::from(env::var("OUT_DIR").unwrap()); - - let core_h_path = out_path.join("core.h"); - let core_h = File::create(&core_h_path).unwrap(); - - // `bindgen` doesn't understand typed constant macros like `UINT8_C(123)`, so this fun regex - // strips them off to yield a copy of `wasi/core.h` with bare constants. - let sed_result = Command::new("sed") - .arg("-E") - .arg(r#"s/U?INT[0-9]+_C\(((0x)?[0-9]+)\)/\1/g"#) - .arg(wasi_sysroot_core_h) - .stdout(Stdio::from(core_h)) - .status() - .expect("can execute sed"); - - if !sed_result.success() { - // something failed, but how? - match sed_result.code() { - Some(code) => panic!("sed failed with code {}", code), - None => panic!("sed exited abnormally"), - } - } - - let host_builder = bindgen::Builder::default() - .clang_arg("-nostdinc") - .clang_arg("-D__wasi__") - .clang_arg(format!("-isystem={}/include/", wasi_sysroot.display())) - .clang_arg(format!("-I{}/include/", wasm_clang_root.display())) - .header(core_h_path.to_str().unwrap()) - .whitelist_type("__wasi_.*") - .whitelist_var("__WASI_.*"); - - host_builder - .generate() - .expect("can generate host bindings") - .write_to_file(out_path.join("wasi_host.rs")) - .expect("can write host bindings"); -} diff --git a/src/ctx.rs b/src/ctx.rs index 1056d5d0fd..4771d9552b 100644 --- a/src/ctx.rs +++ b/src/ctx.rs @@ -225,12 +225,12 @@ impl WasiCtx { // validate rights if !fe.rights_base & rights_base != 0 || !fe.rights_inheriting & rights_inheriting != 0 { - Err(host::__WASI_ENOTCAPABLE as host::__wasi_errno_t) + Err(host::__WASI_ENOTCAPABLE) } else { Ok(fe) } } else { - Err(host::__WASI_EBADF as host::__wasi_errno_t) + Err(host::__WASI_EBADF) } } @@ -244,7 +244,7 @@ impl WasiCtx { if let Some(next_fd) = fd.checked_add(1) { fd = next_fd; } else { - return Err(host::__WASI_EMFILE as host::__wasi_errno_t); + return Err(host::__WASI_EMFILE); } } self.fds.insert(fd, fe); diff --git a/src/fdentry.rs b/src/fdentry.rs index c64ea9b6af..249e14c589 100644 --- a/src/fdentry.rs +++ b/src/fdentry.rs @@ -28,14 +28,14 @@ impl FromRawFd for FdEntry { let flags = OFlag::from_bits_truncate(flags_bits); let accmode = flags & OFlag::O_ACCMODE; if accmode == OFlag::O_RDONLY { - rights_base &= !host::__WASI_RIGHT_FD_WRITE as host::__wasi_rights_t; + rights_base &= !host::__WASI_RIGHT_FD_WRITE; } else if accmode == OFlag::O_WRONLY { - rights_base &= !host::__WASI_RIGHT_FD_READ as host::__wasi_rights_t; + rights_base &= !host::__WASI_RIGHT_FD_READ; } FdEntry { fd_object: FdObject { - ty: ty as u8, + ty: ty, rawfd, needs_close: true, }, @@ -107,7 +107,7 @@ pub unsafe fn determine_type_rights( host::RIGHTS_SOCKET_BASE, host::RIGHTS_SOCKET_INHERITING, ), - _ => return Err(host::__WASI_EINVAL as host::__wasi_errno_t), + _ => return Err(host::__WASI_EINVAL), } } else if ft.is_fifo() { ( @@ -116,14 +116,10 @@ pub unsafe fn determine_type_rights( host::RIGHTS_SOCKET_INHERITING, ) } else { - return Err(host::__WASI_EINVAL as host::__wasi_errno_t); + return Err(host::__WASI_EINVAL); } }; - Ok(( - ty as host::__wasi_filetype_t, - rights_base, - rights_inheriting, - )) + Ok((ty, rights_base, rights_inheriting)) } #[derive(Clone, Debug)] diff --git a/src/host.rs b/src/host.rs index b06b745743..ec025316ae 100644 --- a/src/host.rs +++ b/src/host.rs @@ -1,24 +1,482 @@ +//! WASI host types as defined in host. This file was originally generated +//! by running bindgen over wasi/core.h, and the content +//! still largely reflects that. + #![allow(non_camel_case_types)] #![allow(non_snake_case)] -include!(concat!(env!("OUT_DIR"), "/wasi_host.rs")); - pub type void = ::std::os::raw::c_void; -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 type __wasi_advice_t = u8; +pub const __WASI_ADVICE_NORMAL: __wasi_advice_t = 0; +pub const __WASI_ADVICE_SEQUENTIAL: __wasi_advice_t = 1; +pub const __WASI_ADVICE_RANDOM: __wasi_advice_t = 2; +pub const __WASI_ADVICE_WILLNEED: __wasi_advice_t = 3; +pub const __WASI_ADVICE_DONTNEED: __wasi_advice_t = 4; +pub const __WASI_ADVICE_NOREUSE: __wasi_advice_t = 5; + +pub type __wasi_clockid_t = u32; +pub const __WASI_CLOCK_REALTIME: __wasi_clockid_t = 0; +pub const __WASI_CLOCK_MONOTONIC: __wasi_clockid_t = 1; +pub const __WASI_CLOCK_PROCESS_CPUTIME_ID: __wasi_clockid_t = 2; +pub const __WASI_CLOCK_THREAD_CPUTIME_ID: __wasi_clockid_t = 3; + +pub type __wasi_device_t = u64; + +pub type __wasi_dircookie_t = u64; +pub const __WASI_DIRCOOKIE_START: __wasi_dircookie_t = 0; + +// WASI error codes +pub type __wasi_errno_t = u16; +pub const __WASI_ESUCCESS: __wasi_errno_t = 0; +pub const __WASI_E2BIG: __wasi_errno_t = 1; +pub const __WASI_EACCES: __wasi_errno_t = 2; +pub const __WASI_EADDRINUSE: __wasi_errno_t = 3; +pub const __WASI_EADDRNOTAVAIL: __wasi_errno_t = 4; +pub const __WASI_EAFNOSUPPORT: __wasi_errno_t = 5; +pub const __WASI_EAGAIN: __wasi_errno_t = 6; +pub const __WASI_EALREADY: __wasi_errno_t = 7; +pub const __WASI_EBADF: __wasi_errno_t = 8; +pub const __WASI_EBADMSG: __wasi_errno_t = 9; +pub const __WASI_EBUSY: __wasi_errno_t = 10; +pub const __WASI_ECANCELED: __wasi_errno_t = 11; +pub const __WASI_ECHILD: __wasi_errno_t = 12; +pub const __WASI_ECONNABORTED: __wasi_errno_t = 13; +pub const __WASI_ECONNREFUSED: __wasi_errno_t = 14; +pub const __WASI_ECONNRESET: __wasi_errno_t = 15; +pub const __WASI_EDEADLK: __wasi_errno_t = 16; +pub const __WASI_EDESTADDRREQ: __wasi_errno_t = 17; +pub const __WASI_EDOM: __wasi_errno_t = 18; +pub const __WASI_EDQUOT: __wasi_errno_t = 19; +pub const __WASI_EEXIST: __wasi_errno_t = 20; +pub const __WASI_EFAULT: __wasi_errno_t = 21; +pub const __WASI_EFBIG: __wasi_errno_t = 22; +pub const __WASI_EHOSTUNREACH: __wasi_errno_t = 23; +pub const __WASI_EIDRM: __wasi_errno_t = 24; +pub const __WASI_EILSEQ: __wasi_errno_t = 25; +pub const __WASI_EINPROGRESS: __wasi_errno_t = 26; +pub const __WASI_EINTR: __wasi_errno_t = 27; +pub const __WASI_EINVAL: __wasi_errno_t = 28; +pub const __WASI_EIO: __wasi_errno_t = 29; +pub const __WASI_EISCONN: __wasi_errno_t = 30; +pub const __WASI_EISDIR: __wasi_errno_t = 31; +pub const __WASI_ELOOP: __wasi_errno_t = 32; +pub const __WASI_EMFILE: __wasi_errno_t = 33; +pub const __WASI_EMLINK: __wasi_errno_t = 34; +pub const __WASI_EMSGSIZE: __wasi_errno_t = 35; +pub const __WASI_EMULTIHOP: __wasi_errno_t = 36; +pub const __WASI_ENAMETOOLONG: __wasi_errno_t = 37; +pub const __WASI_ENETDOWN: __wasi_errno_t = 38; +pub const __WASI_ENETRESET: __wasi_errno_t = 39; +pub const __WASI_ENETUNREACH: __wasi_errno_t = 40; +pub const __WASI_ENFILE: __wasi_errno_t = 41; +pub const __WASI_ENOBUFS: __wasi_errno_t = 42; +pub const __WASI_ENODEV: __wasi_errno_t = 43; +pub const __WASI_ENOENT: __wasi_errno_t = 44; +pub const __WASI_ENOEXEC: __wasi_errno_t = 45; +pub const __WASI_ENOLCK: __wasi_errno_t = 46; +pub const __WASI_ENOLINK: __wasi_errno_t = 47; +pub const __WASI_ENOMEM: __wasi_errno_t = 48; +pub const __WASI_ENOMSG: __wasi_errno_t = 49; +pub const __WASI_ENOPROTOOPT: __wasi_errno_t = 50; +pub const __WASI_ENOSPC: __wasi_errno_t = 51; +pub const __WASI_ENOSYS: __wasi_errno_t = 52; +pub const __WASI_ENOTCONN: __wasi_errno_t = 53; +pub const __WASI_ENOTDIR: __wasi_errno_t = 54; +pub const __WASI_ENOTEMPTY: __wasi_errno_t = 55; +pub const __WASI_ENOTRECOVERABLE: __wasi_errno_t = 56; +pub const __WASI_ENOTSOCK: __wasi_errno_t = 57; +pub const __WASI_ENOTSUP: __wasi_errno_t = 58; +pub const __WASI_ENOTTY: __wasi_errno_t = 59; +pub const __WASI_ENXIO: __wasi_errno_t = 60; +pub const __WASI_EOVERFLOW: __wasi_errno_t = 61; +pub const __WASI_EOWNERDEAD: __wasi_errno_t = 62; +pub const __WASI_EPERM: __wasi_errno_t = 63; +pub const __WASI_EPIPE: __wasi_errno_t = 64; +pub const __WASI_EPROTO: __wasi_errno_t = 65; +pub const __WASI_EPROTONOSUPPORT: __wasi_errno_t = 66; +pub const __WASI_EPROTOTYPE: __wasi_errno_t = 67; +pub const __WASI_ERANGE: __wasi_errno_t = 68; +pub const __WASI_EROFS: __wasi_errno_t = 69; +pub const __WASI_ESPIPE: __wasi_errno_t = 70; +pub const __WASI_ESRCH: __wasi_errno_t = 71; +pub const __WASI_ESTALE: __wasi_errno_t = 72; +pub const __WASI_ETIMEDOUT: __wasi_errno_t = 73; +pub const __WASI_ETXTBSY: __wasi_errno_t = 74; +pub const __WASI_EXDEV: __wasi_errno_t = 75; +pub const __WASI_ENOTCAPABLE: __wasi_errno_t = 76; + +pub type __wasi_eventrwflags_t = u16; +pub const __WASI_EVENT_FD_READWRITE_HANGUP: __wasi_eventrwflags_t = 0x0001; + +pub type __wasi_eventtype_t = u8; +pub const __WASI_EVENTTYPE_CLOCK: __wasi_eventtype_t = 0; +pub const __WASI_EVENTTYPE_FD_READ: __wasi_eventtype_t = 1; +pub const __WASI_EVENTTYPE_FD_WRITE: __wasi_eventtype_t = 2; + +pub type __wasi_exitcode_t = u32; + +pub type __wasi_fd_t = u32; + +pub type __wasi_fdflags_t = u16; +pub const __WASI_FDFLAG_APPEND: __wasi_fdflags_t = 0x0001; +pub const __WASI_FDFLAG_DSYNC: __wasi_fdflags_t = 0x0002; +pub const __WASI_FDFLAG_NONBLOCK: __wasi_fdflags_t = 0x0004; +pub const __WASI_FDFLAG_RSYNC: __wasi_fdflags_t = 0x0008; +pub const __WASI_FDFLAG_SYNC: __wasi_fdflags_t = 0x0010; + +pub type __wasi_filedelta_t = i64; + +pub type __wasi_filesize_t = u64; + +pub type __wasi_filetype_t = u8; +pub const __WASI_FILETYPE_UNKNOWN: __wasi_filetype_t = 0; +pub const __WASI_FILETYPE_BLOCK_DEVICE: __wasi_filetype_t = 1; +pub const __WASI_FILETYPE_CHARACTER_DEVICE: __wasi_filetype_t = 2; +pub const __WASI_FILETYPE_DIRECTORY: __wasi_filetype_t = 3; +pub const __WASI_FILETYPE_REGULAR_FILE: __wasi_filetype_t = 4; +pub const __WASI_FILETYPE_SOCKET_DGRAM: __wasi_filetype_t = 5; +pub const __WASI_FILETYPE_SOCKET_STREAM: __wasi_filetype_t = 6; +pub const __WASI_FILETYPE_SYMBOLIC_LINK: __wasi_filetype_t = 7; + +pub type __wasi_fstflags_t = u16; +pub const __WASI_FILESTAT_SET_ATIM: __wasi_fstflags_t = 0x0001; +pub const __WASI_FILESTAT_SET_ATIM_NOW: __wasi_fstflags_t = 0x0002; +pub const __WASI_FILESTAT_SET_MTIM: __wasi_fstflags_t = 0x0004; +pub const __WASI_FILESTAT_SET_MTIM_NOW: __wasi_fstflags_t = 0x0008; + +pub type __wasi_inode_t = u64; + +pub type __wasi_linkcount_t = u32; + +pub type __wasi_lookupflags_t = u32; +pub const __WASI_LOOKUP_SYMLINK_FOLLOW: __wasi_lookupflags_t = 0x00000001; + +pub type __wasi_oflags_t = u16; +pub const __WASI_O_CREAT: __wasi_oflags_t = 0x0001; +pub const __WASI_O_DIRECTORY: __wasi_oflags_t = 0x0002; +pub const __WASI_O_EXCL: __wasi_oflags_t = 0x0004; +pub const __WASI_O_TRUNC: __wasi_oflags_t = 0x0008; + +pub type __wasi_riflags_t = u16; +pub const __WASI_SOCK_RECV_PEEK: __wasi_riflags_t = 0x0001; +pub const __WASI_SOCK_RECV_WAITALL: __wasi_riflags_t = 0x0002; + +pub type __wasi_rights_t = u64; +pub const __WASI_RIGHT_FD_DATASYNC: __wasi_rights_t = 0x0000000000000001; +pub const __WASI_RIGHT_FD_READ: __wasi_rights_t = 0x0000000000000002; +pub const __WASI_RIGHT_FD_SEEK: __wasi_rights_t = 0x0000000000000004; +pub const __WASI_RIGHT_FD_FDSTAT_SET_FLAGS: __wasi_rights_t = 0x0000000000000008; +pub const __WASI_RIGHT_FD_SYNC: __wasi_rights_t = 0x0000000000000010; +pub const __WASI_RIGHT_FD_TELL: __wasi_rights_t = 0x0000000000000020; +pub const __WASI_RIGHT_FD_WRITE: __wasi_rights_t = 0x0000000000000040; +pub const __WASI_RIGHT_FD_ADVISE: __wasi_rights_t = 0x0000000000000080; +pub const __WASI_RIGHT_FD_ALLOCATE: __wasi_rights_t = 0x0000000000000100; +pub const __WASI_RIGHT_PATH_CREATE_DIRECTORY: __wasi_rights_t = 0x0000000000000200; +pub const __WASI_RIGHT_PATH_CREATE_FILE: __wasi_rights_t = 0x0000000000000400; +pub const __WASI_RIGHT_PATH_LINK_SOURCE: __wasi_rights_t = 0x0000000000000800; +pub const __WASI_RIGHT_PATH_LINK_TARGET: __wasi_rights_t = 0x0000000000001000; +pub const __WASI_RIGHT_PATH_OPEN: __wasi_rights_t = 0x0000000000002000; +pub const __WASI_RIGHT_FD_READDIR: __wasi_rights_t = 0x0000000000004000; +pub const __WASI_RIGHT_PATH_READLINK: __wasi_rights_t = 0x0000000000008000; +pub const __WASI_RIGHT_PATH_RENAME_SOURCE: __wasi_rights_t = 0x0000000000010000; +pub const __WASI_RIGHT_PATH_RENAME_TARGET: __wasi_rights_t = 0x0000000000020000; +pub const __WASI_RIGHT_PATH_FILESTAT_GET: __wasi_rights_t = 0x0000000000040000; +pub const __WASI_RIGHT_PATH_FILESTAT_SET_SIZE: __wasi_rights_t = 0x0000000000080000; +pub const __WASI_RIGHT_PATH_FILESTAT_SET_TIMES: __wasi_rights_t = 0x0000000000100000; +pub const __WASI_RIGHT_FD_FILESTAT_GET: __wasi_rights_t = 0x0000000000200000; +pub const __WASI_RIGHT_FD_FILESTAT_SET_SIZE: __wasi_rights_t = 0x0000000000400000; +pub const __WASI_RIGHT_FD_FILESTAT_SET_TIMES: __wasi_rights_t = 0x0000000000800000; +pub const __WASI_RIGHT_PATH_SYMLINK: __wasi_rights_t = 0x0000000001000000; +pub const __WASI_RIGHT_PATH_REMOVE_DIRECTORY: __wasi_rights_t = 0x0000000002000000; +pub const __WASI_RIGHT_PATH_UNLINK_FILE: __wasi_rights_t = 0x0000000004000000; +pub const __WASI_RIGHT_POLL_FD_READWRITE: __wasi_rights_t = 0x0000000008000000; +pub const __WASI_RIGHT_SOCK_SHUTDOWN: __wasi_rights_t = 0x0000000010000000; + +pub const RIGHTS_ALL: __wasi_rights_t = __WASI_RIGHT_FD_DATASYNC + | __WASI_RIGHT_FD_READ + | __WASI_RIGHT_FD_SEEK + | __WASI_RIGHT_FD_FDSTAT_SET_FLAGS + | __WASI_RIGHT_FD_SYNC + | __WASI_RIGHT_FD_TELL + | __WASI_RIGHT_FD_WRITE + | __WASI_RIGHT_FD_ADVISE + | __WASI_RIGHT_FD_ALLOCATE + | __WASI_RIGHT_PATH_CREATE_DIRECTORY + | __WASI_RIGHT_PATH_CREATE_FILE + | __WASI_RIGHT_PATH_LINK_SOURCE + | __WASI_RIGHT_PATH_LINK_TARGET + | __WASI_RIGHT_PATH_OPEN + | __WASI_RIGHT_FD_READDIR + | __WASI_RIGHT_PATH_READLINK + | __WASI_RIGHT_PATH_RENAME_SOURCE + | __WASI_RIGHT_PATH_RENAME_TARGET + | __WASI_RIGHT_PATH_FILESTAT_GET + | __WASI_RIGHT_PATH_FILESTAT_SET_SIZE + | __WASI_RIGHT_PATH_FILESTAT_SET_TIMES + | __WASI_RIGHT_FD_FILESTAT_GET + | __WASI_RIGHT_FD_FILESTAT_SET_SIZE + | __WASI_RIGHT_FD_FILESTAT_SET_TIMES + | __WASI_RIGHT_PATH_SYMLINK + | __WASI_RIGHT_PATH_UNLINK_FILE + | __WASI_RIGHT_PATH_REMOVE_DIRECTORY + | __WASI_RIGHT_POLL_FD_READWRITE + | __WASI_RIGHT_SOCK_SHUTDOWN; + +// Block and character device interaction is outside the scope of +// CloudABI. Simply allow everything. +pub const RIGHTS_BLOCK_DEVICE_BASE: __wasi_rights_t = RIGHTS_ALL; +pub const RIGHTS_BLOCK_DEVICE_INHERITING: __wasi_rights_t = RIGHTS_ALL; +pub const RIGHTS_CHARACTER_DEVICE_BASE: __wasi_rights_t = RIGHTS_ALL; +pub const RIGHTS_CHARACTER_DEVICE_INHERITING: __wasi_rights_t = RIGHTS_ALL; + +// Only allow directory operations on directories. Directories can only +// yield file descriptors to other directories and files. +pub const RIGHTS_DIRECTORY_BASE: __wasi_rights_t = __WASI_RIGHT_FD_FDSTAT_SET_FLAGS + | __WASI_RIGHT_FD_SYNC + | __WASI_RIGHT_FD_ADVISE + | __WASI_RIGHT_PATH_CREATE_DIRECTORY + | __WASI_RIGHT_PATH_CREATE_FILE + | __WASI_RIGHT_PATH_LINK_SOURCE + | __WASI_RIGHT_PATH_LINK_TARGET + | __WASI_RIGHT_PATH_OPEN + | __WASI_RIGHT_FD_READDIR + | __WASI_RIGHT_PATH_READLINK + | __WASI_RIGHT_PATH_RENAME_SOURCE + | __WASI_RIGHT_PATH_RENAME_TARGET + | __WASI_RIGHT_PATH_FILESTAT_GET + | __WASI_RIGHT_PATH_FILESTAT_SET_SIZE + | __WASI_RIGHT_PATH_FILESTAT_SET_TIMES + | __WASI_RIGHT_FD_FILESTAT_GET + | __WASI_RIGHT_FD_FILESTAT_SET_SIZE + | __WASI_RIGHT_FD_FILESTAT_SET_TIMES + | __WASI_RIGHT_PATH_SYMLINK + | __WASI_RIGHT_PATH_UNLINK_FILE + | __WASI_RIGHT_PATH_REMOVE_DIRECTORY + | __WASI_RIGHT_POLL_FD_READWRITE; +pub const RIGHTS_DIRECTORY_INHERITING: __wasi_rights_t = + RIGHTS_DIRECTORY_BASE | RIGHTS_REGULAR_FILE_BASE; + +// Operations that apply to regular files. +pub const RIGHTS_REGULAR_FILE_BASE: __wasi_rights_t = __WASI_RIGHT_FD_DATASYNC + | __WASI_RIGHT_FD_READ + | __WASI_RIGHT_FD_SEEK + | __WASI_RIGHT_FD_FDSTAT_SET_FLAGS + | __WASI_RIGHT_FD_SYNC + | __WASI_RIGHT_FD_TELL + | __WASI_RIGHT_FD_WRITE + | __WASI_RIGHT_FD_ADVISE + | __WASI_RIGHT_FD_ALLOCATE + | __WASI_RIGHT_FD_FILESTAT_GET + | __WASI_RIGHT_FD_FILESTAT_SET_SIZE + | __WASI_RIGHT_FD_FILESTAT_SET_TIMES + | __WASI_RIGHT_POLL_FD_READWRITE; +pub const RIGHTS_REGULAR_FILE_INHERITING: __wasi_rights_t = 0; + +// Operations that apply to shared memory objects. +pub const RIGHTS_SHARED_MEMORY_BASE: __wasi_rights_t = __WASI_RIGHT_FD_READ + | __WASI_RIGHT_FD_WRITE + | __WASI_RIGHT_FD_FILESTAT_GET + | __WASI_RIGHT_FD_FILESTAT_SET_SIZE; +pub const RIGHTS_SHARED_MEMORY_INHERITING: __wasi_rights_t = 0; + +// Operations that apply to sockets and socket pairs. +pub const RIGHTS_SOCKET_BASE: __wasi_rights_t = __WASI_RIGHT_FD_READ + | __WASI_RIGHT_FD_FDSTAT_SET_FLAGS + | __WASI_RIGHT_FD_WRITE + | __WASI_RIGHT_FD_FILESTAT_GET + | __WASI_RIGHT_POLL_FD_READWRITE + | __WASI_RIGHT_SOCK_SHUTDOWN; +pub const RIGHTS_SOCKET_INHERITING: __wasi_rights_t = RIGHTS_ALL; + +// Operations that apply to TTYs. +pub const RIGHTS_TTY_BASE: __wasi_rights_t = __WASI_RIGHT_FD_READ + | __WASI_RIGHT_FD_FDSTAT_SET_FLAGS + | __WASI_RIGHT_FD_WRITE + | __WASI_RIGHT_FD_FILESTAT_GET + | __WASI_RIGHT_POLL_FD_READWRITE; +pub const RIGHTS_TTY_INHERITING: __wasi_rights_t = 0; + +pub type __wasi_roflags_t = u16; +pub const __WASI_SOCK_RECV_DATA_TRUNCATED: __wasi_roflags_t = 0x0001; + +pub type __wasi_sdflags_t = u8; +pub const __WASI_SHUT_RD: __wasi_sdflags_t = 0x01; +pub const __WASI_SHUT_WR: __wasi_sdflags_t = 0x02; + +pub type __wasi_siflags_t = u16; + +pub type __wasi_signal_t = u8; +// 0 is reserved; POSIX has special semantics for kill(pid, 0). +pub const __WASI_SIGHUP: __wasi_signal_t = 1; +pub const __WASI_SIGINT: __wasi_signal_t = 2; +pub const __WASI_SIGQUIT: __wasi_signal_t = 3; +pub const __WASI_SIGILL: __wasi_signal_t = 4; +pub const __WASI_SIGTRAP: __wasi_signal_t = 5; +pub const __WASI_SIGABRT: __wasi_signal_t = 6; +pub const __WASI_SIGBUS: __wasi_signal_t = 7; +pub const __WASI_SIGFPE: __wasi_signal_t = 8; +pub const __WASI_SIGKILL: __wasi_signal_t = 9; +pub const __WASI_SIGUSR1: __wasi_signal_t = 10; +pub const __WASI_SIGSEGV: __wasi_signal_t = 11; +pub const __WASI_SIGUSR2: __wasi_signal_t = 12; +pub const __WASI_SIGPIPE: __wasi_signal_t = 13; +pub const __WASI_SIGALRM: __wasi_signal_t = 14; +pub const __WASI_SIGTERM: __wasi_signal_t = 15; +pub const __WASI_SIGCHLD: __wasi_signal_t = 16; +pub const __WASI_SIGCONT: __wasi_signal_t = 17; +pub const __WASI_SIGSTOP: __wasi_signal_t = 18; +pub const __WASI_SIGTSTP: __wasi_signal_t = 19; +pub const __WASI_SIGTTIN: __wasi_signal_t = 20; +pub const __WASI_SIGTTOU: __wasi_signal_t = 21; +pub const __WASI_SIGURG: __wasi_signal_t = 22; +pub const __WASI_SIGXCPU: __wasi_signal_t = 23; +pub const __WASI_SIGXFSZ: __wasi_signal_t = 24; +pub const __WASI_SIGVTALRM: __wasi_signal_t = 25; +pub const __WASI_SIGPROF: __wasi_signal_t = 26; +pub const __WASI_SIGWINCH: __wasi_signal_t = 27; +pub const __WASI_SIGPOLL: __wasi_signal_t = 28; +pub const __WASI_SIGPWR: __wasi_signal_t = 29; +pub const __WASI_SIGSYS: __wasi_signal_t = 30; + +pub type __wasi_subclockflags_t = u16; +pub const __WASI_SUBSCRIPTION_CLOCK_ABSTIME: __wasi_subclockflags_t = 0x0001; + +pub type __wasi_timestamp_t = u64; + +pub type __wasi_userdata_t = u64; + +pub type __wasi_whence_t = u8; +pub const __WASI_WHENCE_CUR: __wasi_whence_t = 0; +pub const __WASI_WHENCE_END: __wasi_whence_t = 1; +pub const __WASI_WHENCE_SET: __wasi_whence_t = 2; + +pub type __wasi_preopentype_t = u8; +pub const __WASI_PREOPENTYPE_DIR: __wasi_preopentype_t = 0; + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __wasi_dirent_t { + pub d_next: __wasi_dircookie_t, + pub d_ino: __wasi_inode_t, + pub d_namlen: u32, + pub d_type: __wasi_filetype_t, } -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) +#[repr(C)] +#[derive(Copy, Clone)] +pub struct __wasi_event_t { + pub userdata: __wasi_userdata_t, + pub error: __wasi_errno_t, + pub type_: __wasi_eventtype_t, + pub u: __wasi_event_t___wasi_event_u, +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub union __wasi_event_t___wasi_event_u { + pub fd_readwrite: __wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t, + _bindgen_union_align: [u64; 2usize], +} + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t { + pub nbytes: __wasi_filesize_t, + pub flags: __wasi_eventrwflags_t, +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct __wasi_prestat_t { + pub pr_type: __wasi_preopentype_t, + pub u: __wasi_prestat_t___wasi_prestat_u, +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub union __wasi_prestat_t___wasi_prestat_u { + pub dir: __wasi_prestat_t___wasi_prestat_u___wasi_prestat_u_dir_t, + _bindgen_union_align: u64, +} + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __wasi_prestat_t___wasi_prestat_u___wasi_prestat_u_dir_t { + pub pr_name_len: usize, +} + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __wasi_fdstat_t { + pub fs_filetype: __wasi_filetype_t, + pub fs_flags: __wasi_fdflags_t, + pub fs_rights_base: __wasi_rights_t, + pub fs_rights_inheriting: __wasi_rights_t, +} + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __wasi_filestat_t { + pub st_dev: __wasi_device_t, + pub st_ino: __wasi_inode_t, + pub st_filetype: __wasi_filetype_t, + pub st_nlink: __wasi_linkcount_t, + pub st_size: __wasi_filesize_t, + pub st_atim: __wasi_timestamp_t, + pub st_mtim: __wasi_timestamp_t, + pub st_ctim: __wasi_timestamp_t, +} + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __wasi_ciovec_t { + pub buf: *const void, + pub buf_len: usize, +} + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __wasi_iovec_t { + pub buf: *mut void, + pub buf_len: usize, +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct __wasi_subscription_t { + pub userdata: __wasi_userdata_t, + pub type_: __wasi_eventtype_t, + pub u: __wasi_subscription_t___wasi_subscription_u, +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub union __wasi_subscription_t___wasi_subscription_u { + pub clock: __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_clock_t, + pub fd_readwrite: + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_fd_readwrite_t, + _bindgen_union_align: [u64; 5usize], +} + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_clock_t { + pub identifier: __wasi_userdata_t, + pub clock_id: __wasi_clockid_t, + pub timeout: __wasi_timestamp_t, + pub precision: __wasi_timestamp_t, + pub flags: __wasi_subclockflags_t, +} + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_fd_readwrite_t { + pub fd: __wasi_fd_t, } pub fn errno_from_nix(errno: nix::errno::Errno) -> __wasi_errno_t { - let e = match errno { + match errno { nix::errno::Errno::EPERM => __WASI_EPERM, nix::errno::Errno::ENOENT => __WASI_ENOENT, nix::errno::Errno::ESRCH => __WASI_ESRCH, @@ -94,32 +552,43 @@ pub fn errno_from_nix(errno: nix::errno::Errno) -> __wasi_errno_t { nix::errno::Errno::EOWNERDEAD => __WASI_EOWNERDEAD, nix::errno::Errno::ENOTRECOVERABLE => __WASI_ENOTRECOVERABLE, _ => __WASI_ENOSYS, - }; - e as __wasi_errno_t + } +} + +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) } #[cfg(target_os = "linux")] -const O_RSYNC: nix::fcntl::OFlag = nix::fcntl::OFlag::O_RSYNC; +pub const O_RSYNC: nix::fcntl::OFlag = nix::fcntl::OFlag::O_RSYNC; #[cfg(not(target_os = "linux"))] -const O_RSYNC: nix::fcntl::OFlag = nix::fcntl::OFlag::O_SYNC; +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 as __wasi_fdflags_t) != 0 { + if fdflags & __WASI_FDFLAG_APPEND != 0 { nix_flags.insert(OFlag::O_APPEND); } - if fdflags & (__WASI_FDFLAG_DSYNC as __wasi_fdflags_t) != 0 { + if fdflags & __WASI_FDFLAG_DSYNC != 0 { nix_flags.insert(OFlag::O_DSYNC); } - if fdflags & (__WASI_FDFLAG_NONBLOCK as __wasi_fdflags_t) != 0 { + if fdflags & __WASI_FDFLAG_NONBLOCK != 0 { nix_flags.insert(OFlag::O_NONBLOCK); } - if fdflags & (__WASI_FDFLAG_RSYNC as __wasi_fdflags_t) != 0 { + if fdflags & __WASI_FDFLAG_RSYNC != 0 { nix_flags.insert(O_RSYNC); } - if fdflags & (__WASI_FDFLAG_SYNC as __wasi_fdflags_t) != 0 { + if fdflags & __WASI_FDFLAG_SYNC != 0 { nix_flags.insert(OFlag::O_SYNC); } nix_flags @@ -143,22 +612,22 @@ pub fn fdflags_from_nix(oflags: nix::fcntl::OFlag) -> __wasi_fdflags_t { if oflags.contains(OFlag::O_SYNC) { fdflags |= __WASI_FDFLAG_SYNC; } - fdflags as __wasi_fdflags_t + 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 as __wasi_oflags_t) != 0 { + if oflags & __WASI_O_CREAT != 0 { nix_flags.insert(OFlag::O_CREAT); } - if oflags & (__WASI_O_DIRECTORY as __wasi_oflags_t) != 0 { + if oflags & __WASI_O_DIRECTORY != 0 { nix_flags.insert(OFlag::O_DIRECTORY); } - if oflags & (__WASI_O_EXCL as __wasi_oflags_t) != 0 { + if oflags & __WASI_O_EXCL != 0 { nix_flags.insert(OFlag::O_EXCL); } - if oflags & (__WASI_O_TRUNC as __wasi_oflags_t) != 0 { + if oflags & __WASI_O_TRUNC != 0 { nix_flags.insert(OFlag::O_TRUNC); } nix_flags @@ -167,42 +636,42 @@ pub fn nix_from_oflags(oflags: __wasi_oflags_t) -> nix::fcntl::OFlag { 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 as __wasi_filetype_t + __WASI_FILETYPE_CHARACTER_DEVICE } else if sflags.contains(SFlag::S_IFBLK) { - __WASI_FILETYPE_BLOCK_DEVICE as __wasi_filetype_t + __WASI_FILETYPE_BLOCK_DEVICE } else if sflags.contains(SFlag::S_IFIFO) | sflags.contains(SFlag::S_IFSOCK) { - __WASI_FILETYPE_SOCKET_STREAM as __wasi_filetype_t + __WASI_FILETYPE_SOCKET_STREAM } else if sflags.contains(SFlag::S_IFDIR) { - __WASI_FILETYPE_DIRECTORY as __wasi_filetype_t + __WASI_FILETYPE_DIRECTORY } else if sflags.contains(SFlag::S_IFREG) { - __WASI_FILETYPE_REGULAR_FILE as __wasi_filetype_t + __WASI_FILETYPE_REGULAR_FILE } else if sflags.contains(SFlag::S_IFLNK) { - __WASI_FILETYPE_SYMBOLIC_LINK as __wasi_filetype_t + __WASI_FILETYPE_SYMBOLIC_LINK } else { - __WASI_FILETYPE_UNKNOWN as __wasi_filetype_t + __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 as __wasi_filetype_t) != 0 { + if sflags & __WASI_FILETYPE_CHARACTER_DEVICE != 0 { nix_sflags.insert(SFlag::S_IFCHR); } - if sflags & (__WASI_FILETYPE_BLOCK_DEVICE as __wasi_filetype_t) != 0 { + if sflags & __WASI_FILETYPE_BLOCK_DEVICE != 0 { nix_sflags.insert(SFlag::S_IFBLK); } - if sflags & (__WASI_FILETYPE_SOCKET_STREAM as __wasi_filetype_t) != 0 { + if sflags & __WASI_FILETYPE_SOCKET_STREAM != 0 { nix_sflags.insert(SFlag::S_IFIFO); nix_sflags.insert(SFlag::S_IFSOCK); } - if sflags & (__WASI_FILETYPE_DIRECTORY as __wasi_filetype_t) != 0 { + if sflags & __WASI_FILETYPE_DIRECTORY != 0 { nix_sflags.insert(SFlag::S_IFDIR); } - if sflags & (__WASI_FILETYPE_REGULAR_FILE as __wasi_filetype_t) != 0 { + if sflags & __WASI_FILETYPE_REGULAR_FILE != 0 { nix_sflags.insert(SFlag::S_IFREG); } - if sflags & (__WASI_FILETYPE_SYMBOLIC_LINK as __wasi_filetype_t) != 0 { + if sflags & __WASI_FILETYPE_SYMBOLIC_LINK != 0 { nix_sflags.insert(SFlag::S_IFLNK); } nix_sflags @@ -222,114 +691,757 @@ pub fn filestat_from_nix(filestat: nix::sys::stat::FileStat) -> __wasi_filestat_ } } -// Rights sets from wasmtime-wasi sandboxed system primitives. Transcribed because bindgen can't -// parse the #defines. +#[cfg(test)] +mod tests { + use super::*; -pub const RIGHTS_ALL: __wasi_rights_t = (__WASI_RIGHT_FD_DATASYNC - | __WASI_RIGHT_FD_READ - | __WASI_RIGHT_FD_SEEK - | __WASI_RIGHT_FD_FDSTAT_SET_FLAGS - | __WASI_RIGHT_FD_SYNC - | __WASI_RIGHT_FD_TELL - | __WASI_RIGHT_FD_WRITE - | __WASI_RIGHT_FD_ADVISE - | __WASI_RIGHT_FD_ALLOCATE - | __WASI_RIGHT_PATH_CREATE_DIRECTORY - | __WASI_RIGHT_PATH_CREATE_FILE - | __WASI_RIGHT_PATH_LINK_SOURCE - | __WASI_RIGHT_PATH_LINK_TARGET - | __WASI_RIGHT_PATH_OPEN - | __WASI_RIGHT_FD_READDIR - | __WASI_RIGHT_PATH_READLINK - | __WASI_RIGHT_PATH_RENAME_SOURCE - | __WASI_RIGHT_PATH_RENAME_TARGET - | __WASI_RIGHT_PATH_FILESTAT_GET - | __WASI_RIGHT_PATH_FILESTAT_SET_SIZE - | __WASI_RIGHT_PATH_FILESTAT_SET_TIMES - | __WASI_RIGHT_FD_FILESTAT_GET - | __WASI_RIGHT_FD_FILESTAT_SET_SIZE - | __WASI_RIGHT_FD_FILESTAT_SET_TIMES - | __WASI_RIGHT_PATH_SYMLINK - | __WASI_RIGHT_PATH_UNLINK_FILE - | __WASI_RIGHT_PATH_REMOVE_DIRECTORY - | __WASI_RIGHT_POLL_FD_READWRITE - | __WASI_RIGHT_SOCK_SHUTDOWN) as __wasi_rights_t; + #[test] + fn bindgen_test_layout___wasi_dirent_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_dirent_t>(), + 24usize, + concat!("Size of: ", stringify!(__wasi_dirent_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_dirent_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_dirent_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_next as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_next) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_ino as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_ino) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_namlen as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_namlen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_type as *const _ as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_type) + ) + ); + } -// Block and character device interaction is outside the scope of -// CloudABI. Simply allow everything. -pub const RIGHTS_BLOCK_DEVICE_BASE: __wasi_rights_t = RIGHTS_ALL; -pub const RIGHTS_BLOCK_DEVICE_INHERITING: __wasi_rights_t = RIGHTS_ALL; -pub const RIGHTS_CHARACTER_DEVICE_BASE: __wasi_rights_t = RIGHTS_ALL; -pub const RIGHTS_CHARACTER_DEVICE_INHERITING: __wasi_rights_t = RIGHTS_ALL; + #[test] + fn bindgen_test_layout___wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_fd_readwrite_t( + ) { + assert_eq!( + ::std::mem::size_of::< + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_fd_readwrite_t, + >(), + 4usize, + concat!( + "Size of: ", + stringify!( + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_fd_readwrite_t + ) + ) + ); + assert_eq!( + ::std::mem::align_of::< + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_fd_readwrite_t, + >(), + 4usize, + concat!( + "Alignment of ", + stringify!( + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_fd_readwrite_t + ) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::< + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_fd_readwrite_t, + >())) + .fd as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!( + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_fd_readwrite_t + ), + "::", + stringify!(fd) + ) + ); + } + #[test] + fn bindgen_test_layout___wasi_subscription_t___wasi_subscription_u() { + assert_eq!( + ::std::mem::size_of::<__wasi_subscription_t___wasi_subscription_u>(), + 40usize, + concat!( + "Size of: ", + stringify!(__wasi_subscription_t___wasi_subscription_u) + ) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_subscription_t___wasi_subscription_u>(), + 8usize, + concat!( + "Alignment of ", + stringify!(__wasi_subscription_t___wasi_subscription_u) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_t___wasi_subscription_u>())).clock + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_t___wasi_subscription_u), + "::", + stringify!(clock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_t___wasi_subscription_u>())).fd_readwrite + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_t___wasi_subscription_u), + "::", + stringify!(fd_readwrite) + ) + ); + } + #[test] + fn bindgen_test_layout___wasi_subscription_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_subscription_t>(), + 56usize, + concat!("Size of: ", stringify!(__wasi_subscription_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_subscription_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_subscription_t)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_t>())).userdata as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_t), + "::", + stringify!(userdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_subscription_t>())).type_ as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_t), + "::", + stringify!(type_) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_subscription_t>())).u as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_t), + "::", + stringify!(u) + ) + ); + } -// Only allow directory operations on directories. Directories can only -// yield file descriptors to other directories and files. -pub const RIGHTS_DIRECTORY_BASE: __wasi_rights_t = (__WASI_RIGHT_FD_FDSTAT_SET_FLAGS - | __WASI_RIGHT_FD_SYNC - | __WASI_RIGHT_FD_ADVISE - | __WASI_RIGHT_PATH_CREATE_DIRECTORY - | __WASI_RIGHT_PATH_CREATE_FILE - | __WASI_RIGHT_PATH_LINK_SOURCE - | __WASI_RIGHT_PATH_LINK_TARGET - | __WASI_RIGHT_PATH_OPEN - | __WASI_RIGHT_FD_READDIR - | __WASI_RIGHT_PATH_READLINK - | __WASI_RIGHT_PATH_RENAME_SOURCE - | __WASI_RIGHT_PATH_RENAME_TARGET - | __WASI_RIGHT_PATH_FILESTAT_GET - | __WASI_RIGHT_PATH_FILESTAT_SET_SIZE - | __WASI_RIGHT_PATH_FILESTAT_SET_TIMES - | __WASI_RIGHT_FD_FILESTAT_GET - | __WASI_RIGHT_FD_FILESTAT_SET_SIZE - | __WASI_RIGHT_FD_FILESTAT_SET_TIMES - | __WASI_RIGHT_PATH_SYMLINK - | __WASI_RIGHT_PATH_UNLINK_FILE - | __WASI_RIGHT_PATH_REMOVE_DIRECTORY - | __WASI_RIGHT_POLL_FD_READWRITE) - as __wasi_rights_t; -pub const RIGHTS_DIRECTORY_INHERITING: __wasi_rights_t = - (RIGHTS_DIRECTORY_BASE | RIGHTS_REGULAR_FILE_BASE); + #[test] + fn bindgen_test_layout___wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_clock_t( + ) { + assert_eq!( + ::std::mem::size_of::< + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_clock_t, + >(), + 40usize, + concat!( + "Size of: ", + stringify!( + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_clock_t + ) + ) + ); + assert_eq!( + ::std::mem::align_of::< + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_clock_t, + >(), + 8usize, + concat!( + "Alignment of ", + stringify!( + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_clock_t + ) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::< + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_clock_t, + >())) + .identifier as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!( + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_clock_t + ), + "::", + stringify!(identifier) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::< + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_clock_t, + >())) + .clock_id as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!( + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_clock_t + ), + "::", + stringify!(clock_id) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::< + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_clock_t, + >())) + .timeout as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!( + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_clock_t + ), + "::", + stringify!(timeout) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::< + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_clock_t, + >())) + .precision as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!( + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_clock_t + ), + "::", + stringify!(precision) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::< + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_clock_t, + >())) + .flags as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!( + __wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_clock_t + ), + "::", + stringify!(flags) + ) + ); + } -// Operations that apply to regular files. -pub const RIGHTS_REGULAR_FILE_BASE: __wasi_rights_t = (__WASI_RIGHT_FD_DATASYNC - | __WASI_RIGHT_FD_READ - | __WASI_RIGHT_FD_SEEK - | __WASI_RIGHT_FD_FDSTAT_SET_FLAGS - | __WASI_RIGHT_FD_SYNC - | __WASI_RIGHT_FD_TELL - | __WASI_RIGHT_FD_WRITE - | __WASI_RIGHT_FD_ADVISE - | __WASI_RIGHT_FD_ALLOCATE - | __WASI_RIGHT_FD_FILESTAT_GET - | __WASI_RIGHT_FD_FILESTAT_SET_SIZE - | __WASI_RIGHT_FD_FILESTAT_SET_TIMES - | __WASI_RIGHT_POLL_FD_READWRITE) - as __wasi_rights_t; -pub const RIGHTS_REGULAR_FILE_INHERITING: __wasi_rights_t = 0; + #[test] + fn bindgen_test_layout___wasi_iovec_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_iovec_t>(), + 16usize, + concat!("Size of: ", stringify!(__wasi_iovec_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_iovec_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_iovec_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_iovec_t>())).buf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_iovec_t), + "::", + stringify!(buf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_iovec_t>())).buf_len as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_iovec_t), + "::", + stringify!(buf_len) + ) + ); + } -// Operations that apply to shared memory objects. -pub const RIGHTS_SHARED_MEMORY_BASE: __wasi_rights_t = (__WASI_RIGHT_FD_READ - | __WASI_RIGHT_FD_WRITE - | __WASI_RIGHT_FD_FILESTAT_GET - | __WASI_RIGHT_FD_FILESTAT_SET_SIZE) - as __wasi_rights_t; -pub const RIGHTS_SHARED_MEMORY_INHERITING: __wasi_rights_t = 0; + #[test] + fn bindgen_test_layout___wasi_ciovec_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_ciovec_t>(), + 16usize, + concat!("Size of: ", stringify!(__wasi_ciovec_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_ciovec_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_ciovec_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_ciovec_t>())).buf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_ciovec_t), + "::", + stringify!(buf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_ciovec_t>())).buf_len as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_ciovec_t), + "::", + stringify!(buf_len) + ) + ); + } -// Operations that apply to sockets and socket pairs. -pub const RIGHTS_SOCKET_BASE: __wasi_rights_t = (__WASI_RIGHT_FD_READ - | __WASI_RIGHT_FD_FDSTAT_SET_FLAGS - | __WASI_RIGHT_FD_WRITE - | __WASI_RIGHT_FD_FILESTAT_GET - | __WASI_RIGHT_POLL_FD_READWRITE - | __WASI_RIGHT_SOCK_SHUTDOWN) - as __wasi_rights_t; -pub const RIGHTS_SOCKET_INHERITING: __wasi_rights_t = RIGHTS_ALL; + #[test] + fn bindgen_test_layout___wasi_filestat_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_filestat_t>(), + 56usize, + concat!("Size of: ", stringify!(__wasi_filestat_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_filestat_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_filestat_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).st_dev as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_dev) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).st_ino as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_ino) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_filestat_t>())).st_filetype as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_filetype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).st_nlink as *const _ as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_nlink) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).st_size as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_size) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).st_atim as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_atim) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).st_mtim as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_mtim) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).st_ctim as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_ctim) + ) + ); + } -// Operations that apply to TTYs. -pub const RIGHTS_TTY_BASE: __wasi_rights_t = (__WASI_RIGHT_FD_READ - | __WASI_RIGHT_FD_FDSTAT_SET_FLAGS - | __WASI_RIGHT_FD_WRITE - | __WASI_RIGHT_FD_FILESTAT_GET - | __WASI_RIGHT_POLL_FD_READWRITE) - as __wasi_rights_t; -pub const RIGHTS_TTY_INHERITING: __wasi_rights_t = 0; + #[test] + fn bindgen_test_layout___wasi_fdstat_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_fdstat_t>(), + 24usize, + concat!("Size of: ", stringify!(__wasi_fdstat_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_fdstat_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_fdstat_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_filetype as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_filetype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_flags as *const _ as usize }, + 2usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_flags) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_rights_base as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_rights_base) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_rights_inheriting as *const _ + as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_rights_inheriting) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_prestat_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_prestat_t>(), + 16usize, + concat!("Size of: ", stringify!(__wasi_prestat_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_prestat_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_prestat_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_prestat_t>())).pr_type as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_t), + "::", + stringify!(pr_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_prestat_t>())).u as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_t), + "::", + stringify!(u) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_prestat_t___wasi_prestat_u___wasi_prestat_u_dir_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_prestat_t___wasi_prestat_u___wasi_prestat_u_dir_t>(), + 8usize, + concat!( + "Size of: ", + stringify!(__wasi_prestat_t___wasi_prestat_u___wasi_prestat_u_dir_t) + ) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_prestat_t___wasi_prestat_u___wasi_prestat_u_dir_t>(), + 8usize, + concat!( + "Alignment of ", + stringify!(__wasi_prestat_t___wasi_prestat_u___wasi_prestat_u_dir_t) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_prestat_t___wasi_prestat_u___wasi_prestat_u_dir_t>())) + .pr_name_len as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_t___wasi_prestat_u___wasi_prestat_u_dir_t), + "::", + stringify!(pr_name_len) + ) + ); + } + #[test] + fn bindgen_test_layout___wasi_prestat_t___wasi_prestat_u() { + assert_eq!( + ::std::mem::size_of::<__wasi_prestat_t___wasi_prestat_u>(), + 8usize, + concat!("Size of: ", stringify!(__wasi_prestat_t___wasi_prestat_u)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_prestat_t___wasi_prestat_u>(), + 8usize, + concat!( + "Alignment of ", + stringify!(__wasi_prestat_t___wasi_prestat_u) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_prestat_t___wasi_prestat_u>())).dir as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_t___wasi_prestat_u), + "::", + stringify!(dir) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t>(), + 16usize, + concat!( + "Size of: ", + stringify!(__wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t) + ) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t>(), + 8usize, + concat!( + "Alignment of ", + stringify!(__wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t>( + ))) + .nbytes as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t), + "::", + stringify!(nbytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t>( + ))) + .flags as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t), + "::", + stringify!(flags) + ) + ); + } + #[test] + fn bindgen_test_layout___wasi_event_t___wasi_event_u() { + assert_eq!( + ::std::mem::size_of::<__wasi_event_t___wasi_event_u>(), + 16usize, + concat!("Size of: ", stringify!(__wasi_event_t___wasi_event_u)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_event_t___wasi_event_u>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_event_t___wasi_event_u)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_event_t___wasi_event_u>())).fd_readwrite as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t___wasi_event_u), + "::", + stringify!(fd_readwrite) + ) + ); + } + #[test] + fn bindgen_test_layout___wasi_event_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_event_t>(), + 32usize, + concat!("Size of: ", stringify!(__wasi_event_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_event_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_event_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_event_t>())).userdata as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t), + "::", + stringify!(userdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_event_t>())).error as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t), + "::", + stringify!(error) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_event_t>())).type_ as *const _ as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t), + "::", + stringify!(type_) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_event_t>())).u as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t), + "::", + stringify!(u) + ) + ); + } +} diff --git a/src/hostcalls.rs b/src/hostcalls.rs index d0e8db19f9..20643e279c 100644 --- a/src/hostcalls.rs +++ b/src/hostcalls.rs @@ -24,12 +24,6 @@ use std::os::unix::prelude::{FromRawFd, OsStrExt, OsStringExt, RawFd}; use std::time::SystemTime; use std::{cmp, slice}; -#[cfg(target_os = "linux")] -const O_RSYNC: nix::fcntl::OFlag = nix::fcntl::OFlag::O_RSYNC; - -#[cfg(not(target_os = "linux"))] -const O_RSYNC: nix::fcntl::OFlag = nix::fcntl::OFlag::O_SYNC; - pub unsafe fn proc_exit(_vmctx: &mut VmContext, rval: wasm32::__wasi_exitcode_t) -> () { std::process::exit(dec_exitcode(rval) as i32); } @@ -328,14 +322,14 @@ pub unsafe fn fd_seek( let host_newoffset = { use nix::unistd::{lseek, Whence}; - let nwhence = match whence as u32 { + let nwhence = match whence { host::__WASI_WHENCE_CUR => Whence::SeekCur, host::__WASI_WHENCE_END => Whence::SeekEnd, host::__WASI_WHENCE_SET => Whence::SeekSet, _ => return wasm32::__WASI_EINVAL, }; - let rights = if offset == 0 && whence as u32 == host::__WASI_WHENCE_CUR { + let rights = if offset == 0 && whence == host::__WASI_WHENCE_CUR { host::__WASI_RIGHT_FD_TELL } else { host::__WASI_RIGHT_FD_SEEK | host::__WASI_RIGHT_FD_TELL @@ -367,7 +361,7 @@ pub unsafe fn fd_prestat_get( match (*ctx).get_fd_entry(fd, host::__WASI_RIGHT_PATH_OPEN.into(), 0) { Ok(fe) => { if let Some(po_path) = &fe.preopen_path { - if fe.fd_object.ty != host::__WASI_FILETYPE_DIRECTORY as host::__wasi_filetype_t { + if fe.fd_object.ty != host::__WASI_FILETYPE_DIRECTORY { return wasm32::__WASI_ENOTDIR; } unsafe { @@ -375,7 +369,7 @@ pub unsafe fn fd_prestat_get( vmctx, prestat_ptr, host::__wasi_prestat_t { - pr_type: host::__WASI_PREOPENTYPE_DIR as host::__wasi_preopentype_t, + pr_type: host::__WASI_PREOPENTYPE_DIR, u: host::__wasi_prestat_t___wasi_prestat_u { dir: host::__wasi_prestat_t___wasi_prestat_u___wasi_prestat_u_dir_t { @@ -406,7 +400,7 @@ pub unsafe fn fd_prestat_dir_name( match (*(*vmctx).as_wasi_ctx()).get_fd_entry(fd, host::__WASI_RIGHT_PATH_OPEN.into(), 0) { Ok(fe) => { if let Some(po_path) = &fe.preopen_path { - if fe.fd_object.ty != host::__WASI_FILETYPE_DIRECTORY as host::__wasi_filetype_t { + if fe.fd_object.ty != host::__WASI_FILETYPE_DIRECTORY { return wasm32::__WASI_ENOTDIR; } let path_bytes = po_path.as_os_str().as_bytes(); @@ -532,14 +526,12 @@ pub unsafe fn path_open( let fs_flags = dec_fdflags(fs_flags); // which open mode do we need? - let read = fs_rights_base - & ((host::__WASI_RIGHT_FD_READ | host::__WASI_RIGHT_FD_READDIR) as host::__wasi_rights_t) - != 0; + let read = fs_rights_base & (host::__WASI_RIGHT_FD_READ | host::__WASI_RIGHT_FD_READDIR) != 0; let write = fs_rights_base - & ((host::__WASI_RIGHT_FD_DATASYNC + & (host::__WASI_RIGHT_FD_DATASYNC | host::__WASI_RIGHT_FD_WRITE | host::__WASI_RIGHT_FD_ALLOCATE - | host::__WASI_RIGHT_PATH_FILESTAT_SET_SIZE) as host::__wasi_rights_t) + | host::__WASI_RIGHT_PATH_FILESTAT_SET_SIZE) != 0; let mut nix_all_oflags = if read && write { @@ -554,26 +546,26 @@ pub unsafe fn path_open( nix_all_oflags.insert(OFlag::O_NOFOLLOW); // which rights are needed on the dirfd? - let mut needed_base = host::__WASI_RIGHT_PATH_OPEN as host::__wasi_rights_t; + let mut needed_base = host::__WASI_RIGHT_PATH_OPEN; let mut needed_inheriting = fs_rights_base | fs_rights_inheriting; // convert open flags let nix_oflags = host::nix_from_oflags(oflags); nix_all_oflags.insert(nix_oflags); if nix_all_oflags.contains(OFlag::O_CREAT) { - needed_base |= host::__WASI_RIGHT_PATH_CREATE_FILE as host::__wasi_rights_t; + needed_base |= host::__WASI_RIGHT_PATH_CREATE_FILE; } if nix_all_oflags.contains(OFlag::O_TRUNC) { - needed_inheriting |= host::__WASI_RIGHT_PATH_FILESTAT_SET_SIZE as host::__wasi_rights_t; + needed_inheriting |= host::__WASI_RIGHT_PATH_FILESTAT_SET_SIZE; } // convert file descriptor flags nix_all_oflags.insert(host::nix_from_fdflags(fs_flags)); if nix_all_oflags.contains(OFlag::O_DSYNC) { - needed_inheriting |= host::__WASI_RIGHT_FD_DATASYNC as host::__wasi_rights_t; + needed_inheriting |= host::__WASI_RIGHT_FD_DATASYNC; } - if nix_all_oflags.intersects(O_RSYNC | OFlag::O_SYNC) { - needed_inheriting |= host::__WASI_RIGHT_FD_SYNC as host::__wasi_rights_t; + if nix_all_oflags.intersects(host::O_RSYNC | OFlag::O_SYNC) { + needed_inheriting |= host::__WASI_RIGHT_FD_SYNC; } let path = match unsafe { dec_slice_of::(vmctx, path_ptr, path_len) } { @@ -751,12 +743,7 @@ pub unsafe fn poll_oneoff( } }; if ready == 0 { - return poll_oneoff_handle_timeout_event( - &mut *vmctx, - output_slice, - nevents, - timeout, - ); + return poll_oneoff_handle_timeout_event(&mut *vmctx, output_slice, nevents, timeout); } let events = fd_events.iter().zip(poll_fds.iter()).take(ready); poll_oneoff_handle_fd_event(&mut *vmctx, output_slice, nevents, events) @@ -812,7 +799,7 @@ pub unsafe fn path_filestat_get( dirfd, dirflags, path, - host::__WASI_RIGHT_PATH_FILESTAT_GET as host::__wasi_rights_t, + host::__WASI_RIGHT_PATH_FILESTAT_GET, 0, false, ) { @@ -855,8 +842,7 @@ pub unsafe fn path_create_directory( dirfd, 0, path, - (host::__WASI_RIGHT_PATH_OPEN | host::__WASI_RIGHT_PATH_CREATE_DIRECTORY) - as host::__wasi_rights_t, + host::__WASI_RIGHT_PATH_OPEN | host::__WASI_RIGHT_PATH_CREATE_DIRECTORY, 0, false, ) { @@ -893,7 +879,7 @@ pub unsafe fn path_unlink_file( dirfd, 0, path, - host::__WASI_RIGHT_PATH_UNLINK_FILE as host::__wasi_rights_t, + host::__WASI_RIGHT_PATH_UNLINK_FILE, 0, false, ) { @@ -1140,14 +1126,11 @@ pub fn path_get>( } // path is empty (Some([]), None) => { - return ret_error(&mut dir_stack, host::__WASI_ENOENT as host::__wasi_errno_t); + return ret_error(&mut dir_stack, host::__WASI_ENOENT); } // path starts with `/`, is absolute (Some([]), Some(_)) => { - return ret_error( - &mut dir_stack, - host::__WASI_ENOTCAPABLE as host::__wasi_errno_t, - ); + return ret_error(&mut dir_stack, host::__WASI_ENOTCAPABLE); } // the final component of the path with no trailing slash (Some(component), None) => component.to_vec(), @@ -1185,10 +1168,7 @@ pub fn path_get>( // we're not allowed to pop past the original directory if dir_stack.is_empty() { - return ret_error( - &mut dir_stack, - host::__WASI_ENOTCAPABLE as host::__wasi_errno_t, - ); + return ret_error(&mut dir_stack, host::__WASI_ENOTCAPABLE); } else { nix::unistd::close(dirfd).unwrap_or_else(|e| { dbg!(e); @@ -1224,10 +1204,7 @@ pub fn path_get>( Ok(link_path) => { symlink_expansions += 1; if symlink_expansions > MAX_SYMLINK_EXPANSIONS { - return ret_error( - &mut dir_stack, - host::__WASI_ELOOP as host::__wasi_errno_t, - ); + return ret_error(&mut dir_stack, host::__WASI_ELOOP); } let mut link_path = link_path.as_bytes().to_vec(); @@ -1272,10 +1249,7 @@ pub fn path_get>( Ok(link_path) => { symlink_expansions += 1; if symlink_expansions > MAX_SYMLINK_EXPANSIONS { - return ret_error( - &mut dir_stack, - host::__WASI_ELOOP as host::__wasi_errno_t, - ); + return ret_error(&mut dir_stack, host::__WASI_ELOOP); } let mut link_path = link_path.as_bytes().to_vec(); diff --git a/src/memory.rs b/src/memory.rs index 7d65260eee..2de9b5c568 100644 --- a/src/memory.rs +++ b/src/memory.rs @@ -19,7 +19,7 @@ use std::slice; macro_rules! bail_errno { ( $errno:ident ) => { - return Err(host::$errno as host::__wasi_errno_t); + return Err(host::$errno); }; } @@ -56,13 +56,13 @@ pub unsafe fn dec_slice_of( ) -> Result<(*mut T, usize), host::__wasi_errno_t> { // check alignment, and that length doesn't overflow if ptr as usize % align_of::() != 0 { - return Err(host::__WASI_EINVAL as host::__wasi_errno_t); + return Err(host::__WASI_EINVAL); } let len = dec_usize(len); let len_bytes = if let Some(len) = size_of::().checked_mul(len) { len } else { - return Err(host::__WASI_EOVERFLOW as host::__wasi_errno_t); + return Err(host::__WASI_EOVERFLOW); }; let ptr = (*vmctx).dec_ptr(ptr, len_bytes)? as *mut T; @@ -77,13 +77,13 @@ pub unsafe fn enc_slice_of( ) -> Result<(), host::__wasi_errno_t> { // check alignment if ptr as usize % align_of::() != 0 { - return Err(host::__WASI_EINVAL as host::__wasi_errno_t); + return Err(host::__WASI_EINVAL); } // check that length doesn't overflow let len_bytes = if let Some(len) = size_of::().checked_mul(slice.len()) { len } else { - return Err(host::__WASI_EOVERFLOW as host::__wasi_errno_t); + return Err(host::__WASI_EOVERFLOW); }; // get the pointer into guest memory, and copy the bytes @@ -319,11 +319,11 @@ pub fn dec_prestat( }, }; Ok(host::__wasi_prestat_t { - pr_type: host::__WASI_PREOPENTYPE_DIR as host::__wasi_preopentype_t, + pr_type: host::__WASI_PREOPENTYPE_DIR, u, }) } - _ => Err(host::__WASI_EINVAL as host::__wasi_errno_t), + _ => Err(host::__WASI_EINVAL), } } @@ -337,7 +337,7 @@ pub unsafe fn dec_prestat_byref( pub fn enc_prestat( prestat: host::__wasi_prestat_t, ) -> Result { - match prestat.pr_type as u32 { + match prestat.pr_type { host::__WASI_PREOPENTYPE_DIR => { let u = wasm32::__wasi_prestat_t___wasi_prestat_u { dir: wasm32::__wasi_prestat_t___wasi_prestat_u___wasi_prestat_u_dir_t { @@ -345,11 +345,11 @@ pub fn enc_prestat( }, }; Ok(wasm32::__wasi_prestat_t { - pr_type: wasm32::__WASI_PREOPENTYPE_DIR as wasm32::__wasi_preopentype_t, + pr_type: wasm32::__WASI_PREOPENTYPE_DIR, u, }) } - _ => Err(host::__WASI_EINVAL as host::__wasi_errno_t), + _ => Err(host::__WASI_EINVAL), } }