A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
return `ERRNO_AGAIN` from `fd_{read,write}` when appropriate (#13111)
Joel Diced60f17817df1
diff --git a/crates/test-programs/src/bin/p1_cli_hostcall_fuel.rs b/crates/test-programs/src/bin/p1_cli_hostcall_fuel.rsindex 9fb93efe89..ef7e360025 100644--- a/crates/test-programs/src/bin/p1_cli_hostcall_fuel.rs+++ b/crates/test-programs/src/bin/p1_cli_hostcall_fuel.rs@@ -1,9 +1,11 @@use std::ptr;+use test_programs::preview1::BlockingMode;fn main() {big_poll();big_string();- big_iovecs();+ big_iovecs(BlockingMode::Blocking);+ big_iovecs(BlockingMode::NonBlocking);}fn big_string() {@@ -18,7 +20,7 @@ fn big_string() {);}-fn big_iovecs() {+fn big_iovecs(blocking_mode: BlockingMode) {let mut iovs = Vec::new();let mut ciovs = Vec::new();for _ in 0..10_000 {@@ -40,14 +42,14 @@ fn big_iovecs() {wasip1::OFLAGS_CREAT,wasip1::RIGHTS_FD_WRITE | wasip1::RIGHTS_FD_READ,0,- 0,+ blocking_mode.fd_flags(),).unwrap()};unsafe {- assert_eq!(wasip1::fd_write(fd, &ciovs), Err(wasip1::ERRNO_NOMEM));- assert_eq!(wasip1::fd_read(fd, &iovs), Err(wasip1::ERRNO_NOMEM));+ assert_eq!(blocking_mode.write(fd, &ciovs), Err(wasip1::ERRNO_NOMEM));+ assert_eq!(blocking_mode.read(fd, &iovs), Err(wasip1::ERRNO_NOMEM));assert_eq!(wasip1::fd_pwrite(fd, &ciovs, 0), Err(wasip1::ERRNO_NOMEM));assert_eq!(wasip1::fd_pread(fd, &iovs, 0), Err(wasip1::ERRNO_NOMEM));}@@ -63,8 +65,8 @@ fn big_iovecs() {buf_len: 10_000,});unsafe {- assert_eq!(wasip1::fd_write(fd, &ciovs), Err(wasip1::ERRNO_NOMEM));- assert_eq!(wasip1::fd_read(fd, &iovs), Err(wasip1::ERRNO_NOMEM));+ assert_eq!(blocking_mode.write(fd, &ciovs), Err(wasip1::ERRNO_NOMEM));+ assert_eq!(blocking_mode.read(fd, &iovs), Err(wasip1::ERRNO_NOMEM));assert_eq!(wasip1::fd_pwrite(fd, &ciovs, 0), Err(wasip1::ERRNO_NOMEM));assert_eq!(wasip1::fd_pread(fd, &iovs, 0), Err(wasip1::ERRNO_NOMEM));}diff --git a/crates/test-programs/src/bin/p1_fd_flags_set.rs b/crates/test-programs/src/bin/p1_fd_flags_set.rsindex 8770f2450c..ae0f13b5fb 100644--- a/crates/test-programs/src/bin/p1_fd_flags_set.rs+++ b/crates/test-programs/src/bin/p1_fd_flags_set.rs@@ -1,9 +1,9 @@#![expect(unsafe_op_in_unsafe_fn, reason = "old code, not worth updating yet")]use std::{env, process};-use test_programs::preview1::open_scratch_directory;+use test_programs::preview1::{BlockingMode, open_scratch_directory};-unsafe fn test_fd_fdstat_set_flags(dir_fd: wasip1::Fd) {+unsafe fn test_fd_fdstat_set_flags(dir_fd: wasip1::Fd, blocking_mode: BlockingMode) {const FILE_NAME: &str = "file";let data = &[0u8; 100];@@ -14,20 +14,21 @@ unsafe fn test_fd_fdstat_set_flags(dir_fd: wasip1::Fd) {wasip1::OFLAGS_CREAT,wasip1::RIGHTS_FD_READ | wasip1::RIGHTS_FD_WRITE,0,- wasip1::FDFLAGS_APPEND,+ blocking_mode.fd_flags() | wasip1::FDFLAGS_APPEND,).expect("opening a file");// Write some data and then verify the written dataassert_eq!(- wasip1::fd_write(- file_fd,- &[wasip1::Ciovec {- buf: data.as_ptr(),- buf_len: data.len(),- }],- )- .expect("writing to a file"),+ blocking_mode+ .write(+ file_fd,+ &[wasip1::Ciovec {+ buf: data.as_ptr(),+ buf_len: data.len(),+ }],+ )+ .expect("writing to a file"),data.len(),"should write {} bytes",data.len(),@@ -38,14 +39,15 @@ unsafe fn test_fd_fdstat_set_flags(dir_fd: wasip1::Fd) {let buffer = &mut [0u8; 100];assert_eq!(- wasip1::fd_read(- file_fd,- &[wasip1::Iovec {- buf: buffer.as_mut_ptr(),- buf_len: buffer.len(),- }]- )- .expect("reading file"),+ blocking_mode+ .read(+ file_fd,+ &[wasip1::Iovec {+ buf: buffer.as_mut_ptr(),+ buf_len: buffer.len(),+ }]+ )+ .expect("reading file"),buffer.len(),"should read {} bytes",buffer.len()@@ -59,14 +61,15 @@ unsafe fn test_fd_fdstat_set_flags(dir_fd: wasip1::Fd) {wasip1::fd_seek(file_fd, 0, wasip1::WHENCE_SET).expect("seeking file");assert_eq!(- wasip1::fd_write(- file_fd,- &[wasip1::Ciovec {- buf: data.as_ptr(),- buf_len: data.len(),- }],- )- .expect("writing to a file"),+ blocking_mode+ .write(+ file_fd,+ &[wasip1::Ciovec {+ buf: data.as_ptr(),+ buf_len: data.len(),+ }],+ )+ .expect("writing to a file"),data.len(),"should write {} bytes",data.len(),@@ -75,14 +78,15 @@ unsafe fn test_fd_fdstat_set_flags(dir_fd: wasip1::Fd) {wasip1::fd_seek(file_fd, 100, wasip1::WHENCE_SET).expect("seeking file");assert_eq!(- wasip1::fd_read(- file_fd,- &[wasip1::Iovec {- buf: buffer.as_mut_ptr(),- buf_len: buffer.len(),- }]- )- .expect("reading file"),+ blocking_mode+ .read(+ file_fd,+ &[wasip1::Iovec {+ buf: buffer.as_mut_ptr(),+ buf_len: buffer.len(),+ }]+ )+ .expect("reading file"),buffer.len(),"should read {} bytes",buffer.len()@@ -90,7 +94,7 @@ unsafe fn test_fd_fdstat_set_flags(dir_fd: wasip1::Fd) {assert_eq!(&data[..], &buffer[..]);- wasip1::fd_fdstat_set_flags(file_fd, 0).expect("disabling flags");+ wasip1::fd_fdstat_set_flags(file_fd, blocking_mode.fd_flags()).expect("disabling flags");// Overwrite some existing data to ensure the append mode is now offwasip1::fd_seek(file_fd, 0, wasip1::WHENCE_SET).expect("seeking file");@@ -98,14 +102,15 @@ unsafe fn test_fd_fdstat_set_flags(dir_fd: wasip1::Fd) {let data = &[2u8; 100];assert_eq!(- wasip1::fd_write(- file_fd,- &[wasip1::Ciovec {- buf: data.as_ptr(),- buf_len: data.len(),- }],- )- .expect("writing to a file"),+ blocking_mode+ .write(+ file_fd,+ &[wasip1::Ciovec {+ buf: data.as_ptr(),+ buf_len: data.len(),+ }],+ )+ .expect("writing to a file"),data.len(),"should write {} bytes",data.len(),@@ -114,14 +119,15 @@ unsafe fn test_fd_fdstat_set_flags(dir_fd: wasip1::Fd) {wasip1::fd_seek(file_fd, 0, wasip1::WHENCE_SET).expect("seeking file");assert_eq!(- wasip1::fd_read(- file_fd,- &[wasip1::Iovec {- buf: buffer.as_mut_ptr(),- buf_len: buffer.len(),- }]- )- .expect("reading file"),+ blocking_mode+ .read(+ file_fd,+ &[wasip1::Iovec {+ buf: buffer.as_mut_ptr(),+ buf_len: buffer.len(),+ }]+ )+ .expect("reading file"),buffer.len(),"should read {} bytes",buffer.len()@@ -157,6 +163,7 @@ fn main() {};unsafe {- test_fd_fdstat_set_flags(dir_fd);+ test_fd_fdstat_set_flags(dir_fd, BlockingMode::Blocking);+ test_fd_fdstat_set_flags(dir_fd, BlockingMode::NonBlocking);}}diff --git a/crates/test-programs/src/bin/p1_file_read_write.rs b/crates/test-programs/src/bin/p1_file_read_write.rsindex 0ca2f1eefa..abb008e311 100644--- a/crates/test-programs/src/bin/p1_file_read_write.rs+++ b/crates/test-programs/src/bin/p1_file_read_write.rs@@ -1,9 +1,9 @@#![expect(unsafe_op_in_unsafe_fn, reason = "old code, not worth updating yet")]use std::{env, process};-use test_programs::preview1::open_scratch_directory;+use test_programs::preview1::{BlockingMode, open_scratch_directory};-unsafe fn test_file_read_write(dir_fd: wasip1::Fd) {+unsafe fn test_file_read_write(dir_fd: wasip1::Fd, blocking_mode: BlockingMode) {// Create a file in the scratch directory.let file_fd = wasip1::path_open(dir_fd,@@ -12,7 +12,7 @@ unsafe fn test_file_read_write(dir_fd: wasip1::Fd) {wasip1::OFLAGS_CREAT,wasip1::RIGHTS_FD_READ | wasip1::RIGHTS_FD_WRITE,0,- 0,+ blocking_mode.fd_flags(),).expect("opening a file");assert!(@@ -25,7 +25,9 @@ unsafe fn test_file_read_write(dir_fd: wasip1::Fd) {buf: contents.as_ptr() as *const _,buf_len: contents.len(),};- let mut nwritten = wasip1::fd_write(file_fd, &[ciovec]).expect("writing bytes at offset 0");+ let mut nwritten = blocking_mode+ .write(file_fd, &[ciovec])+ .expect("writing bytes at offset 0");assert_eq!(nwritten, 4, "nwritten bytes check");let contents = &mut [0u8; 4];@@ -34,7 +36,9 @@ unsafe fn test_file_read_write(dir_fd: wasip1::Fd) {buf_len: contents.len(),};wasip1::fd_seek(file_fd, 0, wasip1::WHENCE_SET).expect("seeking to offset 0");- let mut nread = wasip1::fd_read(file_fd, &[iovec]).expect("reading bytes at offset 0");+ let mut nread = blocking_mode+ .read(file_fd, &[iovec])+ .expect("reading bytes at offset 0");assert_eq!(nread, 4, "nread bytes check");assert_eq!(contents, &[0u8, 1, 2, 3], "written bytes equal read bytes");@@ -61,8 +65,9 @@ unsafe fn test_file_read_write(dir_fd: wasip1::Fd) {buf_len: remaining,});- nwritten =- wasip1::fd_write(file_fd, ciovecs.as_slice()).expect("writing bytes at offset 0");+ nwritten = blocking_mode+ .write(file_fd, ciovecs.as_slice())+ .expect("writing bytes at offset 0");offset += nwritten;if offset == contents.len() {@@ -91,7 +96,9 @@ unsafe fn test_file_read_write(dir_fd: wasip1::Fd) {buf_len: 2,},];- nread = wasip1::fd_read(file_fd, iovecs).expect("reading bytes at offset 0");+ nread = blocking_mode+ .read(file_fd, iovecs)+ .expect("reading bytes at offset 0");if nread == 0 {break;}@@ -107,7 +114,9 @@ unsafe fn test_file_read_write(dir_fd: wasip1::Fd) {buf_len: contents.len(),};wasip1::fd_seek(file_fd, 2, wasip1::WHENCE_SET).expect("seeking to offset 2");- nread = wasip1::fd_read(file_fd, &[iovec]).expect("reading bytes at offset 2");+ nread = blocking_mode+ .read(file_fd, &[iovec])+ .expect("reading bytes at offset 2");assert_eq!(nread, 2, "nread bytes check");assert_eq!(contents, &[2u8, 3, 0, 0], "file cursor was overwritten");@@ -117,7 +126,9 @@ unsafe fn test_file_read_write(dir_fd: wasip1::Fd) {buf_len: contents.len(),};wasip1::fd_seek(file_fd, 2, wasip1::WHENCE_SET).expect("seeking to offset 2");- nwritten = wasip1::fd_write(file_fd, &[ciovec]).expect("writing bytes at offset 2");+ nwritten = blocking_mode+ .write(file_fd, &[ciovec])+ .expect("writing bytes at offset 2");assert_eq!(nwritten, 2, "nwritten bytes check");let contents = &mut [0u8; 4];@@ -126,7 +137,9 @@ unsafe fn test_file_read_write(dir_fd: wasip1::Fd) {buf_len: contents.len(),};wasip1::fd_seek(file_fd, 0, wasip1::WHENCE_SET).expect("seeking to offset 0");- nread = wasip1::fd_read(file_fd, &[iovec]).expect("reading bytes at offset 0");+ nread = blocking_mode+ .read(file_fd, &[iovec])+ .expect("reading bytes at offset 0");assert_eq!(nread, 4, "nread bytes check");assert_eq!(contents, &[0u8, 1, 1, 0], "file cursor was overwritten");@@ -134,7 +147,7 @@ unsafe fn test_file_read_write(dir_fd: wasip1::Fd) {wasip1::path_unlink_file(dir_fd, "file").expect("removing a file");}-unsafe fn test_file_write_and_file_pos(dir_fd: wasip1::Fd) {+unsafe fn test_file_write_and_file_pos(dir_fd: wasip1::Fd, blocking_mode: BlockingMode) {let path = "file2";let file_fd = wasip1::path_open(dir_fd,@@ -160,7 +173,9 @@ unsafe fn test_file_write_and_file_pos(dir_fd: wasip1::Fd) {buf_len: 0,};wasip1::fd_seek(file_fd, 2, wasip1::WHENCE_SET).expect("seeking to offset 2");- let n = wasip1::fd_write(file_fd, &[ciovec]).expect("writing bytes at offset 2");+ let n = blocking_mode+ .write(file_fd, &[ciovec])+ .expect("writing bytes at offset 2");assert_eq!(n, 0);assert_eq!(wasip1::fd_tell(file_fd).unwrap(), 2);@@ -174,7 +189,9 @@ unsafe fn test_file_write_and_file_pos(dir_fd: wasip1::Fd) {buf_len: buf.len(),};wasip1::fd_seek(file_fd, 50, wasip1::WHENCE_SET).expect("seeking to offset 50");- let n = wasip1::fd_write(file_fd, &[ciovec]).expect("writing bytes at offset 50");+ let n = blocking_mode+ .write(file_fd, &[ciovec])+ .expect("writing bytes at offset 50");assert_eq!(n, 1);assert_eq!(wasip1::fd_tell(file_fd).unwrap(), 51);@@ -206,7 +223,9 @@ fn main() {// Run the tests.unsafe {- test_file_read_write(dir_fd);- test_file_write_and_file_pos(dir_fd);+ test_file_read_write(dir_fd, BlockingMode::Blocking);+ test_file_read_write(dir_fd, BlockingMode::NonBlocking);+ test_file_write_and_file_pos(dir_fd, BlockingMode::Blocking);+ test_file_write_and_file_pos(dir_fd, BlockingMode::NonBlocking);}}diff --git a/crates/test-programs/src/bin/p1_file_seek_tell.rs b/crates/test-programs/src/bin/p1_file_seek_tell.rsindex 57630da029..b39b30827a 100644--- a/crates/test-programs/src/bin/p1_file_seek_tell.rs+++ b/crates/test-programs/src/bin/p1_file_seek_tell.rs@@ -1,9 +1,9 @@#![expect(unsafe_op_in_unsafe_fn, reason = "old code, not worth updating yet")]use std::{env, process};-use test_programs::preview1::{assert_errno, open_scratch_directory};+use test_programs::preview1::{BlockingMode, assert_errno, open_scratch_directory};-unsafe fn test_file_seek_tell(dir_fd: wasip1::Fd) {+unsafe fn test_file_seek_tell(dir_fd: wasip1::Fd, blocking_mode: BlockingMode) {// Create a file in the scratch directory.let file_fd = wasip1::path_open(dir_fd,@@ -12,7 +12,7 @@ unsafe fn test_file_seek_tell(dir_fd: wasip1::Fd) {wasip1::OFLAGS_CREAT,wasip1::RIGHTS_FD_READ | wasip1::RIGHTS_FD_WRITE,0,- 0,+ blocking_mode.fd_flags(),).expect("opening a file");assert!(@@ -30,7 +30,9 @@ unsafe fn test_file_seek_tell(dir_fd: wasip1::Fd) {buf: data.as_ptr() as *const _,buf_len: data.len(),};- let nwritten = wasip1::fd_write(file_fd, &[iov]).expect("writing to a file");+ let nwritten = blocking_mode+ .write(file_fd, &[iov])+ .expect("writing to a file");assert_eq!(nwritten, 100, "should write 100 bytes to file");// Check current offset@@ -72,7 +74,7 @@ unsafe fn test_file_seek_tell(dir_fd: wasip1::Fd) {buf: buffer.as_mut_ptr(),buf_len: buffer.len(),};- let nread = wasip1::fd_read(file_fd, &[iovec]).expect("reading file");+ let nread = blocking_mode.read(file_fd, &[iovec]).expect("reading file");assert_eq!(nread, buffer.len(), "should read {} bytes", buffer.len());offset = wasip1::fd_tell(file_fd).expect("getting file offset after reading");@@ -84,7 +86,7 @@ unsafe fn test_file_seek_tell(dir_fd: wasip1::Fd) {// Test that when a file is opened with `O_APPEND` that acquiring the current// position indicates the end of the file.-unsafe fn seek_and_o_append(dir_fd: wasip1::Fd) {+unsafe fn seek_and_o_append(dir_fd: wasip1::Fd, blocking_mode: BlockingMode) {let path = "file2";let file_fd = wasip1::path_open(dir_fd,@@ -93,7 +95,7 @@ unsafe fn seek_and_o_append(dir_fd: wasip1::Fd) {wasip1::OFLAGS_CREAT,wasip1::RIGHTS_FD_READ | wasip1::RIGHTS_FD_WRITE,0,- wasip1::FDFLAGS_APPEND,+ blocking_mode.fd_flags() | wasip1::FDFLAGS_APPEND,).expect("opening a file");assert!(@@ -111,7 +113,7 @@ unsafe fn seek_and_o_append(dir_fd: wasip1::Fd) {buf: data.as_ptr() as *const _,buf_len: data.len(),};- let nwritten = wasip1::fd_write(file_fd, &[iov]).unwrap();+ let nwritten = blocking_mode.write(file_fd, &[iov]).unwrap();assert_eq!(nwritten, 100);let mut offset = wasip1::fd_seek(file_fd, 0, wasip1::WHENCE_CUR).unwrap();@@ -144,7 +146,9 @@ fn main() {// Run the tests.unsafe {- test_file_seek_tell(dir_fd);- seek_and_o_append(dir_fd);+ test_file_seek_tell(dir_fd, BlockingMode::Blocking);+ test_file_seek_tell(dir_fd, BlockingMode::NonBlocking);+ seek_and_o_append(dir_fd, BlockingMode::Blocking);+ seek_and_o_append(dir_fd, BlockingMode::NonBlocking);}}diff --git a/crates/test-programs/src/bin/p1_file_truncation.rs b/crates/test-programs/src/bin/p1_file_truncation.rsindex bac0268599..6dbb85c7d3 100644--- a/crates/test-programs/src/bin/p1_file_truncation.rs+++ b/crates/test-programs/src/bin/p1_file_truncation.rs@@ -1,9 +1,9 @@#![expect(unsafe_op_in_unsafe_fn, reason = "old code, not worth updating yet")]use std::{env, process};-use test_programs::preview1::open_scratch_directory;+use test_programs::preview1::{BlockingMode, open_scratch_directory};-unsafe fn test_file_truncation(dir_fd: wasip1::Fd) {+unsafe fn test_file_truncation(dir_fd: wasip1::Fd, blocking_mode: BlockingMode) {const FILENAME: &str = "test.txt";// Open a file for writing@@ -14,20 +14,21 @@ unsafe fn test_file_truncation(dir_fd: wasip1::Fd) {wasip1::OFLAGS_CREAT,wasip1::RIGHTS_FD_WRITE,0,- 0,+ blocking_mode.fd_flags(),).expect("creating a file for writing");// Write to the filelet content = b"this content will be truncated!";- let nwritten = wasip1::fd_write(- file_fd,- &[wasip1::Ciovec {- buf: content.as_ptr() as *const _,- buf_len: content.len(),- }],- )- .expect("writing file content");+ let nwritten = blocking_mode+ .write(+ file_fd,+ &[wasip1::Ciovec {+ buf: content.as_ptr() as *const _,+ buf_len: content.len(),+ }],+ )+ .expect("writing file content");assert_eq!(nwritten, content.len(), "nwritten bytes check");wasip1::fd_close(file_fd).expect("closing the file");@@ -40,20 +41,21 @@ unsafe fn test_file_truncation(dir_fd: wasip1::Fd) {wasip1::OFLAGS_CREAT | wasip1::OFLAGS_TRUNC,wasip1::RIGHTS_FD_WRITE | wasip1::RIGHTS_FD_READ,0,- 0,+ blocking_mode.fd_flags(),).expect("creating a truncated file for reading");// Read the file's contentslet buffer = &mut [0u8; 100];- let nread = wasip1::fd_read(- file_fd,- &[wasip1::Iovec {- buf: buffer.as_mut_ptr(),- buf_len: buffer.len(),- }],- )- .expect("reading file content");+ let nread = blocking_mode+ .read(+ file_fd,+ &[wasip1::Iovec {+ buf: buffer.as_mut_ptr(),+ buf_len: buffer.len(),+ }],+ )+ .expect("reading file content");// The file should be empty due to truncationassert_eq!(nread, 0, "expected an empty file after truncation");@@ -81,5 +83,8 @@ fn main() {};// Run the tests.- unsafe { test_file_truncation(dir_fd) }+ unsafe {+ test_file_truncation(dir_fd, BlockingMode::Blocking);+ test_file_truncation(dir_fd, BlockingMode::NonBlocking);+ }}diff --git a/crates/test-programs/src/bin/p1_file_unbuffered_write.rs b/crates/test-programs/src/bin/p1_file_unbuffered_write.rsindex d69c948e52..713cffe4ab 100644--- a/crates/test-programs/src/bin/p1_file_unbuffered_write.rs+++ b/crates/test-programs/src/bin/p1_file_unbuffered_write.rs@@ -1,9 +1,9 @@#![expect(unsafe_op_in_unsafe_fn, reason = "old code, not worth updating yet")]use std::{env, process};-use test_programs::preview1::open_scratch_directory;+use test_programs::preview1::{BlockingMode, open_scratch_directory};-unsafe fn test_file_unbuffered_write(dir_fd: wasip1::Fd) {+unsafe fn test_file_unbuffered_write(dir_fd: wasip1::Fd, blocking_mode: BlockingMode) {// Create and open file for readinglet fd_read = wasip1::path_open(dir_fd,@@ -12,7 +12,7 @@ unsafe fn test_file_unbuffered_write(dir_fd: wasip1::Fd) {wasip1::OFLAGS_CREAT,wasip1::RIGHTS_FD_READ,0,- 0,+ blocking_mode.fd_flags(),).expect("create and open file for reading");assert!(@@ -21,8 +21,16 @@ unsafe fn test_file_unbuffered_write(dir_fd: wasip1::Fd) {);// Open the same file but for writing- let fd_write = wasip1::path_open(dir_fd, 0, "file", 0, wasip1::RIGHTS_FD_WRITE, 0, 0)- .expect("opening file for writing");+ let fd_write = wasip1::path_open(+ dir_fd,+ 0,+ "file",+ 0,+ wasip1::RIGHTS_FD_WRITE,+ 0,+ blocking_mode.fd_flags(),+ )+ .expect("opening file for writing");assert!(fd_write > libc::STDERR_FILENO as wasip1::Fd,"file descriptor range check",@@ -34,7 +42,9 @@ unsafe fn test_file_unbuffered_write(dir_fd: wasip1::Fd) {buf: contents.as_ptr() as *const _,buf_len: contents.len(),};- let nwritten = wasip1::fd_write(fd_write, &[ciovec]).expect("writing byte to file");+ let nwritten = blocking_mode+ .write(fd_write, &[ciovec])+ .expect("writing byte to file");assert_eq!(nwritten, 1, "nwritten bytes check");// Read from file@@ -43,7 +53,9 @@ unsafe fn test_file_unbuffered_write(dir_fd: wasip1::Fd) {buf: contents.as_mut_ptr() as *mut _,buf_len: contents.len(),};- let nread = wasip1::fd_read(fd_read, &[iovec]).expect("reading bytes from file");+ let nread = blocking_mode+ .read(fd_read, &[iovec])+ .expect("reading bytes from file");assert_eq!(nread, 1, "nread bytes check");assert_eq!(contents, &[1u8], "written bytes equal read bytes");@@ -72,5 +84,8 @@ fn main() {};// Run the tests.- unsafe { test_file_unbuffered_write(dir_fd) }+ unsafe {+ test_file_unbuffered_write(dir_fd, BlockingMode::Blocking);+ test_file_unbuffered_write(dir_fd, BlockingMode::NonBlocking);+ }}diff --git a/crates/test-programs/src/bin/p1_file_write.rs b/crates/test-programs/src/bin/p1_file_write.rsindex ccc3629b8e..27a8163856 100644--- a/crates/test-programs/src/bin/p1_file_write.rs+++ b/crates/test-programs/src/bin/p1_file_write.rs@@ -1,9 +1,9 @@#![expect(unsafe_op_in_unsafe_fn, reason = "old code, not worth updating yet")]use std::{env, process};-use test_programs::preview1::open_scratch_directory;+use test_programs::preview1::{BlockingMode, open_scratch_directory};-unsafe fn test_file_long_write(dir_fd: wasip1::Fd, filename: &str) {+unsafe fn test_file_long_write(dir_fd: wasip1::Fd, filename: &str, blocking_mode: BlockingMode) {// Open a file for writinglet file_fd = wasip1::path_open(dir_fd,@@ -12,7 +12,7 @@ unsafe fn test_file_long_write(dir_fd: wasip1::Fd, filename: &str) {wasip1::OFLAGS_CREAT,wasip1::RIGHTS_FD_WRITE,0,- 0,+ blocking_mode.fd_flags(),).expect("creating a file for writing");@@ -25,14 +25,15 @@ unsafe fn test_file_long_write(dir_fd: wasip1::Fd, filename: &str) {}// Write to the file- let nwritten = wasip1::fd_write(- file_fd,- &[wasip1::Ciovec {- buf: content.as_slice().as_ptr() as *const _,- buf_len: content.len(),- }],- )- .expect("writing file content");+ let nwritten = blocking_mode+ .write(+ file_fd,+ &[wasip1::Ciovec {+ buf: content.as_slice().as_ptr() as *const _,+ buf_len: content.len(),+ }],+ )+ .expect("writing file content");assert_eq!(nwritten, content.len(), "nwritten bytes check");let stat = wasip1::fd_filestat_get(file_fd).expect("reading file stats");@@ -44,19 +45,28 @@ unsafe fn test_file_long_write(dir_fd: wasip1::Fd, filename: &str) {wasip1::fd_close(file_fd).expect("closing the file");// Open the file for reading- let file_fd = wasip1::path_open(dir_fd, 0, filename, 0, wasip1::RIGHTS_FD_READ, 0, 0)- .expect("open the file for reading");+ let file_fd = wasip1::path_open(+ dir_fd,+ 0,+ filename,+ 0,+ wasip1::RIGHTS_FD_READ,+ 0,+ blocking_mode.fd_flags(),+ )+ .expect("open the file for reading");// Read the file's contentslet buffer = &mut [0u8; 100];- let nread = wasip1::fd_read(- file_fd,- &[wasip1::Iovec {- buf: buffer.as_mut_ptr(),- buf_len: buffer.len(),- }],- )- .expect("reading first chunk file content");+ let nread = blocking_mode+ .read(+ file_fd,+ &[wasip1::Iovec {+ buf: buffer.as_mut_ptr(),+ buf_len: buffer.len(),+ }],+ )+ .expect("reading first chunk file content");assert_eq!(nread, buffer.len(), "read first chunk");assert_eq!(@@ -69,14 +79,15 @@ unsafe fn test_file_long_write(dir_fd: wasip1::Fd, filename: &str) {wasip1::fd_seek(file_fd, end_cursor as i64, wasip1::WHENCE_SET).expect("seeking to end of file minus buffer size");- let nread = wasip1::fd_read(- file_fd,- &[wasip1::Iovec {- buf: buffer.as_mut_ptr(),- buf_len: buffer.len(),- }],- )- .expect("reading end chunk of file content");+ let nread = blocking_mode+ .read(+ file_fd,+ &[wasip1::Iovec {+ buf: buffer.as_mut_ptr(),+ buf_len: buffer.len(),+ }],+ )+ .expect("reading end chunk of file content");assert_eq!(nread, buffer.len(), "read end chunk len");assert_eq!(buffer, &content[end_cursor..], "contents of end read chunk");@@ -92,13 +103,21 @@ unsafe fn test_file_long_write(dir_fd: wasip1::Fd, filename: &str) {wasip1::OFLAGS_CREAT,wasip1::RIGHTS_FD_WRITE,0,- 0,+ blocking_mode.fd_flags(),).expect("creating a file for writing");wasip1::fd_close(file_fd).expect("closing the file");- let file_fd = wasip1::path_open(dir_fd, 0, filename, 0, wasip1::RIGHTS_FD_READ, 0, 0)- .expect("opening a file for writing");- let res = wasip1::fd_write(+ let file_fd = wasip1::path_open(+ dir_fd,+ 0,+ filename,+ 0,+ wasip1::RIGHTS_FD_READ,+ 0,+ blocking_mode.fd_flags(),+ )+ .expect("opening a file for writing");+ let res = blocking_mode.write(file_fd,&[wasip1::Ciovec {buf: 3 as *const u8,@@ -131,5 +150,8 @@ fn main() {};// Run the tests.- unsafe { test_file_long_write(dir_fd, "long_write.txt") }+ unsafe {+ test_file_long_write(dir_fd, "long_write.txt", BlockingMode::Blocking);+ test_file_long_write(dir_fd, "long_write.txt", BlockingMode::NonBlocking);+ }}diff --git a/crates/test-programs/src/bin/p1_path_open_lots.rs b/crates/test-programs/src/bin/p1_path_open_lots.rsindex 5b56d3b643..6fe0d3b73a 100644--- a/crates/test-programs/src/bin/p1_path_open_lots.rs+++ b/crates/test-programs/src/bin/p1_path_open_lots.rs@@ -1,29 +1,47 @@#![expect(unsafe_op_in_unsafe_fn, reason = "old code, not worth updating yet")]use std::{env, process};-use test_programs::preview1::{create_file, open_scratch_directory};+use test_programs::preview1::{BlockingMode, create_file, open_scratch_directory};-unsafe fn test_path_open_lots(dir_fd: wasip1::Fd) {+unsafe fn test_path_open_lots(dir_fd: wasip1::Fd, blocking_mode: BlockingMode) {create_file(dir_fd, "file");for _ in 0..2000 {- let f_readonly = wasip1::path_open(dir_fd, 0, "file", 0, wasip1::RIGHTS_FD_READ, 0, 0)- .expect("open file readonly");+ let f_readonly = wasip1::path_open(+ dir_fd,+ 0,+ "file",+ 0,+ wasip1::RIGHTS_FD_READ,+ 0,+ blocking_mode.fd_flags(),+ )+ .expect("open file readonly");let buffer = &mut [0u8; 100];let iovec = wasip1::Iovec {buf: buffer.as_mut_ptr(),buf_len: buffer.len(),};- let nread = wasip1::fd_read(f_readonly, &[iovec]).expect("reading readonly file");+ let nread = blocking_mode+ .read(f_readonly, &[iovec])+ .expect("reading readonly file");assert_eq!(nread, 0, "readonly file is empty");wasip1::fd_close(f_readonly).expect("close readonly");}for _ in 0..2000 {- let f_readonly = wasip1::path_open(dir_fd, 0, "file", 0, wasip1::RIGHTS_FD_READ, 0, 0)- .expect("open file readonly");+ let f_readonly = wasip1::path_open(+ dir_fd,+ 0,+ "file",+ 0,+ wasip1::RIGHTS_FD_READ,+ 0,+ blocking_mode.fd_flags(),+ )+ .expect("open file readonly");let buffer = &mut [0u8; 100];let iovec = wasip1::Iovec {@@ -44,7 +62,7 @@ unsafe fn test_path_open_lots(dir_fd: wasip1::Fd) {0,wasip1::RIGHTS_FD_READ | wasip1::RIGHTS_FD_WRITE,0,- 0,+ blocking_mode.fd_flags(),).unwrap();@@ -53,7 +71,7 @@ unsafe fn test_path_open_lots(dir_fd: wasip1::Fd) {buf: buffer.as_ptr(),buf_len: buffer.len(),};- let nwritten = wasip1::fd_write(f, &[ciovec]).expect("write failed");+ let nwritten = blocking_mode.write(f, &[ciovec]).expect("write failed");assert_eq!(nwritten, 100);wasip1::fd_close(f).unwrap();@@ -67,7 +85,7 @@ unsafe fn test_path_open_lots(dir_fd: wasip1::Fd) {0,wasip1::RIGHTS_FD_READ | wasip1::RIGHTS_FD_WRITE,0,- 0,+ blocking_mode.fd_flags(),).unwrap();@@ -105,5 +123,8 @@ fn main() {};// Run the tests.- unsafe { test_path_open_lots(dir_fd) }+ unsafe {+ test_path_open_lots(dir_fd, BlockingMode::Blocking);+ test_path_open_lots(dir_fd, BlockingMode::NonBlocking);+ }}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.rsindex 00d839878a..f91b874419 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@@ -1,13 +1,21 @@#![expect(unsafe_op_in_unsafe_fn, reason = "old code, not worth updating yet")]use std::{env, process};-use test_programs::preview1::{assert_errno, create_file, open_scratch_directory};+use test_programs::preview1::{BlockingMode, assert_errno, create_file, open_scratch_directory};-unsafe fn test_path_open_read_write(dir_fd: wasip1::Fd) {+unsafe fn test_path_open_read_write(dir_fd: wasip1::Fd, blocking_mode: BlockingMode) {create_file(dir_fd, "file");- let f_readonly = wasip1::path_open(dir_fd, 0, "file", 0, wasip1::RIGHTS_FD_READ, 0, 0)- .expect("open file readonly");+ let f_readonly = wasip1::path_open(+ dir_fd,+ 0,+ "file",+ 0,+ wasip1::RIGHTS_FD_READ,+ 0,+ blocking_mode.fd_flags(),+ )+ .expect("open file readonly");let stat = wasip1::fd_fdstat_get(f_readonly).expect("get fdstat readonly");assert!(@@ -24,7 +32,9 @@ unsafe fn test_path_open_read_write(dir_fd: wasip1::Fd) {buf: buffer.as_mut_ptr(),buf_len: buffer.len(),};- let nread = wasip1::fd_read(f_readonly, &[iovec]).expect("reading readonly file");+ let nread = blocking_mode+ .read(f_readonly, &[iovec])+ .expect("reading readonly file");assert_eq!(nread, 0, "readonly file is empty");let write_buffer = &[1u8; 50];@@ -36,7 +46,8 @@ unsafe fn test_path_open_read_write(dir_fd: wasip1::Fd) {// fails on windows with BADF, so we can't use the `windows =>` syntax// because that doesn't support alternatives like the agnostic syntax does.assert_errno!(- wasip1::fd_write(f_readonly, &[ciovec])+ blocking_mode+ .write(f_readonly, &[ciovec]).err().expect("read of writeonly fails"),wasip1::ERRNO_PERM,@@ -46,8 +57,16 @@ unsafe fn test_path_open_read_write(dir_fd: wasip1::Fd) {wasip1::fd_close(f_readonly).expect("close readonly");// =============== WRITE ONLY ==================- let f_writeonly = wasip1::path_open(dir_fd, 0, "file", 0, wasip1::RIGHTS_FD_WRITE, 0, 0)- .expect("open file writeonly");+ let f_writeonly = wasip1::path_open(+ dir_fd,+ 0,+ "file",+ 0,+ wasip1::RIGHTS_FD_WRITE,+ 0,+ blocking_mode.fd_flags(),+ )+ .expect("open file writeonly");let stat = wasip1::fd_fdstat_get(f_writeonly).expect("get fdstat writeonly");assert!(@@ -65,13 +84,16 @@ unsafe fn test_path_open_read_write(dir_fd: wasip1::Fd) {// See above for description of PERMassert_errno!(- wasip1::fd_read(f_writeonly, &[iovec])+ blocking_mode+ .read(f_writeonly, &[iovec]).err().expect("read of writeonly fails"),wasip1::ERRNO_PERM,wasip1::ERRNO_BADF);- let bytes_written = wasip1::fd_write(f_writeonly, &[ciovec]).expect("write to writeonly");+ let bytes_written = blocking_mode+ .write(f_writeonly, &[ciovec])+ .expect("write to writeonly");assert_eq!(bytes_written, write_buffer.len());wasip1::fd_close(f_writeonly).expect("close writeonly");@@ -85,7 +107,7 @@ unsafe fn test_path_open_read_write(dir_fd: wasip1::Fd) {0,wasip1::RIGHTS_FD_READ | wasip1::RIGHTS_FD_WRITE,0,- 0,+ blocking_mode.fd_flags(),).expect("open file readwrite");let stat = wasip1::fd_fdstat_get(f_readwrite).expect("get fdstat readwrite");@@ -98,7 +120,9 @@ unsafe fn test_path_open_read_write(dir_fd: wasip1::Fd) {"readwrite has write right");- let nread = wasip1::fd_read(f_readwrite, &[iovec]).expect("reading readwrite file");+ let nread = blocking_mode+ .read(f_readwrite, &[iovec])+ .expect("reading readwrite file");assert_eq!(nread,write_buffer.len(),@@ -110,7 +134,9 @@ unsafe fn test_path_open_read_write(dir_fd: wasip1::Fd) {buf: write_buffer_2.as_ptr(),buf_len: write_buffer_2.len(),};- let bytes_written = wasip1::fd_write(f_readwrite, &[ciovec]).expect("write to readwrite");+ let bytes_written = blocking_mode+ .write(f_readwrite, &[ciovec])+ .expect("write to readwrite");assert_eq!(bytes_written, write_buffer_2.len());let filestat = wasip1::fd_filestat_get(f_readwrite).expect("get filestat readwrite");@@ -145,5 +171,8 @@ fn main() {};// Run the tests.- unsafe { test_path_open_read_write(dir_fd) }+ unsafe {+ test_path_open_read_write(dir_fd, BlockingMode::Blocking);+ test_path_open_read_write(dir_fd, BlockingMode::NonBlocking);+ }}diff --git a/crates/test-programs/src/bin/p1_poll_oneoff_files.rs b/crates/test-programs/src/bin/p1_poll_oneoff_files.rsindex 252ad1b92c..0586c5e8d9 100644--- a/crates/test-programs/src/bin/p1_poll_oneoff_files.rs+++ b/crates/test-programs/src/bin/p1_poll_oneoff_files.rs@@ -1,7 +1,7 @@#![expect(unsafe_op_in_unsafe_fn, reason = "old code, not worth updating yet")]use std::{env, mem::MaybeUninit, process};-use test_programs::preview1::{assert_errno, open_scratch_directory};+use test_programs::preview1::{BlockingMode, assert_errno, open_scratch_directory};const CLOCK_ID: wasip1::Userdata = 0x0123_45678;@@ -189,7 +189,7 @@ unsafe fn test_fd_readwrite();}-unsafe fn test_fd_readwrite_valid_fd(dir_fd: wasip1::Fd) {+unsafe fn test_fd_readwrite_valid_fd(dir_fd: wasip1::Fd, blocking_mode: BlockingMode) {// Create a file in the scratch directory.let nonempty_file = wasip1::path_open(dir_fd,@@ -198,7 +198,7 @@ unsafe fn test_fd_readwrite_valid_fd(dir_fd: wasip1::Fd) {wasip1::OFLAGS_CREAT,wasip1::RIGHTS_FD_WRITE,0,- 0,+ blocking_mode.fd_flags(),).expect("create writable file");// Write to file@@ -207,7 +207,9 @@ unsafe fn test_fd_readwrite_valid_fd(dir_fd: wasip1::Fd) {buf: contents.as_ptr() as *const _,buf_len: contents.len(),};- wasip1::fd_write(nonempty_file, &[ciovec]).expect("write");+ blocking_mode+ .write(nonempty_file, &[ciovec])+ .expect("write");wasip1::fd_close(nonempty_file).expect("close");// Now open the file for reading@@ -271,11 +273,11 @@ unsafe fn test_fd_readwrite_invalid_fd() {assert_eq!(err, wasip1::ERRNO_BADF)}-unsafe fn test_poll_oneoff(dir_fd: wasip1::Fd) {+unsafe fn test_poll_oneoff(dir_fd: wasip1::Fd, blocking_mode: BlockingMode) {test_timeout();test_sleep();test_empty_poll();- test_fd_readwrite_valid_fd(dir_fd);+ test_fd_readwrite_valid_fd(dir_fd, blocking_mode);test_fd_readwrite_invalid_fd();}fn main() {@@ -298,5 +300,8 @@ fn main() {};// Run the tests.- unsafe { test_poll_oneoff(dir_fd) }+ unsafe {+ test_poll_oneoff(dir_fd, BlockingMode::Blocking);+ test_poll_oneoff(dir_fd, BlockingMode::NonBlocking);+ }}diff --git a/crates/test-programs/src/preview1.rs b/crates/test-programs/src/preview1.rsindex 4d4da78be3..afd7c86867 100644--- a/crates/test-programs/src/preview1.rs+++ b/crates/test-programs/src/preview1.rs@@ -1,4 +1,4 @@-use std::{sync::OnceLock, time::Duration};+use std::{mem::MaybeUninit, sync::OnceLock, time::Duration};pub fn config() -> &'static TestConfig {static TESTCONFIG: OnceLock<TestConfig> = OnceLock::new();@@ -197,3 +197,72 @@ impl TestConfig {self.rename_dir_onto_file}}++pub enum BlockingMode {+ Blocking,+ NonBlocking,+}++impl BlockingMode {+ pub fn fd_flags(&self) -> u16 {+ match self {+ BlockingMode::Blocking => 0,+ BlockingMode::NonBlocking => wasip1::FDFLAGS_NONBLOCK,+ }+ }++ fn poll(fd: wasip1::Fd, event: wasip1::Eventtype) -> Result<(), wasip1::Errno> {+ assert!(+ unsafe {+ wasip1::poll_oneoff(+ [wasip1::Subscription {+ userdata: 0,+ u: wasip1::SubscriptionU {+ tag: event.raw(),+ u: wasip1::SubscriptionUU {+ fd_read: wasip1::SubscriptionFdReadwrite {+ file_descriptor: fd,+ },+ },+ },+ }]+ .as_ptr(),+ MaybeUninit::<wasip1::Event>::uninit().as_mut_ptr(),+ 1,+ )+ }? == 1+ );++ Ok(())+ }++ pub unsafe fn read(+ &self,+ fd: wasip1::Fd,+ iovs: wasip1::IovecArray<'_>,+ ) -> Result<wasip1::Size, wasip1::Errno> {+ loop {+ match (self, unsafe { wasip1::fd_read(fd, iovs) }) {+ (BlockingMode::NonBlocking, Err(wasip1::ERRNO_AGAIN)) => {+ Self::poll(fd, wasip1::EVENTTYPE_FD_READ)?;+ }+ (_, result) => break result,+ }+ }+ }++ pub unsafe fn write(+ &self,+ fd: wasip1::Fd,+ iovs: wasip1::CiovecArray<'_>,+ ) -> Result<wasip1::Size, wasip1::Errno> {+ loop {+ match (self, unsafe { wasip1::fd_write(fd, iovs) }) {+ (BlockingMode::NonBlocking, Err(wasip1::ERRNO_AGAIN)) => {+ Self::poll(fd, wasip1::EVENTTYPE_FD_WRITE)?;+ }+ (_, result) => break result,+ }+ }+ }+}diff --git a/crates/wasi-common/src/sync/dir.rs b/crates/wasi-common/src/sync/dir.rsindex cba660e7e4..5ad37441cb 100644--- a/crates/wasi-common/src/sync/dir.rs+++ b/crates/wasi-common/src/sync/dir.rs@@ -95,7 +95,13 @@ impl Dir {} else {// NONBLOCK does not have an OpenOption either, but we can patch that on with set_fd_flags:if fdflags.contains(crate::file::FdFlags::NONBLOCK) {- let set_fd_flags = f.new_set_fd_flags(system_interface::fs::FdFlags::NONBLOCK)?;+ let set_fd_flags = f.new_set_fd_flags(+ if fdflags.contains(crate::file::FdFlags::APPEND) {+ system_interface::fs::FdFlags::APPEND+ } else {+ system_interface::fs::FdFlags::empty()+ } | system_interface::fs::FdFlags::NONBLOCK,+ )?;f.set_fd_flags(set_fd_flags)?;}Ok(OpenResult::File(File::from_cap_std(f)))diff --git a/crates/wasi-preview1-component-adapter/src/lib.rs b/crates/wasi-preview1-component-adapter/src/lib.rsindex 3e89ea191d..7235c1f24d 100644--- a/crates/wasi-preview1-component-adapter/src/lib.rs+++ b/crates/wasi-preview1-component-adapter/src/lib.rs@@ -1271,20 +1271,11 @@ pub unsafe extern "C" fn fd_read(let read_len = u64::try_from(len).trapping_unwrap();let wasi_stream = streams.get_read_stream()?;- let data = match state- .with_one_import_alloc(ptr, len, || blocking_mode.read(wasi_stream, read_len))- {- Ok(data) => data,- Err(streams::StreamError::Closed) => {- *nread = 0;- return Ok(());- }- Err(streams::StreamError::LastOperationFailed(e)) => {- Err(stream_error_to_errno(e))?- }- };+ let data = state.with_one_import_alloc(ptr, len, || {+ blocking_mode.read(wasi_stream, read_len)+ })?;- assert_eq!(data.as_ptr(), ptr);+ assert!(data.is_empty() || data.as_ptr() == ptr);assert!(data.len() <= len);// If this is a file, keep the current-position pointer up to date.@@ -1294,8 +1285,7 @@ pub unsafe extern "C" fn fd_read(.set(file.position.get() + data.len() as filesystem::Filesize);}- let len = data.len();- *nread = len;+ *nread = data.len();forget(data);Ok(())}@@ -2563,14 +2553,22 @@ impl BlockingMode {// note: these methods must take self, not &self, to avoid rustc creating a constant// out of a BlockingMode literal that it places in .romem, creating a data section and// breaking our fragile linking scheme- fn read(- self,- input_stream: &streams::InputStream,- read_len: u64,- ) -> Result<Vec<u8>, streams::StreamError> {+ fn read(self, input_stream: &streams::InputStream, read_len: u64) -> Result<Vec<u8>, Errno> {match self {- BlockingMode::NonBlocking => input_stream.read(read_len),- BlockingMode::Blocking => input_stream.blocking_read(read_len),+ BlockingMode::Blocking => match input_stream.blocking_read(read_len) {+ Ok(data) => Ok(data),+ Err(streams::StreamError::Closed) => Ok(Vec::new()),+ Err(streams::StreamError::LastOperationFailed(e)) => Err(stream_error_to_errno(e)),+ },+ BlockingMode::NonBlocking => match input_stream.read(read_len) {+ Ok(data) if data.is_empty() && read_len > 0 => {+ forget(data);+ Err(ERRNO_AGAIN)+ }+ Ok(data) => Ok(data),+ Err(streams::StreamError::Closed) => Ok(Vec::new()),+ Err(streams::StreamError::LastOperationFailed(e)) => Err(stream_error_to_errno(e)),+ },}}fn write(@@ -2599,6 +2597,7 @@ impl BlockingMode {BlockingMode::NonBlocking => {let permit = match output_stream.check_write() {+ Ok(0) if bytes.len() > 0 => return Err(ERRNO_AGAIN),Ok(n) => n,Err(streams::StreamError::Closed) => 0,Err(streams::StreamError::LastOperationFailed(e)) => {