[common,host/mem] added user memory offset to PEB

W/ this, now the guest can access that memory region.

Signed-off-by: danbugs <[email protected]>

Author: danbugs

src/hyperlight_common/src/mem.rs

@@ -46,6 +46,7 @@ pub struct HyperlightPEB {
     pub code_ptr: u64,
     pub input_stack: GuestMemoryRegion,
     pub output_stack: GuestMemoryRegion,
+    pub init_data: GuestMemoryRegion,
     pub guest_heap: GuestMemoryRegion,
     pub guest_stack: GuestStack,
     pub host_function_definitions: GuestMemoryRegion,

src/hyperlight_guest/src/guest_handle/host_comm.rs

@@ -34,6 +34,29 @@ use crate::error::{HyperlightGuestError, Result};
 use crate::exit::out32;
 
 impl GuestHandle {
+    /// Get user memory region as bytes.
+    pub fn read_n_bytes_from_user_memory(&self, num: u64) -> Result<Vec<u8>> {
+        let peb_ptr = self.peb().unwrap();
+        let user_memory_region_ptr = unsafe { (*peb_ptr).init_data.ptr as *mut u8 };
+        let user_memory_region_size = unsafe { (*peb_ptr).init_data.size };
+
+        if num > user_memory_region_size {
+            return Err(HyperlightGuestError::new(
+                ErrorCode::GuestError,
+                format!(
+                    "Requested {} bytes from user memory, but only {} bytes are available",
+                    num, user_memory_region_size
+                ),
+            ));
+        } else {
+            let user_memory_region_slice =
+                unsafe { core::slice::from_raw_parts(user_memory_region_ptr, num as usize) };
+            let user_memory_region_bytes = user_memory_region_slice.to_vec();
+
+            Ok(user_memory_region_bytes)
+        }
+    }
+
     /// Get a return value from a host function call.
     /// This usually requires a host function to be called first using
     /// `call_host_function_internal`.

src/hyperlight_host/src/mem/layout.rs

@@ -100,6 +100,7 @@ pub(crate) struct SandboxMemoryLayout {
     pub(super) peb_host_function_definitions_offset: usize,
     peb_input_data_offset: usize,
     peb_output_data_offset: usize,
+    peb_init_data_offset: usize,
     peb_heap_data_offset: usize,
     peb_guest_stack_data_offset: usize,
 
@@ -163,6 +164,10 @@ impl Debug for SandboxMemoryLayout {
                 "Output Data Offset",
                 &format_args!("{:#x}", self.peb_output_data_offset),
             )
+            .field(
+                "Init Data Offset",
+                &format_args!("{:#x}", self.peb_init_data_offset),
+            )
             .field(
                 "Guest Heap Offset",
                 &format_args!("{:#x}", self.peb_heap_data_offset),
@@ -264,6 +269,7 @@ impl SandboxMemoryLayout {
         let peb_code_pointer_offset = peb_offset + offset_of!(HyperlightPEB, code_ptr);
         let peb_input_data_offset = peb_offset + offset_of!(HyperlightPEB, input_stack);
         let peb_output_data_offset = peb_offset + offset_of!(HyperlightPEB, output_stack);
+        let peb_init_data_offset = peb_offset + offset_of!(HyperlightPEB, init_data);
         let peb_heap_data_offset = peb_offset + offset_of!(HyperlightPEB, guest_heap);
         let peb_guest_stack_data_offset = peb_offset + offset_of!(HyperlightPEB, guest_stack);
         let peb_host_function_definitions_offset =
@@ -307,6 +313,7 @@ impl SandboxMemoryLayout {
             peb_host_function_definitions_offset,
             peb_input_data_offset,
             peb_output_data_offset,
+            peb_init_data_offset,
             peb_heap_data_offset,
             peb_guest_stack_data_offset,
             sandbox_memory_config: cfg,
@@ -349,6 +356,13 @@ impl SandboxMemoryLayout {
         self.peb_host_function_definitions_offset + size_of::<u64>()
     }
 
+    /// Get the offset in guest memory to the init data size
+    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
+    pub(super) fn get_init_data_size_offset(&self) -> usize {
+        // The init data size is the first field in the `GuestMemoryRegion` struct
+        self.peb_init_data_offset
+    }
+
     /// Get the offset in guest memory to the minimum guest stack address.
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn get_min_guest_stack_address_offset(&self) -> usize {
@@ -385,6 +399,14 @@ impl SandboxMemoryLayout {
         self.get_output_data_size_offset() + size_of::<u64>()
     }
 
+    /// Get the offset in guest memory to the init data pointer.
+    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
+    pub(super) fn get_init_data_pointer_offset(&self) -> usize {
+        // The init data pointer is immediately after the init data size field,
+        // which is a `u64`.
+        self.get_init_data_size_offset() + size_of::<u64>()
+    }
+
     /// Get the offset in guest memory to the start of output data.
     ///
     /// This function exists to accommodate the macro that generates C API
@@ -820,6 +842,14 @@ impl SandboxMemoryLayout {
         let addr = get_address!(output_data_buffer_offset);
         shared_mem.write_u64(self.get_output_data_pointer_offset(), addr)?;
 
+        // Set up init data pointer
+        shared_mem.write_u64(
+            self.get_init_data_size_offset(),
+            (self.get_unaligned_memory_size() - self.init_data_offset).try_into()?,
+        )?;
+        let addr = get_address!(init_data_offset);
+        shared_mem.write_u64(self.get_init_data_pointer_offset(), addr)?;
+
         // Set up heap buffer pointer
         let addr = get_address!(guest_heap_buffer_offset);
         shared_mem.write_u64(self.get_heap_size_offset(), self.heap_size.try_into()?)?;