Provide read_buf and vectored read/write for SGX stdio

Author: thaliaarchi

library/std/src/sys/pal/sgx/abi/usercalls/alloc.rs

@@ -6,7 +6,7 @@ use super::super::mem::{is_enclave_range, is_user_range};
 use crate::arch::asm;
 use crate::cell::UnsafeCell;
 use crate::convert::TryInto;
-use crate::mem::{self, ManuallyDrop};
+use crate::mem::{self, ManuallyDrop, MaybeUninit};
 use crate::ops::{CoerceUnsized, Deref, DerefMut, Index, IndexMut};
 use crate::pin::PinCoerceUnsized;
 use crate::ptr::{self, NonNull};
@@ -651,13 +651,29 @@ where
     /// the source. This can happen for dynamically-sized types such as slices.
     pub fn copy_to_enclave_vec(&self, dest: &mut Vec<T>) {
         if let Some(missing) = self.len().checked_sub(dest.capacity()) {
-            dest.reserve(missing)
+            dest.reserve(missing);
         }
         // SAFETY: We reserve enough space above.
         unsafe { dest.set_len(self.len()) };
         self.copy_to_enclave(&mut dest[..]);
     }
 
+    /// Copies the value from user memory and place it into `dest`.
+    ///
+    /// # Panics
+    /// This function panics if the destination doesn't have the same length as
+    /// the source.
+    pub fn copy_to_enclave_uninit(&self, dest: &mut [MaybeUninit<T>]) {
+        unsafe {
+            assert_eq!(self.len(), dest.len());
+            copy_from_userspace(
+                self.0.get() as *const [T] as *const u8,
+                dest.as_mut_ptr() as *mut u8,
+                mem::size_of_val(dest),
+            );
+        }
+    }
+
     /// Copies the value from user memory into a vector in enclave memory.
     pub fn to_enclave(&self) -> Vec<T> {
         let mut ret = Vec::with_capacity(self.len());

library/std/src/sys/pal/sgx/abi/usercalls/mod.rs

@@ -1,5 +1,6 @@
 use crate::cmp;
 use crate::io::{Error as IoError, ErrorKind, IoSlice, IoSliceMut, Result as IoResult};
+use crate::mem::MaybeUninit;
 use crate::random::{DefaultRandomSource, Random};
 use crate::time::{Duration, Instant};
 
@@ -12,11 +13,35 @@ mod tests;
 use self::raw::*;
 
 /// Usercall `read`. See the ABI documentation for more information.
+#[unstable(feature = "sgx_platform", issue = "56975")]
+pub fn read(fd: Fd, buf: &mut [u8]) -> IoResult<usize> {
+    unsafe {
+        let mut userbuf = alloc::User::<[u8]>::uninitialized(buf.len());
+        let len = raw::read(fd, userbuf.as_mut_ptr(), userbuf.len()).from_sgx_result()?;
+        userbuf[..len].copy_to_enclave(&mut buf[..len]);
+        Ok(len)
+    }
+}
+
+/// Usercall `read` with an uninitialized buffer. See the ABI documentation for
+/// more information.
+#[unstable(feature = "sgx_platform", issue = "56975")]
+pub fn read_uninit(fd: Fd, buf: &mut [MaybeUninit<u8>]) -> IoResult<usize> {
+    unsafe {
+        let mut userbuf = alloc::User::<[u8]>::uninitialized(buf.len());
+        let len = raw::read(fd, userbuf.as_mut_ptr().cast(), userbuf.len()).from_sgx_result()?;
+        userbuf[..len].copy_to_enclave_uninit(&mut buf[..len]);
+        Ok(len)
+    }
+}
+
+/// Usercall `read` with a slice of buffers. See the ABI documentation for more
+/// information.
 ///
 /// This will do a single `read` usercall and scatter the read data among
-/// `bufs`. To read to a single buffer, just pass a slice of length one.
+/// `bufs`.
 #[unstable(feature = "sgx_platform", issue = "56975")]
-pub fn read(fd: Fd, bufs: &mut [IoSliceMut<'_>]) -> IoResult<usize> {
+pub fn read_vectored(fd: Fd, bufs: &mut [IoSliceMut<'_>]) -> IoResult<usize> {
     unsafe {
         let total_len = bufs.iter().fold(0usize, |sum, buf| sum.saturating_add(buf.len()));
         let mut userbuf = alloc::User::<[u8]>::uninitialized(total_len);
@@ -48,11 +73,21 @@ pub fn read_alloc(fd: Fd) -> IoResult<Vec<u8>> {
 }
 
 /// Usercall `write`. See the ABI documentation for more information.
+#[unstable(feature = "sgx_platform", issue = "56975")]
+pub fn write(fd: Fd, buf: &[u8]) -> IoResult<usize> {
+    unsafe {
+        let userbuf = alloc::User::new_from_enclave(buf);
+        raw::write(fd, userbuf.as_ptr(), userbuf.len()).from_sgx_result()
+    }
+}
+
+/// Usercall `write` with a slice of buffers. See the ABI documentation for more
+/// information.
 ///
 /// This will do a single `write` usercall and gather the written data from
-/// `bufs`. To write from a single buffer, just pass a slice of length one.
+/// `bufs`.
 #[unstable(feature = "sgx_platform", issue = "56975")]
-pub fn write(fd: Fd, bufs: &[IoSlice<'_>]) -> IoResult<usize> {
+pub fn write_vectored(fd: Fd, bufs: &[IoSlice<'_>]) -> IoResult<usize> {
     unsafe {
         let total_len = bufs.iter().fold(0usize, |sum, buf| sum.saturating_add(buf.len()));
         let mut userbuf = alloc::User::<[u8]>::uninitialized(total_len);

library/std/src/sys/pal/sgx/fd.rs

@@ -25,15 +25,19 @@ impl FileDesc {
     }
 
     pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
-        usercalls::read(self.fd, &mut [IoSliceMut::new(buf)])
+        usercalls::read(self.fd, buf)
     }
 
-    pub fn read_buf(&self, buf: BorrowedCursor<'_>) -> io::Result<()> {
-        crate::io::default_read_buf(|b| self.read(b), buf)
+    pub fn read_buf(&self, mut buf: BorrowedCursor<'_>) -> io::Result<()> {
+        unsafe {
+            let len = usercalls::read_uninit(self.fd, buf.as_mut())?;
+            buf.advance_unchecked(len);
+            Ok(())
+        }
     }
 
     pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
-        usercalls::read(self.fd, bufs)
+        usercalls::read_vectored(self.fd, bufs)
     }
 
     #[inline]
@@ -42,11 +46,11 @@ impl FileDesc {
     }
 
     pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
-        usercalls::write(self.fd, &[IoSlice::new(buf)])
+        usercalls::write(self.fd, buf)
     }
 
     pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        usercalls::write(self.fd, bufs)
+        usercalls::write_vectored(self.fd, bufs)
     }
 
     #[inline]

library/std/src/sys/pal/sgx/stdio.rs

@@ -1,6 +1,6 @@
 use fortanix_sgx_abi as abi;
 
-use crate::io;
+use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut};
 #[cfg(not(test))]
 use crate::slice;
 #[cfg(not(test))]
@@ -28,6 +28,19 @@ impl io::Read for Stdin {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         with_std_fd(abi::FD_STDIN, |fd| fd.read(buf))
     }
+
+    fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> io::Result<()> {
+        with_std_fd(abi::FD_STDIN, |fd| fd.read_buf(buf))
+    }
+
+    fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
+        with_std_fd(abi::FD_STDIN, |fd| fd.read_vectored(bufs))
+    }
+
+    #[inline]
+    fn is_read_vectored(&self) -> bool {
+        true
+    }
 }
 
 impl Stdout {
@@ -44,6 +57,15 @@ impl io::Write for Stdout {
     fn flush(&mut self) -> io::Result<()> {
         with_std_fd(abi::FD_STDOUT, |fd| fd.flush())
     }
+
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        with_std_fd(abi::FD_STDOUT, |fd| fd.write_vectored(bufs))
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
 }
 
 impl Stderr {
@@ -60,6 +82,15 @@ impl io::Write for Stderr {
     fn flush(&mut self) -> io::Result<()> {
         with_std_fd(abi::FD_STDERR, |fd| fd.flush())
     }
+
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        with_std_fd(abi::FD_STDERR, |fd| fd.write_vectored(bufs))
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
 }
 
 pub const STDIN_BUF_SIZE: usize = crate::sys::io::DEFAULT_BUF_SIZE;