cbf7cbfa39
* Introduce strongly-typed system primitives This commit does a lot of reshuffling and even some more. It introduces strongly-typed system primitives which are: `OsFile`, `OsDir`, `Stdio`, and `OsOther`. Those primitives are separate structs now, each implementing a subset of `Handle` methods, rather than all being an enumeration of some supertype such as `OsHandle`. To summarise the structs: * `OsFile` represents a regular file, and implements fd-ops of `Handle` trait * `OsDir` represents a directory, and primarily implements path-ops, plus `readdir` and some common fd-ops such as `fdstat`, etc. * `Stdio` represents a stdio handle, and implements a subset of fd-ops such as `fdstat` _and_ `read_` and `write_vectored` calls * `OsOther` currently represents anything else and implements a set similar to that implemented by `Stdio` This commit is effectively an experiment and an excercise into better understanding what's going on for each OS resource/type under-the-hood. It's meant to give us some intuition in order to move on with the idea of having strongly-typed handles in WASI both in the syscall impl as well as at the libc level. Some more minor changes include making `OsHandle` represent an OS-specific wrapper for a raw OS handle (Unix fd or Windows handle). Also, since `OsDir` is tricky across OSes, we also have a supertype of `OsHandle` called `OsDirHandle` which may store a `DIR*` stream pointer (mainly BSD). Last but not least, the `Filetype` and `Rights` are now computed when the resource is created, rather than every time we call `Handle::get_file_type` and `Handle::get_rights`. Finally, in order to facilitate the latter, I've converted `EntryRights` into `HandleRights` and pushed them into each `Handle` implementor. * Do not adjust rights on Stdio * Clean up testing for TTY and escaping writes * Implement AsFile for dyn Handle This cleans up a lot of repeating boilerplate code todo with dynamic dispatch. * Delegate definition of OsDir to OS-specific modules Delegates defining `OsDir` struct to OS-specific modules (BSD, Linux, Emscripten, Windows). This way, `OsDir` can safely re-use `OsHandle` for raw OS handle storage, and can store some aux data such as an initialized stream ptr in case of BSD. As a result, we can safely get rid of `OsDirHandle` which IMHO was causing unnecessary noise and overcomplicating the design. On the other hand, delegating definition of `OsDir` to OS-specific modules isn't super clean in and of itself either. Perhaps there's a better way of handling this? * Check if filetype of OS handle matches WASI filetype when creating It seems prudent to check if the passed in `File` instance is of type matching that of the requested WASI filetype. In other words, we'd like to avoid situations where `OsFile` is created from a pipe. * Make AsFile fallible Return `EBADF` in `AsFile` in case a `Handle` cannot be made into a `std::fs::File`. * Remove unnecessary as_file conversion * Remove unnecessary check for TTY for Stdio handle type * Fix incorrect stdio ctors on Unix * Split Stdio into three separate types: Stdin, Stdout, Stderr * Rename PendingEntry::File to PendingEntry::OsHandle to avoid confusion * Rename OsHandle to RawOsHandle Also, since `RawOsHandle` on *nix doesn't need interior mutability wrt the inner raw file descriptor, we can safely swap the `RawFd` for `File` instance. * Add docs explaining what OsOther is * Allow for stdio to be non-character-device (e.g., piped) * Return error on bad preopen rather than panic
82 lines
2.9 KiB
Rust
82 lines
2.9 KiB
Rust
use super::oshandle::RawOsHandle;
|
|
use crate::sys::osdir::OsDir;
|
|
use crate::sys::osfile::OsFile;
|
|
use crate::wasi::{self, types, 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> {
|
|
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>> {
|
|
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.
|
|
// This is needed as on Windows this operation required reopening a file.
|
|
Ok(None)
|
|
}
|
|
|
|
pub(crate) fn advise(
|
|
file: &OsFile,
|
|
advice: types::Advice,
|
|
offset: types::Filesize,
|
|
len: types::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,
|
|
};
|
|
unsafe { posix_fadvise(file.as_raw_fd(), offset, len, host_advice)? };
|
|
Ok(())
|
|
}
|
|
|
|
pub(crate) fn filestat_get(file: &File) -> Result<types::Filestat> {
|
|
use yanix::file::fstat;
|
|
let stat = unsafe { fstat(file.as_raw_fd())? };
|
|
Ok(stat.try_into()?)
|
|
}
|
|
|
|
pub(crate) fn readdir<'a>(
|
|
dirfd: &'a OsDir,
|
|
cookie: types::Dircookie,
|
|
) -> Result<Box<dyn Iterator<Item = Result<(types::Dirent, String)>> + 'a>> {
|
|
use yanix::dir::{DirIter, Entry, EntryExt, SeekLoc};
|
|
|
|
// Get an instance of `Dir`; this is host-specific due to intricasies
|
|
// of managing a dir stream between Linux and BSD *nixes
|
|
let mut dir = dirfd.stream_ptr()?;
|
|
|
|
// Seek if needed. Unless cookie is wasi::__WASI_DIRCOOKIE_START,
|
|
// new items may not be returned to the caller.
|
|
if cookie == wasi::DIRCOOKIE_START {
|
|
log::trace!(" | fd_readdir: doing rewinddir");
|
|
dir.rewind();
|
|
} else {
|
|
log::trace!(" | fd_readdir: doing seekdir to {}", cookie);
|
|
let loc = unsafe { SeekLoc::from_raw(cookie as i64)? };
|
|
dir.seek(loc);
|
|
}
|
|
|
|
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 {
|
|
d_next: entry.seek_loc()?.to_raw().try_into()?,
|
|
d_ino: entry.ino(),
|
|
d_namlen: name.len().try_into()?,
|
|
d_type: entry.file_type().into(),
|
|
};
|
|
Ok((dirent, name))
|
|
})))
|
|
}
|