[common,guest,host] refactor PEB-related structs

- InputData, OutputData, and GuestHeapData were functionally the same and so they were combined into a single
GuestMemoryRegion struct.
- removed the allow_non_snake_case attribute.
- general housekeeping.

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

Author: danbugs

src/hyperlight_common/src/mem.rs

@@ -14,50 +14,38 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-#![allow(non_snake_case)]
-
 pub const PAGE_SHIFT: u64 = 12;
 pub const PAGE_SIZE: u64 = 1 << 12;
 pub const PAGE_SIZE_USIZE: usize = 1 << 12;
 
+/// A memory region in the guest address space
 #[derive(Debug, Clone, Copy)]
 #[repr(C)]
-pub struct InputData {
-    pub inputDataSize: u64,
-    pub inputDataBuffer: u64,
-}
-
-#[derive(Debug, Clone, Copy)]
-#[repr(C)]
-pub struct OutputData {
-    pub outputDataSize: u64,
-    pub outputDataBuffer: u64,
-}
-
-#[derive(Debug, Clone, Copy)]
-#[repr(C)]
-pub struct GuestHeapData {
-    pub guestHeapSize: u64,
-    pub guestHeapBuffer: u64,
+pub struct GuestMemoryRegion {
+    /// The size of the memory region
+    pub size: u64,
+    /// The address of the memory region
+    pub ptr: u64,
 }
 
+/// A memory region in the guest address space that is used for the stack
 #[derive(Debug, Clone, Copy)]
 #[repr(C)]
-pub struct GuestStackData {
-    /// This is the top of the user stack
-    pub minUserStackAddress: u64,
-    /// This is the user stack pointer
-    pub userStackAddress: u64,
+pub struct GuestStack {
+    /// The top of the user stack
+    pub min_user_stack_address: u64,
+    /// The user stack pointer
+    pub user_stack_address: u64,
 }
 
 #[derive(Debug, Clone, Copy)]
 #[repr(C)]
 pub struct HyperlightPEB {
     pub security_cookie_seed: u64,
     pub guest_function_dispatch_ptr: u64,
-    pub pCode: u64,
-    pub inputdata: InputData,
-    pub outputdata: OutputData,
-    pub guestheapData: GuestHeapData,
-    pub gueststackData: GuestStackData,
+    pub code_ptr: u64,
+    pub input_stack: GuestMemoryRegion,
+    pub output_stack: GuestMemoryRegion,
+    pub guest_heap: GuestMemoryRegion,
+    pub guest_stack: GuestStack,
 }

src/hyperlight_guest/src/entrypoint.rs

@@ -98,7 +98,7 @@ pub extern "C" fn entrypoint(peb_address: u64, seed: u64, ops: u64, max_log_leve
             // This static is to make it easier to implement the __chkstk function in assembly.
             // It also means that should we change the layout of the struct in the future, we
             // don't have to change the assembly code.
-            MIN_STACK_ADDRESS = (*peb_ptr).gueststackData.minUserStackAddress;
+            MIN_STACK_ADDRESS = (*peb_ptr).guest_stack.min_user_stack_address;
 
             #[cfg(target_arch = "x86_64")]
             {
@@ -107,8 +107,8 @@ pub extern "C" fn entrypoint(peb_address: u64, seed: u64, ops: u64, max_log_leve
                 load_idt();
             }
 
-            let heap_start = (*peb_ptr).guestheapData.guestHeapBuffer as usize;
-            let heap_size = (*peb_ptr).guestheapData.guestHeapSize as usize;
+            let heap_start = (*peb_ptr).guest_heap.ptr as usize;
+            let heap_size = (*peb_ptr).guest_heap.size as usize;
             HEAP_ALLOCATOR
                 .try_lock()
                 .expect("Failed to access HEAP_ALLOCATOR")

src/hyperlight_guest/src/shared_input_data.rs

@@ -30,14 +30,10 @@ where
     T: for<'a> TryFrom<&'a [u8]>,
 {
     let peb_ptr = unsafe { P_PEB.unwrap() };
-    let shared_buffer_size = unsafe { (*peb_ptr).inputdata.inputDataSize as usize };
+    let shared_buffer_size = unsafe { (*peb_ptr).input_stack.size as usize };
 
-    let idb = unsafe {
-        from_raw_parts_mut(
-            (*peb_ptr).inputdata.inputDataBuffer as *mut u8,
-            shared_buffer_size,
-        )
-    };
+    let idb =
+        unsafe { from_raw_parts_mut((*peb_ptr).input_stack.ptr as *mut u8, shared_buffer_size) };
 
     if idb.is_empty() {
         return Err(HyperlightGuestError::new(

src/hyperlight_guest/src/shared_output_data.rs

@@ -26,13 +26,9 @@ use crate::P_PEB;
 
 pub fn push_shared_output_data(data: Vec<u8>) -> Result<()> {
     let peb_ptr = unsafe { P_PEB.unwrap() };
-    let shared_buffer_size = unsafe { (*peb_ptr).outputdata.outputDataSize as usize };
-    let odb = unsafe {
-        from_raw_parts_mut(
-            (*peb_ptr).outputdata.outputDataBuffer as *mut u8,
-            shared_buffer_size,
-        )
-    };
+    let shared_buffer_size = unsafe { (*peb_ptr).output_stack.size as usize };
+    let odb =
+        unsafe { from_raw_parts_mut((*peb_ptr).output_stack.ptr as *mut u8, shared_buffer_size) };
 
     if odb.is_empty() {
         return Err(HyperlightGuestError::new(

src/hyperlight_host/src/mem/layout.rs

@@ -16,7 +16,7 @@ limitations under the License.
 use std::fmt::Debug;
 use std::mem::{offset_of, size_of};
 
-use hyperlight_common::mem::{GuestStackData, HyperlightPEB, PAGE_SIZE_USIZE};
+use hyperlight_common::mem::{GuestStack, HyperlightPEB, PAGE_SIZE_USIZE};
 use rand::{rng, RngCore};
 use tracing::{instrument, Span};
 
@@ -225,17 +225,17 @@ impl SandboxMemoryLayout {
             peb_offset + offset_of!(HyperlightPEB, security_cookie_seed);
         let peb_guest_dispatch_function_ptr_offset =
             peb_offset + offset_of!(HyperlightPEB, guest_function_dispatch_ptr);
-        let peb_code_pointer_offset = peb_offset + offset_of!(HyperlightPEB, pCode);
-        let peb_input_data_offset = peb_offset + offset_of!(HyperlightPEB, inputdata);
-        let peb_output_data_offset = peb_offset + offset_of!(HyperlightPEB, outputdata);
-        let peb_heap_data_offset = peb_offset + offset_of!(HyperlightPEB, guestheapData);
-        let peb_guest_stack_data_offset = peb_offset + offset_of!(HyperlightPEB, gueststackData);
+        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_heap_data_offset = peb_offset + offset_of!(HyperlightPEB, guest_heap);
+        let peb_guest_stack_data_offset = peb_offset + offset_of!(HyperlightPEB, guest_stack);
 
         // The following offsets are the actual values that relate to memory layout,
         // which are written to PEB struct
         let peb_address = Self::BASE_ADDRESS + peb_offset;
         let input_data_buffer_offset = round_up_to(
-            peb_guest_stack_data_offset + size_of::<GuestStackData>(),
+            peb_guest_stack_data_offset + size_of::<GuestStack>(),
             PAGE_SIZE_USIZE,
         );
         let output_data_buffer_offset = round_up_to(
@@ -332,15 +332,15 @@ impl SandboxMemoryLayout {
     /// Get the offset in guest memory to the input data size.
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     pub(super) fn get_input_data_size_offset(&self) -> usize {
-        // The input data size is the first field in the `InputData` struct
+        // The input data size is the first field in the input stack's `GuestMemoryRegion` struct
         self.peb_input_data_offset
     }
 
     /// Get the offset in guest memory to the input data pointer.
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn get_input_data_pointer_offset(&self) -> usize {
         // The input data pointer is immediately after the input
-        // data size field in the `InputData` struct which is a `u64`.
+        // data size field in the input data `GuestMemoryRegion` struct which is a `u64`.
         self.get_input_data_size_offset() + size_of::<u64>()
     }
 
@@ -375,7 +375,7 @@ impl SandboxMemoryLayout {
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn get_heap_pointer_offset(&self) -> usize {
         // The heap pointer is immediately after the
-        // heap size field in the `GuestHeap` struct which is a `u64`.
+        // heap size field in the guest heap's `GuestMemoryRegion` struct which is a `u64`.
         self.get_heap_size_offset() + size_of::<u64>()
     }