feat(virtq): fix host function error test

Signed-off-by: Tomasz Andrzejak <andreiltd@gmail.com>

Author: andreiltd

src/hyperlight_guest/src/virtq/context.rs

@@ -72,7 +72,7 @@ pub struct GuestContext {
     g2h_producer: G2hProducer,
     h2g_producer: H2gProducer,
     generation: u16,
-    last_host_return: Option<ReturnValue>,
+    last_host_result: Option<Result<ReturnValue>>,
 }
 
 impl GuestContext {
@@ -101,7 +101,7 @@ impl GuestContext {
             g2h_producer,
             h2g_producer,
             generation,
-            last_host_return: None,
+            last_host_result: None,
         };
 
         ctx.prefill_h2g();
@@ -309,6 +309,7 @@ impl GuestContext {
         // restore_h2g_prefill() wrote matching descriptors to the
         // zeroed ring memory. Both sides are in sync.
         self.generation = new_generation;
+        self.last_host_result = None;
     }
 
     pub(super) fn generation(&self) -> u16 {
@@ -346,24 +347,27 @@ impl GuestContext {
         self.g2h_producer.submit(entry)
     }
 
-    /// Stash a host function return value for later retrieval.
+    /// Stash a host function result for later retrieval.
     ///
     /// Used by the C API's two-step calling convention where
     /// `hl_call_host_function` and `hl_get_host_return_value_as_*`
     /// are separate calls.
-    pub fn stash_host_return(&mut self, value: ReturnValue) {
-        self.last_host_return = Some(value);
+    pub fn stash_host_result(&mut self, result: Result<ReturnValue>) {
+        self.last_host_result = Some(result);
     }
 
     /// Take the stashed host return value.
     ///
     /// Panics if no value was stashed or if the type conversion fails.
+    /// If the stashed result was an error, panics with the error message.
     pub fn take_host_return<T: TryFrom<ReturnValue>>(&mut self) -> T {
-        let rv = self
-            .last_host_return
+        let val = self
+            .last_host_result
             .take()
-            .expect("No host return value available");
-        match T::try_from(rv) {
+            .expect("No host return value available")
+            .expect("Host function returned an error");
+
+        match T::try_from(val) {
             Ok(v) => v,
             Err(_) => panic!("Host return value type mismatch"),
         }

src/hyperlight_guest_capi/src/dispatch.rs

@@ -109,22 +109,9 @@ pub extern "C" fn hl_call_host_function(function_call: &FfiFunctionCall) {
     let return_type = unsafe { function_call.copy_return_type() };
 
     virtq::with_context(|ctx| {
-        match ctx.call_host_function::<ReturnValue>(&func_name, Some(parameters), return_type) {
-            Ok(result) => ctx.stash_host_return(result),
-            Err(e) => {
-                // Host function returned an error. Abort with the error
-                // message so the host can capture it via the abort buffer.
-                let msg = alloc::ffi::CString::new(e.message)
-                    .unwrap_or_else(|_| alloc::ffi::CString::new("host error").unwrap());
-
-                unsafe {
-                    hyperlight_guest::exit::abort_with_code_and_message(
-                        &[e.kind as u8],
-                        msg.as_ptr(),
-                    );
-                }
-            }
-        }
+        let result =
+            ctx.call_host_function::<ReturnValue>(&func_name, Some(parameters), return_type);
+        ctx.stash_host_result(result);
     });
 }
 

src/hyperlight_host/tests/sandbox_host_tests.rs

@@ -344,7 +344,6 @@ fn callback_test_parallel() {
 }
 
 #[test]
-#[ignore] // TODO(virtq): C guest host-function error path needs fixing.
 fn host_function_error() {
     with_all_uninit_sandboxes(|mut sandbox| {
         // create host function