implement preadv and pwritev syscalls (#1058)

* implement preadv and pwritev syscalls

Adds preadv/pwritev support (syscall 295/296) following the same
pattern as the existing readv/writev and pread/pwrite implementations.

glibc: replace SYSCALL_CANCEL with MAKE_LEGACY_SYSCALL in preadv64.c
and pwritev64.c, using __lind_translate_iov to translate iov_base
pointers from guest to host addresses.

rawposix: add preadv_syscall and pwritev_syscall handlers.

test: preadv_pwritev.c covers scatter/gather at offset 0 and non-zero
offset, and verifies the file pointer is not modified.

* debug: print pwritev error

* debug: always print pwritev return value

* debug: compare writev vs pwritev

* debug: try raw syscall for preadv/pwritev

* debug: print raw args in pwritev handler

* fix preadv/pwritev: update non-64 glibc wrappers

The 32-bit preadv.c and pwritev.c (used when __OFF_T_MATCHES_OFF64_T
is not defined, which is the case on wasm32) were still using
SYSCALL_CANCEL which bypasses 3i. Only the 64-bit variants had been
updated to use MAKE_LEGACY_SYSCALL.

Also reverts debug prints and raw syscall experiments.

* implement preadv and pwritev syscalls

Adds preadv/pwritev support (syscall 295/296) following the same
pattern as the existing readv/writev and pread/pwrite implementations.

glibc: replace SYSCALL_CANCEL with MAKE_LEGACY_SYSCALL in preadv.c
and pwritev.c (the non-64 versions, which are what wasm32 uses since
__OFF_T_MATCHES_OFF64_T is not defined). Uses __lind_translate_iov to
translate iov_base pointers from guest to host addresses.

rawposix: add preadv_syscall and pwritev_syscall handlers.

test: preadv_pwritev.c covers scatter/gather at offset 0 and non-zero
offset, and verifies the file pointer is not modified.

Author: rennergade

src/glibc/lind_syscall/lind_syscall_num.h

@@ -119,6 +119,8 @@
 #define EPOLL_CREATE1_SYSCALL 291
 #define DUP3_SYSCALL 292
 #define PIPE2_SYSCALL 293
+#define PREADV_SYSCALL 295
+#define PWRITEV_SYSCALL 296
 #define PRLIMIT64_SYSCALL 302
 #define GETRANDOM_SYSCALL 318
 

src/glibc/sysdeps/unix/sysv/linux/preadv.c

@@ -17,33 +17,23 @@
 
 #include <sys/uio.h>
 #include <sysdep-cancel.h>
+#include <syscall-template.h>
+#include <lind_syscall_num.h>
+#include <addr_translation.h>
 
 #ifndef __OFF_T_MATCHES_OFF64_T
 
-# ifdef __ASSUME_PREADV
-
-ssize_t
-preadv (int fd, const struct iovec *vector, int count, off_t offset)
-{
-  return SYSCALL_CANCEL (preadv, fd, vector, count, LO_HI_LONG (offset));
-}
-# else
-static ssize_t __atomic_preadv_replacement (int, const struct iovec *,
-					    int, off_t);
 ssize_t
 preadv (int fd, const struct iovec *vector, int count, off_t offset)
 {
-  ssize_t result = SYSCALL_CANCEL (preadv, fd, vector, count,
-				   LO_HI_LONG (offset));
-  if (result >= 0 || errno != ENOSYS)
-    return result;
-  return __atomic_preadv_replacement (fd, vector, count, offset);
+  struct iovec host_iov[count];
+  __lind_translate_iov (vector, host_iov, count);
+
+  return MAKE_LEGACY_SYSCALL (PREADV_SYSCALL, "syscall|preadv",
+               (uint64_t) fd,
+               (uint64_t) TRANSLATE_GUEST_POINTER_TO_HOST ((uintptr_t) host_iov),
+               (uint64_t) count,
+               (uint64_t) offset, NOTUSED, NOTUSED, TRANSLATE_ERRNO_ON);
 }
-#  define PREADV static __atomic_preadv_replacement
-#  define PREAD __pread
-#  define OFF_T off_t
-#  include <sysdeps/posix/preadv_common.c>
-# endif /* __ASSUME_PREADV  */
-
 libc_hidden_def (preadv)
 #endif

src/glibc/sysdeps/unix/sysv/linux/pwritev.c

@@ -17,33 +17,23 @@
 
 #include <sys/uio.h>
 #include <sysdep-cancel.h>
+#include <syscall-template.h>
+#include <lind_syscall_num.h>
+#include <addr_translation.h>
 
 #ifndef __OFF_T_MATCHES_OFF64_T
 
-# ifdef __ASSUME_PREADV
-
-ssize_t
-pwritev (int fd, const struct iovec *vector, int count, off_t offset)
-{
-  return SYSCALL_CANCEL (pwritev, fd, vector, count, LO_HI_LONG (offset));
-}
-# else
-static ssize_t __atomic_pwritev_replacement (int, const struct iovec *,
-					     int, off_t);
 ssize_t
 pwritev (int fd, const struct iovec *vector, int count, off_t offset)
 {
-  ssize_t result = SYSCALL_CANCEL (pwritev, fd, vector, count,
-				   LO_HI_LONG (offset));
-  if (result >= 0 || errno != ENOSYS)
-    return result;
-  return __atomic_pwritev_replacement (fd, vector, count, offset);
+  struct iovec host_iov[count];
+  __lind_translate_iov (vector, host_iov, count);
+
+  return MAKE_LEGACY_SYSCALL (PWRITEV_SYSCALL, "syscall|pwritev",
+               (uint64_t) fd,
+               (uint64_t) TRANSLATE_GUEST_POINTER_TO_HOST ((uintptr_t) host_iov),
+               (uint64_t) count,
+               (uint64_t) offset, NOTUSED, NOTUSED, TRANSLATE_ERRNO_ON);
 }
-#  define PWRITEV static __atomic_pwritev_replacement
-#  define PWRITE __pwrite
-#  define OFF_T off_t
-#  include <sysdeps/posix/pwritev_common.c>
-# endif /* __ASSUME_PREADV  */
-
 libc_hidden_def (pwritev)
 #endif

src/rawposix/src/fs_calls.rs

@@ -2767,6 +2767,112 @@ pub extern "C" fn readv_syscall(
     ret
 }
 
+/// Reference to Linux: https://man7.org/linux/man-pages/man2/preadv.2.html
+///
+/// `preadv()` combines the functionality of `readv()` and `pread()`: it performs
+/// scatter input from the file at the given offset without changing the file pointer.
+///
+/// ## Arguments:
+///     - vfd_arg: virtual file descriptor
+///     - iov_arg: pointer to an array of iovec structures
+///     - iovcnt_arg: number of iovec structures
+///     - offset_arg: file offset to read from
+///
+/// ## Returns:
+///     - On success, the number of bytes read.
+///     - On error, -1 with errno set.
+pub extern "C" fn preadv_syscall(
+    cageid: u64,
+    vfd_arg: u64,
+    vfd_cageid: u64,
+    iov_arg: u64,
+    iov_cageid: u64,
+    iovcnt_arg: u64,
+    iovcnt_cageid: u64,
+    offset_arg: u64,
+    offset_cageid: u64,
+    arg5: u64,
+    arg5_cageid: u64,
+    arg6: u64,
+    arg6_cageid: u64,
+) -> i32 {
+    let kernel_fd = convert_fd_to_host(vfd_arg, vfd_cageid, cageid);
+    if kernel_fd < 0 {
+        return handle_errno(-kernel_fd, "preadv");
+    }
+
+    let iovcnt = sc_convert_sysarg_to_i32(iovcnt_arg, iovcnt_cageid, cageid);
+    let iov_ptr = sc_convert_buf(iov_arg, iov_cageid, cageid);
+    let offset = sc_convert_sysarg_to_i64(offset_arg, offset_cageid, cageid);
+
+    if !(sc_unusedarg(arg5, arg5_cageid) && sc_unusedarg(arg6, arg6_cageid)) {
+        panic!(
+            "{}: unused arguments contain unexpected values -- security violation",
+            "preadv_syscall"
+        );
+    }
+
+    let ret =
+        unsafe { libc::preadv(kernel_fd, iov_ptr as *const libc::iovec, iovcnt, offset) as i32 };
+    if ret < 0 {
+        return handle_errno(get_errno(), "preadv");
+    }
+    ret
+}
+
+/// Reference to Linux: https://man7.org/linux/man-pages/man2/pwritev.2.html
+///
+/// `pwritev()` combines the functionality of `writev()` and `pwrite()`: it performs
+/// gather output to the file at the given offset without changing the file pointer.
+///
+/// ## Arguments:
+///     - vfd_arg: virtual file descriptor
+///     - iov_arg: pointer to an array of iovec structures
+///     - iovcnt_arg: number of iovec structures
+///     - offset_arg: file offset to write at
+///
+/// ## Returns:
+///     - On success, the number of bytes written.
+///     - On error, -1 with errno set.
+pub extern "C" fn pwritev_syscall(
+    cageid: u64,
+    vfd_arg: u64,
+    vfd_cageid: u64,
+    iov_arg: u64,
+    iov_cageid: u64,
+    iovcnt_arg: u64,
+    iovcnt_cageid: u64,
+    offset_arg: u64,
+    offset_cageid: u64,
+    arg5: u64,
+    arg5_cageid: u64,
+    arg6: u64,
+    arg6_cageid: u64,
+) -> i32 {
+    let kernel_fd = convert_fd_to_host(vfd_arg, vfd_cageid, cageid);
+    if kernel_fd < 0 {
+        return handle_errno(-kernel_fd, "pwritev");
+    }
+
+    let iovcnt = sc_convert_sysarg_to_i32(iovcnt_arg, iovcnt_cageid, cageid);
+    let iov_ptr = sc_convert_buf(iov_arg, iov_cageid, cageid);
+    let offset = sc_convert_sysarg_to_i64(offset_arg, offset_cageid, cageid);
+
+    if !(sc_unusedarg(arg5, arg5_cageid) && sc_unusedarg(arg6, arg6_cageid)) {
+        panic!(
+            "{}: unused arguments contain unexpected values -- security violation",
+            "pwritev_syscall"
+        );
+    }
+
+    let ret =
+        unsafe { libc::pwritev(kernel_fd, iov_ptr as *const libc::iovec, iovcnt, offset) as i32 };
+    if ret < 0 {
+        return handle_errno(get_errno(), "pwritev");
+    }
+    ret
+}
+
 /// Reference to Linux: https://man7.org/linux/man-pages/man2/fstat.2.html
 ///
 /// Linux `fstat()` syscall retrieves information about the file referred to by the open file descriptor `fd`.

src/rawposix/src/syscall_table.rs

@@ -10,11 +10,11 @@ use super::fs_calls::{
     ftruncate_syscall, futex_syscall, getcwd_syscall, getdents_syscall, getrandom_syscall,
     ioctl_syscall, link_syscall, lseek_syscall, mkdir_syscall, mknod_syscall, mmap_syscall,
     mprotect_syscall, munmap_syscall, nanosleep_time64_syscall, open_syscall, openat_syscall,
-    pipe2_syscall, pipe_syscall, pread_syscall, pwrite_syscall, read_syscall, readlink_syscall,
-    readlinkat_syscall, readv_syscall, rename_syscall, rmdir_syscall, shmat_syscall,
-    shmctl_syscall, shmdt_syscall, shmget_syscall, stat_syscall, statfs_syscall,
-    sync_file_range_syscall, truncate_syscall, unlink_syscall, unlinkat_syscall, write_syscall,
-    writev_syscall,
+    pipe2_syscall, pipe_syscall, pread_syscall, preadv_syscall, pwrite_syscall, pwritev_syscall,
+    read_syscall, readlink_syscall, readlinkat_syscall, readv_syscall, rename_syscall,
+    rmdir_syscall, shmat_syscall, shmctl_syscall, shmdt_syscall, shmget_syscall, stat_syscall,
+    statfs_syscall, sync_file_range_syscall, truncate_syscall, unlink_syscall, unlinkat_syscall,
+    write_syscall, writev_syscall,
 };
 use super::init::RawCallFunc;
 use super::net_calls::{
@@ -150,6 +150,8 @@ pub const SYSCALL_TABLE: &[(u64, RawCallFunc)] = &[
         sync_file_range_syscall,
     ),
     (syscall_const::ACCEPT4_SYSCALL as u64, accept4_syscall),
+    (syscall_const::PREADV_SYSCALL as u64, preadv_syscall),
+    (syscall_const::PWRITEV_SYSCALL as u64, pwritev_syscall),
     (
         syscall_const::EPOLL_CREATE1_SYSCALL as u64,
         epoll_create1_syscall,

src/sysdefs/src/constants/syscall_const.rs

@@ -97,6 +97,8 @@ pub const UNLINKAT_SYSCALL: i32 = 263;
 pub const READLINKAT_SYSCALL: i32 = 267;
 pub const SYNC_FILE_RANGE_SYSCALL: i32 = 277;
 pub const ACCEPT4_SYSCALL: i32 = 288;
+pub const PREADV_SYSCALL: i32 = 295;
+pub const PWRITEV_SYSCALL: i32 = 296;
 pub const PRLIMIT64_SYSCALL: i32 = 302;
 pub const EPOLL_CREATE1_SYSCALL: i32 = 291;
 pub const DUP3_SYSCALL: i32 = 292;

tests/unit-tests/file_tests/deterministic/preadv_pwritev.c

@@ -0,0 +1,67 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/uio.h>
+
+int main(void) {
+    const char *path = "testfiles/preadv_pwritev_test.txt";
+    int fd = open(path, O_CREAT | O_RDWR | O_TRUNC, 0644);
+    assert(fd >= 0);
+
+    /* pwritev: write two buffers at offset 0 */
+    char buf1[] = "hello ";
+    char buf2[] = "world";
+    struct iovec wv[2];
+    wv[0].iov_base = buf1;
+    wv[0].iov_len = strlen(buf1);
+    wv[1].iov_base = buf2;
+    wv[1].iov_len = strlen(buf2);
+
+    ssize_t nw = pwritev(fd, wv, 2, 0);
+    assert(nw == (ssize_t)(strlen(buf1) + strlen(buf2)));
+
+    /* preadv: read back into two buffers at offset 0 */
+    char rbuf1[6] = {0};
+    char rbuf2[5] = {0};
+    struct iovec rv[2];
+    rv[0].iov_base = rbuf1;
+    rv[0].iov_len = sizeof(rbuf1);
+    rv[1].iov_base = rbuf2;
+    rv[1].iov_len = sizeof(rbuf2);
+
+    ssize_t nr = preadv(fd, rv, 2, 0);
+    assert(nr == 11);
+    assert(memcmp(rbuf1, "hello ", 6) == 0);
+    assert(memcmp(rbuf2, "world", 5) == 0);
+
+    /* pwritev at non-zero offset */
+    char buf3[] = "LIND";
+    struct iovec wv2;
+    wv2.iov_base = buf3;
+    wv2.iov_len = strlen(buf3);
+
+    nw = pwritev(fd, &wv2, 1, 6);
+    assert(nw == 4);
+
+    /* verify file pointer unchanged by preadv/pwritev */
+    off_t pos = lseek(fd, 0, SEEK_CUR);
+    assert(pos == 0);
+
+    /* read full contents to verify */
+    char full[12] = {0};
+    struct iovec fv;
+    fv.iov_base = full;
+    fv.iov_len = 11;
+    nr = preadv(fd, &fv, 1, 0);
+    assert(nr == 11);
+    assert(memcmp(full, "hello LINDd", 11) == 0);
+
+    close(fd);
+    unlink(path);
+    printf("preadv_pwritev: all tests passed\n");
+    return 0;
+}