fixup! tmp 2

Author: danbugs

src/hyperlight_guest/src/entrypoint.rs

@@ -27,7 +27,7 @@ use crate::gdt::load_gdt;
 use crate::guest_function_call::dispatch_function;
 use crate::guest_logger::init_logger;
 use crate::idtr::load_idt;
-use crate::{__security_cookie, panic, HEAP_ALLOCATOR};
+use crate::{__security_cookie, HEAP_ALLOCATOR};
 
 #[inline(never)]
 pub fn halt() {
@@ -135,8 +135,6 @@ pub extern "win64" fn entrypoint(peb_address: u64, seed: u64, max_log_level: u64
             _ => panic!("Invalid runmode in PEB"),
         }
 
-        panic!("ok");
-
         hyperlight_main();
     });
 

src/hyperlight_guest/src/lib.rs

@@ -66,7 +66,6 @@ pub(crate) static _fltused: i32 = 0;
 // to satisfy the clippy when cfg == test
 #[allow(dead_code)]
 fn panic(info: &core::panic::PanicInfo) -> ! {
-    loop {}
     unsafe {
         copy_nonoverlapping(
             info.to_string().as_ptr(),

src/hyperlight_host/src/hypervisor/kvm.rs

@@ -418,7 +418,19 @@ impl Hypervisor for KVMDriver {
 
         let regs = kvm_regs {
             rip: self.entrypoint,
-            rsp: self.orig_rsp.absolute()?,
+            // For MSVC, move rsp down by 0x28.  This gives the called 'main'
+            // function the appearance that rsp was 16 byte aligned before
+            // the 'call' that calls main (note we don't really have a return value
+            // on the stack but some assembly instructions are expecting rsp have
+            // started 0x8 bytes off of 16 byte alignment when 'main' is invoked.
+            // We do 0x28 instead of 0x8 because MSVC can expect that there are
+            // 0x20 bytes of space to write to by the called function.
+            // I am not sure if this happens with the 'main' method, but we do this
+            // just in case.
+            //
+            // NOTE: We do this also for GCC freestanding binaries because we
+            // specify __attribute__((ms_abi)) on the start method
+            rsp: self.orig_rsp.absolute()? - 0x28,
 
             // function args
             rcx: hyperlight_peb_guest_memory_region_address,
@@ -439,13 +451,17 @@ impl Hypervisor for KVMDriver {
         )?;
 
         // The guest may have chosen a different stack region. If so, we drop usage of our tmp stack.
-        let hyperlight_peb = self.mem_sections.read_hyperlight_peb()?;
+        let mut hyperlight_peb = self.mem_sections.read_hyperlight_peb()?;
 
         if let Some(guest_stack_data) = &hyperlight_peb.get_guest_stack_data_region() {
             if guest_stack_data.offset.is_some() {
                 // If we got here, it means the guest has set up a new stack
                 let rsp = hyperlight_peb.get_top_of_guest_stack_data();
-                self.orig_rsp = GuestPtr::try_from(RawPtr::from(rsp))?;
+                self.orig_rsp = GuestPtr::try_from(RawPtr::from(rsp - 0x28))?;
+
+                // Need to update the min stack address from tmp_stack address to the new stack
+                hyperlight_peb.min_stack_address = hyperlight_peb.calculate_min_stack_address();
+                self.mem_sections.write_hyperlight_peb(hyperlight_peb)?;
             }
         }
 
@@ -579,9 +595,13 @@ impl Hypervisor for KVMDriver {
                     log_then_return!("Error running VCPU {:?}", e);
                 }
             },
-            Ok(other) => {
-                crate::debug!("KVM Other Exit {:?}", other);
-                HyperlightExit::Unknown(format!("Unexpected KVM Exit {:?}", other))
+            Ok(_) => {
+                // get registers
+                let regs = self.vcpu_fd.get_regs()?;
+                dbg!(regs.clone());
+
+                // crate::debug!("KVM Other Exit {:?}", other);
+                HyperlightExit::Unknown(format!("Unexpected KVM Exit {:?}", VcpuExit::Unknown))
             }
         };
         Ok(result)

src/hyperlight_host/src/sandbox/sandbox_builder.rs

@@ -543,7 +543,7 @@ impl SandboxBuilder {
         const DEFAULT_TMP_STACK_GUARD_PAGE_NAME: &str = "tmp stack guard page";
         const DEFAULT_CUSTOM_GUEST_MEMORY_GUARD_PAGE_NAME: &str = "custom guest memory guard page";
 
-        let tmp_stack_size = 0x200_000;
+        let tmp_stack_size = 0x20_000;
         let guest_memory_size = self.guest_memory_size;
 
         // (a) guest code added on `new`
@@ -775,6 +775,8 @@ impl SandboxBuilder {
         // Map host addresses to guest addresses
         sandbox_builder.map_host_addresses(exclusive_shared_memory.base_addr());
 
+        dbg!(sandbox_builder.memory_sections.clone());
+
         let hyperlight_peb = HyperlightPEB::new(
             sandbox_builder
                 .memory_sections
@@ -934,15 +936,15 @@ mod tests {
         host_function.register(&mut uninitialized_sandbox, "HostAdd")?;
 
         // Tests evolving to a multi-use sandbox
-        let multi_use_sandbox = uninitialized_sandbox.evolve(Noop::default())?;
+        let mut multi_use_sandbox = uninitialized_sandbox.evolve(Noop::default())?;
 
-        // let result = multi_use_sandbox.call_guest_function_by_name(
-        //     "Add",
-        //     ReturnType::Int,
-        //     Some(vec![ParameterValue::Int(1), ParameterValue::Int(41)]),
-        // )?;
-        //
-        // assert_eq!(result, ReturnValue::Int(42));
+        let result = multi_use_sandbox.call_guest_function_by_name(
+            "Add",
+            ReturnType::Int,
+            Some(vec![ParameterValue::Int(1), ParameterValue::Int(41)]),
+        )?;
+
+        assert_eq!(result, ReturnValue::Int(42));
 
         Ok(())
     }
@@ -965,15 +967,15 @@ mod tests {
         host_function.register(&mut uninitialized_sandbox, "HostAdd")?;
 
         // Tests evolving to a multi-use sandbox
-        let multi_use_sandbox = uninitialized_sandbox.evolve(Noop::default())?;
-
-        // let result = multi_use_sandbox.call_guest_function_by_name(
-        //     "Add",
-        //     ReturnType::Int,
-        //     Some(vec![ParameterValue::Int(1), ParameterValue::Int(41)]),
-        // )?;
-        //
-        // assert_eq!(result, ReturnValue::Int(42));
+        let mut multi_use_sandbox = uninitialized_sandbox.evolve(Noop::default())?;
+
+        let result = multi_use_sandbox.call_guest_function_by_name(
+            "Add",
+            ReturnType::Int,
+            Some(vec![ParameterValue::Int(1), ParameterValue::Int(41)]),
+        )?;
+
+        assert_eq!(result, ReturnValue::Int(42));
 
         Ok(())
     }