Merge pull request #189 from Freax13/enhancement/smaller-future

reduce size of syscall handler future

Author: Freax13

tee/kernel/src/fs/fd.rs

@@ -74,7 +74,8 @@ pub mod timer;
 pub mod unix_socket;
 
 pub use self::buf::{
-    KernelReadBuf, KernelWriteBuf, OffsetBuf, ReadBuf, UserBuf, VectoredUserBuf, WriteBuf,
+    KernelPageWriteBuf, KernelReadBuf, KernelWriteBuf, OffsetBuf, ReadBuf, UserBuf,
+    VectoredUserBuf, WriteBuf,
 };
 
 pub struct OpenFileDescriptionData<T: ?Sized> {

tee/kernel/src/fs/fd/buf.rs

@@ -6,6 +6,7 @@ use x86_64::VirtAddr;
 
 use crate::{
     error::Result,
+    memory::page::KernelPage,
     user::{
         memory::VirtualMemory,
         syscall::{
@@ -372,3 +373,33 @@ where
         unsafe { self.buffer.read_volatile(offset + self.offset, bytes) }
     }
 }
+
+pub struct KernelPageWriteBuf<'a> {
+    page: &'a KernelPage,
+    offset: usize,
+    len: usize,
+}
+
+impl<'a> KernelPageWriteBuf<'a> {
+    pub fn new(page: &'a KernelPage, offset: usize, len: usize) -> Self {
+        Self { page, offset, len }
+    }
+}
+
+impl WriteBuf for KernelPageWriteBuf<'_> {
+    fn buffer_len(&self) -> usize {
+        self.len
+    }
+
+    fn read(&self, offset: usize, bytes: &mut [u8]) -> Result<()> {
+        self.page.read(self.offset + offset, bytes);
+        Ok(())
+    }
+
+    unsafe fn read_volatile(&self, offset: usize, bytes: NonNull<[u8]>) -> Result<()> {
+        unsafe {
+            self.page.read_volatile(self.offset + offset, bytes);
+        }
+        Ok(())
+    }
+}

tee/kernel/src/memory/page/kernel.rs

@@ -169,13 +169,23 @@ impl KernelPage {
     }
 
     pub fn read(&self, index: usize, buf: &mut [u8]) {
-        let ptr = self.index(index..index + buf.len());
-        unsafe {
-            core::intrinsics::volatile_copy_nonoverlapping_memory(
-                buf.as_mut_ptr(),
-                ptr.as_ptr().cast(),
-                buf.len(),
-            );
+        unsafe { self.read_volatile(index, NonNull::from_mut(buf)) }
+    }
+
+    pub unsafe fn read_volatile(&self, index: usize, buf: NonNull<[u8]>) {
+        if self.is_zero_page() {
+            unsafe {
+                core::intrinsics::volatile_set_memory(buf.as_mut_ptr(), 0, buf.len());
+            }
+        } else {
+            let ptr = self.index(index..index + buf.len());
+            unsafe {
+                core::intrinsics::volatile_copy_nonoverlapping_memory(
+                    buf.as_mut_ptr(),
+                    ptr.as_ptr().cast(),
+                    buf.len(),
+                );
+            }
         }
     }
 

tee/kernel/src/user/syscall.rs

@@ -30,7 +30,7 @@ use crate::{
     fs::{
         StatFs,
         fd::{
-            Events, FdFlags, FileDescriptorTable, KernelWriteBuf, OffsetBuf, ReadBuf,
+            Events, FdFlags, FileDescriptorTable, KernelPageWriteBuf, OffsetBuf, ReadBuf,
             StrongFileDescriptor, UnixLock, UnixLockOwner, UnixLockType, UserBuf, VectoredUserBuf,
             WriteBuf, do_io, do_write_io,
             epoll::Epoll,
@@ -1327,23 +1327,16 @@ async fn sendfile(
     let stat = r#in.stat()?;
     let count = cmp::min(count, (stat.size as usize).saturating_sub(offset_value));
 
-    let mut buffer = [0; 0x1000];
     let mut total_len = 0;
     while total_len < count {
         let page_offset = offset_value / 0x1000;
         let offset_in_page = offset_value % 0x1000;
         let chunk_len = cmp::min(0x1000 - offset_in_page, count - total_len);
 
-        let buffer = &mut buffer[offset_in_page..];
-        let buffer = &mut buffer[..chunk_len];
-
         let page = r#in.get_page(page_offset, false)?;
-        page.read(offset_in_page, buffer);
+        let buf = KernelPageWriteBuf::new(&page, offset_in_page, chunk_len);
 
-        let res = do_write_io(&**r#in, buffer.len(), || {
-            out.write(&KernelWriteBuf::new(buffer))
-        })
-        .await;
+        let res = do_write_io(&**r#in, chunk_len, || out.write(&buf)).await;
         match res {
             Ok(0) => break,
             Ok(n) => {

tee/kernel/src/user/syscall/traits.rs

@@ -133,6 +133,11 @@ impl SyscallHandlers {
             self.future_size = return_size;
         }
 
+        // Make sure that the future is not too big. There's no technical
+        // reason why large futures can't work, but we should avoid them if
+        // possible.
+        assert!(return_size < 2048, "future is very big");
+
         /// Returns the alignment of the return type of `T::execute`.
         const fn return_align<'a, T>(
             _: fn(thread: &'a Arc<Thread>, syscall_args: SyscallArgs) -> T,