Merge branch 'main' into vm_trait

Author: ludfjig

.github/CODEOWNERS

@@ -0,0 +1,2 @@
+# Global Code Owners
+* @danbugs @ludfjig @dblnz @devigned @syntactically @marosset @jprendes @simongdavies

Cargo.lock

@@ -1,7 +1,7 @@
 <div align="center">
     <h1>Hyperlight</h1>
     <img src="https://raw.githubusercontent.com/hyperlight-dev/hyperlight/refs/heads/main/docs/assets/hyperlight-logo.png" width="150px" alt="hyperlight logo"/>
-    <p><strong>Hyperlight is a lightweight Virtual Machine Manager (VMM) designed to be embedded within applications. It enables safe execution of untrusted code within <i>micro virtual machines</i> with very low latency and minimal overhead.</strong></p>    
+    <p><strong>Hyperlight is a lightweight Virtual Machine Manager (VMM) designed to be embedded within applications. It enables safe execution of untrusted code within <i>micro virtual machines</i> with very low latency and minimal overhead.</strong> <br> We are a <a href="https://cncf.io/">Cloud Native Computing Foundation</a> sandbox project. </p>    
 </div>
 
 > Note: Hyperlight is a nascent project with an evolving API and no guaranteed support. Assistance is provided on a
@@ -47,16 +47,11 @@ fn main() -> hyperlight_host::Result<()> {
         None, // default host print function
     )?;
 
-    // Register a host function
-    fn sleep_5_secs() -> hyperlight_host::Result<()> {
+    // Registering a host function makes it available to be called by the guest
+    uninitialized_sandbox.register("Sleep5Secs", || {
         thread::sleep(std::time::Duration::from_secs(5));
         Ok(())
-    }
-
-    let host_function = Arc::new(Mutex::new(sleep_5_secs));
-
-    // Registering a host function makes it available to be called by the guest
-    host_function.register(&mut uninitialized_sandbox, "Sleep5Secs")?;
+    })?;
     // Note: This function is unused by the guest code below, it's just here for demonstration purposes
 
     // Initialize sandbox to be able to call host functions

README.md

@@ -99,7 +99,7 @@ pub enum ReturnValue {
     /// bool
     Bool(bool),
     /// ()
-    Void,
+    Void(()),
     /// Vec<u8>
     VecBytes(Vec<u8>),
 }
