tmp (x6)

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

Author: danbugs

Diff for: src/hyperlight_common/src/flatbuffer_wrappers/hyperlight_peb.rs

@@ -141,37 +141,39 @@ impl HyperlightPEB {
         );
     }
 
-    // TODO(danbugs:297): comment
+    // Sets the guest error data region, where the guest can write errors to.
     pub fn set_guest_error_data_region(&mut self, ptr: u64, size: u64) {
         self.guest_error_data_ptr = self.guest_memory_base_address + ptr;
         self.guest_error_data_size = size;
     }
 
-    // TODO(danbugs:297): comment
+    // Sets the host error data region, where the host can write errors to.
     pub fn set_host_error_data_region(&mut self, ptr: u64, size: u64) {
         self.host_error_data_ptr = self.guest_memory_base_address + ptr;
         self.host_error_data_size = size;
     }
 
-    // TODO(danbugs:297): comment
+    // Sets the input data region, where the host can write things like function calls to.
     pub fn set_input_data_region(&mut self, ptr: u64, size: u64) {
         self.input_data_ptr = self.guest_memory_base_address + ptr;
         self.input_data_size = size;
     }
 
-    // TODO(danbugs:297): comment
+    // Sets the output data region, where the guest can write things like function return values to.
     pub fn set_output_data_region(&mut self, ptr: u64, size: u64) {
         self.output_data_ptr = self.guest_memory_base_address + ptr;
         self.output_data_size = size;
     }
 
-    // TODO(danbugs:297): comment
+    // Sets the guest panic context region, where the guest can write panic context data to.
     pub fn set_guest_panic_context_region(&mut self, ptr: u64, size: u64) {
         self.guest_panic_context_ptr = self.guest_memory_base_address + ptr;
         self.guest_panic_context_size = size;
     }
 
