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

Refactor use of Refs and RefMuts in wasi-common (#1412)

Browse Source 
* Refactor use of Refs and RefMuts in wasi-common

This commit refactors the use of `Ref`s and `RefMut`s in `wasi-common`.
Now, `Entry` is stored behind an `Rc` inside the `EntryTable`. The `Entry`
itself on the other hand now stores rights behind a `RefCell` and the
descriptor as `Rc<RefCell<..>>` combo to enable easy reference tracking
and interior mutability which is required down the line in a couple of
syscalls. In essence, this implies that we no longer have need for
mutable accessor to `Entry` from `WasiCtx`, and so all related methods
go away (`get_entry_mut`, etc.).

While here, I've also simplified handling and aggregating of rights on
the `Entry` object. Instead of storing base and inheriting rights as
separate fields, they are now aggregated into one struct `EntryRights`
which features convenient constructors for each possible combination; i.e.,
when only base rights are set, or both base and inheriting are set, or
both are left as empty. Since we do need to be able to mutate those
rights down the line in `fdstat_set_rights` syscall, this object
is kept behind a `RefCell` (note no `Rc` since we don't need to pass it
around anywhere).

The descriptor field in `Entry` is now kept behind `Rc<RefCell<..>>` combo
since we not only need to mutate it down the line, but we also need to
be able to pass it around (as part of the machinery making `poll_oneoff`
work).

I've also removed `as_file` and `try_clone` methods on `Descriptor` struct
since they were adding more noise than necessary, and making them work
with `Rc` was unnecessarily complicated.

Finally, I've converted the `get_dir_from_os_handle` function into a
method attached to the `OsHandle` itself, called `dir_stream`. IMHO,
it makes more sense to have it there directly as a method than as a separate
function.

* Use Cell for types that are Copy
This commit is contained in:
Jakub Konka
2020-03-27 09:34:52 +01:00
committed by GitHub
parent 092538cc54
commit 5c51940100
20 changed files with 446 additions and 550 deletions
Download Patch File Download Diff File Expand all files Collapse all files

340
crates/wasi-common/src/snapshots/wasi_snapshot_preview1.rs
View File

@@ -1,11 +1,10 @@
use crate::entry::{Descriptor, Entry};
use crate::entry::{Descriptor, Entry, EntryRights};
use crate::sandboxed_tty_writer::SandboxedTTYWriter;
use crate::wasi::wasi_snapshot_preview1::WasiSnapshotPreview1;
use crate::wasi::{types, AsBytes, Errno, Result};
use crate::WasiCtx;
use crate::{clock, fd, path, poll};
use log::{debug, error, trace};
use std::cell::Ref;
use std::convert::TryInto;
use std::fs::File;
use std::io::{self, Read, Seek, SeekFrom, Write};
@@ -124,19 +123,15 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
len,
advice
);
let required_rights = EntryRights::from_base(types::Rights::FD_ADVISE);
let entry = self.get_entry(fd)?;
let file = entry
.as_descriptor(types::Rights::FD_ADVISE, types::Rights::empty())?
.as_file()?;
match file {
Descriptor::OsHandle(fd) => fd::advise(&fd, advice, offset, len),
Descriptor::VirtualFile(virt) => virt.advise(advice, offset, len),
_ => {
unreachable!(
"implementation error: fd should have been checked to not be a stream already"
);
}
}
let desc = entry.as_descriptor(&required_rights)?;
match &*desc.borrow() {
Descriptor::OsHandle(fd) => fd::advise(&fd, advice, offset, len)?,
Descriptor::VirtualFile(virt) => virt.advise(advice, offset, len)?,
_ => return Err(Errno::Badf),
};
Ok(())
}
fn fd_allocate(
@@ -147,11 +142,10 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
) -> Result<()> {
trace!("fd_allocate(fd={:?}, offset={}, len={})", fd, offset, len);
let required_rights = EntryRights::from_base(types::Rights::FD_ALLOCATE);
let entry = self.get_entry(fd)?;
let file = entry
.as_descriptor(types::Rights::FD_ALLOCATE, types::Rights::empty())?
.as_file()?;
match file {
let desc = entry.as_descriptor(&required_rights)?;
match &*desc.borrow() {
Descriptor::OsHandle(fd) => {
let metadata = fd.metadata()?;
let current_size = metadata.len();
@@ -163,15 +157,11 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
if wanted_size > current_size {
fd.set_len(wanted_size)?;
}
Ok(())
}
Descriptor::VirtualFile(virt) => virt.allocate(offset, len),
_ => {
unreachable!(
"implementation error: fd should have been checked to not be a stream already"
);
}
}
Descriptor::VirtualFile(virt) => virt.allocate(offset, len)?,
_ => return Err(Errno::Badf),
};
Ok(())
}
fn fd_close(&self, fd: types::Fd) -> Result<()> {
@@ -191,9 +181,10 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
fn fd_datasync(&self, fd: types::Fd) -> Result<()> {
trace!("fd_datasync(fd={:?})", fd);
let required_rights = EntryRights::from_base(types::Rights::FD_DATASYNC);
let entry = self.get_entry(fd)?;
let file = entry.as_descriptor(types::Rights::FD_DATASYNC, types::Rights::empty())?;
match file {
let file = entry.as_descriptor(&required_rights)?;
match &*file.borrow() {
Descriptor::OsHandle(fd) => fd.sync_data()?,
Descriptor::VirtualFile(virt) => virt.datasync()?,
other => other.as_os_handle().sync_data()?,
@@ -205,16 +196,17 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
trace!("fd_fdstat_get(fd={:?})", fd);
let fe = self.get_entry(fd)?;
let wasi_file = fe.as_descriptor(types::Rights::empty(), types::Rights::empty())?;
let fs_flags = match wasi_file {
let wasi_file = fe.as_descriptor(&EntryRights::empty())?;
let fs_flags = match &*wasi_file.borrow() {
Descriptor::OsHandle(wasi_fd) => fd::fdstat_get(&wasi_fd)?,
Descriptor::VirtualFile(virt) => virt.fdstat_get(),
other => fd::fdstat_get(&other.as_os_handle())?,
};
let rights = fe.rights.get();
let fdstat = types::Fdstat {
fs_filetype: fe.file_type,
fs_rights_base: fe.rights_base,
fs_rights_inheriting: fe.rights_inheriting,
fs_rights_base: rights.base,
fs_rights_inheriting: rights.inheriting,
fs_flags,
};
@@ -226,27 +218,24 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
fn fd_fdstat_set_flags(&self, fd: types::Fd, flags: types::Fdflags) -> Result<()> {
trace!("fd_fdstat_set_flags(fd={:?}, fdflags={})", fd, flags);
let mut entry = self.get_entry_mut(fd)?;
let descriptor =
entry.as_descriptor_mut(types::Rights::FD_FDSTAT_SET_FLAGS, types::Rights::empty())?;
match descriptor {
let required_rights = EntryRights::from_base(types::Rights::FD_FDSTAT_SET_FLAGS);
let entry = self.get_entry(fd)?;
let desc = entry.as_descriptor(&required_rights)?;
let maybe_new_desc = match &*desc.borrow() {
Descriptor::OsHandle(handle) => {
let set_result = fd::fdstat_set_flags(&handle, flags)?.map(Descriptor::OsHandle);
if let Some(new_descriptor) = set_result {
*descriptor = new_descriptor;
}
fd::fdstat_set_flags(&handle, flags)?.map(Descriptor::OsHandle)
}
Descriptor::VirtualFile(handle) => {
handle.fdstat_set_flags(flags)?;
handle.fdstat_set_flags(flags)?.map(Descriptor::VirtualFile)
}
_ => {
let set_result = fd::fdstat_set_flags(&descriptor.as_os_handle(), flags)?
.map(Descriptor::OsHandle);
if let Some(new_descriptor) = set_result {
*descriptor = new_descriptor;
}
stream => {
fd::fdstat_set_flags(&stream.as_os_handle(), flags)?.map(Descriptor::OsHandle)
}
};
// TODO What happens on None?
if let Some(new_desc) = maybe_new_desc {
*desc.borrow_mut() = new_desc;
}
Ok(())
}
@@ -262,32 +251,25 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
fs_rights_base,
fs_rights_inheriting
);
let mut entry = self.get_entry_mut(fd)?;
if entry.rights_base & fs_rights_base != fs_rights_base
|| entry.rights_inheriting & fs_rights_inheriting != fs_rights_inheriting
{
let rights = EntryRights::new(fs_rights_base, fs_rights_inheriting);
let entry = self.get_entry(fd)?;
if !entry.rights.get().contains(&rights) {
return Err(Errno::Notcapable);
}
entry.rights_base = fs_rights_base;
entry.rights_inheriting = fs_rights_inheriting;
entry.rights.set(rights);
Ok(())
}
fn fd_filestat_get(&self, fd: types::Fd) -> Result<types::Filestat> {
trace!("fd_filestat_get(fd={:?})", fd);
let required_rights = EntryRights::from_base(types::Rights::FD_FILESTAT_GET);
let entry = self.get_entry(fd)?;
let fd = entry
.as_descriptor(types::Rights::FD_FILESTAT_GET, types::Rights::empty())?
.as_file()?;
let host_filestat = match fd {
let desc = entry.as_descriptor(&required_rights)?;
let host_filestat = match &*desc.borrow() {
Descriptor::OsHandle(fd) => fd::filestat_get(&fd)?,
Descriptor::VirtualFile(virt) => virt.filestat_get()?,
_ => {
unreachable!(
"implementation error: fd should have been checked to not be a stream already"
);
}
_ => return Err(Errno::Badf),
};
trace!(" | *filestat_ptr={:?}", host_filestat);
@@ -298,22 +280,17 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
fn fd_filestat_set_size(&self, fd: types::Fd, size: types::Filesize) -> Result<()> {
trace!("fd_filestat_set_size(fd={:?}, size={})", fd, size);
let required_rights = EntryRights::from_base(types::Rights::FD_FILESTAT_SET_SIZE);
let entry = self.get_entry(fd)?;
let file = entry
.as_descriptor(types::Rights::FD_FILESTAT_SET_SIZE, types::Rights::empty())?
.as_file()?;
let desc = entry.as_descriptor(&required_rights)?;
// This check will be unnecessary when rust-lang/rust#63326 is fixed
if size > i64::max_value() as u64 {
return Err(Errno::TooBig);
}
match file {
match &*desc.borrow() {
Descriptor::OsHandle(fd) => fd.set_len(size)?,
Descriptor::VirtualFile(virt) => virt.filestat_set_size(size)?,
_ => {
unreachable!(
"implementation error: fd should have been checked to not be a stream already"
);
}
_ => return Err(Errno::Badf),
};
Ok(())
}
@@ -332,11 +309,11 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
mtim,
fst_flags
);
let required_rights = EntryRights::from_base(types::Rights::FD_FILESTAT_SET_TIMES);
let entry = self.get_entry(fd)?;
let fd = entry
.as_descriptor(types::Rights::FD_FILESTAT_SET_TIMES, types::Rights::empty())?
.as_file()?;
fd::filestat_set_times_impl(&fd, atim, mtim, fst_flags)
let desc = entry.as_descriptor(&required_rights)?;
fd::filestat_set_times_impl(&desc.borrow(), atim, mtim, fst_flags)?;
Ok(())
}
fn fd_pread(
@@ -361,19 +338,16 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
buf.push(io::IoSliceMut::new(slice));
}
let required_rights =
EntryRights::from_base(types::Rights::FD_READ | types::Rights::FD_SEEK);
let entry = self.get_entry(fd)?;
let file = entry
.as_descriptor(
types::Rights::FD_READ | types::Rights::FD_SEEK,
types::Rights::empty(),
)?
.as_file()?;
let desc = entry.as_descriptor(&required_rights)?;
if offset > i64::max_value() as u64 {
return Err(Errno::Io);
}
let host_nread = match file {
let host_nread = match &*desc.borrow() {
Descriptor::OsHandle(fd) => {
let mut fd: &File = fd;
let cur_pos = fd.seek(SeekFrom::Current(0))?;
@@ -383,11 +357,7 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
nread
}
Descriptor::VirtualFile(virt) => virt.preadv(&mut buf, offset)?,
_ => {
unreachable!(
"implementation error: fd should have been checked to not be a stream already"
);
}
_ => return Err(Errno::Badf),
};
let host_nread = host_nread.try_into()?;
@@ -475,19 +445,16 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
buf.push(io::IoSlice::new(slice));
}
let required_rights =
EntryRights::from_base(types::Rights::FD_WRITE | types::Rights::FD_SEEK);
let entry = self.get_entry(fd)?;
let file = entry
.as_descriptor(
types::Rights::FD_WRITE | types::Rights::FD_SEEK,
types::Rights::empty(),
)?
.as_file()?;
let desc = entry.as_descriptor(&required_rights)?;
if offset > i64::max_value() as u64 {
return Err(Errno::Io);
}
let host_nwritten = match file {
let host_nwritten = match &*desc.borrow() {
Descriptor::OsHandle(fd) => {
let mut fd: &File = fd;
let cur_pos = fd.seek(SeekFrom::Current(0))?;
@@ -497,11 +464,7 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
nwritten
}
Descriptor::VirtualFile(virt) => virt.pwritev(&buf, offset)?,
_ => {
unreachable!(
"implementation error: fd should have been checked to not be a stream already"
);
}
_ => return Err(Errno::Badf),
};
trace!(" | *nwritten={:?}", host_nwritten);
let host_nwritten = host_nwritten.try_into()?;
@@ -526,14 +489,14 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
slices.push(io::IoSliceMut::new(slice));
}
let required_rights = EntryRights::from_base(types::Rights::FD_READ);
let entry = self.get_entry(fd)?;
let host_nread =
match entry.as_descriptor(types::Rights::FD_READ, types::Rights::empty())? {
Descriptor::OsHandle(file) => (file as &File).read_vectored(&mut slices)?,
Descriptor::VirtualFile(virt) => virt.read_vectored(&mut slices)?,
Descriptor::Stdin => io::stdin().read_vectored(&mut slices)?,
_ => return Err(Errno::Badf),
};
let host_nread = match &*entry.as_descriptor(&required_rights)?.borrow() {
Descriptor::OsHandle(file) => (file as &File).read_vectored(&mut slices)?,
Descriptor::VirtualFile(virt) => virt.read_vectored(&mut slices)?,
Descriptor::Stdin => io::stdin().read_vectored(&mut slices)?,
_ => return Err(Errno::Badf),
};
let host_nread = host_nread.try_into()?;
trace!(" | *nread={:?}", host_nread);
@@ -556,10 +519,9 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
cookie,
);
let required_rights = EntryRights::from_base(types::Rights::FD_READDIR);
let entry = self.get_entry(fd)?;
let file = entry
.as_descriptor(types::Rights::FD_READDIR, types::Rights::empty())?
.as_file()?;
let desc = entry.as_descriptor(&required_rights)?;
fn copy_entities<T: Iterator<Item = Result<(types::Dirent, String)>>>(
iter: T,
@@ -587,14 +549,10 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
}
Ok(bufused)
}
let bufused = match file {
let bufused = match &*desc.borrow() {
Descriptor::OsHandle(file) => copy_entities(fd::readdir(file, cookie)?, buf, buf_len)?,
Descriptor::VirtualFile(virt) => copy_entities(virt.readdir(cookie)?, buf, buf_len)?,
_ => {
unreachable!(
"implementation error: fd should have been checked to not be a stream already"
);
}
_ => return Err(Errno::Badf),
};
trace!(" | *buf_used={:?}", bufused);
@@ -640,28 +598,23 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
whence,
);
let rights = if offset == 0 && whence == types::Whence::Cur {
let base = if offset == 0 && whence == types::Whence::Cur {
types::Rights::FD_TELL
} else {
types::Rights::FD_SEEK | types::Rights::FD_TELL
};
let required_rights = EntryRights::from_base(base);
let entry = self.get_entry(fd)?;
let file = entry
.as_descriptor(rights, types::Rights::empty())?
.as_file()?;
let desc = entry.as_descriptor(&required_rights)?;
let pos = match whence {
types::Whence::Cur => SeekFrom::Current(offset),
types::Whence::End => SeekFrom::End(offset),
types::Whence::Set => SeekFrom::Start(offset as u64),
};
let host_newoffset = match file {
let host_newoffset = match &*desc.borrow() {
Descriptor::OsHandle(fd) => (fd as &File).seek(pos)?,
Descriptor::VirtualFile(virt) => virt.seek(pos)?,
_ => {
unreachable!(
"implementation error: fd should have been checked to not be a stream already"
);
}
_ => return Err(Errno::Badf),
};
trace!(" | *newoffset={:?}", host_newoffset);
@@ -672,18 +625,13 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
fn fd_sync(&self, fd: types::Fd) -> Result<()> {
trace!("fd_sync(fd={:?})", fd);
let required_rights = EntryRights::from_base(types::Rights::FD_SYNC);
let entry = self.get_entry(fd)?;
let file = entry
.as_descriptor(types::Rights::FD_SYNC, types::Rights::empty())?
.as_file()?;
match file {
let desc = entry.as_descriptor(&required_rights)?;
match &*desc.borrow() {
Descriptor::OsHandle(fd) => fd.sync_all()?,
Descriptor::VirtualFile(virt) => virt.sync()?,
_ => {
unreachable!(
"implementation error: fd should have been checked to not be a stream already"
);
}
_ => return Err(Errno::Badf),
};
Ok(())
}
@@ -691,18 +639,13 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
fn fd_tell(&self, fd: types::Fd) -> Result<types::Filesize> {
trace!("fd_tell(fd={:?})", fd);
let required_rights = EntryRights::from_base(types::Rights::FD_TELL);
let entry = self.get_entry(fd)?;
let file = entry
.as_descriptor(types::Rights::FD_TELL, types::Rights::empty())?
.as_file()?;
let host_offset = match file {
let desc = entry.as_descriptor(&required_rights)?;
let host_offset = match &*desc.borrow() {
Descriptor::OsHandle(fd) => (fd as &File).seek(SeekFrom::Current(0))?,
Descriptor::VirtualFile(virt) => virt.seek(SeekFrom::Current(0))?,
_ => {
unreachable!(
"implementation error: fd should have been checked to not be a stream already"
);
}
_ => return Err(Errno::Badf),
};
trace!(" | *newoffset={:?}", host_offset);
@@ -728,10 +671,11 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
}
// perform unbuffered writes
let required_rights = EntryRights::from_base(types::Rights::FD_WRITE);
let entry = self.get_entry(fd)?;
let isatty = entry.isatty();
let desc = entry.as_descriptor(types::Rights::FD_WRITE, types::Rights::empty())?;
let host_nwritten = match desc {
let desc = entry.as_descriptor(&required_rights)?;
let host_nwritten = match &*desc.borrow() {
Descriptor::OsHandle(file) => {
if isatty {
SandboxedTTYWriter::new(&mut (file as &File)).write_vectored(&slices)?
@@ -774,12 +718,12 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
fn path_create_directory(&self, dirfd: types::Fd, path: &GuestPtr<'_, str>) -> Result<()> {
trace!("path_create_directory(dirfd={:?}, path={:?})", dirfd, path);
let rights = types::Rights::PATH_OPEN | types::Rights::PATH_CREATE_DIRECTORY;
let required_rights =
EntryRights::from_base(types::Rights::PATH_OPEN | types::Rights::PATH_CREATE_DIRECTORY);
let entry = self.get_entry(dirfd)?;
let resolved = path::get(
&entry,
rights,
types::Rights::empty(),
&required_rights,
types::Lookupflags::empty(),
path,
false,
@@ -800,15 +744,9 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
path,
);
let required_rights = EntryRights::from_base(types::Rights::PATH_FILESTAT_GET);
let entry = self.get_entry(dirfd)?;
let resolved = path::get(
&entry,
types::Rights::PATH_FILESTAT_GET,
types::Rights::empty(),
flags,
path,
false,
)?;
let resolved = path::get(&entry, &required_rights, flags, path, false)?;
let host_filestat = match resolved.dirfd() {
Descriptor::VirtualFile(virt) => virt
.openat(
@@ -846,15 +784,9 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
fst_flags,
);
let required_rights = EntryRights::from_base(types::Rights::PATH_FILESTAT_SET_TIMES);
let entry = self.get_entry(dirfd)?;
let resolved = path::get(
&entry,
types::Rights::PATH_FILESTAT_SET_TIMES,
types::Rights::empty(),
flags,
path,
false,
)?;
let resolved = path::get(&entry, &required_rights, flags, path, false)?;
match resolved.dirfd() {
Descriptor::VirtualFile(_virt) => {
unimplemented!("virtual filestat_set_times");
@@ -880,20 +812,20 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
new_path,
);
let required_rights = EntryRights::from_base(types::Rights::PATH_LINK_SOURCE);
let old_entry = self.get_entry(old_fd)?;
let resolved_old = path::get(
&old_entry,
types::Rights::PATH_LINK_SOURCE,
types::Rights::empty(),
&required_rights,
types::Lookupflags::empty(),
old_path,
false,
)?;
let required_rights = EntryRights::from_base(types::Rights::PATH_LINK_TARGET);
let new_entry = self.get_entry(new_fd)?;
let resolved_new = path::get(
&new_entry,
types::Rights::PATH_LINK_TARGET,
types::Rights::empty(),
&required_rights,
types::Lookupflags::empty(),
new_path,
false,
@@ -926,21 +858,19 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
fdflags,
);
let (needed_base, needed_inheriting) =
path::open_rights(fs_rights_base, fs_rights_inheriting, oflags, fdflags);
trace!(
" | needed_base = {}, needed_inheriting = {}",
needed_base,
needed_inheriting
let needed_rights = path::open_rights(
&EntryRights::new(fs_rights_base, fs_rights_inheriting),
oflags,
fdflags,
);
trace!(" | needed rights = {}", needed_rights);
let resolved = {
let entry = self.get_entry(dirfd)?;
path::get(
&entry,
needed_base,
needed_inheriting,
&needed_rights,
dirflags,
path,
oflags & types::Oflags::CREAT != types::Oflags::empty(),
@@ -964,11 +894,13 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
);
let fd = resolved.open_with(read, write, oflags, fdflags)?;
let mut fe = Entry::from(fd)?;
let fe = Entry::from(fd)?;
// We need to manually deny the rights which are not explicitly requested
// because Entry::from will assign maximal consistent rights.
fe.rights_base &= fs_rights_base;
fe.rights_inheriting &= fs_rights_inheriting;
let mut rights = fe.rights.get();
rights.base &= fs_rights_base;
rights.inheriting &= fs_rights_inheriting;
fe.rights.set(rights);
let guest_fd = self.insert_entry(fe)?;
trace!(" | *fd={:?}", guest_fd);
@@ -991,11 +923,11 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
buf_len,
);
let required_rights = EntryRights::from_base(types::Rights::PATH_READLINK);
let entry = self.get_entry(dirfd)?;
let resolved = path::get(
&entry,
types::Rights::PATH_READLINK,
types::Rights::empty(),
&required_rights,
types::Lookupflags::empty(),
path,
false,
@@ -1024,11 +956,11 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
fn path_remove_directory(&self, dirfd: types::Fd, path: &GuestPtr<'_, str>) -> Result<()> {
trace!("path_remove_directory(dirfd={:?}, path={:?})", dirfd, path);
let required_rights = EntryRights::from_base(types::Rights::PATH_REMOVE_DIRECTORY);
let entry = self.get_entry(dirfd)?;
let resolved = path::get(
&entry,
types::Rights::PATH_REMOVE_DIRECTORY,
types::Rights::empty(),
&required_rights,
types::Lookupflags::empty(),
path,
true,
@@ -1057,20 +989,20 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
new_path,
);
let required_rights = EntryRights::from_base(types::Rights::PATH_RENAME_SOURCE);
let entry = self.get_entry(old_fd)?;
let resolved_old = path::get(
&entry,
types::Rights::PATH_RENAME_SOURCE,
types::Rights::empty(),
&required_rights,
types::Lookupflags::empty(),
old_path,
true,
)?;
let required_rights = EntryRights::from_base(types::Rights::PATH_RENAME_TARGET);
let entry = self.get_entry(new_fd)?;
let resolved_new = path::get(
&entry,
types::Rights::PATH_RENAME_TARGET,
types::Rights::empty(),
&required_rights,
types::Lookupflags::empty(),
new_path,
true,
@@ -1103,11 +1035,11 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
new_path,
);
let required_rights = EntryRights::from_base(types::Rights::PATH_SYMLINK);
let entry = self.get_entry(dirfd)?;
let resolved_new = path::get(
&entry,
types::Rights::PATH_SYMLINK,
types::Rights::empty(),
&required_rights,
types::Lookupflags::empty(),
new_path,
true,
@@ -1132,11 +1064,11 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
fn path_unlink_file(&self, dirfd: types::Fd, path: &GuestPtr<'_, str>) -> Result<()> {
trace!("path_unlink_file(dirfd={:?}, path={:?})", dirfd, path);
let required_rights = EntryRights::from_base(types::Rights::PATH_UNLINK_FILE);
let entry = self.get_entry(dirfd)?;
let resolved = path::get(
&entry,
types::Rights::PATH_UNLINK_FILE,
types::Rights::empty(),
&required_rights,
types::Lookupflags::empty(),
path,
false,
@@ -1201,7 +1133,9 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
}
types::SubscriptionU::FdRead(fd_read) => {
let fd = fd_read.file_descriptor;
let rights = types::Rights::FD_READ | types::Rights::POLL_FD_READWRITE;
let required_rights = EntryRights::from_base(
types::Rights::FD_READ | types::Rights::POLL_FD_READWRITE,
);
let entry = match self.get_entry(fd) {
Ok(entry) => entry,
Err(error) => {
@@ -1217,21 +1151,17 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
continue;
}
};
// TODO Can this be simplified?
// Validate rights on the entry before converting into host descriptor.
entry.validate_rights(rights, types::Rights::empty())?;
let descriptor = Ref::map(entry, |entry| {
entry.as_descriptor(rights, types::Rights::empty()).unwrap()
});
fd_events.push(poll::FdEventData {
descriptor,
descriptor: entry.as_descriptor(&required_rights)?,
r#type: types::Eventtype::FdRead,
userdata: subscription.userdata,
});
}
types::SubscriptionU::FdWrite(fd_write) => {
let fd = fd_write.file_descriptor;
let rights = types::Rights::FD_WRITE | types::Rights::POLL_FD_READWRITE;
let required_rights = EntryRights::from_base(
types::Rights::FD_WRITE | types::Rights::POLL_FD_READWRITE,
);
let entry = match self.get_entry(fd) {
Ok(entry) => entry,
Err(error) => {
@@ -1247,14 +1177,8 @@ impl<'a> WasiSnapshotPreview1 for WasiCtx {
continue;
}
};
// TODO Can this be simplified?
// Validate rights on the entry before converting into host descriptor.
entry.validate_rights(rights, types::Rights::empty())?;
let descriptor = Ref::map(entry, |entry| {
entry.as_descriptor(rights, types::Rights::empty()).unwrap()
});
fd_events.push(poll::FdEventData {
descriptor,
descriptor: entry.as_descriptor(&required_rights)?,
r#type: types::Eventtype::FdWrite,
userdata: subscription.userdata,
});