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

sys: import types from handle or sched, not wasi. drop types:: prefix.

Browse Source
This commit is contained in:
Pat Hickey
2020-09-14 16:32:35 -07:00
parent e5129b39cb
commit 4763678be2
23 changed files with 328 additions and 362 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
crates/wasi-common/src/sys/clock.rs
View File

@@ -1,4 +1,4 @@
use crate::wasi::types::{Subclockflags, SubscriptionClock};
use crate::sched::{Subclockflags, SubscriptionClock};
use crate::{Error, Result};
use std::time::SystemTime;

16
crates/wasi-common/src/sys/fd.rs
View File

@@ -1,4 +1,4 @@
use crate::wasi::types;
use crate::handle::{Fstflags, Timestamp};
use crate::{Error, Result};
use filetime::{set_file_handle_times, FileTime};
use std::fs::File;
@@ -8,14 +8,14 @@ pub(crate) use super::sys_impl::fd::*;
pub(crate) fn filestat_set_times(
file: &File,
st_atim: types::Timestamp,
st_mtim: types::Timestamp,
fst_flags: types::Fstflags,
st_atim: Timestamp,
st_mtim: Timestamp,
fst_flags: Fstflags,
) -> Result<()> {
let set_atim = fst_flags.contains(&types::Fstflags::ATIM);
let set_atim_now = fst_flags.contains(&types::Fstflags::ATIM_NOW);
let set_mtim = fst_flags.contains(&types::Fstflags::MTIM);
let set_mtim_now = fst_flags.contains(&types::Fstflags::MTIM_NOW);
let set_atim = fst_flags.contains(&Fstflags::ATIM);
let set_atim_now = fst_flags.contains(&Fstflags::ATIM_NOW);
let set_mtim = fst_flags.contains(&Fstflags::MTIM);
let set_mtim_now = fst_flags.contains(&Fstflags::MTIM_NOW);
if (set_atim && set_atim_now) || (set_mtim && set_mtim_now) {
return Err(Error::Inval);

7
crates/wasi-common/src/sys/mod.rs
View File

@@ -24,8 +24,7 @@ cfg_if! {
pub(crate) use sys_impl::path;
pub(crate) use sys_impl::poll;
use super::handle::Handle;
use crate::wasi::types;
use super::handle::{Filetype, Handle};
use osdir::OsDir;
use osfile::OsFile;
use osother::OsOther;
@@ -67,7 +66,7 @@ impl TryFrom<File> for Box<dyn Handle> {
fn try_from(file: File) -> io::Result<Self> {
let file_type = get_file_type(&file)?;
match file_type {
types::Filetype::RegularFile => {
Filetype::RegularFile => {
let handle = OsFile::try_from(file)?;
tracing::debug!(
handle = tracing::field::debug(&handle),
@@ -75,7 +74,7 @@ impl TryFrom<File> for Box<dyn Handle> {
);
Ok(Box::new(handle))
}
types::Filetype::Directory => {
Filetype::Directory => {
let handle = OsDir::try_from(file)?;
tracing::debug!(
handle = tracing::field::debug(&handle),

38
crates/wasi-common/src/sys/osdir.rs
View File

@@ -1,7 +1,9 @@
use super::sys_impl::oshandle::RawOsHandle;
use super::{fd, path, AsFile};
use crate::handle::{Handle, HandleRights};
use crate::wasi::types;
use crate::handle::{
Dircookie, Dirent, Fdflags, Filestat, Filetype, Fstflags, Handle, HandleRights, Oflags,
};
use crate::sched::Timestamp;
use crate::{Error, Result};
use std::any::Any;
use std::io;
@@ -30,8 +32,8 @@ impl Handle for OsDir {
let new = Self::new(self.rights.get(), handle)?;
Ok(Box::new(new))
}
fn get_file_type(&self) -> types::Filetype {
types::Filetype::Directory
fn get_file_type(&self) -> Filetype {
Filetype::Directory
}
fn get_rights(&self) -> HandleRights {
self.rights.get()
@@ -40,45 +42,45 @@ impl Handle for OsDir {
self.rights.set(rights)
}
// FdOps
fn fdstat_get(&self) -> Result<types::Fdflags> {
fn fdstat_get(&self) -> Result<Fdflags> {
fd::fdstat_get(&*self.as_file()?)
}
fn fdstat_set_flags(&self, fdflags: types::Fdflags) -> Result<()> {
fn fdstat_set_flags(&self, fdflags: Fdflags) -> Result<()> {
if let Some(new_file) = fd::fdstat_set_flags(&*self.as_file()?, fdflags)? {
self.handle.update_from(new_file);
}
Ok(())
}
fn filestat_get(&self) -> Result<types::Filestat> {
fn filestat_get(&self) -> Result<Filestat> {
fd::filestat_get(&*self.as_file()?)
}
fn filestat_set_times(
&self,
atim: types::Timestamp,
mtim: types::Timestamp,
fst_flags: types::Fstflags,
atim: Timestamp,
mtim: Timestamp,
fst_flags: Fstflags,
) -> Result<()> {
fd::filestat_set_times(&*self.as_file()?, atim, mtim, fst_flags)
}
fn readdir<'a>(
&'a self,
cookie: types::Dircookie,
) -> Result<Box<dyn Iterator<Item = Result<(types::Dirent, String)>> + 'a>> {
cookie: Dircookie,
) -> Result<Box<dyn Iterator<Item = Result<(Dirent, String)>> + 'a>> {
fd::readdir(self, cookie)
}
// PathOps
fn create_directory(&self, path: &str) -> Result<()> {
path::create_directory(self, path)
}
fn filestat_get_at(&self, path: &str, follow: bool) -> Result<types::Filestat> {
fn filestat_get_at(&self, path: &str, follow: bool) -> Result<Filestat> {
path::filestat_get_at(self, path, follow)
}
fn filestat_set_times_at(
&self,
path: &str,
atim: types::Timestamp,
mtim: types::Timestamp,
fst_flags: types::Fstflags,
atim: Timestamp,
mtim: Timestamp,
fst_flags: Fstflags,
follow: bool,
) -> Result<()> {
path::filestat_set_times_at(self, path, atim, mtim, fst_flags, follow)
@@ -88,8 +90,8 @@ impl Handle for OsDir {
path: &str,
read: bool,
write: bool,
oflags: types::Oflags,
fd_flags: types::Fdflags,
oflags: Oflags,
fd_flags: Fdflags,
) -> Result<Box<dyn Handle>> {
path::open(self, path, read, write, oflags, fd_flags)
}

33
crates/wasi-common/src/sys/osfile.rs
View File

@@ -1,7 +1,9 @@
use super::sys_impl::oshandle::RawOsHandle;
use super::{fd, AsFile};
use crate::handle::{Handle, HandleRights};
use crate::wasi::types;
use crate::handle::{
Advice, Fdflags, Filesize, Filestat, Filetype, Fstflags, Handle, HandleRights,
};
use crate::sched::Timestamp;
use crate::{Error, Result};
use std::any::Any;
use std::cell::Cell;
@@ -56,8 +58,8 @@ impl Handle for OsFile {
let rights = self.rights.clone();
Ok(Box::new(Self { rights, handle }))
}
fn get_file_type(&self) -> types::Filetype {
types::Filetype::RegularFile
fn get_file_type(&self) -> Filetype {
Filetype::RegularFile
}
fn get_rights(&self) -> HandleRights {
self.rights.get()
@@ -66,15 +68,10 @@ impl Handle for OsFile {
self.rights.set(rights)
}
// FdOps
fn advise(
&self,
advice: types::Advice,
offset: types::Filesize,
len: types::Filesize,
) -> Result<()> {
fn advise(&self, advice: Advice, offset: Filesize, len: Filesize) -> Result<()> {
fd::advise(self, advice, offset, len)
}
fn allocate(&self, offset: types::Filesize, len: types::Filesize) -> Result<()> {
fn allocate(&self, offset: Filesize, len: Filesize) -> Result<()> {
let fd = self.as_file()?;
let metadata = fd.metadata()?;
let current_size = metadata.len();
@@ -92,27 +89,27 @@ impl Handle for OsFile {
self.as_file()?.sync_data()?;
Ok(())
}
fn fdstat_get(&self) -> Result<types::Fdflags> {
fn fdstat_get(&self) -> Result<Fdflags> {
fd::fdstat_get(&*self.as_file()?)
}
fn fdstat_set_flags(&self, fdflags: types::Fdflags) -> Result<()> {
fn fdstat_set_flags(&self, fdflags: Fdflags) -> Result<()> {
if let Some(new_handle) = fd::fdstat_set_flags(&*self.as_file()?, fdflags)? {
self.handle.update_from(new_handle);
}
Ok(())
}
fn filestat_get(&self) -> Result<types::Filestat> {
fn filestat_get(&self) -> Result<Filestat> {
fd::filestat_get(&*self.as_file()?)
}
fn filestat_set_size(&self, size: types::Filesize) -> Result<()> {
fn filestat_set_size(&self, size: Filesize) -> Result<()> {
self.as_file()?.set_len(size)?;
Ok(())
}
fn filestat_set_times(
&self,
atim: types::Timestamp,
mtim: types::Timestamp,
fst_flags: types::Fstflags,
atim: Timestamp,
mtim: Timestamp,
fst_flags: Fstflags,
) -> Result<()> {
fd::filestat_set_times(&*self.as_file()?, atim, mtim, fst_flags)
}

7
crates/wasi-common/src/sys/osother.rs
View File

@@ -1,8 +1,7 @@
use super::sys_impl::oshandle::RawOsHandle;
use super::{fd, AsFile};
use crate::handle::{Handle, HandleRights};
use crate::handle::{Fdflags, Filetype, Handle, HandleRights};
use crate::sandboxed_tty_writer::SandboxedTTYWriter;
use crate::wasi::types::{self, Filetype};
use crate::Result;
use std::any::Any;
use std::cell::Cell;
@@ -79,10 +78,10 @@ impl Handle for OsOther {
self.rights.set(new_rights)
}
// FdOps
fn fdstat_get(&self) -> Result<types::Fdflags> {
fn fdstat_get(&self) -> Result<Fdflags> {
fd::fdstat_get(&*self.as_file()?)
}
fn fdstat_set_flags(&self, fdflags: types::Fdflags) -> Result<()> {
fn fdstat_set_flags(&self, fdflags: Fdflags) -> Result<()> {
if let Some(handle) = fd::fdstat_set_flags(&*self.as_file()?, fdflags)? {
self.handle.update_from(handle);
}

34
crates/wasi-common/src/sys/stdio.rs
View File

@@ -17,10 +17,8 @@
// TODO it might worth re-investigating the suitability of this type on Windows.
use super::{fd, AsFile};
use crate::handle::{Handle, HandleRights};
use crate::handle::{Fdflags, Filetype, Handle, HandleRights, Rights, RightsExt, Size};
use crate::sandboxed_tty_writer::SandboxedTTYWriter;
use crate::wasi::types::{self, Filetype};
use crate::wasi::RightsExt;
use crate::{Error, Result};
use std::any::Any;
use std::cell::Cell;
@@ -55,10 +53,10 @@ impl Handle for Stdin {
self.rights.set(new_rights)
}
// FdOps
fn fdstat_get(&self) -> Result<types::Fdflags> {
fn fdstat_get(&self) -> Result<Fdflags> {
fd::fdstat_get(&*self.as_file()?)
}
fn fdstat_set_flags(&self, fdflags: types::Fdflags) -> Result<()> {
fn fdstat_set_flags(&self, fdflags: Fdflags) -> Result<()> {
if let Some(_) = fd::fdstat_set_flags(&*self.as_file()?, fdflags)? {
// OK, this means we should somehow update the underlying os handle,
// and we can't do that with `std::io::std{in, out, err}`, so we'll
@@ -101,10 +99,10 @@ impl Handle for Stdout {
self.rights.set(new_rights)
}
// FdOps
fn fdstat_get(&self) -> Result<types::Fdflags> {
fn fdstat_get(&self) -> Result<Fdflags> {
fd::fdstat_get(&*self.as_file()?)
}
fn fdstat_set_flags(&self, fdflags: types::Fdflags) -> Result<()> {
fn fdstat_set_flags(&self, fdflags: Fdflags) -> Result<()> {
if let Some(_) = fd::fdstat_set_flags(&*self.as_file()?, fdflags)? {
// OK, this means we should somehow update the underlying os handle,
// and we can't do that with `std::io::std{in, out, err}`, so we'll
@@ -155,10 +153,10 @@ impl Handle for Stderr {
self.rights.set(new_rights)
}
// FdOps
fn fdstat_get(&self) -> Result<types::Fdflags> {
fn fdstat_get(&self) -> Result<Fdflags> {
fd::fdstat_get(&*self.as_file()?)
}
fn fdstat_set_flags(&self, fdflags: types::Fdflags) -> Result<()> {
fn fdstat_set_flags(&self, fdflags: Fdflags) -> Result<()> {
if let Some(_) = fd::fdstat_set_flags(&*self.as_file()?, fdflags)? {
// OK, this means we should somehow update the underlying os handle,
// and we can't do that with `std::io::std{in, out, err}`, so we'll
@@ -180,17 +178,17 @@ impl Handle for Stderr {
#[derive(Debug, Clone)]
pub(crate) struct NullDevice {
pub(crate) rights: Cell<HandleRights>,
pub(crate) fd_flags: Cell<types::Fdflags>,
pub(crate) fd_flags: Cell<Fdflags>,
}
impl NullDevice {
pub(crate) fn new() -> Self {
let rights = HandleRights::new(
types::Rights::character_device_base(),
types::Rights::character_device_inheriting(),
Rights::character_device_base(),
Rights::character_device_inheriting(),
);
let rights = Cell::new(rights);
let fd_flags = types::Fdflags::empty();
let fd_flags = Fdflags::empty();
let fd_flags = Cell::new(fd_flags);
Self { rights, fd_flags }
}
@@ -203,8 +201,8 @@ impl Handle for NullDevice {
fn try_clone(&self) -> io::Result<Box<dyn Handle>> {
Ok(Box::new(self.clone()))
}
fn get_file_type(&self) -> types::Filetype {
types::Filetype::CharacterDevice
fn get_file_type(&self) -> Filetype {
Filetype::CharacterDevice
}
fn get_rights(&self) -> HandleRights {
self.rights.get()
@@ -213,10 +211,10 @@ impl Handle for NullDevice {
self.rights.set(rights)
}
// FdOps
fn fdstat_get(&self) -> Result<types::Fdflags> {
fn fdstat_get(&self) -> Result<Fdflags> {
Ok(self.fd_flags.get())
}
fn fdstat_set_flags(&self, fdflags: types::Fdflags) -> Result<()> {
fn fdstat_set_flags(&self, fdflags: Fdflags) -> Result<()> {
self.fd_flags.set(fdflags);
Ok(())
}
@@ -226,7 +224,7 @@ impl Handle for NullDevice {
fn write_vectored(&self, iovs: &[io::IoSlice]) -> Result<usize> {
let mut total_len = 0u32;
for iov in iovs {
let len: types::Size = iov.len().try_into()?;
let len: Size = iov.len().try_into()?;
total_len = total_len.checked_add(len).ok_or(Error::Overflow)?;
}
Ok(total_len as usize)

14
crates/wasi-common/src/sys/unix/clock.rs
View File

@@ -1,17 +1,17 @@
use crate::wasi::types;
use crate::sched::{Clockid, Timestamp};
use crate::{Error, Result};
use yanix::clock::{clock_getres, clock_gettime, ClockId};
pub(crate) fn res_get(clock_id: types::Clockid) -> Result<types::Timestamp> {
pub(crate) fn res_get(clock_id: Clockid) -> Result<Timestamp> {
let clock_id: ClockId = clock_id.into();
let timespec = clock_getres(clock_id)?;
// 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 types::Timestamp)
(timespec.tv_sec as Timestamp)
.checked_mul(1_000_000_000)
.and_then(|sec_ns| sec_ns.checked_add(timespec.tv_nsec as types::Timestamp))
.and_then(|sec_ns| sec_ns.checked_add(timespec.tv_nsec as Timestamp))
.map_or(Err(Error::Overflow), |resolution| {
// a supported clock can never return zero; this case will probably never get hit, but
// make sure we follow the spec
@@ -23,14 +23,14 @@ pub(crate) fn res_get(clock_id: types::Clockid) -> Result<types::Timestamp> {
})
}
pub(crate) fn time_get(clock_id: types::Clockid) -> Result<types::Timestamp> {
pub(crate) fn time_get(clock_id: Clockid) -> Result<Timestamp> {
let clock_id: ClockId = clock_id.into();
let timespec = clock_gettime(clock_id)?;
// 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 types::Timestamp)
(timespec.tv_sec as Timestamp)
.checked_mul(1_000_000_000)
.and_then(|sec_ns| sec_ns.checked_add(timespec.tv_nsec as types::Timestamp))
.and_then(|sec_ns| sec_ns.checked_add(timespec.tv_nsec as Timestamp))
.map_or(Err(Error::Overflow), Ok)
}

35
crates/wasi-common/src/sys/unix/fd.rs
View File

@@ -1,18 +1,18 @@
use super::oshandle::RawOsHandle;
use crate::handle::{Advice, Dircookie, Dirent, Fdflags, Filesize, Filestat, DIRCOOKIE_START};
use crate::sys::osdir::OsDir;
use crate::sys::osfile::OsFile;
use crate::wasi::{self, types};
use crate::Result;
use std::convert::TryInto;
use std::fs::File;
use std::os::unix::prelude::AsRawFd;
pub(crate) fn fdstat_get(fd: &File) -> Result<types::Fdflags> {
pub(crate) fn fdstat_get(fd: &File) -> Result<Fdflags> {
let fdflags = unsafe { yanix::fcntl::get_status_flags(fd.as_raw_fd())? };
Ok(fdflags.into())
}
pub(crate) fn fdstat_set_flags(fd: &File, fdflags: types::Fdflags) -> Result<Option<RawOsHandle>> {
pub(crate) fn fdstat_set_flags(fd: &File, fdflags: Fdflags) -> Result<Option<RawOsHandle>> {
unsafe { yanix::fcntl::set_status_flags(fd.as_raw_fd(), fdflags.into())? };
// We return None here to signal that the operation succeeded on the original
// file descriptor and mutating the original WASI Descriptor is thus unnecessary.
@@ -20,28 +20,23 @@ pub(crate) fn fdstat_set_flags(fd: &File, fdflags: types::Fdflags) -> Result<Opt
Ok(None)
}
pub(crate) fn advise(
file: &OsFile,
advice: types::Advice,
offset: types::Filesize,
len: types::Filesize,
) -> Result<()> {
pub(crate) fn advise(file: &OsFile, advice: Advice, offset: Filesize, len: Filesize) -> Result<()> {
use yanix::fadvise::{posix_fadvise, PosixFadviseAdvice};
let offset = offset.try_into()?;
let len = len.try_into()?;
let host_advice = match advice {
types::Advice::Dontneed => PosixFadviseAdvice::DontNeed,
types::Advice::Sequential => PosixFadviseAdvice::Sequential,
types::Advice::Willneed => PosixFadviseAdvice::WillNeed,
types::Advice::Noreuse => PosixFadviseAdvice::NoReuse,
types::Advice::Random => PosixFadviseAdvice::Random,
types::Advice::Normal => PosixFadviseAdvice::Normal,
Advice::Dontneed => PosixFadviseAdvice::DontNeed,
Advice::Sequential => PosixFadviseAdvice::Sequential,
Advice::Willneed => PosixFadviseAdvice::WillNeed,
Advice::Noreuse => PosixFadviseAdvice::NoReuse,
Advice::Random => PosixFadviseAdvice::Random,
Advice::Normal => PosixFadviseAdvice::Normal,
};
unsafe { posix_fadvise(file.as_raw_fd(), offset, len, host_advice)? };
Ok(())
}
pub(crate) fn filestat_get(file: &File) -> Result<types::Filestat> {
pub(crate) fn filestat_get(file: &File) -> Result<Filestat> {
use yanix::file::fstat;
let stat = unsafe { fstat(file.as_raw_fd())? };
Ok(stat.try_into()?)
@@ -49,8 +44,8 @@ pub(crate) fn filestat_get(file: &File) -> Result<types::Filestat> {
pub(crate) fn readdir<'a>(
dirfd: &'a OsDir,
cookie: types::Dircookie,
) -> Result<Box<dyn Iterator<Item = Result<(types::Dirent, String)>> + 'a>> {
cookie: Dircookie,
) -> Result<Box<dyn Iterator<Item = Result<(Dirent, String)>> + 'a>> {
use yanix::dir::{DirIter, Entry, EntryExt, SeekLoc};
// Get an instance of `Dir`; this is host-specific due to intricasies
@@ -59,7 +54,7 @@ pub(crate) fn readdir<'a>(
// Seek if needed. Unless cookie is wasi::__WASI_DIRCOOKIE_START,
// new items may not be returned to the caller.
if cookie == wasi::DIRCOOKIE_START {
if cookie == DIRCOOKIE_START {
tracing::trace!("fd_readdir: doing rewinddir");
dir.rewind();
} else {
@@ -71,7 +66,7 @@ pub(crate) fn readdir<'a>(
Ok(Box::new(DirIter::new(dir).map(|entry| {
let entry: Entry = entry?;
let name = entry.file_name().to_str()?.to_owned();
let dirent = types::Dirent {
let dirent = Dirent {
d_next: entry.seek_loc()?.to_raw().try_into()?,
d_ino: entry.ino(),
d_namlen: name.len().try_into()?,

114
crates/wasi-common/src/sys/unix/mod.rs
View File

@@ -26,9 +26,11 @@ cfg_if::cfg_if! {
}
}
use crate::handle::HandleRights;
use crate::handle::{
Fdflags, Filesize, Filestat, Filetype, HandleRights, Lookupflags, Oflags, Rights, RightsExt,
};
use crate::sched::{Clockid, Timestamp};
use crate::sys::AsFile;
use crate::wasi::{types, RightsExt};
use crate::{Error, Result};
use std::convert::{TryFrom, TryInto};
use std::fs::File;
@@ -48,34 +50,34 @@ impl<T: AsRawFd> AsFile for T {
}
}
pub(super) fn get_file_type(file: &File) -> io::Result<types::Filetype> {
pub(super) fn get_file_type(file: &File) -> io::Result<Filetype> {
let ft = file.metadata()?.file_type();
let file_type = if ft.is_block_device() {
tracing::debug!(
host_fd = tracing::field::display(file.as_raw_fd()),
"Host fd is a block device"
);
types::Filetype::BlockDevice
Filetype::BlockDevice
} else if ft.is_char_device() {
tracing::debug!("Host fd {:?} is a char device", file.as_raw_fd());
types::Filetype::CharacterDevice
Filetype::CharacterDevice
} else if ft.is_dir() {
tracing::debug!("Host fd {:?} is a directory", file.as_raw_fd());
types::Filetype::Directory
Filetype::Directory
} else if ft.is_file() {
tracing::debug!("Host fd {:?} is a file", file.as_raw_fd());
types::Filetype::RegularFile
Filetype::RegularFile
} else if ft.is_socket() {
tracing::debug!("Host fd {:?} is a socket", file.as_raw_fd());
use yanix::socket::{get_socket_type, SockType};
match unsafe { get_socket_type(file.as_raw_fd())? } {
SockType::Datagram => types::Filetype::SocketDgram,
SockType::Stream => types::Filetype::SocketStream,
SockType::Datagram => Filetype::SocketDgram,
SockType::Stream => Filetype::SocketStream,
_ => return Err(io::Error::from_raw_os_error(libc::EINVAL)),
}
} else if ft.is_fifo() {
tracing::debug!("Host fd {:?} is a fifo", file.as_raw_fd());
types::Filetype::Unknown
Filetype::Unknown
} else {
tracing::debug!("Host fd {:?} is unknown", file.as_raw_fd());
return Err(io::Error::from_raw_os_error(libc::EINVAL));
@@ -83,48 +85,44 @@ pub(super) fn get_file_type(file: &File) -> io::Result<types::Filetype> {
Ok(file_type)
}
pub(super) fn get_rights(file: &File, file_type: &types::Filetype) -> io::Result<HandleRights> {
pub(super) fn get_rights(file: &File, file_type: &Filetype) -> io::Result<HandleRights> {
use yanix::{fcntl, file::OFlags};
let (base, inheriting) = match file_type {
types::Filetype::BlockDevice => (
types::Rights::block_device_base(),
types::Rights::block_device_inheriting(),
Filetype::BlockDevice => (
Rights::block_device_base(),
Rights::block_device_inheriting(),
),
types::Filetype::CharacterDevice => {
Filetype::CharacterDevice => {
use yanix::file::isatty;
if unsafe { isatty(file.as_raw_fd())? } {
(types::Rights::tty_base(), types::Rights::tty_base())
(Rights::tty_base(), Rights::tty_base())
} else {
(
types::Rights::character_device_base(),
types::Rights::character_device_inheriting(),
Rights::character_device_base(),
Rights::character_device_inheriting(),
)
}
}
types::Filetype::SocketDgram | types::Filetype::SocketStream => (
types::Rights::socket_base(),
types::Rights::socket_inheriting(),
Filetype::SocketDgram | Filetype::SocketStream => {
(Rights::socket_base(), Rights::socket_inheriting())
}
Filetype::SymbolicLink | Filetype::Unknown => (
Rights::regular_file_base(),
Rights::regular_file_inheriting(),
),
types::Filetype::SymbolicLink | types::Filetype::Unknown => (
types::Rights::regular_file_base(),
types::Rights::regular_file_inheriting(),
),
types::Filetype::Directory => (
types::Rights::directory_base(),
types::Rights::directory_inheriting(),
),
types::Filetype::RegularFile => (
types::Rights::regular_file_base(),
types::Rights::regular_file_inheriting(),
Filetype::Directory => (Rights::directory_base(), Rights::directory_inheriting()),
Filetype::RegularFile => (
Rights::regular_file_base(),
Rights::regular_file_inheriting(),
),
};
let mut rights = HandleRights::new(base, inheriting);
let flags = unsafe { fcntl::get_status_flags(file.as_raw_fd())? };
let accmode = flags & OFlags::ACCMODE;
if accmode == OFlags::RDONLY {
rights.base &= !types::Rights::FD_WRITE;
rights.base &= !Rights::FD_WRITE;
} else if accmode == OFlags::WRONLY {
rights.base &= !types::Rights::FD_READ;
rights.base &= !Rights::FD_READ;
}
Ok(rights)
}
@@ -133,9 +131,9 @@ pub fn preopen_dir<P: AsRef<Path>>(path: P) -> io::Result<File> {
File::open(path)
}
impl From<types::Clockid> for ClockId {
fn from(clock_id: types::Clockid) -> Self {
use types::Clockid::*;
impl From<Clockid> for ClockId {
fn from(clock_id: Clockid) -> Self {
use Clockid::*;
match clock_id {
Realtime => Self::Realtime,
Monotonic => Self::Monotonic,
@@ -145,29 +143,29 @@ impl From<types::Clockid> for ClockId {
}
}
impl From<types::Fdflags> for OFlags {
fn from(fdflags: types::Fdflags) -> Self {
impl From<Fdflags> for OFlags {
fn from(fdflags: Fdflags) -> Self {
let mut nix_flags = Self::empty();
if fdflags.contains(&types::Fdflags::APPEND) {
if fdflags.contains(&Fdflags::APPEND) {
nix_flags.insert(Self::APPEND);
}
if fdflags.contains(&types::Fdflags::DSYNC) {
if fdflags.contains(&Fdflags::DSYNC) {
nix_flags.insert(Self::DSYNC);
}
if fdflags.contains(&types::Fdflags::NONBLOCK) {
if fdflags.contains(&Fdflags::NONBLOCK) {
nix_flags.insert(Self::NONBLOCK);
}
if fdflags.contains(&types::Fdflags::RSYNC) {
if fdflags.contains(&Fdflags::RSYNC) {
nix_flags.insert(O_RSYNC);
}
if fdflags.contains(&types::Fdflags::SYNC) {
if fdflags.contains(&Fdflags::SYNC) {
nix_flags.insert(Self::SYNC);
}
nix_flags
}
}
impl From<OFlags> for types::Fdflags {
impl From<OFlags> for Fdflags {
fn from(oflags: OFlags) -> Self {
let mut fdflags = Self::empty();
if oflags.contains(OFlags::APPEND) {
@@ -189,30 +187,30 @@ impl From<OFlags> for types::Fdflags {
}
}
impl From<types::Oflags> for OFlags {
fn from(oflags: types::Oflags) -> Self {
impl From<Oflags> for OFlags {
fn from(oflags: Oflags) -> Self {
let mut nix_flags = Self::empty();
if oflags.contains(&types::Oflags::CREAT) {
if oflags.contains(&Oflags::CREAT) {
nix_flags.insert(Self::CREAT);
}
if oflags.contains(&types::Oflags::DIRECTORY) {
if oflags.contains(&Oflags::DIRECTORY) {
nix_flags.insert(Self::DIRECTORY);
}
if oflags.contains(&types::Oflags::EXCL) {
if oflags.contains(&Oflags::EXCL) {
nix_flags.insert(Self::EXCL);
}
if oflags.contains(&types::Oflags::TRUNC) {
if oflags.contains(&Oflags::TRUNC) {
nix_flags.insert(Self::TRUNC);
}
nix_flags
}
}
impl TryFrom<libc::stat> for types::Filestat {
impl TryFrom<libc::stat> for Filestat {
type Error = Error;
fn try_from(filestat: libc::stat) -> Result<Self> {
fn filestat_to_timestamp(secs: u64, nsecs: u64) -> Result<types::Timestamp> {
fn filestat_to_timestamp(secs: u64, nsecs: u64) -> Result<Timestamp> {
secs.checked_mul(1_000_000_000)
.and_then(|sec_nsec| sec_nsec.checked_add(nsecs))
.ok_or(Error::Overflow)
@@ -238,7 +236,7 @@ impl TryFrom<libc::stat> for types::Filestat {
dev,
ino,
nlink: filestat.st_nlink.into(),
size: filestat.st_size as types::Filesize,
size: filestat.st_size as Filesize,
atim,
ctim,
mtim,
@@ -247,7 +245,7 @@ impl TryFrom<libc::stat> for types::Filestat {
}
}
impl From<yanix::file::FileType> for types::Filetype {
impl From<yanix::file::FileType> for Filetype {
fn from(ft: yanix::file::FileType) -> Self {
use yanix::file::FileType::*;
match ft {
@@ -267,10 +265,10 @@ impl From<yanix::file::FileType> for types::Filetype {
}
}
impl From<types::Lookupflags> for AtFlags {
fn from(flags: types::Lookupflags) -> Self {
impl From<Lookupflags> for AtFlags {
fn from(flags: Lookupflags) -> Self {
match flags {
types::Lookupflags::SYMLINK_FOLLOW => Self::empty(),
Lookupflags::SYMLINK_FOLLOW => Self::empty(),
_ => Self::SYMLINK_NOFOLLOW,
}
}

12
crates/wasi-common/src/sys/unix/osdir.rs
View File

@@ -1,6 +1,5 @@
use super::oshandle::RawOsHandle;
use crate::handle::HandleRights;
use crate::wasi::{types, RightsExt};
use crate::handle::{HandleRights, Rights, RightsExt};
use std::convert::TryFrom;
use std::fs::File;
use std::io;
@@ -24,16 +23,13 @@ impl TryFrom<File> for OsDir {
fn get_rights(file: &File) -> io::Result<HandleRights> {
use yanix::{fcntl, file::OFlags};
let mut rights = HandleRights::new(
types::Rights::directory_base(),
types::Rights::directory_inheriting(),
);
let mut rights = HandleRights::new(Rights::directory_base(), Rights::directory_inheriting());
let flags = unsafe { fcntl::get_status_flags(file.as_raw_fd())? };
let accmode = flags & OFlags::ACCMODE;
if accmode == OFlags::RDONLY {
rights.base &= !types::Rights::FD_WRITE;
rights.base &= !Rights::FD_WRITE;
} else if accmode == OFlags::WRONLY {
rights.base &= !types::Rights::FD_READ;
rights.base &= !Rights::FD_READ;
}
Ok(rights)
}

11
crates/wasi-common/src/sys/unix/osfile.rs
View File

@@ -1,7 +1,6 @@
use super::oshandle::RawOsHandle;
use crate::handle::HandleRights;
use crate::handle::{HandleRights, Rights, RightsExt};
use crate::sys::osfile::OsFile;
use crate::wasi::{types, RightsExt};
use std::convert::TryFrom;
use std::fs::File;
use std::io;
@@ -24,15 +23,15 @@ impl TryFrom<File> for OsFile {
fn get_rights(file: &File) -> io::Result<HandleRights> {
use yanix::{fcntl, file::OFlags};
let mut rights = HandleRights::new(
types::Rights::regular_file_base(),
types::Rights::regular_file_inheriting(),
Rights::regular_file_base(),
Rights::regular_file_inheriting(),
);
let flags = unsafe { fcntl::get_status_flags(file.as_raw_fd())? };
let accmode = flags & OFlags::ACCMODE;
if accmode == OFlags::RDONLY {
rights.base &= !types::Rights::FD_WRITE;
rights.base &= !Rights::FD_WRITE;
} else if accmode == OFlags::WRONLY {
rights.base &= !types::Rights::FD_READ;
rights.base &= !Rights::FD_READ;
}
Ok(rights)
}

4
crates/wasi-common/src/sys/unix/osother.rs
View File

@@ -1,7 +1,7 @@
use super::oshandle::RawOsHandle;
use super::{get_file_type, get_rights};
use crate::handle::Filetype;
use crate::sys::osother::OsOther;
use crate::wasi::types;
use std::convert::TryFrom;
use std::fs::File;
use std::io;
@@ -12,7 +12,7 @@ impl TryFrom<File> for OsOther {
fn try_from(file: File) -> io::Result<Self> {
let file_type = get_file_type(&file)?;
if file_type == types::Filetype::RegularFile || file_type == types::Filetype::Directory {
if file_type == Filetype::RegularFile || file_type == Filetype::Directory {
return Err(io::Error::from_raw_os_error(libc::EINVAL));
}
let rights = get_rights(&file, &file_type)?;

38
crates/wasi-common/src/sys/unix/path.rs
View File

@@ -1,7 +1,7 @@
use crate::handle::{Handle, HandleRights};
use crate::handle::{Fdflags, Filestat, Fstflags, Handle, HandleRights, Oflags, Rights};
use crate::sched::Timestamp;
use crate::sys::osdir::OsDir;
use crate::sys::AsFile;
use crate::wasi::types;
use crate::{Error, Result};
use std::convert::{TryFrom, TryInto};
use std::ffi::OsStr;
@@ -23,29 +23,29 @@ pub(crate) fn from_host<S: AsRef<OsStr>>(s: S) -> Result<String> {
pub(crate) fn open_rights(
input_rights: &HandleRights,
oflags: types::Oflags,
fs_flags: types::Fdflags,
oflags: Oflags,
fs_flags: Fdflags,
) -> HandleRights {
// which rights are needed on the dirfd?
let mut needed_base = types::Rights::PATH_OPEN;
let mut needed_base = Rights::PATH_OPEN;
let mut needed_inheriting = input_rights.base | input_rights.inheriting;
// convert open flags
let oflags: OFlags = oflags.into();
if oflags.contains(OFlags::CREAT) {
needed_base |= types::Rights::PATH_CREATE_FILE;
needed_base |= Rights::PATH_CREATE_FILE;
}
if oflags.contains(OFlags::TRUNC) {
needed_base |= types::Rights::PATH_FILESTAT_SET_SIZE;
needed_base |= Rights::PATH_FILESTAT_SET_SIZE;
}
// convert file descriptor flags
let fdflags: OFlags = fs_flags.into();
if fdflags.contains(OFlags::DSYNC) {
needed_inheriting |= types::Rights::FD_DATASYNC;
needed_inheriting |= Rights::FD_DATASYNC;
}
if fdflags.intersects(super::O_RSYNC | OFlags::SYNC) {
needed_inheriting |= types::Rights::FD_SYNC;
needed_inheriting |= Rights::FD_SYNC;
}
HandleRights::new(needed_base, needed_inheriting)
@@ -98,8 +98,8 @@ pub(crate) fn open(
path: &str,
read: bool,
write: bool,
oflags: types::Oflags,
fs_flags: types::Fdflags,
oflags: Oflags,
fs_flags: Fdflags,
) -> Result<Box<dyn Handle>> {
use yanix::file::{fstatat, openat, AtFlags, FileType, Mode, OFlags};
@@ -216,7 +216,7 @@ pub(crate) fn remove_directory(dirfd: &OsDir, path: &str) -> Result<()> {
Ok(())
}
pub(crate) fn filestat_get_at(dirfd: &OsDir, path: &str, follow: bool) -> Result<types::Filestat> {
pub(crate) fn filestat_get_at(dirfd: &OsDir, path: &str, follow: bool) -> Result<Filestat> {
use yanix::file::{fstatat, AtFlags};
let flags = if follow {
AtFlags::empty()
@@ -231,18 +231,18 @@ pub(crate) fn filestat_get_at(dirfd: &OsDir, path: &str, follow: bool) -> Result
pub(crate) fn filestat_set_times_at(
dirfd: &OsDir,
path: &str,
atim: types::Timestamp,
mtim: types::Timestamp,
fst_flags: types::Fstflags,
atim: Timestamp,
mtim: Timestamp,
fst_flags: Fstflags,
follow: bool,
) -> Result<()> {
use std::time::{Duration, UNIX_EPOCH};
use yanix::filetime::*;
let set_atim = fst_flags.contains(&types::Fstflags::ATIM);
let set_atim_now = fst_flags.contains(&types::Fstflags::ATIM_NOW);
let set_mtim = fst_flags.contains(&types::Fstflags::MTIM);
let set_mtim_now = fst_flags.contains(&types::Fstflags::MTIM_NOW);
let set_atim = fst_flags.contains(&Fstflags::ATIM);
let set_atim_now = fst_flags.contains(&Fstflags::ATIM_NOW);
let set_mtim = fst_flags.contains(&Fstflags::MTIM);
let set_mtim_now = fst_flags.contains(&Fstflags::MTIM_NOW);
if (set_atim && set_atim_now) || (set_mtim && set_mtim_now) {
return Err(Error::Inval);

58
crates/wasi-common/src/sys/unix/poll.rs
View File

@@ -1,7 +1,9 @@
use crate::entry::EntryHandle;
use crate::poll::{ClockEventData, FdEventData};
use crate::handle::Filetype;
use crate::sched::{
ClockEventData, Errno, Event, EventFdReadwrite, Eventrwflags, Eventtype, FdEventData,
};
use crate::sys::AsFile;
use crate::wasi::types;
use crate::{Error, Result};
use std::io;
use std::{convert::TryInto, os::unix::prelude::AsRawFd};
@@ -11,7 +13,7 @@ use yanix::poll::{poll, PollFd, PollFlags};
pub(crate) fn oneoff(
timeout: Option<ClockEventData>,
fd_events: Vec<FdEventData>,
events: &mut Vec<types::Event>,
events: &mut Vec<Event>,
) -> Result<()> {
if fd_events.is_empty() && timeout.is_none() {
return Ok(());
@@ -22,8 +24,8 @@ pub(crate) fn oneoff(
.map(|event| {
let mut flags = PollFlags::empty();
match event.r#type {
types::Eventtype::FdRead => flags.insert(PollFlags::POLLIN),
types::Eventtype::FdWrite => flags.insert(PollFlags::POLLOUT),
Eventtype::FdRead => flags.insert(PollFlags::POLLIN),
Eventtype::FdWrite => flags.insert(PollFlags::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.
@@ -65,13 +67,13 @@ pub(crate) fn oneoff(
})
}
fn handle_timeout_event(timeout: ClockEventData, events: &mut Vec<types::Event>) {
events.push(types::Event {
fn handle_timeout_event(timeout: ClockEventData, events: &mut Vec<Event>) {
events.push(Event {
userdata: timeout.userdata,
error: types::Errno::Success,
type_: types::Eventtype::Clock,
fd_readwrite: types::EventFdReadwrite {
flags: types::Eventrwflags::empty(),
error: Errno::Success,
type_: Eventtype::Clock,
fd_readwrite: EventFdReadwrite {
flags: Eventrwflags::empty(),
nbytes: 0,
},
});
@@ -79,11 +81,11 @@ fn handle_timeout_event(timeout: ClockEventData, events: &mut Vec<types::Event>)
fn handle_fd_event(
ready_events: impl Iterator<Item = (FdEventData, yanix::poll::PollFd)>,
events: &mut Vec<types::Event>,
events: &mut Vec<Event>,
) -> Result<()> {
fn query_nbytes(handle: EntryHandle) -> Result<u64> {
let file = handle.as_file()?;
if handle.get_file_type() == types::Filetype::RegularFile {
if handle.get_file_type() == Filetype::RegularFile {
// fionread may overflow for large files, so use another way for regular files.
use yanix::file::tell;
let meta = file.metadata()?;
@@ -106,50 +108,50 @@ fn handle_fd_event(
None => continue,
};
let nbytes = if fd_event.r#type == types::Eventtype::FdRead {
let nbytes = if fd_event.r#type == Eventtype::FdRead {
query_nbytes(fd_event.handle)?
} else {
0
};
let output_event = if revents.contains(PollFlags::POLLNVAL) {
types::Event {
Event {
userdata: fd_event.userdata,
error: Error::Badf.into(),
type_: fd_event.r#type,
fd_readwrite: types::EventFdReadwrite {
fd_readwrite: EventFdReadwrite {
nbytes: 0,
flags: types::Eventrwflags::FD_READWRITE_HANGUP,
flags: Eventrwflags::FD_READWRITE_HANGUP,
},
}
} else if revents.contains(PollFlags::POLLERR) {
types::Event {
Event {
userdata: fd_event.userdata,
error: Error::Io.into(),
type_: fd_event.r#type,
fd_readwrite: types::EventFdReadwrite {
fd_readwrite: EventFdReadwrite {
nbytes: 0,
flags: types::Eventrwflags::FD_READWRITE_HANGUP,
flags: Eventrwflags::FD_READWRITE_HANGUP,
},
}
} else if revents.contains(PollFlags::POLLHUP) {
types::Event {
Event {
userdata: fd_event.userdata,
error: types::Errno::Success,
error: Errno::Success,
type_: fd_event.r#type,
fd_readwrite: types::EventFdReadwrite {
fd_readwrite: EventFdReadwrite {
nbytes: 0,
flags: types::Eventrwflags::FD_READWRITE_HANGUP,
flags: Eventrwflags::FD_READWRITE_HANGUP,
},
}
} else if revents.contains(PollFlags::POLLIN) | revents.contains(PollFlags::POLLOUT) {
types::Event {
Event {
userdata: fd_event.userdata,
error: types::Errno::Success,
error: Errno::Success,
type_: fd_event.r#type,
fd_readwrite: types::EventFdReadwrite {
fd_readwrite: EventFdReadwrite {
nbytes: nbytes.try_into()?,
flags: types::Eventrwflags::empty(),
flags: Eventrwflags::empty(),
},
}
} else {

22
crates/wasi-common/src/sys/windows/clock.rs
View File

@@ -1,4 +1,4 @@
use crate::wasi::types;
use crate::sched::{Clockid, Timestamp};
use crate::{Error, Result};
use cpu_time::{ProcessTime, ThreadTime};
use lazy_static::lazy_static;
@@ -12,7 +12,7 @@ lazy_static! {
// Timer resolution on Windows is really hard. We may consider exposing the resolution of the respective
// timers as an associated function in the future.
pub(crate) fn res_get(clock_id: types::Clockid) -> Result<types::Timestamp> {
pub(crate) fn res_get(clock_id: Clockid) -> Result<Timestamp> {
let ts = match clock_id {
// This is the best that we can do with std::time::SystemTime.
// Rust uses GetSystemTimeAsFileTime, which is said to have the resolution of
@@ -47,25 +47,25 @@ pub(crate) fn res_get(clock_id: types::Clockid) -> Result<types::Timestamp> {
// [4] https://www.codeproject.com/Tips/1011902/High-Resolution-Time-For-Windows
// [5] https://stackoverflow.com/questions/7685762/windows-7-timing-functions-how-to-use-getsystemtimeadjustment-correctly
// [6] https://bugs.python.org/issue19007
types::Clockid::Realtime => 55_000_000,
Clockid::Realtime => 55_000_000,
// std::time::Instant uses QueryPerformanceCounter & QueryPerformanceFrequency internally
types::Clockid::Monotonic => *PERF_COUNTER_RES,
Clockid::Monotonic => *PERF_COUNTER_RES,
// The best we can do is to hardcode the value from the docs.
// https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getprocesstimes
types::Clockid::ProcessCputimeId => 100,
Clockid::ProcessCputimeId => 100,
// The best we can do is to hardcode the value from the docs.
// https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getthreadtimes
types::Clockid::ThreadCputimeId => 100,
Clockid::ThreadCputimeId => 100,
};
Ok(ts)
}
pub(crate) fn time_get(clock_id: types::Clockid) -> Result<types::Timestamp> {
pub(crate) fn time_get(clock_id: Clockid) -> Result<Timestamp> {
let duration = match clock_id {
types::Clockid::Realtime => get_monotonic_time(),
types::Clockid::Monotonic => get_realtime_time()?,
types::Clockid::ProcessCputimeId => get_proc_cputime()?,
types::Clockid::ThreadCputimeId => get_thread_cputime()?,
Clockid::Realtime => get_monotonic_time(),
Clockid::Monotonic => get_realtime_time()?,
Clockid::ProcessCputimeId => get_proc_cputime()?,
Clockid::ThreadCputimeId => get_thread_cputime()?,
};
let duration = duration.as_nanos().try_into()?;
Ok(duration)

39
crates/wasi-common/src/sys/windows/fd.rs
View File

@@ -1,10 +1,10 @@
use super::file_serial_no;
use super::oshandle::RawOsHandle;
use crate::handle::{Advice, Dircookie, Dirent, Fdflags, Filesize, Filestat};
use crate::path;
use crate::sys::osdir::OsDir;
use crate::sys::osfile::OsFile;
use crate::sys::AsFile;
use crate::wasi::types;
use crate::Result;
use std::convert::TryInto;
use std::fs::{File, OpenOptions};
@@ -14,8 +14,8 @@ use std::path::Path;
use tracing::trace;
use winx::file::{AccessMode, FileModeInformation, Flags};
pub(crate) fn fdstat_get(file: &File) -> Result<types::Fdflags> {
let mut fdflags = types::Fdflags::empty();
pub(crate) fn fdstat_get(file: &File) -> Result<Fdflags> {
let mut fdflags = Fdflags::empty();
let handle = file.as_raw_handle();
let access_mode = winx::file::query_access_information(handle)?;
let mode = winx::file::query_mode_information(handle)?;
@@ -24,13 +24,13 @@ pub(crate) fn fdstat_get(file: &File) -> Result<types::Fdflags> {
if access_mode.contains(AccessMode::FILE_APPEND_DATA)
&& !access_mode.contains(AccessMode::FILE_WRITE_DATA)
{
fdflags |= types::Fdflags::APPEND;
fdflags |= Fdflags::APPEND;
}
if mode.contains(FileModeInformation::FILE_WRITE_THROUGH) {
// Only report __WASI_FDFLAGS_SYNC
// This is technically the only one of the O_?SYNC flags Windows supports.
fdflags |= types::Fdflags::SYNC;
fdflags |= Fdflags::SYNC;
}
// Files do not support the `__WASI_FDFLAGS_NONBLOCK` flag
@@ -42,10 +42,7 @@ pub(crate) fn fdstat_get(file: &File) -> Result<types::Fdflags> {
// handle came from `CreateFile`, but the Rust's libstd will use `GetStdHandle`
// rather than `CreateFile`. Relevant discussion can be found in:
// https://github.com/rust-lang/rust/issues/40490
pub(crate) fn fdstat_set_flags(
file: &File,
fdflags: types::Fdflags,
) -> Result<Option<RawOsHandle>> {
pub(crate) fn fdstat_set_flags(file: &File, fdflags: Fdflags) -> Result<Option<RawOsHandle>> {
let handle = file.as_raw_handle();
let access_mode = winx::file::query_access_information(handle)?;
let new_access_mode = file_access_mode_from_fdflags(
@@ -65,14 +62,14 @@ pub(crate) fn fdstat_set_flags(
pub(crate) fn advise(
_file: &OsFile,
_advice: types::Advice,
_offset: types::Filesize,
_len: types::Filesize,
_advice: Advice,
_offset: Filesize,
_len: Filesize,
) -> Result<()> {
Ok(())
}
fn file_access_mode_from_fdflags(fdflags: types::Fdflags, read: bool, write: bool) -> AccessMode {
fn file_access_mode_from_fdflags(fdflags: Fdflags, read: bool, write: bool) -> AccessMode {
let mut access_mode = AccessMode::READ_CONTROL;
// Note that `GENERIC_READ` and `GENERIC_WRITE` cannot be used to properly support append-only mode
@@ -89,7 +86,7 @@ fn file_access_mode_from_fdflags(fdflags: types::Fdflags, read: bool, write: boo
// For append, grant the handle FILE_APPEND_DATA access but *not* FILE_WRITE_DATA.
// This makes the handle "append only".
// Changes to the file pointer will be ignored (like POSIX's O_APPEND behavior).
if fdflags.contains(&types::Fdflags::APPEND) {
if fdflags.contains(&Fdflags::APPEND) {
access_mode.insert(AccessMode::FILE_APPEND_DATA);
access_mode.remove(AccessMode::FILE_WRITE_DATA);
}
@@ -127,8 +124,8 @@ fn file_access_mode_from_fdflags(fdflags: types::Fdflags, read: bool, write: boo
// other entries, in order they were returned by FindNextFileW get subsequent integers as their cookies
pub(crate) fn readdir(
dirfd: &OsDir,
cookie: types::Dircookie,
) -> Result<Box<dyn Iterator<Item = Result<(types::Dirent, String)>>>> {
cookie: Dircookie,
) -> Result<Box<dyn Iterator<Item = Result<(Dirent, String)>>>> {
use winx::file::get_file_path;
let cookie = cookie.try_into()?;
@@ -146,7 +143,7 @@ pub(crate) fn readdir(
let ftype = dir.file_type()?;
let name = path::from_host(dir.file_name())?;
let d_ino = File::open(dir.path()).and_then(|f| file_serial_no(&f))?;
let dirent = types::Dirent {
let dirent = Dirent {
d_namlen: name.len().try_into()?,
d_type: ftype.into(),
d_ino,
@@ -171,8 +168,8 @@ pub(crate) fn readdir(
fn dirent_from_path<P: AsRef<Path>>(
path: P,
name: &str,
cookie: types::Dircookie,
) -> Result<(types::Dirent, String)> {
cookie: Dircookie,
) -> Result<(Dirent, String)> {
let path = path.as_ref();
trace!("dirent_from_path: opening {}", path.to_string_lossy());
@@ -183,7 +180,7 @@ fn dirent_from_path<P: AsRef<Path>>(
.open(path)?;
let ty = file.metadata()?.file_type();
let name = name.to_owned();
let dirent = types::Dirent {
let dirent = Dirent {
d_namlen: name.len().try_into()?,
d_next: cookie,
d_type: ty.into(),
@@ -192,7 +189,7 @@ fn dirent_from_path<P: AsRef<Path>>(
Ok((dirent, name))
}
pub(crate) fn filestat_get(file: &File) -> Result<types::Filestat> {
pub(crate) fn filestat_get(file: &File) -> Result<Filestat> {
let filestat = file.try_into()?;
Ok(filestat)
}

71
crates/wasi-common/src/sys/windows/mod.rs
View File

@@ -8,9 +8,8 @@ pub(crate) mod path;
pub(crate) mod poll;
pub(crate) mod stdio;
use crate::handle::HandleRights;
use crate::handle::{Fdflags, Filestat, Filetype, HandleRights, Oflags, Rights, RightsExt};
use crate::sys::AsFile;
use crate::wasi::{types, RightsExt};
use crate::{Error, Result};
use std::convert::{TryFrom, TryInto};
use std::fs::File;
@@ -28,54 +27,50 @@ impl<T: AsRawHandle> AsFile for T {
}
}
pub(super) fn get_file_type(file: &File) -> io::Result<types::Filetype> {
pub(super) fn get_file_type(file: &File) -> io::Result<Filetype> {
let file_type = unsafe { winx::file::get_file_type(file.as_raw_handle())? };
let file_type = if file_type.is_char() {
// character file: LPT device or console
// TODO: rule out LPT device
types::Filetype::CharacterDevice
Filetype::CharacterDevice
} else if file_type.is_disk() {
// disk file: file, dir or disk device
let meta = file.metadata()?;
if meta.is_dir() {
types::Filetype::Directory
Filetype::Directory
} else if meta.is_file() {
types::Filetype::RegularFile
Filetype::RegularFile
} else {
return Err(io::Error::from_raw_os_error(libc::EINVAL));
}
} else if file_type.is_pipe() {
// pipe object: socket, named pipe or anonymous pipe
// TODO: what about pipes, etc?
types::Filetype::SocketStream
Filetype::SocketStream
} else {
return Err(io::Error::from_raw_os_error(libc::EINVAL));
};
Ok(file_type)
}
pub(super) fn get_rights(file_type: &types::Filetype) -> io::Result<HandleRights> {
pub(super) fn get_rights(file_type: &Filetype) -> io::Result<HandleRights> {
let (base, inheriting) = match file_type {
types::Filetype::BlockDevice => (
types::Rights::block_device_base(),
types::Rights::block_device_inheriting(),
Filetype::BlockDevice => (
Rights::block_device_base(),
Rights::block_device_inheriting(),
),
types::Filetype::CharacterDevice => (types::Rights::tty_base(), types::Rights::tty_base()),
types::Filetype::SocketDgram | types::Filetype::SocketStream => (
types::Rights::socket_base(),
types::Rights::socket_inheriting(),
Filetype::CharacterDevice => (Rights::tty_base(), Rights::tty_base()),
Filetype::SocketDgram | Filetype::SocketStream => {
(Rights::socket_base(), Rights::socket_inheriting())
}
Filetype::SymbolicLink | Filetype::Unknown => (
Rights::regular_file_base(),
Rights::regular_file_inheriting(),
),
types::Filetype::SymbolicLink | types::Filetype::Unknown => (
types::Rights::regular_file_base(),
types::Rights::regular_file_inheriting(),
),
types::Filetype::Directory => (
types::Rights::directory_base(),
types::Rights::directory_inheriting(),
),
types::Filetype::RegularFile => (
types::Rights::regular_file_base(),
types::Rights::regular_file_inheriting(),
Filetype::Directory => (Rights::directory_base(), Rights::directory_inheriting()),
Filetype::RegularFile => (
Rights::regular_file_base(),
Rights::regular_file_inheriting(),
),
};
let rights = HandleRights::new(base, inheriting);
@@ -132,12 +127,12 @@ fn systemtime_to_timestamp(st: SystemTime) -> Result<u64> {
.map_err(Into::into) // u128 doesn't fit into u64
}
impl TryFrom<&File> for types::Filestat {
impl TryFrom<&File> for Filestat {
type Error = Error;
fn try_from(file: &File) -> Result<Self> {
let metadata = file.metadata()?;
Ok(types::Filestat {
Ok(Filestat {
dev: device_id(file)?,
ino: file_serial_no(file)?,
nlink: num_hardlinks(file)?.try_into()?, // u64 doesn't fit into u32
@@ -150,15 +145,15 @@ impl TryFrom<&File> for types::Filestat {
}
}
impl From<types::Oflags> for CreationDisposition {
fn from(oflags: types::Oflags) -> Self {
if oflags.contains(&types::Oflags::CREAT) {
if oflags.contains(&types::Oflags::EXCL) {
impl From<Oflags> for CreationDisposition {
fn from(oflags: Oflags) -> Self {
if oflags.contains(&Oflags::CREAT) {
if oflags.contains(&Oflags::EXCL) {
CreationDisposition::CREATE_NEW
} else {
CreationDisposition::CREATE_ALWAYS
}
} else if oflags.contains(&types::Oflags::TRUNC) {
} else if oflags.contains(&Oflags::TRUNC) {
CreationDisposition::TRUNCATE_EXISTING
} else {
CreationDisposition::OPEN_EXISTING
@@ -166,8 +161,8 @@ impl From<types::Oflags> for CreationDisposition {
}
}
impl From<types::Fdflags> for Flags {
fn from(fdflags: types::Fdflags) -> Self {
impl From<Fdflags> for Flags {
fn from(fdflags: Fdflags) -> Self {
// Enable backup semantics so directories can be opened as files
let mut flags = Flags::FILE_FLAG_BACKUP_SEMANTICS;
@@ -176,9 +171,9 @@ impl From<types::Fdflags> for Flags {
// treat I/O operations on files as synchronous. WASI might have an async-io API in the future.
// Technically, Windows only supports __WASI_FDFLAGS_SYNC, but treat all the flags as the same.
if fdflags.contains(&types::Fdflags::DSYNC)
|| fdflags.contains(&types::Fdflags::RSYNC)
|| fdflags.contains(&types::Fdflags::SYNC)
if fdflags.contains(&Fdflags::DSYNC)
|| fdflags.contains(&Fdflags::RSYNC)
|| fdflags.contains(&Fdflags::SYNC)
{
flags.insert(Flags::FILE_FLAG_WRITE_THROUGH);
}

12
crates/wasi-common/src/sys/windows/osdir.rs
View File

@@ -1,6 +1,5 @@
use super::oshandle::RawOsHandle;
use crate::handle::HandleRights;
use crate::wasi::{types, RightsExt};
use crate::handle::{HandleRights, Rights, RightsExt};
use std::cell::Cell;
use std::convert::TryFrom;
use std::fs::File;
@@ -55,16 +54,13 @@ impl TryFrom<File> for OsDir {
fn get_rights(file: &File) -> io::Result<HandleRights> {
use winx::file::{query_access_information, AccessMode};
let mut rights = HandleRights::new(
types::Rights::directory_base(),
types::Rights::directory_inheriting(),
);
let mut rights = HandleRights::new(Rights::directory_base(), Rights::directory_inheriting());
let mode = query_access_information(file.as_raw_handle())?;
if mode.contains(AccessMode::FILE_GENERIC_READ) {
rights.base |= types::Rights::FD_READ;
rights.base |= Rights::FD_READ;
}
if mode.contains(AccessMode::FILE_GENERIC_WRITE) {
rights.base |= types::Rights::FD_WRITE;
rights.base |= Rights::FD_WRITE;
}
Ok(rights)
}

11
crates/wasi-common/src/sys/windows/osfile.rs
View File

@@ -1,7 +1,6 @@
use super::oshandle::RawOsHandle;
use crate::handle::HandleRights;
use crate::handle::{HandleRights, Rights, RightsExt};
use crate::sys::osfile::OsFile;
use crate::wasi::{types, RightsExt};
use std::convert::TryFrom;
use std::fs::File;
use std::io;
@@ -24,15 +23,15 @@ impl TryFrom<File> for OsFile {
fn get_rights(file: &File) -> io::Result<HandleRights> {
use winx::file::{query_access_information, AccessMode};
let mut rights = HandleRights::new(
types::Rights::regular_file_base(),
types::Rights::regular_file_inheriting(),
Rights::regular_file_base(),
Rights::regular_file_inheriting(),
);
let mode = query_access_information(file.as_raw_handle())?;
if mode.contains(AccessMode::FILE_GENERIC_READ) {
rights.base |= types::Rights::FD_READ;
rights.base |= Rights::FD_READ;
}
if mode.contains(AccessMode::FILE_GENERIC_WRITE) {
rights.base |= types::Rights::FD_WRITE;
rights.base |= Rights::FD_WRITE;
}
Ok(rights)
}

4
crates/wasi-common/src/sys/windows/osother.rs
View File

@@ -1,7 +1,7 @@
use super::oshandle::RawOsHandle;
use super::{get_file_type, get_rights};
use crate::handle::Filetype;
use crate::sys::osother::OsOther;
use crate::wasi::types;
use std::convert::TryFrom;
use std::fs::File;
use std::io;
@@ -12,7 +12,7 @@ impl TryFrom<File> for OsOther {
fn try_from(file: File) -> io::Result<Self> {
let file_type = get_file_type(&file)?;
if file_type == types::Filetype::RegularFile || file_type == types::Filetype::Directory {
if file_type == Filetype::RegularFile || file_type == Filetype::Directory {
return Err(io::Error::from_raw_os_error(libc::EINVAL));
}
let rights = get_rights(&file_type)?;

50
crates/wasi-common/src/sys/windows/path.rs
View File

@@ -1,7 +1,7 @@
use crate::handle::{Handle, HandleRights};
use crate::handle::{Fdflags, Filestat, Fstflags, Handle, HandleRights, Oflags, Rights};
use crate::sched::Timestamp;
use crate::sys::osdir::OsDir;
use crate::sys::{fd, AsFile};
use crate::wasi::types;
use crate::{Error, Result};
use std::convert::TryFrom;
use std::ffi::{OsStr, OsString};
@@ -52,7 +52,7 @@ fn concatenate<P: AsRef<Path>>(file: &OsDir, path: P) -> Result<PathBuf> {
Ok(out_path)
}
fn file_access_mode_from_fdflags(fdflags: types::Fdflags, read: bool, write: bool) -> AccessMode {
fn file_access_mode_from_fdflags(fdflags: Fdflags, read: bool, write: bool) -> AccessMode {
let mut access_mode = AccessMode::READ_CONTROL;
// We always need `FILE_WRITE_ATTRIBUTES` so that we can set attributes such as filetimes, etc.
@@ -72,7 +72,7 @@ fn file_access_mode_from_fdflags(fdflags: types::Fdflags, read: bool, write: boo
// For append, grant the handle FILE_APPEND_DATA access but *not* FILE_WRITE_DATA.
// This makes the handle "append only".
// Changes to the file pointer will be ignored (like POSIX's O_APPEND behavior).
if fdflags.contains(&types::Fdflags::APPEND) {
if fdflags.contains(&Fdflags::APPEND) {
access_mode.insert(AccessMode::FILE_APPEND_DATA);
access_mode.remove(AccessMode::FILE_WRITE_DATA);
}
@@ -92,27 +92,27 @@ pub(crate) fn from_host<S: AsRef<OsStr>>(s: S) -> Result<String> {
pub(crate) fn open_rights(
input_rights: &HandleRights,
oflags: types::Oflags,
fdflags: types::Fdflags,
oflags: Oflags,
fdflags: Fdflags,
) -> HandleRights {
// which rights are needed on the dirfd?
let mut needed_base = types::Rights::PATH_OPEN;
let mut needed_base = Rights::PATH_OPEN;
let mut needed_inheriting = input_rights.base | input_rights.inheriting;
// convert open flags
if oflags.contains(&types::Oflags::CREAT) {
needed_base |= types::Rights::PATH_CREATE_FILE;
} else if oflags.contains(&types::Oflags::TRUNC) {
needed_base |= types::Rights::PATH_FILESTAT_SET_SIZE;
if oflags.contains(&Oflags::CREAT) {
needed_base |= Rights::PATH_CREATE_FILE;
} else if oflags.contains(&Oflags::TRUNC) {
needed_base |= Rights::PATH_FILESTAT_SET_SIZE;
}
// convert file descriptor flags
if fdflags.contains(&types::Fdflags::DSYNC)
|| fdflags.contains(&types::Fdflags::RSYNC)
|| fdflags.contains(&types::Fdflags::SYNC)
if fdflags.contains(&Fdflags::DSYNC)
|| fdflags.contains(&Fdflags::RSYNC)
|| fdflags.contains(&Fdflags::SYNC)
{
needed_inheriting |= types::Rights::FD_DATASYNC;
needed_inheriting |= types::Rights::FD_SYNC;
needed_inheriting |= Rights::FD_DATASYNC;
needed_inheriting |= Rights::FD_SYNC;
}
HandleRights::new(needed_base, needed_inheriting)
@@ -206,18 +206,18 @@ pub(crate) fn open(
path: &str,
read: bool,
write: bool,
oflags: types::Oflags,
fdflags: types::Fdflags,
oflags: Oflags,
fdflags: Fdflags,
) -> Result<Box<dyn Handle>> {
use winx::file::{AccessMode, CreationDisposition, Flags};
let is_trunc = oflags.contains(&types::Oflags::TRUNC);
let is_trunc = oflags.contains(&Oflags::TRUNC);
if is_trunc {
// Windows does not support append mode when opening for truncation
// This is because truncation requires `GENERIC_WRITE` access, which will override the removal
// of the `FILE_WRITE_DATA` permission.
if fdflags.contains(&types::Fdflags::APPEND) {
if fdflags.contains(&Fdflags::APPEND) {
return Err(Error::Notsup);
}
}
@@ -246,7 +246,7 @@ pub(crate) fn open(
return Err(Error::Loop);
}
// check if we are trying to open a file as a dir
if file_type.is_file() && oflags.contains(&types::Oflags::DIRECTORY) {
if file_type.is_file() && oflags.contains(&Oflags::DIRECTORY) {
return Err(Error::Notdir);
}
}
@@ -499,7 +499,7 @@ pub(crate) fn remove_directory(dirfd: &OsDir, path: &str) -> Result<()> {
std::fs::remove_dir(&path).map_err(Into::into)
}
pub(crate) fn filestat_get_at(dirfd: &OsDir, path: &str, follow: bool) -> Result<types::Filestat> {
pub(crate) fn filestat_get_at(dirfd: &OsDir, path: &str, follow: bool) -> Result<Filestat> {
use winx::file::Flags;
let path = concatenate(dirfd, path)?;
let mut opts = OpenOptions::new();
@@ -517,9 +517,9 @@ pub(crate) fn filestat_get_at(dirfd: &OsDir, path: &str, follow: bool) -> Result
pub(crate) fn filestat_set_times_at(
dirfd: &OsDir,
path: &str,
atim: types::Timestamp,
mtim: types::Timestamp,
fst_flags: types::Fstflags,
atim: Timestamp,
mtim: Timestamp,
fst_flags: Fstflags,
follow: bool,
) -> Result<()> {
use winx::file::{AccessMode, Flags};

58
crates/wasi-common/src/sys/windows/poll.rs
View File

@@ -1,11 +1,12 @@
use crate::handle::Handle;
use crate::poll::{ClockEventData, FdEventData};
use crate::handle::{Filetype, Handle};
use crate::sched::{
ClockEventData, Errno, Event, EventFdReadwrite, Eventrwflags, Eventtype, FdEventData,
};
use crate::sys::osdir::OsDir;
use crate::sys::osfile::OsFile;
use crate::sys::osother::OsOther;
use crate::sys::stdio::{Stderr, Stdin, Stdout};
use crate::sys::AsFile;
use crate::wasi::types;
use crate::{Error, Result};
use lazy_static::lazy_static;
use std::convert::TryInto;
@@ -24,7 +25,7 @@ enum PollState {
Ready,
NotReady, // it's not ready, but we didn't wait
TimedOut, // it's not ready and a timeout has occurred
Error(types::Errno),
Error(Errno),
}
enum WaitMode {
@@ -80,7 +81,7 @@ impl StdinPoll {
// Linux returns `POLLIN` in both cases, and we imitate this behavior.
let resp = match std::io::stdin().lock().fill_buf() {
Ok(_) => PollState::Ready,
Err(e) => PollState::Error(types::Errno::from(Error::from(e))),
Err(e) => PollState::Error(Errno::from(Error::from(e))),
};
// Notify the requestor about data in stdin. They may have already timed out,
@@ -102,52 +103,45 @@ lazy_static! {
};
}
fn make_rw_event(
event: &FdEventData,
nbytes: std::result::Result<u64, types::Errno>,
) -> types::Event {
fn make_rw_event(event: &FdEventData, nbytes: std::result::Result<u64, Errno>) -> Event {
let (nbytes, error) = match nbytes {
Ok(nbytes) => (nbytes, types::Errno::Success),
Ok(nbytes) => (nbytes, Errno::Success),
Err(e) => (u64::default(), e),
};
types::Event {
Event {
userdata: event.userdata,
type_: event.r#type,
error,
fd_readwrite: types::EventFdReadwrite {
fd_readwrite: EventFdReadwrite {
nbytes,
flags: types::Eventrwflags::empty(),
flags: Eventrwflags::empty(),
},
}
}
fn make_timeout_event(timeout: &ClockEventData) -> types::Event {
types::Event {
fn make_timeout_event(timeout: &ClockEventData) -> Event {
Event {
userdata: timeout.userdata,
type_: types::Eventtype::Clock,
error: types::Errno::Success,
fd_readwrite: types::EventFdReadwrite {
type_: Eventtype::Clock,
error: Errno::Success,
fd_readwrite: EventFdReadwrite {
nbytes: 0,
flags: types::Eventrwflags::empty(),
flags: Eventrwflags::empty(),
},
}
}
fn handle_timeout(
timeout_event: ClockEventData,
timeout: Duration,
events: &mut Vec<types::Event>,
) {
fn handle_timeout(timeout_event: ClockEventData, timeout: Duration, events: &mut Vec<Event>) {
thread::sleep(timeout);
handle_timeout_event(timeout_event, events);
}
fn handle_timeout_event(timeout_event: ClockEventData, events: &mut Vec<types::Event>) {
fn handle_timeout_event(timeout_event: ClockEventData, events: &mut Vec<Event>) {
let new_event = make_timeout_event(&timeout_event);
events.push(new_event);
}
fn handle_rw_event(event: FdEventData, out_events: &mut Vec<types::Event>) {
fn handle_rw_event(event: FdEventData, out_events: &mut Vec<Event>) {
let handle = &event.handle;
let size = if let Some(_) = handle.as_any().downcast_ref::<Stdin>() {
// We return the only universally correct lower bound, see the comment later in the function.
@@ -159,12 +153,12 @@ fn handle_rw_event(event: FdEventData, out_events: &mut Vec<types::Event>) {
// On Unix, ioctl(FIONREAD) will return 0 for stdout/stderr. Emulate the same behavior on Windows.
Ok(0)
} else {
if event.r#type == types::Eventtype::FdRead {
if event.r#type == Eventtype::FdRead {
handle
.as_file()
.and_then(|f| f.metadata())
.map(|m| m.len())
.map_err(|ioerror| types::Errno::from(Error::from(ioerror)))
.map_err(|ioerror| Errno::from(Error::from(ioerror)))
} else {
// The spec is unclear what nbytes should actually be for __WASI_EVENTTYPE_FD_WRITE and
// the implementation on Unix just returns 0 here, so it's probably fine
@@ -177,7 +171,7 @@ fn handle_rw_event(event: FdEventData, out_events: &mut Vec<types::Event>) {
out_events.push(new_event);
}
fn handle_error_event(event: FdEventData, error: types::Errno, out_events: &mut Vec<types::Event>) {
fn handle_error_event(event: FdEventData, error: Errno, out_events: &mut Vec<Event>) {
let new_event = make_rw_event(&event, Err(error));
out_events.push(new_event);
}
@@ -185,7 +179,7 @@ fn handle_error_event(event: FdEventData, error: types::Errno, out_events: &mut
pub(crate) fn oneoff(
timeout: Option<ClockEventData>,
fd_events: Vec<FdEventData>,
events: &mut Vec<types::Event>,
events: &mut Vec<Event>,
) -> Result<()> {
let timeout = timeout
.map(|event| {
@@ -234,7 +228,7 @@ pub(crate) fn oneoff(
// considered immediately ready, following the behavior on Linux.
immediate_events.push(event);
} else if let Some(other) = handle.as_any().downcast_ref::<OsOther>() {
if other.get_file_type() == types::Filetype::SocketStream {
if other.get_file_type() == Filetype::SocketStream {
// We map pipe to SocketStream
pipe_events.push(event);
} else {
@@ -242,7 +236,7 @@ pub(crate) fn oneoff(
"poll_oneoff: unsupported file type: {}",
other.get_file_type()
);
handle_error_event(event, types::Errno::Notsup, events);
handle_error_event(event, Errno::Notsup, events);
}
} else {
tracing::error!("can poll FdEvent for OS resources only");