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

inline only what we need of cap-std/system-interface traits

Browse Source
This commit is contained in:
Pat Hickey
2021-01-20 20:53:44 -08:00
parent f3e40e2fc4
commit 7ec03631da
7 changed files with 354 additions and 337 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
crates/wasi-c2/src/file.rs
View File

@@ -1,13 +1,11 @@
use crate::Error;
use bitflags::bitflags;
use fs_set_times::SetTimes;
use fs_set_times::SystemTimeSpec;
use std::any::Any;
use std::cell::Ref;
use std::ops::Deref;
use system_interface::fs::FileIoExt;
use system_interface::io::ReadReady;
pub trait WasiFile: FileIoExt + SetTimes + ReadReady {
pub trait WasiFile {
fn as_any(&self) -> &dyn Any;
fn datasync(&self) -> Result<(), Error>;
fn sync(&self) -> Result<(), Error>;
@@ -16,6 +14,27 @@ pub trait WasiFile: FileIoExt + SetTimes + ReadReady {
fn set_fdflags(&self, _flags: FdFlags) -> Result<(), Error>;
fn get_filestat(&self) -> Result<Filestat, Error>;
fn set_filestat_size(&self, _size: u64) -> Result<(), Error>;
fn advise(
&self,
offset: u64,
len: u64,
advice: system_interface::fs::Advice,
) -> Result<(), Error>;
fn allocate(&self, offset: u64, len: u64) -> Result<(), Error>;
fn set_times(
&self,
atime: Option<SystemTimeSpec>,
mtime: Option<SystemTimeSpec>,
) -> Result<(), Error>;
fn read_vectored(&self, bufs: &mut [std::io::IoSliceMut]) -> Result<u64, Error>;
fn read_vectored_at(&self, bufs: &mut [std::io::IoSliceMut], offset: u64)
-> Result<u64, Error>;
fn write_vectored(&self, bufs: &[std::io::IoSlice]) -> Result<u64, Error>;
fn write_vectored_at(&self, bufs: &[std::io::IoSlice], offset: u64) -> Result<u64, Error>;
fn seek(&self, pos: std::io::SeekFrom) -> Result<u64, Error>;
fn stream_position(&self) -> Result<u64, Error>;
fn peek(&self, buf: &mut [u8]) -> Result<u64, Error>;
fn num_ready_bytes(&self) -> Result<u64, Error>;
}
#[derive(Debug, Copy, Clone)]
@@ -30,31 +49,6 @@ pub enum FileType {
Unknown,
}
impl From<&cap_std::fs::FileType> for FileType {
fn from(ft: &cap_std::fs::FileType) -> FileType {
use cap_fs_ext::FileTypeExt;
if ft.is_dir() {
FileType::Directory
} else if ft.is_symlink() {
FileType::SymbolicLink
} else if ft.is_socket() {
if ft.is_block_device() {
FileType::SocketDgram
} else {
FileType::SocketStream
}
} else if ft.is_block_device() {
FileType::BlockDevice
} else if ft.is_char_device() {
FileType::CharacterDevice
} else if ft.is_file() {
FileType::RegularFile
} else {
FileType::Unknown
}
}
}
bitflags! {
pub struct FdFlags: u32 {
const APPEND = 0b1;

232
crates/wasi-c2/src/pipe.rs
View File

@@ -12,10 +12,10 @@
use crate::file::{FdFlags, FileType, Filestat, WasiFile};
use crate::Error;
use std::any::Any;
use std::convert::TryInto;
use std::io::{self, Read, Write};
use std::sync::{Arc, RwLock};
use system_interface::fs::{Advice, FileIoExt};
use system_interface::io::ReadReady;
use system_interface::fs::Advice;
/// A virtual pipe read end.
///
@@ -96,82 +96,6 @@ impl From<&str> for ReadPipe<io::Cursor<String>> {
}
}
impl<R: Read> FileIoExt for ReadPipe<R> {
fn advise(&self, offset: u64, len: u64, advice: Advice) -> io::Result<()> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn allocate(&self, offset: u64, len: u64) -> io::Result<()> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
self.borrow().read(buf)
}
fn read_exact(&self, buf: &mut [u8]) -> io::Result<()> {
self.borrow().read_exact(buf)
}
fn read_at(&self, buf: &mut [u8], offset: u64) -> io::Result<usize> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn read_exact_at(&self, buf: &mut [u8], offset: u64) -> io::Result<()> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn read_vectored(&self, bufs: &mut [io::IoSliceMut]) -> io::Result<usize> {
self.borrow().read_vectored(bufs)
}
fn read_to_end(&self, buf: &mut Vec<u8>) -> io::Result<usize> {
self.borrow().read_to_end(buf)
}
fn read_to_string(&self, buf: &mut String) -> io::Result<usize> {
self.borrow().read_to_string(buf)
}
fn write(&self, buf: &[u8]) -> io::Result<usize> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn write_all(&self, buf: &[u8]) -> io::Result<()> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn write_at(&self, buf: &[u8], offset: u64) -> io::Result<usize> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn write_all_at(&self, buf: &[u8], offset: u64) -> io::Result<()> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn write_vectored(&self, bufs: &[io::IoSlice]) -> io::Result<usize> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn write_fmt(&self, fmt: std::fmt::Arguments) -> io::Result<()> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn flush(&self) -> io::Result<()> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn seek(&self, _pos: std::io::SeekFrom) -> io::Result<u64> {
Err(std::io::Error::from_raw_os_error(libc::ESPIPE))
}
fn stream_position(&self) -> io::Result<u64> {
Err(std::io::Error::from_raw_os_error(libc::ESPIPE))
}
fn peek(&self, _buf: &mut [u8]) -> io::Result<usize> {
Err(std::io::Error::from_raw_os_error(libc::EBADF)) // XXX is this right? or do we have to implement this faithfully, and add a buffer of peeked values to handle during reads?
}
}
impl<R: Read> fs_set_times::SetTimes for ReadPipe<R> {
fn set_times(
&self,
_: Option<fs_set_times::SystemTimeSpec>,
_: Option<fs_set_times::SystemTimeSpec>,
) -> io::Result<()> {
todo!()
}
}
impl<R: Read + Any> ReadReady for ReadPipe<R> {
fn num_ready_bytes(&self) -> Result<u64, std::io::Error> {
todo!()
}
}
impl<R: Read + Any> WasiFile for ReadPipe<R> {
fn as_any(&self) -> &dyn Any {
self
@@ -206,6 +130,44 @@ impl<R: Read + Any> WasiFile for ReadPipe<R> {
fn set_filestat_size(&self, _size: u64) -> Result<(), Error> {
Err(Error::Perm)
}
fn advise(&self, offset: u64, len: u64, advice: Advice) -> Result<(), Error> {
Err(Error::Badf)
}
fn allocate(&self, offset: u64, len: u64) -> Result<(), Error> {
Err(Error::Badf)
}
fn read_vectored(&self, bufs: &mut [io::IoSliceMut]) -> Result<u64, Error> {
let n = self.borrow().read_vectored(bufs)?;
Ok(n.try_into().map_err(|_| Error::Overflow)?)
}
fn read_vectored_at(&self, bufs: &mut [io::IoSliceMut], offset: u64) -> Result<u64, Error> {
Err(Error::Badf)
}
fn write_vectored(&self, bufs: &[io::IoSlice]) -> Result<u64, Error> {
Err(Error::Badf)
}
fn write_vectored_at(&self, bufs: &[io::IoSlice], offset: u64) -> Result<u64, Error> {
Err(Error::Badf)
}
fn seek(&self, pos: std::io::SeekFrom) -> Result<u64, Error> {
Err(Error::Badf)
}
fn stream_position(&self) -> Result<u64, Error> {
Err(Error::Badf)
}
fn peek(&self, buf: &mut [u8]) -> Result<u64, Error> {
Err(Error::Badf)
}
fn set_times(
&self,
atime: Option<fs_set_times::SystemTimeSpec>,
mtime: Option<fs_set_times::SystemTimeSpec>,
) -> Result<(), Error> {
Err(Error::Badf)
}
fn num_ready_bytes(&self) -> Result<u64, Error> {
Ok(0)
}
}
/// A virtual pipe write end.
@@ -273,82 +235,6 @@ impl WritePipe<io::Cursor<Vec<u8>>> {
}
}
impl<W: Write> FileIoExt for WritePipe<W> {
fn advise(&self, offset: u64, len: u64, advice: Advice) -> io::Result<()> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn allocate(&self, offset: u64, len: u64) -> io::Result<()> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn read_exact(&self, buf: &mut [u8]) -> io::Result<()> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn read_at(&self, buf: &mut [u8], offset: u64) -> io::Result<usize> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn read_exact_at(&self, buf: &mut [u8], offset: u64) -> io::Result<()> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn read_vectored(&self, bufs: &mut [io::IoSliceMut]) -> io::Result<usize> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn read_to_end(&self, buf: &mut Vec<u8>) -> io::Result<usize> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn read_to_string(&self, buf: &mut String) -> io::Result<usize> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn write(&self, buf: &[u8]) -> io::Result<usize> {
self.borrow().write(buf)
}
fn write_all(&self, buf: &[u8]) -> io::Result<()> {
self.borrow().write_all(buf)
}
fn write_at(&self, buf: &[u8], offset: u64) -> io::Result<usize> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn write_all_at(&self, buf: &[u8], offset: u64) -> io::Result<()> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
fn write_vectored(&self, bufs: &[io::IoSlice]) -> io::Result<usize> {
self.borrow().write_vectored(bufs)
}
fn write_fmt(&self, fmt: std::fmt::Arguments) -> io::Result<()> {
self.borrow().write_fmt(fmt)
}
fn flush(&self) -> io::Result<()> {
self.borrow().flush()
}
fn seek(&self, pos: std::io::SeekFrom) -> io::Result<u64> {
Err(std::io::Error::from_raw_os_error(libc::ESPIPE))
}
fn stream_position(&self) -> io::Result<u64> {
Err(std::io::Error::from_raw_os_error(libc::ESPIPE))
}
fn peek(&self, _buf: &mut [u8]) -> io::Result<usize> {
Err(std::io::Error::from_raw_os_error(libc::EBADF))
}
}
impl<W: Write> fs_set_times::SetTimes for WritePipe<W> {
fn set_times(
&self,
_: Option<fs_set_times::SystemTimeSpec>,
_: Option<fs_set_times::SystemTimeSpec>,
) -> io::Result<()> {
todo!() //
}
}
impl<W: Write + Any> ReadReady for WritePipe<W> {
fn num_ready_bytes(&self) -> Result<u64, std::io::Error> {
Ok(0)
}
}
impl<W: Write + Any> WasiFile for WritePipe<W> {
fn as_any(&self) -> &dyn Any {
self
@@ -383,4 +269,42 @@ impl<W: Write + Any> WasiFile for WritePipe<W> {
fn set_filestat_size(&self, _size: u64) -> Result<(), Error> {
Err(Error::Perm)
}
fn advise(&self, offset: u64, len: u64, advice: Advice) -> Result<(), Error> {
Err(Error::Badf)
}
fn allocate(&self, offset: u64, len: u64) -> Result<(), Error> {
Err(Error::Badf)
}
fn read_vectored(&self, bufs: &mut [io::IoSliceMut]) -> Result<u64, Error> {
Err(Error::Badf)
}
fn read_vectored_at(&self, bufs: &mut [io::IoSliceMut], offset: u64) -> Result<u64, Error> {
Err(Error::Badf)
}
fn write_vectored(&self, bufs: &[io::IoSlice]) -> Result<u64, Error> {
let n = self.borrow().write_vectored(bufs)?;
Ok(n.try_into().map_err(|_| Error::Overflow)?)
}
fn write_vectored_at(&self, bufs: &[io::IoSlice], offset: u64) -> Result<u64, Error> {
Err(Error::Badf)
}
fn seek(&self, pos: std::io::SeekFrom) -> Result<u64, Error> {
Err(Error::Badf)
}
fn stream_position(&self) -> Result<u64, Error> {
Err(Error::Badf)
}
fn peek(&self, buf: &mut [u8]) -> Result<u64, Error> {
Err(Error::Badf)
}
fn set_times(
&self,
atime: Option<fs_set_times::SystemTimeSpec>,
mtime: Option<fs_set_times::SystemTimeSpec>,
) -> Result<(), Error> {
Err(Error::Badf)
}
fn num_ready_bytes(&self) -> Result<u64, Error> {
Ok(0)
}
}

6
crates/wasi-c2/src/snapshots/preview_1.rs
View File

@@ -369,8 +369,7 @@ impl<'a> wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
.get_file(fd)
.expect("checked that entry is file")
.get_cap(FileCaps::FILESTAT_SET_TIMES)?
.set_times(atim, mtim)?;
Ok(())
.set_times(atim, mtim)
} else if table.is::<DirEntry>(fd) {
use cap_std::time::{Duration, SystemClock};
@@ -398,8 +397,7 @@ impl<'a> wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
.get_dir(fd)
.expect("checked that entry is dir")
.get_cap(DirCaps::FILESTAT_SET_TIMES)?
.set_times(".", atim, mtim)?;
Ok(())
.set_times(".", atim, mtim)
} else {
Err(Error::Badf)
}