Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

Remove `system-interface` from `wasmtime-wasi` (#13109)

Alex Crichton362f85764e46
diff --git a/Cargo.lock b/Cargo.lock
index c126b11ae8..020d8930e2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5268,6 +5268,7 @@ dependencies = [
"cap-net-ext",
"cap-std",
"cap-time-ext",
+ "cfg-if",
"env_logger 0.11.5",
"fs-set-times",
"futures",
@@ -5275,7 +5276,6 @@ dependencies = [
"io-lifetimes",
"rand 0.10.1",
"rustix 1.1.4",
- "system-interface",
"tempfile",
"test-log",
"test-programs-artifacts",
diff --git a/crates/test-programs/src/bin/p1_file_write.rs b/crates/test-programs/src/bin/p1_file_write.rs
index 27a8163856..c795fdd53a 100644
--- a/crates/test-programs/src/bin/p1_file_write.rs
+++ b/crates/test-programs/src/bin/p1_file_write.rs
@@ -125,7 +125,9 @@ unsafe fn test_file_long_write(dir_fd: wasip1::Fd, filename: &str, blocking_mode
}],
);
assert!(
- res == Err(wasip1::ERRNO_BADF) || res == Err(wasip1::ERRNO_PERM),
+ res == Err(wasip1::ERRNO_BADF)
+ || res == Err(wasip1::ERRNO_PERM)
+ || res == Err(wasip1::ERRNO_ACCES),
"bad result {res:?}"
)
}
diff --git a/crates/test-programs/src/bin/p1_path_open_read_write.rs b/crates/test-programs/src/bin/p1_path_open_read_write.rs
index f91b874419..f856b8926c 100644
--- a/crates/test-programs/src/bin/p1_path_open_read_write.rs
+++ b/crates/test-programs/src/bin/p1_path_open_read_write.rs
@@ -51,7 +51,8 @@ unsafe fn test_path_open_read_write(dir_fd: wasip1::Fd, blocking_mode: BlockingM
.err()
.expect("read of writeonly fails"),
wasip1::ERRNO_PERM,
- wasip1::ERRNO_BADF
+ wasip1::ERRNO_BADF,
+ wasip1::ERRNO_ACCES
);
wasip1::fd_close(f_readonly).expect("close readonly");
@@ -89,7 +90,8 @@ unsafe fn test_path_open_read_write(dir_fd: wasip1::Fd, blocking_mode: BlockingM
.err()
.expect("read of writeonly fails"),
wasip1::ERRNO_PERM,
- wasip1::ERRNO_BADF
+ wasip1::ERRNO_BADF,
+ wasip1::ERRNO_ACCES
);
let bytes_written = blocking_mode
.write(f_writeonly, &[ciovec])
diff --git a/crates/test-programs/src/bin/p3_filesystem_file_read_write.rs b/crates/test-programs/src/bin/p3_filesystem_file_read_write.rs
index 94f1adeb8f..b4a9518cbe 100644
--- a/crates/test-programs/src/bin/p3_filesystem_file_read_write.rs
+++ b/crates/test-programs/src/bin/p3_filesystem_file_read_write.rs
@@ -12,41 +12,43 @@ impl test_programs::p3::exports::wasi::cli::run::Guest for Component {
let (dir, _) = &preopens[0];
let filename = "test.txt";
- let file = dir
- .open_at(
- PathFlags::empty(),
- filename.to_string(),
- OpenFlags::CREATE,
- DescriptorFlags::READ | DescriptorFlags::WRITE,
- )
- .await
- .unwrap();
- let (mut data_tx, data_rx) = wit_stream::new();
- join!(
- async {
- file.write_via_stream(data_rx, 5).await.unwrap();
- },
- async {
- let remaining = data_tx.write_all(b"Hello, ".to_vec()).await;
- assert!(remaining.is_empty());
- let remaining = data_tx.write_all(b"World!".to_vec()).await;
- assert!(remaining.is_empty());
- drop(data_tx);
- },
- );
- let (data_rx, data_fut) = file.read_via_stream(0);
- let contents = data_rx.collect().await;
- data_fut.await.unwrap();
- assert_eq!(
- String::from_utf8_lossy(&contents),
- "\0\0\0\0\0Hello, World!"
- );
+ {
+ let file = dir
+ .open_at(
+ PathFlags::empty(),
+ filename.to_string(),
+ OpenFlags::CREATE,
+ DescriptorFlags::READ | DescriptorFlags::WRITE,
+ )
+ .await
+ .unwrap();
+ let (mut data_tx, data_rx) = wit_stream::new();
+ join!(
+ async {
+ file.write_via_stream(data_rx, 5).await.unwrap();
+ },
+ async {
+ let remaining = data_tx.write_all(b"Hello, ".to_vec()).await;
+ assert!(remaining.is_empty());
+ let remaining = data_tx.write_all(b"World!".to_vec()).await;
+ assert!(remaining.is_empty());
+ drop(data_tx);
+ },
+ );
+ let (data_rx, data_fut) = file.read_via_stream(0);
+ let contents = data_rx.collect().await;
+ data_fut.await.unwrap();
+ assert_eq!(
+ String::from_utf8_lossy(&contents),
+ "\0\0\0\0\0Hello, World!"
+ );
- // Test that file read streams behave like other read streams.
- let (data_rx, data_fut) = file.read_via_stream(5);
- let contents = data_rx.collect().await;
- data_fut.await.unwrap();
- assert_eq!(String::from_utf8_lossy(&contents), "Hello, World!");
+ // Test that file read streams behave like other read streams.
+ let (data_rx, data_fut) = file.read_via_stream(5);
+ let contents = data_rx.collect().await;
+ data_fut.await.unwrap();
+ assert_eq!(String::from_utf8_lossy(&contents), "Hello, World!");
+ }
dir.unlink_file_at(filename.to_string()).await.unwrap();
Ok(())
diff --git a/crates/wasi/Cargo.toml b/crates/wasi/Cargo.toml
index 4e934c34a6..829a330794 100644
--- a/crates/wasi/Cargo.toml
+++ b/crates/wasi/Cargo.toml
@@ -34,10 +34,10 @@ io-lifetimes = { workspace = true }
fs-set-times = { workspace = true }
bitflags = { workspace = true }
async-trait = { workspace = true }
-system-interface = { workspace = true}
futures = { workspace = true }
url = { workspace = true }
rand = { workspace = true, features = ['std_rng', 'thread_rng'] }
+cfg-if = { workspace = true }
[dev-dependencies]
tokio = { workspace = true, features = ["time", "sync", "io-std", "io-util", "rt", "rt-multi-thread", "net", "macros", "fs"] }
@@ -54,9 +54,17 @@ rustix = { workspace = true, features = ["event", "fs", "net"] }
[target.'cfg(windows)'.dependencies]
io-extras = { workspace = true }
-windows-sys = { workspace = true }
rustix = { workspace = true, features = ["event", "net"] }
+[target.'cfg(windows)'.dependencies.windows-sys]
+workspace = true
+features = [
+ "Wdk_Storage_FileSystem",
+ "Win32_Foundation",
+ "Win32_Storage_FileSystem",
+ "Win32_System_IO",
+]
+
[features]
default = ["p1", "p2"]
p0 = ["p1"]
diff --git a/crates/wasi/src/filesystem.rs b/crates/wasi/src/filesystem.rs
index 917defac77..963a068ca2 100644
--- a/crates/wasi/src/filesystem.rs
+++ b/crates/wasi/src/filesystem.rs
@@ -8,6 +8,15 @@ use tracing::debug;
use wasmtime::component::{HasData, Resource, ResourceTable};
use wasmtime::error::Context as _;
+#[cfg(unix)]
+pub(crate) mod unix;
+#[cfg(unix)]
+pub(crate) use unix as sys;
+#[cfg(windows)]
+pub(crate) mod windows;
+#[cfg(windows)]
+pub(crate) use windows as sys;
+
/// A helper struct which implements [`HasData`] for the `wasi:filesystem` APIs.
///
/// This can be useful when directly calling `add_to_linker` functions directly,
@@ -350,6 +359,16 @@ impl From<&cap_std::fs::Metadata> for MetadataHashValue {
}
}
+#[derive(Copy, Clone, Debug)]
+pub(crate) enum Advice {
+ Normal,
+ Sequential,
+ Random,
+ WillNeed,
+ DontNeed,
+ NoReuse,
+}
+
#[cfg(unix)]
fn from_raw_os_error(err: Option<i32>) -> Option<ErrorCode> {
use rustix::io::Errno as RustixErrno;
@@ -509,25 +528,9 @@ impl Descriptor {
}
pub(crate) async fn get_flags(&self) -> Result<DescriptorFlags, ErrorCode> {
- use system_interface::fs::{FdFlags, GetSetFdFlags};
-
- fn get_from_fdflags(flags: FdFlags) -> DescriptorFlags {
- let mut out = DescriptorFlags::empty();
- if flags.contains(FdFlags::DSYNC) {
- out |= DescriptorFlags::REQUESTED_WRITE_SYNC;
- }
- if flags.contains(FdFlags::RSYNC) {
- out |= DescriptorFlags::DATA_INTEGRITY_SYNC;
- }
- if flags.contains(FdFlags::SYNC) {
- out |= DescriptorFlags::FILE_INTEGRITY_SYNC;
- }
- out
- }
match self {
Self::File(f) => {
- let flags = f.run_blocking(|f| f.get_fd_flags()).await?;
- let mut flags = get_from_fdflags(flags);
+ let mut flags = f.run_blocking(|f| sys::get_flags(f)).await?;
if f.open_mode.contains(OpenMode::READ) {
flags |= DescriptorFlags::READ;
}
@@ -537,8 +540,7 @@ impl Descriptor {
Ok(flags)
}
Self::Dir(d) => {
- let flags = d.run_blocking(|d| d.get_fd_flags()).await?;
- let mut flags = get_from_fdflags(flags);
+ let mut flags = d.run_blocking(|d| sys::get_flags(d)).await?;
if d.open_mode.contains(OpenMode::READ) {
flags |= DescriptorFlags::READ;
}
@@ -747,10 +749,9 @@ impl File {
&self,
offset: u64,
len: u64,
- advice: system_interface::fs::Advice,
+ advice: Advice,
) -> Result<(), ErrorCode> {
- use system_interface::fs::FileIoExt as _;
- self.run_blocking(move |f| f.advise(offset, len, advice))
+ self.run_blocking(move |f| sys::advise(f, offset, len, advice))
.await?;
Ok(())
}
@@ -930,7 +931,6 @@ impl Dir {
allow_blocking_current_thread: bool,
) -> Result<Descriptor, ErrorCode> {
use cap_fs_ext::{FollowSymlinks, OpenOptionsFollowExt, OpenOptionsMaybeDirExt};
- use system_interface::fs::{FdFlags, GetSetFdFlags};
if !self.perms.contains(DirPerms::READ) {
return Err(ErrorCode::NotPermitted);
@@ -1023,7 +1023,7 @@ impl Dir {
let opened = self
.run_blocking::<_, std::io::Result<OpenResult>>(move |d| {
- let mut opened = d.open_with(&path, &opts)?;
+ let opened = d.open_with(&path, &opts)?;
if opened.metadata()?.is_dir() {
Ok(OpenResult::Dir(cap_std::fs::Dir::from_std_file(
opened.into_std(),
@@ -1031,10 +1031,6 @@ impl Dir {
} else if oflags.contains(OpenFlags::DIRECTORY) {
Ok(OpenResult::NotDir)
} else {
- // FIXME cap-std needs a nonblocking open option so that files reads and writes
- // are nonblocking. Instead we set it after opening here:
- let set_fd_flags = opened.new_set_fd_flags(FdFlags::NONBLOCK)?;
- opened.set_fd_flags(set_fd_flags)?;
Ok(OpenResult::File(opened))
}
})
diff --git a/crates/wasi/src/filesystem/unix.rs b/crates/wasi/src/filesystem/unix.rs
new file mode 100644
index 0000000000..12826d854d
--- /dev/null
+++ b/crates/wasi/src/filesystem/unix.rs
@@ -0,0 +1,100 @@
+use crate::filesystem::{Advice, DescriptorFlags};
+use io_lifetimes::AsFilelike;
+use rustix::fs::{OFlags, fcntl_getfl, fcntl_setfl};
+use rustix::io::write;
+use std::fs::File;
+use std::io;
+use std::os::fd::AsFd;
+use std::os::unix::fs::FileExt;
+
+pub(crate) fn get_flags(file: impl AsFd) -> io::Result<DescriptorFlags> {
+ let flags = fcntl_getfl(file)?;
+ let mut ret = DescriptorFlags::empty();
+ ret.set(
+ DescriptorFlags::REQUESTED_WRITE_SYNC,
+ flags.contains(OFlags::DSYNC),
+ );
+ ret.set(
+ DescriptorFlags::FILE_INTEGRITY_SYNC,
+ flags.contains(OFlags::SYNC),
+ );
+ #[cfg(not(any(target_vendor = "apple", target_os = "freebsd")))]
+ ret.set(
+ DescriptorFlags::DATA_INTEGRITY_SYNC,
+ flags.contains(OFlags::RSYNC),
+ );
+ Ok(ret)
+}
+
+pub(crate) fn advise(file: impl AsFd, offset: u64, len: u64, advice: Advice) -> io::Result<()> {
+ cfg_if::cfg_if! {
+ if #[cfg(target_vendor = "apple")] {
+ match advice {
+ Advice::WillNeed => {
+ rustix::fs::fcntl_rdadvise(file, offset, len)?;
+ }
+ Advice::Normal |
+ Advice::Sequential |
+ Advice::Random |
+ Advice::DontNeed |
+ Advice::NoReuse => {}
+ }
+ } else if #[cfg(any(target_os = "linux", target_os = "android"))] {
+ use std::num::NonZeroU64;
+ let advice = match advice {
+ Advice::Normal => rustix::fs::Advice::Normal,
+ Advice::Sequential => rustix::fs::Advice::Sequential,
+ Advice::Random => rustix::fs::Advice::Random,
+ Advice::WillNeed => rustix::fs::Advice::WillNeed,
+ Advice::DontNeed => rustix::fs::Advice::DontNeed,
+ Advice::NoReuse => rustix::fs::Advice::NoReuse,
+ };
+ rustix::fs::fadvise(file, offset, NonZeroU64::new(len), advice)?;
+ } else {
+ // noop on other platforms
+ let _ = (file, offset, len, advice);
+ }
+ }
+ Ok(())
+}
+
+pub(crate) fn append_cursor_unspecified(file: impl AsFd, data: &[u8]) -> io::Result<usize> {
+ // On Linux, use `pwritev2`.
+ #[cfg(target_os = "linux")]
+ {
+ use rustix::io::{Errno, ReadWriteFlags, pwritev2};
+ use std::io::IoSlice;
+
+ let iovs = [IoSlice::new(data)];
+ match pwritev2(&file, &iovs, 0, ReadWriteFlags::APPEND) {
+ Err(Errno::NOSYS) | Err(Errno::NOTSUP) => {}
+ otherwise => return Ok(otherwise?),
+ }
+ }
+
+ // Otherwise use `F_SETFL` to switch the file description to append
+ // mode, do the write, and switch back. This is not atomic with
+ // respect to other users of the file description, but WASI isn't fully
+ // threaded right now anyway.
+ let old_flags = fcntl_getfl(&file)?;
+ fcntl_setfl(&file, old_flags | OFlags::APPEND)?;
+ let result = write(&file, data);
+ fcntl_setfl(&file, old_flags).unwrap();
+ Ok(result?)
+}
+
+pub(crate) fn write_at_cursor_unspecified(
+ file: impl AsFd,
+ data: &[u8],
+ pos: u64,
+) -> io::Result<usize> {
+ file.as_filelike_view::<File>().write_at(data, pos)
+}
+
+pub(crate) fn read_at_cursor_unspecified(
+ file: impl AsFd,
+ buf: &mut [u8],
+ pos: u64,
+) -> io::Result<usize> {
+ file.as_filelike_view::<File>().read_at(buf, pos)
+}
diff --git a/crates/wasi/src/filesystem/windows.rs b/crates/wasi/src/filesystem/windows.rs
new file mode 100644
index 0000000000..9c1952bfca
--- /dev/null
+++ b/crates/wasi/src/filesystem/windows.rs
@@ -0,0 +1,127 @@
+use crate::filesystem::{Advice, DescriptorFlags};
+use io_lifetimes::AsFilelike;
+use std::fs::File;
+use std::io::{self, Write};
+use std::mem::{self, MaybeUninit};
+use std::os::windows::fs::FileExt;
+use std::os::windows::io::*;
+use windows_sys::Wdk::Storage::FileSystem::*;
+use windows_sys::Win32::Foundation::*;
+use windows_sys::Win32::Storage::FileSystem::*;
+use windows_sys::Win32::System::IO::*;
+
+pub(crate) fn get_flags(file: impl AsHandle) -> io::Result<DescriptorFlags> {
+ let file = file.as_handle();
+ let mode = query_mode_information(file)?;
+ let mut ret = DescriptorFlags::empty();
+ ret.set(
+ DescriptorFlags::REQUESTED_WRITE_SYNC,
+ mode & FILE_WRITE_THROUGH != 0,
+ );
+ Ok(ret)
+}
+
+pub(crate) fn advise(file: impl AsHandle, offset: u64, len: u64, advice: Advice) -> io::Result<()> {
+ let _ = (file, offset, len, advice);
+
+ // ... noop for now ...
+
+ Ok(())
+}
+
+pub(crate) fn append_cursor_unspecified(file: impl AsHandle, data: &[u8]) -> io::Result<usize> {
+ let file = file.as_handle();
+ let access = query_access_information(file)?;
+
+ // If this file doesn't allow writing then it can't be appended to.
+ if access & (FILE_WRITE_DATA | FILE_APPEND_DATA) == 0 {
+ return Err(io::Error::new(
+ io::ErrorKind::PermissionDenied,
+ "file not opened with write or append access",
+ ));
+ }
+
+ // Reopen the file with append
+ reopen_file(
+ file,
+ FILE_GENERIC_WRITE & !FILE_WRITE_DATA,
+ // Files on Windows are opened with DELETE, READ, and WRITE share mode
+ // by default (see OpenOptions in stdlib) This keeps the same share mode
+ // when reopening the file handle
+ FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+ 0,
+ )?
+ .write(data)
+}
+
+pub(crate) fn write_at_cursor_unspecified(
+ file: impl AsHandle,
+ data: &[u8],
+ pos: u64,
+) -> io::Result<usize> {
+ file.as_filelike_view::<File>().seek_write(data, pos)
+}
+
+pub(crate) fn read_at_cursor_unspecified(
+ file: impl AsHandle,
+ buf: &mut [u8],
+ pos: u64,
+) -> io::Result<usize> {
+ file.as_filelike_view::<File>().seek_read(buf, pos)
+}
+
+fn query_access_information(handle: BorrowedHandle<'_>) -> io::Result<u32> {
+ unsafe {
+ Ok(
+ nt_query_information_file::<FILE_ACCESS_INFORMATION>(handle, FileAccessInformation)?
+ .AccessFlags,
+ )
+ }
+}
+
+fn reopen_file(
+ handle: BorrowedHandle<'_>,
+ access_mode: u32,
+ share_mode: u32,
+ flags: u32,
+) -> io::Result<File> {
+ let new_handle = unsafe { ReOpenFile(handle.as_raw_handle(), access_mode, share_mode, flags) };
+
+ if new_handle == INVALID_HANDLE_VALUE {
+ return Err(io::Error::last_os_error());
+ }
+
+ Ok(unsafe { File::from_raw_handle(new_handle) })
+}
+
+fn query_mode_information(handle: BorrowedHandle<'_>) -> io::Result<u32> {
+ unsafe {
+ Ok(nt_query_information_file::<FILE_MODE_INFORMATION>(handle, FileModeInformation)?.Mode)
+ }
+}
+
+unsafe fn nt_query_information_file<T>(
+ handle: BorrowedHandle<'_>,
+ info: FILE_INFORMATION_CLASS,
+) -> io::Result<T> {
+ unsafe {
+ let mut io_status_block = mem::zeroed::<IO_STATUS_BLOCK>();
+ let mut payload = MaybeUninit::<T>::uninit();
+
+ let status = NtQueryInformationFile(
+ handle.as_raw_handle(),
+ &mut io_status_block,
+ payload.as_mut_ptr().cast(),
+ mem::size_of_val(&payload).try_into().unwrap(),
+ info,
+ );
+
+ if status != STATUS_SUCCESS {
+ return Err(io::Error::from_raw_os_error(
+ RtlNtStatusToDosError(status) as i32
+ ));
+ }
+
+ Ok(payload.assume_init())
+ }
+}
diff --git a/crates/wasi/src/p1.rs b/crates/wasi/src/p1.rs
index b063aa7a9a..95c688e2db 100644
--- a/crates/wasi/src/p1.rs
+++ b/crates/wasi/src/p1.rs
@@ -64,6 +64,7 @@
use crate::cli::WasiCliView as _;
use crate::clocks::WasiClocksView as _;
use crate::filesystem::WasiFilesystemView as _;
+use crate::filesystem::sys;
use crate::p2::bindings::{
cli::{
stderr::Host as _, stdin::Host as _, stdout::Host as _, terminal_input, terminal_output,
@@ -79,7 +80,6 @@ use std::mem::{self, size_of, size_of_val};
use std::slice;
use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};
-use system_interface::fs::FileIoExt;
use wasmtime::component::Resource;
use wasmtime::{bail, error::Context as _};
use wasmtime_wasi_io::{
@@ -657,9 +657,9 @@ impl WasiP1Ctx {
// Note that this is implementing Linux semantics of
// `pwrite` where the offset is ignored if the file was
// opened in append mode.
- (true, _) => f.append(&buf),
- (false, FdWrite::At(pos)) => f.write_at(&buf, pos),
- (false, FdWrite::AtCur) => f.write_at(&buf, pos),
+ (true, _) => sys::append_cursor_unspecified(f, &buf),
+ (false, FdWrite::At(pos)) => sys::write_at_cursor_unspecified(f, &buf, pos),
+ (false, FdWrite::AtCur) => sys::write_at_cursor_unspecified(f, &buf, pos),
};
let nwritten = match f.as_blocking_file() {
@@ -1690,9 +1690,10 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiP1Ctx {
// Try to read directly into wasm memory where possible
// when the current thread can block and additionally wasm
// memory isn't shared.
- (Some(file), Some(mut buf)) => file
- .read_at(&mut buf, pos)
- .map_err(|e| StreamError::LastOperationFailed(e.into()))?,
+ (Some(file), Some(mut buf)) => {
+ sys::read_at_cursor_unspecified(file, &mut buf, pos)
+ .map_err(|e| StreamError::LastOperationFailed(e.into()))?
+ }
// ... otherwise fall back to performing the read on a
// blocking thread and which copies the data back into wasm
// memory.
@@ -1701,9 +1702,9 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiP1Ctx {
let mut buf = vec![0; iov.len() as usize];
let buf = file
.run_blocking(move |file| -> Result<_, types::Error> {
- let bytes_read = file
- .read_at(&mut buf, pos)
- .map_err(|e| StreamError::LastOperationFailed(e.into()))?;
+ let bytes_read =
+ sys::read_at_cursor_unspecified(file, &mut buf, pos)
+ .map_err(|e| StreamError::LastOperationFailed(e.into()))?;
buf.truncate(bytes_read);
Ok(buf)
})
diff --git a/crates/wasi/src/p2/filesystem.rs b/crates/wasi/src/p2/filesystem.rs
index acdafcc2c0..39e10e354c 100644
--- a/crates/wasi/src/p2/filesystem.rs
+++ b/crates/wasi/src/p2/filesystem.rs
@@ -1,5 +1,6 @@
use crate::TrappableError;
use crate::filesystem::File;
+use crate::filesystem::sys;
use crate::p2::bindings::filesystem::types;
use crate::p2::{InputStream, OutputStream, Pollable, StreamError, StreamResult};
use crate::runtime::AbortOnDropJoinHandle;
@@ -84,11 +85,9 @@ impl FileInputStream {
}
fn blocking_read(file: &cap_std::fs::File, offset: u64, size: usize) -> ReadState {
- use system_interface::fs::FileIoExt;
-
let mut buf = BytesMut::zeroed(size.min(crate::MAX_READ_SIZE_ALLOC));
loop {
- match file.read_at(&mut buf, offset) {
+ match sys::read_at_cursor_unspecified(file, &mut buf, offset) {
Ok(0) => return ReadState::Closed,
Ok(n) => {
buf.truncate(n);
@@ -243,13 +242,11 @@ impl FileOutputStream {
mut buf: Bytes,
mode: FileOutputMode,
) -> io::Result<usize> {
- use system_interface::fs::FileIoExt;
-
match mode {
FileOutputMode::Position(mut p) => {
let mut total = 0;
loop {
- let nwritten = file.write_at(buf.as_ref(), p)?;
+ let nwritten = sys::write_at_cursor_unspecified(file, buf.as_ref(), p)?;
// afterwards buf contains [nwritten, len):
let _ = buf.split_to(nwritten);
p += nwritten as u64;
@@ -263,7 +260,7 @@ impl FileOutputStream {
FileOutputMode::Append => {
let mut total = 0;
loop {
- let nwritten = file.append(buf.as_ref())?;
+ let nwritten = sys::append_cursor_unspecified(file, buf.as_ref())?;
let _ = buf.split_to(nwritten);
total += nwritten;
if buf.is_empty() {
diff --git a/crates/wasi/src/p2/host/filesystem.rs b/crates/wasi/src/p2/host/filesystem.rs
index 3772f03d18..6ac208254d 100644
--- a/crates/wasi/src/p2/host/filesystem.rs
+++ b/crates/wasi/src/p2/host/filesystem.rs
@@ -1,3 +1,4 @@
+use crate::filesystem::sys;
use crate::filesystem::{Descriptor, WasiFilesystemCtxView};
use crate::p2::bindings::clocks::wall_clock;
use crate::p2::bindings::filesystem::preopens;
@@ -105,9 +106,6 @@ impl HostDescriptor for WasiFilesystemCtxView<'_> {
len: types::Filesize,
offset: types::Filesize,
) -> FsResult<(Vec<u8>, bool)> {
- use std::io::IoSliceMut;
- use system_interface::fs::FileIoExt;
-
let f = self.table.get(&fd)?.file()?;
if !f.perms.contains(FilePerms::READ) {
return Err(ErrorCode::NotPermitted.into());
@@ -121,7 +119,7 @@ impl HostDescriptor for WasiFilesystemCtxView<'_> {
.unwrap_or(usize::MAX)
.min(crate::MAX_READ_SIZE_ALLOC)
];
- let r = f.read_vectored_at(&mut [IoSliceMut::new(&mut buffer)], offset);
+ let r = sys::read_at_cursor_unspecified(f, &mut buffer, offset);
(buffer, r)
})
.await;
@@ -142,16 +140,13 @@ impl HostDescriptor for WasiFilesystemCtxView<'_> {
buf: Vec<u8>,
offset: types::Filesize,
) -> FsResult<types::Filesize> {
- use std::io::IoSlice;
- use system_interface::fs::FileIoExt;
-
let f = self.table.get(&fd)?.file()?;
if !f.perms.contains(FilePerms::WRITE) {
return Err(ErrorCode::NotPermitted.into());
}
let bytes_written = f
- .run_blocking(move |f| f.write_vectored_at(&[IoSlice::new(&buf)], offset))
+ .run_blocking(move |f| sys::write_at_cursor_unspecified(f, &buf, offset))
.await?;
Ok(types::Filesize::try_from(bytes_written).expect("usize fits in Filesize"))
@@ -481,7 +476,7 @@ impl HostDirectoryEntryStream for WasiFilesystemCtxView<'_> {
}
}
-impl From<types::Advice> for system_interface::fs::Advice {
+impl From<types::Advice> for crate::filesystem::Advice {
fn from(advice: types::Advice) -> Self {
match advice {
types::Advice::Normal => Self::Normal,
diff --git a/crates/wasi/src/p3/filesystem/host.rs b/crates/wasi/src/p3/filesystem/host.rs
index a7c8724cf9..ea763abbd2 100644
--- a/crates/wasi/src/p3/filesystem/host.rs
+++ b/crates/wasi/src/p3/filesystem/host.rs
@@ -1,3 +1,4 @@
+use crate::filesystem::sys;
use crate::filesystem::{Descriptor, Dir, File, WasiFilesystem, WasiFilesystemCtxView};
use crate::p3::bindings::clocks::system_clock;
use crate::p3::bindings::filesystem::types::{
@@ -13,7 +14,6 @@ use core::task::{Context, Poll, ready};
use core::{iter, mem};
use std::io::{self, Cursor};
use std::sync::Arc;
-use system_interface::fs::FileIoExt as _;
use tokio::sync::{mpsc, oneshot};
use tokio::task::{JoinHandle, spawn_blocking};
use wasmtime::StoreContextMut;
@@ -179,7 +179,7 @@ impl<D> StreamProducer<D> for ReadStreamProducer {
if buf.is_empty() {
return Poll::Ready(Ok(StreamResult::Completed));
}
- return match file.read_at(buf, self.offset) {
+ return match sys::read_at_cursor_unspecified(file, buf, self.offset) {
Ok(0) => {
self.close(Ok(()));
Poll::Ready(Ok(StreamResult::Dropped))
@@ -203,7 +203,7 @@ impl<D> StreamProducer<D> for ReadStreamProducer {
let file = Arc::clone(me.file.as_file());
let offset = me.offset;
spawn_blocking(move || {
- file.read_at(&mut buf, offset).map(|n| {
+ sys::read_at_cursor_unspecified(file, &mut buf, offset).map(|n| {
buf.truncate(n);
buf
})
@@ -420,8 +420,8 @@ impl WriteStreamConsumer {
impl WriteLocation {
fn write(&self, file: &cap_std::fs::File, bytes: &[u8]) -> io::Result<usize> {
match *self {
- WriteLocation::End => file.append(bytes),
- WriteLocation::Offset(at) => file.write_at(bytes, at),
+ WriteLocation::End => sys::append_cursor_unspecified(file, bytes),
+ WriteLocation::Offset(at) => sys::write_at_cursor_unspecified(file, bytes, at),
}
}
}
diff --git a/crates/wasi/src/p3/filesystem/mod.rs b/crates/wasi/src/p3/filesystem/mod.rs
index 0ef9c3166c..06862db3e4 100644
--- a/crates/wasi/src/p3/filesystem/mod.rs
+++ b/crates/wasi/src/p3/filesystem/mod.rs
@@ -130,7 +130,7 @@ impl From<wasmtime::component::ResourceTableError> for FilesystemError {
}
}
-impl From<types::Advice> for system_interface::fs::Advice {
+impl From<types::Advice> for crate::filesystem::Advice {
fn from(advice: types::Advice) -> Self {
match advice {
types::Advice::Normal => Self::Normal,