[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 user_memory: GuestMemoryRegion,
     pub guest_heap: GuestMemoryRegion,
     pub guest_stack: GuestStack,
 }

src/hyperlight_host/src/mem/layout.rs

@@ -87,6 +87,7 @@ pub(crate) struct SandboxMemoryLayout {
     peb_code_pointer_offset: usize,
     peb_input_data_offset: usize,
     peb_output_data_offset: usize,
+    peb_user_memory_offset: usize,
     peb_heap_data_offset: usize,
     peb_guest_stack_data_offset: usize,
 
@@ -140,6 +141,10 @@ impl Debug for SandboxMemoryLayout {
                 "Output Data Offset",
                 &format_args!("{:#x}", self.peb_output_data_offset),
             )
+            .field(
+                "User Memory Offset",
+                &format_args!("{:#x}", self.peb_user_memory_offset),
+            )
             .field(
                 "Guest Heap Offset",
                 &format_args!("{:#x}", self.peb_heap_data_offset),
@@ -235,6 +240,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_user_memory_offset = peb_offset + offset_of!(HyperlightPEB, user_memory);
         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);
 
@@ -270,6 +276,7 @@ impl SandboxMemoryLayout {
             peb_code_pointer_offset,
             peb_input_data_offset,
             peb_output_data_offset,
+            peb_user_memory_offset,
             peb_heap_data_offset,
             peb_guest_stack_data_offset,
             sandbox_memory_config: cfg,
@@ -293,6 +300,13 @@ impl SandboxMemoryLayout {
         self.peb_output_data_offset
     }
 
+    /// Get the offset in guest memory to the user memory size
+    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
+    pub(super) fn get_user_memory_size_offset(&self) -> usize {
+        // The user memory size is the first field in the `GuestMemoryRegion` struct
+        self.peb_user_memory_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 {
@@ -329,6 +343,14 @@ impl SandboxMemoryLayout {
         self.get_output_data_size_offset() + size_of::<u64>()
     }
 
+    /// Get the offset in guest memory to the user memory pointer.
+    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
+    pub(super) fn get_user_memory_pointer_offset(&self) -> usize {
+        // The user memory pointer is immediately after the user memory size field,
+        // which is a `u64`.
+        self.get_user_memory_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
@@ -745,6 +767,14 @@ impl SandboxMemoryLayout {
         let addr = get_address!(output_data_buffer_offset);
         shared_mem.write_u64(self.get_output_data_pointer_offset(), addr)?;
 
+        // Set up user memory pointer
+        shared_mem.write_u64(
+            self.get_user_memory_size_offset(),
+            (self.get_unaligned_memory_size() - self.user_memory_offset).try_into()?,
+        )?;
+        let addr = get_address!(user_memory_offset);
+        shared_mem.write_u64(self.get_user_memory_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()?)?;