Introduce strongly-typed system primitives (#1561)
* 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
This commit is contained in:
Jakub Konka
@@ -1,11 +1,14 @@
|
||||
use super::super::oshandle::OsHandle;
|
||||
use crate::handle::Handle;
|
||||
use crate::poll::{ClockEventData, FdEventData};
|
||||
use crate::sys::oshandle::AsFile;
|
||||
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, Errno, Result};
|
||||
use lazy_static::lazy_static;
|
||||
use log::{debug, error, trace, warn};
|
||||
use std::convert::TryInto;
|
||||
use std::os::windows::io::AsRawHandle;
|
||||
use std::sync::mpsc::{self, Receiver, RecvTimeoutError, Sender, TryRecvError};
|
||||
use std::sync::Mutex;
|
||||
use std::thread;
|
||||
@@ -141,32 +144,31 @@ fn handle_timeout_event(timeout_event: ClockEventData, events: &mut Vec<types::E
|
||||
}
|
||||
|
||||
fn handle_rw_event(event: FdEventData, out_events: &mut Vec<types::Event>) {
|
||||
let handle = event
|
||||
.handle
|
||||
.as_any()
|
||||
.downcast_ref::<OsHandle>()
|
||||
.expect("can poll FdEvent for OS resources only");
|
||||
let size = match handle {
|
||||
OsHandle::OsFile(file) => {
|
||||
if event.r#type == types::Eventtype::FdRead {
|
||||
file.as_file()
|
||||
.metadata()
|
||||
.map(|m| m.len())
|
||||
.map_err(Into::into)
|
||||
} 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
|
||||
// to do the same on Windows for now.
|
||||
// cf. https://github.com/WebAssembly/WASI/issues/148
|
||||
Ok(0)
|
||||
}
|
||||
}
|
||||
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.
|
||||
OsHandle::Stdin => Ok(1),
|
||||
Ok(1)
|
||||
} else if let Some(_) = handle.as_any().downcast_ref::<Stdout>() {
|
||||
// On Unix, ioctl(FIONREAD) will return 0 for stdout. Emulate the same behavior on Windows.
|
||||
Ok(0)
|
||||
} else if let Some(_) = handle.as_any().downcast_ref::<Stderr>() {
|
||||
// On Unix, ioctl(FIONREAD) will return 0 for stdout/stderr. Emulate the same behavior on Windows.
|
||||
OsHandle::Stdout | OsHandle::Stderr => Ok(0),
|
||||
Ok(0)
|
||||
} else {
|
||||
if event.r#type == types::Eventtype::FdRead {
|
||||
handle
|
||||
.as_file()
|
||||
.and_then(|f| f.metadata())
|
||||
.map(|m| m.len())
|
||||
.map_err(Into::into)
|
||||
} 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
|
||||
// to do the same on Windows for now.
|
||||
// cf. https://github.com/WebAssembly/WASI/issues/148
|
||||
Ok(0)
|
||||
}
|
||||
};
|
||||
|
||||
let new_event = make_rw_event(&event, size);
|
||||
out_events.push(new_event);
|
||||
}
|
||||
@@ -206,33 +208,42 @@ pub(crate) fn oneoff(
|
||||
let mut pipe_events = vec![];
|
||||
|
||||
for event in fd_events {
|
||||
let handle = event
|
||||
.handle
|
||||
.as_any()
|
||||
.downcast_ref::<OsHandle>()
|
||||
.expect("can poll FdEvent for OS resources only");
|
||||
match handle {
|
||||
OsHandle::Stdin if event.r#type == types::Eventtype::FdRead => stdin_events.push(event),
|
||||
// stdout/stderr are always considered ready to write because there seems to
|
||||
let handle = &event.handle;
|
||||
if let Some(_) = handle.as_any().downcast_ref::<OsFile>() {
|
||||
immediate_events.push(event);
|
||||
} else if let Some(_) = handle.as_any().downcast_ref::<OsDir>() {
|
||||
immediate_events.push(event);
|
||||
} else if let Some(_) = handle.as_any().downcast_ref::<Stdin>() {
|
||||
stdin_events.push(event);
|
||||
} else if let Some(_) = handle.as_any().downcast_ref::<Stdout>() {
|
||||
// stdout are always considered ready to write because there seems to
|
||||
// be no way of checking if a write to stdout would block.
|
||||
//
|
||||
// If stdin is polled for anything else then reading, then it is also
|
||||
// considered immediately ready, following the behavior on Linux.
|
||||
OsHandle::Stdin | OsHandle::Stderr | OsHandle::Stdout => immediate_events.push(event),
|
||||
OsHandle::OsFile(file) => {
|
||||
let ftype = unsafe { winx::file::get_file_type(file.as_raw_handle()) }?;
|
||||
if ftype.is_unknown() || ftype.is_char() {
|
||||
debug!("poll_oneoff: unsupported file type: {:?}", ftype);
|
||||
handle_error_event(event, Errno::Notsup, events);
|
||||
} else if ftype.is_disk() {
|
||||
immediate_events.push(event);
|
||||
} else if ftype.is_pipe() {
|
||||
pipe_events.push(event);
|
||||
} else {
|
||||
unreachable!();
|
||||
}
|
||||
immediate_events.push(event);
|
||||
} else if let Some(_) = handle.as_any().downcast_ref::<Stderr>() {
|
||||
// stderr are always considered ready to write because there seems to
|
||||
// be no way of checking if a write to stdout would block.
|
||||
//
|
||||
// If stdin is polled for anything else then reading, then it is also
|
||||
// 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 {
|
||||
// We map pipe to SocketStream
|
||||
pipe_events.push(event);
|
||||
} else {
|
||||
debug!(
|
||||
"poll_oneoff: unsupported file type: {}",
|
||||
other.get_file_type()
|
||||
);
|
||||
handle_error_event(event, Errno::Notsup, events);
|
||||
}
|
||||
};
|
||||
} else {
|
||||
log::error!("can poll FdEvent for OS resources only");
|
||||
return Err(Errno::Badf);
|
||||
}
|
||||
}
|
||||
|
||||
let immediate = !immediate_events.is_empty();
|
||||
|
||||
Reference in New Issue
Block a user