-    // TODO(danbugs:297): comment
+    // Gets the guest heap size. If not set, this function panics—this is because the host is always
+    // expected to set the size of the heap data region in accordance to info from the guest binary,
+    // so, if this is not set, we have a critical error.
     pub fn get_guest_heap_data_size(&self) -> u64 {
         if self.guest_heap_data_size == 0 {
             panic!("Heap data size is not set");
@@ -180,7 +182,7 @@ impl HyperlightPEB {
         self.guest_heap_data_size
     }
 
-    // TODO(danbugs:297): comment
+    // Sets the guest heap data region.
     pub fn set_guest_heap_data_region(&mut self, ptr: u64, size_override: Option<u64>) {
         self.guest_heap_data_ptr = self.guest_memory_base_address + ptr;
         // the Hyperlight host always sets the heap data size to a default value, the
@@ -196,7 +198,9 @@ impl HyperlightPEB {
         }
     }
 
-    // TODO(danbugs:297): comment
+    // Gets the guest heap size. If not set, this function panics—this is because the host is always
+    // expected to set the size of the heap data region in accordance to info from the guest binary,
+    // so, if this is not set, we have a critical error.
     pub fn get_guest_stack_data_size(&self) -> u64 {
         if self.guest_stack_data_size == 0 {
             panic!("Stack data size is not set");
@@ -205,7 +209,7 @@ impl HyperlightPEB {
         self.guest_stack_data_size
     }
 
-    // TODO(danbugs:297): comment
+    // Sets the guest stack data region.
     pub fn set_guest_stack_data_region(&mut self, ptr: u64, size_override: Option<u64>) {
         self.guest_stack_data_ptr = self.guest_memory_base_address + ptr;
 
@@ -222,14 +226,19 @@ impl HyperlightPEB {
         }
     }
 
-    // TODO(danbugs:297): comment
+    // Sets the host function details region, where the guest can write host function details to.
     pub fn set_host_function_details_region(&mut self, ptr: u64, size: u64) {
         self.host_function_details_ptr = self.guest_memory_base_address + ptr;
         self.host_function_details_size = size;
     }
 
-    // TODO(danbugs:297): comment
+    // Gets the input data region, where the host can write things like function calls to.
     pub fn get_input_data_region(&self) -> (u64, u64) {
         (self.input_data_ptr, self.input_data_size)
     }
+
+    // Gets the output data region, where the guest can write things like function return values to.
+    pub fn get_output_data_region(&self) -> (u64, u64) {
+        (self.output_data_ptr, self.output_data_size)
+    }
 }

Diff for: src/hyperlight_common/src/input_output/mod.rs

@@ -105,12 +105,16 @@ impl OutputDataSection {
         }
 
         // get offset to next free address on the stack
-        let stack_ptr_rel: usize = usize::from_le_bytes(
+        let mut stack_ptr_rel: usize = usize::from_le_bytes(
             output_data_buffer[..8]
                 .try_into()
                 .expect("Shared output buffer too small"),
         );
 
+        if stack_ptr_rel == 0 {
+            stack_ptr_rel = 8;
+        }
+
         // check if the stack pointer is within the bounds of the buffer.
         // It can be equal to the size, but never greater
         // It can never be less than 8. An empty buffer's stack pointer is 8
@@ -148,3 +152,15 @@ impl OutputDataSection {
         Ok(())
     }
 }
+
+impl From<(u64, u64)> for InputDataSection {
+    fn from((ptr, len): (u64, u64)) -> Self {
+        InputDataSection::new(ptr as *mut u8, len as usize)
+    }
+}
+
+impl From<(u64, u64)> for OutputDataSection {
+    fn from((ptr, len): (u64, u64)) -> Self {
+        OutputDataSection::new(ptr as *mut u8, len as usize)
+    }
+}

Diff for: src/hyperlight_guest/src/chkstk.rs

@@ -16,9 +16,7 @@ limitations under the License.
 
 use core::arch::global_asm;
 use core::mem::size_of;
-
-use hyperlight_common::mem::RunMode;
-
+use hyperlight_common::flatbuffer_wrappers::hyperlight_peb::RunMode;
 use crate::guest_error::{set_invalid_runmode_error, set_stack_allocate_error};
 use crate::{MIN_STACK_ADDRESS, RUNNING_MODE};
 

Diff for: src/hyperlight_guest/src/entrypoint.rs

@@ -14,55 +14,56 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 use core::arch::asm;
-
+use core::ffi::{c_char, CStr};
+use core::ptr::copy_nonoverlapping;
+use log::LevelFilter;
 use hyperlight_common::flatbuffer_wrappers::hyperlight_peb::{HyperlightPEB, RunMode};
 use spin::Once;
 
 use crate::guest_function_call::dispatch_function;
-use crate::{__security_cookie, HEAP_ALLOCATOR, PEB};
+use crate::{__security_cookie, HEAP_ALLOCATOR, MIN_STACK_ADDRESS, PEB, RUNNING_MODE};
+use crate::gdt::load_gdt;
+use crate::guest_error::reset_error;
+use crate::guest_logger::init_logger;
+use crate::host_function_call::{outb, OutBAction};
+use crate::idtr::load_idt;
 
 #[inline(never)]
 pub fn halt() {
     unsafe {
-        if let RunMode::Hypervisor = PEB.clone().unwrap().run_mode {
+        if RUNNING_MODE == RunMode::Hypervisor {
             asm!("hlt", options(nostack))
         }
     }
 }
 
-// TODO(danbugs:297): delete
 #[no_mangle]
-pub fn __chkstk() {}
+pub extern "C" fn abort() -> ! {
+    abort_with_code(0)
+}
 
-// TODO(danbugs:297): bring back
-// #[no_mangle]
-// pub extern "C" fn abort() -> ! {
-//     abort_with_code(0)
-// }
-//
-// pub fn abort_with_code(code: i32) -> ! {
-//     outb(OutBAction::Abort as u16, code as u8);
-//     unreachable!()
-// }
-//
-// /// Aborts the program with a code and a message.
-// ///
-// /// # Safety
-// /// This function is unsafe because it dereferences a raw pointer.
-// pub unsafe fn abort_with_code_and_message(code: i32, message_ptr: *const c_char) -> ! {
-//     let peb_ptr = PEB.unwrap();
-//     copy_nonoverlapping(
-//         message_ptr,
-//         (*peb_ptr).guestPanicContextData.guestPanicContextDataBuffer as *mut c_char,
-//         CStr::from_ptr(message_ptr).count_bytes() + 1, // +1 for null terminator
-//     );
-//     outb(OutBAction::Abort as u16, code as u8);
-//     unreachable!()
-// }
+pub fn abort_with_code(code: i32) -> ! {
+    outb(OutBAction::Abort as u16, code as u8);
+    unreachable!()
+}
+
+/// Aborts the program with a code and a message.
+///
+/// # Safety
+/// This function is unsafe because it dereferences a raw pointer.
+pub unsafe fn abort_with_code_and_message(code: i32, message_ptr: *const c_char) -> ! {
+    copy_nonoverlapping(
+        message_ptr,
+        (*PEB).guest_panic_context_ptr as *mut c_char,
+        CStr::from_ptr(message_ptr).count_bytes() + 1, // +1 for null terminator
+    );
+    outb(OutBAction::Abort as u16, code as u8);
+    unreachable!()
+}
 
 extern "C" {
     fn hyperlight_main();
-    //     fn srand(seed: u32);
+    fn srand(seed: u32);
 }
 
 static INIT: Once = Once::new();
@@ -71,25 +72,58 @@ static INIT: Once = Once::new();
 //       target without first having setup global `RUNNING_MODE` variable, which __chkstk relies on.
 #[no_mangle]
 pub extern "win64" fn entrypoint(
-    hyperlight_peb_ptr: u64,
-    _hyperlight_peb_size: u64,
+    peb_address: u64,
+    // TODO(danbugs:297): remove the extra arg
+    _: u64,
     seed: u64,
-    _max_log_level: u64,
+    max_log_level: u64,
 ) {
     INIT.call_once(|| unsafe {
-        let peb = hyperlight_peb_ptr as *mut HyperlightPEB;
+        PEB = peb_address as *mut HyperlightPEB;
+        RUNNING_MODE = (*PEB).clone().run_mode;
+
+        // The guest receives an undifferentiated block of memory that it can address as it sees fit.
+        // This 'addressing' is done by writing to the PEB the guest's memory layout via this function,
+        // or by directly altering the PEB. `set_default_memory_layout` will configure the PEB to
+        // with a memory layout that is compatible with the expectations of guests that use the
+        // `hyperlight_guest` library (e.g., simpleguest, and callbackguest).
+        (*PEB).set_default_memory_layout();
+
+        // The guest sets the address to a "guest function dispatch" function, which is a function
+        // that is called by the host to dispatch calls to guest functions.
+        (*PEB).guest_function_dispatch_ptr = dispatch_function as usize as u64;
 
+        // Set up the guest heap
         HEAP_ALLOCATOR
             .try_lock()
             .expect("Failed to access HEAP_ALLOCATOR")
-            .init((*peb).guest_heap_data_ptr as usize, (*peb).guest_heap_data_size as usize);
-
-        (*peb).set_default_memory_layout();
-        (*peb).guest_function_dispatch_ptr = dispatch_function as usize as u64;
+            .init((*PEB).guest_heap_data_ptr as usize, (*PEB).guest_heap_data_size as usize);
 
         __security_cookie = seed;
 
-        PEB = Some((*peb).clone());
+        // Set the seed for the random number generator for C code using rand;
+        let srand_seed = ((peb_address << 8 ^ seed >> 4) >> 32) as u32;
+        srand(srand_seed);
+
+        // Set up the logger
+        let max_log_level = LevelFilter::iter()
+            .nth(max_log_level as usize)
+            .expect("Invalid log level");
+        init_logger(max_log_level);
+
+        if (*PEB).run_mode == RunMode::Hypervisor {
+            // 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. Plus, while this could be accessible via
+            // the PEB, we don't want to expose it entirely to user code.
+            MIN_STACK_ADDRESS = (*PEB).guest_stack_data_ptr;
+
+            // Setup GDT and IDT
+            load_gdt();
+            load_idt();
+        }
+
+        reset_error();
 
         hyperlight_main();
     });

Diff for: src/hyperlight_guest/src/guest_error.rs

@@ -22,10 +22,11 @@ use hyperlight_common::flatbuffer_wrappers::guest_error::{ErrorCode, GuestError}
 use log::error;
 
 use crate::entrypoint::halt;
+use crate::host_function_call::{outb, OutBAction};
 use crate::PEB;
 
 pub(crate) fn write_error(error_code: ErrorCode, message: Option<&str>) {
-    let peb = unsafe { PEB.clone().unwrap() };
+    let peb = unsafe { (*PEB).clone() };
     let guest_error = GuestError::new(
         error_code.clone(),
         message.map_or("".to_string(), |m| m.to_string()),
@@ -35,7 +36,7 @@ pub(crate) fn write_error(error_code: ErrorCode, message: Option<&str>) {
         .expect("Invalid guest_error_buffer, could not be converted to a Vec<u8>");
 
     unsafe {
-        assert!(!peb.guest_error_data_ptr != 0);
+        assert_ne!(!peb.guest_error_data_ptr, 0);
         let len = guest_error_buffer.len();
         if guest_error_buffer.len() > peb.guest_error_data_size as usize {
             error!(
@@ -73,11 +74,10 @@ pub(crate) fn write_error(error_code: ErrorCode, message: Option<&str>) {
 
 pub(crate) fn reset_error() {
     unsafe {
-        let peb = PEB.clone().unwrap();
         core::ptr::write_bytes(
-            peb.guest_error_data_ptr as *mut u8,
+            (*PEB).guest_error_data_ptr as *mut u8,
             0,
-            peb.guest_error_data_size as usize,
+            (*PEB).guest_error_data_size as usize,
         );
     }
 }
@@ -86,16 +86,15 @@ pub(crate) fn set_error(error_code: ErrorCode, message: &str) {
     write_error(error_code, Some(message));
 }
 
-// TODO(danbugs:297): bring back
-// pub(crate) fn set_error_and_halt(error_code: ErrorCode, message: &str) {
-//     set_error(error_code, message);
-//     halt();
-// }
-//
-// #[no_mangle]
-// pub(crate) extern "win64" fn set_stack_allocate_error() {
-//     outb(OutBAction::Abort as u16, ErrorCode::StackOverflow as u8);
-// }
+pub(crate) fn set_error_and_halt(error_code: ErrorCode, message: &str) {
+    set_error(error_code, message);
+    halt();
+}
+
+#[no_mangle]
+pub(crate) extern "win64" fn set_stack_allocate_error() {
+    outb(OutBAction::Abort as u16, ErrorCode::StackOverflow as u8);
+}
 
 #[no_mangle]
 pub(crate) extern "win64" fn set_invalid_runmode_error() {

Diff for: src/hyperlight_guest/src/guest_function_call.rs

@@ -85,17 +85,10 @@ fn internal_dispatch_function() -> Result<()> {
     #[cfg(debug_assertions)]
     log::trace!("internal_dispatch_function");
 
-    let peb = unsafe { PEB.clone().unwrap() };
+    let peb = unsafe { (*PEB).clone() };
 
-    let input_data_ptr = peb.input_data_ptr;
-    let input_data_size = peb.input_data_size;
-    let input_data_section =
-        InputDataSection::new(input_data_ptr as *mut u8, input_data_size as usize);
-
-    let output_data_ptr = peb.output_data_ptr;
-    let output_data_size = peb.output_data_size;
-    let output_data_section =
-        OutputDataSection::new(output_data_ptr as *mut u8, output_data_size as usize);
+    let input_data_section: InputDataSection = peb.get_input_data_region().into();
+    let output_data_section: OutputDataSection = peb.get_output_data_region().into();
 
     let function_call = input_data_section
         .try_pop_shared_input_data_into::<FunctionCall>()