@@ -508,7 +508,7 @@ impl TryFrom<ReturnValue> for () {
     #[cfg_attr(feature = "tracing", instrument(err(Debug), skip_all, parent = Span::current(), level= "Trace"))]
     fn try_from(value: ReturnValue) -> Result<Self> {
         match value {
-            ReturnValue::Void => Ok(()),
+            ReturnValue::Void(()) => Ok(()),
             _ => {
                 bail!("Unexpected return value type: {:?}", value)
             }
@@ -570,7 +570,7 @@ impl TryFrom<FbFunctionCallResult<'_>> for ReturnValue {
                 };
                 Ok(ReturnValue::String(hlstring.unwrap_or("".to_string())))
             }
-            FbReturnValue::hlvoid => Ok(ReturnValue::Void),
+            FbReturnValue::hlvoid => Ok(ReturnValue::Void(())),
             FbReturnValue::hlsizeprefixedbuffer => {
                 let hlvecbytes =
                     match function_call_result_fb.return_value_as_hlsizeprefixedbuffer() {
@@ -724,7 +724,7 @@ impl TryFrom<&ReturnValue> for Vec<u8> {
                 builder.finish_size_prefixed(function_call_result, None);
                 builder.finished_data().to_vec()
             }
-            ReturnValue::Void => {
+            ReturnValue::Void(()) => {
                 let hlvoid = hlvoid::create(&mut builder, &hlvoidArgs {});
                 let function_call_result = FbFunctionCallResult::create(
                     &mut builder,

src/hyperlight_common/src/flatbuffer_wrappers/function_types.rs

@@ -36,3 +36,6 @@ pub mod flatbuffer_wrappers;
 mod flatbuffers;
 /// cbindgen:ignore
 pub mod mem;
+
+/// cbindgen:ignore
+pub mod outb;

src/hyperlight_common/src/lib.rs

@@ -74,24 +74,16 @@ pub struct GuestStackData {
     pub bootStackAddress: u64,
 }
 
-#[repr(C)]
-pub struct GuestPanicContextData {
-    pub guestPanicContextDataSize: u64,
-    pub guestPanicContextDataBuffer: *mut c_void,
-}
-
 #[repr(C)]
 pub struct HyperlightPEB {
     pub security_cookie_seed: u64,
     pub guest_function_dispatch_ptr: u64,
-    pub guestErrorData: GuestErrorData,
     pub pCode: *mut c_char,
     pub pOutb: *mut c_void,
     pub pOutbContext: *mut c_void,
     pub runMode: RunMode,
     pub inputdata: InputData,
     pub outputdata: OutputData,
-    pub guestPanicContextData: GuestPanicContextData,
     pub guestheapData: GuestHeapData,
     pub gueststackData: GuestStackData,
 }

src/hyperlight_common/src/mem/mod.rs renamed to src/hyperlight_common/src/mem.rs

@@ -0,0 +1,95 @@
+use core::convert::TryFrom;
+
+use anyhow::{anyhow, Error};
+
+/// Exception codes for the x86 architecture.
+/// These are helpful to identify the type of exception that occurred
+/// together with OutBAction::Abort.
+#[repr(u8)]
+#[derive(Debug, Clone, Copy)]
+pub enum Exception {
+    DivideByZero = 0,
+    Debug = 1,
+    NonMaskableInterrupt = 2,
+    Breakpoint = 3,
+    Overflow = 4,
+    BoundRangeExceeded = 5,
+    InvalidOpcode = 6,
+    DeviceNotAvailable = 7,
+    DoubleFault = 8,
+    CoprocessorSegmentOverrun = 9,
+    InvalidTSS = 10,
+    SegmentNotPresent = 11,
+    StackSegmentFault = 12,
+    GeneralProtectionFault = 13,
+    PageFault = 14,
+    Reserved = 15,
+    X87FloatingPointException = 16,
+    AlignmentCheck = 17,
+    MachineCheck = 18,
+    SIMDFloatingPointException = 19,
+    VirtualizationException = 20,
+    SecurityException = 30,
+    NoException = 0xFF,
+}
+
+impl TryFrom<u8> for Exception {
+    type Error = Error;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        use Exception::*;
+        let exception = match value {
+            0 => DivideByZero,
+            1 => Debug,
+            2 => NonMaskableInterrupt,
+            3 => Breakpoint,
+            4 => Overflow,
+            5 => BoundRangeExceeded,
+            6 => InvalidOpcode,
+            7 => DeviceNotAvailable,
+            8 => DoubleFault,
+            9 => CoprocessorSegmentOverrun,
+            10 => InvalidTSS,
+            11 => SegmentNotPresent,
+            12 => StackSegmentFault,
+            13 => GeneralProtectionFault,
+            14 => PageFault,
+            15 => Reserved,
+            16 => X87FloatingPointException,
+            17 => AlignmentCheck,
+            18 => MachineCheck,
+            19 => SIMDFloatingPointException,
+            20 => VirtualizationException,
+            30 => SecurityException,
+            0x7F => NoException,
+            _ => return Err(anyhow!("Unknown exception code: {:#x}", value)),
+        };
+
+        Ok(exception)
+    }
+}
+
+/// Supported actions when issuing an OUTB actions by Hyperlight.
+/// - Log: for logging,
+/// - CallFunction: makes a call to a host function,
+/// - Abort: aborts the execution of the guest,
+/// - DebugPrint: prints a message to the host
+pub enum OutBAction {
+    Log = 99,
+    CallFunction = 101,
+    Abort = 102,
+    DebugPrint = 103,
+}
+
+impl TryFrom<u16> for OutBAction {
+    type Error = anyhow::Error;
+    fn try_from(val: u16) -> anyhow::Result<Self> {
+        match val {
+            99 => Ok(OutBAction::Log),
+            101 => Ok(OutBAction::CallFunction),
+            102 => Ok(OutBAction::Abort),
+            103 => Ok(OutBAction::DebugPrint),
+            _ => Err(anyhow::anyhow!("Invalid OutBAction value: {}", val)),
+        }
+    }
+}

src/hyperlight_common/src/outb.rs

@@ -16,17 +16,16 @@ limitations under the License.
 
 use core::arch::asm;
 use core::ffi::{c_char, c_void, CStr};
-use core::ptr::copy_nonoverlapping;
 
 use hyperlight_common::mem::{HyperlightPEB, RunMode};
+use hyperlight_common::outb::OutBAction;
 use log::LevelFilter;
 use spin::Once;
 
 use crate::gdt::load_gdt;
-use crate::guest_error::reset_error;
 use crate::guest_function_call::dispatch_function;
 use crate::guest_logger::init_logger;
-use crate::host_function_call::{outb, OutBAction};
+use crate::host_function_call::{debug_print, outb};
 use crate::idtr::load_idt;
 use crate::{
     __security_cookie, HEAP_ALLOCATOR, MIN_STACK_ADDRESS, OS_PAGE_SIZE, OUTB_PTR,
@@ -44,26 +43,26 @@ pub fn halt() {
 
 #[no_mangle]
 pub extern "C" fn abort() -> ! {
-    abort_with_code(0)
+    abort_with_code(&[0])
 }
 
-pub fn abort_with_code(code: i32) -> ! {
-    outb(OutBAction::Abort as u16, code as u8);
+pub fn abort_with_code(code: &[u8]) -> ! {
+    outb(OutBAction::Abort as u16, code);
     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 = P_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
+pub unsafe fn abort_with_code_and_message(code: &[u8], message_ptr: *const c_char) -> ! {
+    debug_print(
+        CStr::from_ptr(message_ptr)
+            .to_str()
+            .expect("Invalid UTF-8 string"),
     );
-    outb(OutBAction::Abort as u16, code as u8);
+
+    outb(OutBAction::Abort as u16, code);
     unreachable!()
 }
 
@@ -115,7 +114,7 @@ pub extern "win64" fn entrypoint(peb_address: u64, seed: u64, ops: u64, max_log_
                     RUNNING_MODE = (*peb_ptr).runMode;
 
                     OUTB_PTR = {
-                        let outb_ptr: extern "win64" fn(u16, u8) =
+                        let outb_ptr: extern "win64" fn(u16, *const u8, u64) =
                             core::mem::transmute((*peb_ptr).pOutb);
                         Some(outb_ptr)
                     };
@@ -125,8 +124,12 @@ pub extern "win64" fn entrypoint(peb_address: u64, seed: u64, ops: u64, max_log_
                     }
 
                     OUTB_PTR_WITH_CONTEXT = {
-                        let outb_ptr_with_context: extern "win64" fn(*mut c_void, u16, u8) =
-                            core::mem::transmute((*peb_ptr).pOutb);
+                        let outb_ptr_with_context: extern "win64" fn(
+                            *mut c_void,
+                            u16,
+                            *const u8,
+                            u64,
+                        ) = core::mem::transmute((*peb_ptr).pOutb);
                         Some(outb_ptr_with_context)
                     };
                 }
@@ -146,8 +149,6 @@ pub extern "win64" fn entrypoint(peb_address: u64, seed: u64, ops: u64, max_log_
 
             (*peb_ptr).guest_function_dispatch_ptr = dispatch_function as usize as u64;
 
-            reset_error();
-
             hyperlight_main();
         }
     });