[*] remove uses of panic/unwrap/expect

Satisfying clippy in release by removing panic/unwrap/expect usages from the new
APIs

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

Author: danbugs

fuzz/fuzz_targets/host_call.rs

@@ -19,11 +19,13 @@ limitations under the License.
 use std::sync::{Mutex, OnceLock};
 
 use hyperlight_host::func::{ParameterValue, ReturnType};
+use hyperlight_host::sandbox::sandbox_builder::SandboxBuilder;
 use hyperlight_host::sandbox_state::sandbox::EvolvableSandbox;
 use hyperlight_host::sandbox_state::transition::Noop;
-use hyperlight_host::{HyperlightError, MultiUseSandbox};
+use hyperlight_host::{GuestBinary, HyperlightError, MultiUseSandbox};
 use hyperlight_testing::simple_guest_for_fuzzing_as_string;
 use libfuzzer_sys::fuzz_target;
+
 static SANDBOX: OnceLock<Mutex<MultiUseSandbox>> = OnceLock::new();
 
 // This fuzz target tests all combinations of ReturnType and Parameters for `call_guest_function_by_name`.

src/hyperlight_common/src/host_calling.rs

@@ -14,10 +14,8 @@ use crate::PEB;
 /// This usually requires a host function to be called first using `call_host_function`.
 pub fn get_host_return_value<T: TryFrom<ReturnValue>>() -> Result<T> {
     let input_data_section: InputDataSection =
-        unsafe { (*PEB).clone() }.get_input_data_region().into();
-    let return_value = input_data_section
-        .try_pop_shared_input_data_into::<ReturnValue>()
-        .expect("Unable to deserialize a return value from host");
+        unsafe { (*PEB).clone() }.get_input_data_region()?.into();
+    let return_value = input_data_section.try_pop_shared_input_data_into::<ReturnValue>()?;
 
     T::try_from(return_value).map_err(|_| {
         anyhow::anyhow!(
@@ -42,24 +40,22 @@ pub fn call_host_function(
         return_type,
     );
 
-    let host_function_call_buffer: Vec<u8> = host_function_call
-        .try_into()
-        .expect("Unable to serialize host function call");
+    let host_function_call_buffer: Vec<u8> = host_function_call.try_into()?;
 
     let output_data_section: OutputDataSection =
-        unsafe { (*PEB).clone() }.get_output_data_region().into();
+        unsafe { (*PEB).clone() }.get_output_data_region()?.into();
     output_data_section.push_shared_output_data(host_function_call_buffer)?;
 
-    outb(OutBAction::CallFunction as u16, 0);
-
-    Ok(())
+    outb(OutBAction::CallFunction as u16, 0)
 }
 
 /// Uses `hloutb` to issue multiple `DebugPrint` `OutBAction`s to print a message.
-pub fn print(message: &str) {
+pub fn print(message: &str) -> Result<()> {
     for byte in message.bytes() {
-        outb(OutBAction::DebugPrint as u16, byte);
+        outb(OutBAction::DebugPrint as u16, byte)?;
     }
+
+    Ok(())
 }
 
 /// Exposes a C API to allow the guest to print a string, byte by byte
@@ -68,5 +64,6 @@ pub fn print(message: &str) {
 /// This function is not thread safe and assumes `outb` is safe to call directly.
 #[no_mangle]
 pub unsafe extern "C" fn _putchar(c: c_char) {
-    outb(OutBAction::DebugPrint as u16, c as u8);
+    #[allow(clippy::expect_used)] // allow `expect` over C API functions
+    outb(OutBAction::DebugPrint as u16, c as u8).expect("Failed to print character");
 }

src/hyperlight_common/src/outb.rs

@@ -37,7 +37,7 @@ fn hloutb(port: u16, val: u8) {
     }
 }
 
-pub fn outb(port: u16, value: u8) {
+pub fn outb(port: u16, value: u8) -> Result<()> {
     unsafe {
         match RUNNING_MODE {
             RunMode::Hypervisor => {
@@ -53,12 +53,14 @@ pub fn outb(port: u16, value: u8) {
                 } else if let Some(outb_func) = OUTB_HANDLER {
                     outb_func(port, value);
                 } else {
-                    panic!("Tried to call outb without hypervisor and without outb function ptrs");
+                    bail!("Tried to call outb without hypervisor and without outb function ptrs");
                 }
             }
             _ => {
-                panic!("Tried to call outb in invalid runmode");
+                bail!("Tried to call outb in invalid runmode");
             }
         }
     }
+
+    Ok(())
 }