[test] added test for exception handling

- added new guest fxn to simpleguest that triggers an invalid
opcode exception
- added test in guest_dispatch that calls the new guest fxn
to test exception handling

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

Author: danbugs

src/hyperlight_host/src/func/guest_dispatch.rs

@@ -480,4 +480,36 @@ mod tests {
             ),
         }
     }
+
+    #[test]
+    fn test_trigger_exception_on_guest() {
+        let usbox = UninitializedSandbox::new(
+            GuestBinary::FilePath(simple_guest_as_string().expect("Guest Binary Missing")),
+            None,
+            None,
+            None,
+        )
+        .unwrap();
+
+        let mut multi_use_sandbox: MultiUseSandbox = usbox.evolve(Noop::default()).unwrap();
+
+        let res = multi_use_sandbox.call_guest_function_by_name(
+            "TriggerException",
+            ReturnType::Void,
+            None,
+        );
+
+        assert!(res.is_err());
+
+        match res.unwrap_err() {
+            HyperlightError::GuestAborted(_, msg) => {
+                // msg should indicate we got an invalid opcode exception
+                assert!(msg.contains("EXCEPTION: 0x6"));
+            }
+            e => panic!(
+                "Expected HyperlightError::GuestExecutionError but got {:?}",
+                e
+            ),
+        }
+    }
 }

src/hyperlight_host/tests/integration_test.rs

@@ -17,8 +17,6 @@ limitations under the License.
 use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode;
 use hyperlight_common::mem::PAGE_SIZE;
 use hyperlight_host::func::{ParameterValue, ReturnType, ReturnValue};
-#[cfg(not(feature = "executable_heap"))]
-use hyperlight_host::mem::memory_region::MemoryRegionFlags;
 use hyperlight_host::sandbox::SandboxConfiguration;
 use hyperlight_host::sandbox_state::sandbox::EvolvableSandbox;
 use hyperlight_host::sandbox_state::transition::Noop;
@@ -388,7 +386,10 @@ fn execute_on_stack() {
         .call_guest_function_by_name("ExecuteOnStack", ReturnType::String, Some(vec![]))
         .unwrap_err();
 
-    // TODO: because we set the stack as NX in the guest PTE we get a generic error, once we handle the exception correctly in the guest we can make this more specific
+    // (Note) We do this because, currently:
+    // - the C guest triggers a generic error, while
+    // - the Rust guest triggers a proper exception.
+    // TODO: figure out discrepancy between C and Rust guests here
     if let HyperlightError::Error(message) = result {
         cfg_if::cfg_if! {
             if #[cfg(target_os = "linux")] {
@@ -400,7 +401,11 @@ fn execute_on_stack() {
             }
         }
     } else {
-        panic!("Unexpected error type");
+        let err = result.to_string();
+        assert!(
+            // exception that indicates a page fault
+            err.contains("EXCEPTION: 0xe")
+        );
     }
 }
 
@@ -419,13 +424,8 @@ fn execute_on_heap() {
     {
         assert!(result.is_err());
         let err = result.unwrap_err();
-        assert!(
-            matches!(
-                err,
-                HyperlightError::MemoryAccessViolation(_, MemoryRegionFlags::EXECUTE, _)
-            ) || matches!(err, HyperlightError::Error(ref s) if s.starts_with("Unexpected VM Exit"))
-                || matches!(err, HyperlightError::Error(ref s) if s.starts_with("unknown Hyper-V run message type")) // Because the memory is set as NX in the guest PTE we get a generic error, once we handle the exception correctly in the guest we can make this more specific
-        );
+
+        assert!(err.to_string().contains("EXCEPTION: 0xe"));
     }
 }
 

src/tests/rust_guests/simpleguest/src/main.rs

@@ -637,6 +637,13 @@ fn log_message(function_call: &FunctionCall) -> Result<Vec<u8>> {
     }
 }
 
+fn trigger_exception(_: &FunctionCall) -> Result<Vec<u8>> {
+    unsafe {
+        core::arch::asm!("ud2");
+    } // trigger an undefined instruction exception
+    Ok(get_flatbuffer_result_from_void())
+}
+
 static mut COUNTER: i32 = 0;
 
 fn add_to_static(function_call: &FunctionCall) -> Result<Vec<u8>> {
@@ -1094,6 +1101,14 @@ pub extern "C" fn hyperlight_main() {
         add as i64,
     );
     register_function(add_def);
+
+    let trigger_exception_def = GuestFunctionDefinition::new(
+        "TriggerException".to_string(),
+        Vec::new(),
+        ReturnType::Void,
+        trigger_exception as i64,
+    );
+    register_function(trigger_exception_def);
 }
 
 #[no_mangle]