Remove OutBHandlerCaller trait and OutBHandlerFunction type, rename handle_outb_impl to handle_outb, fix duplicate imports in hyperv_windows.rs

Co-authored-by: simongdavies <[email protected]>

Author: Copilot

src/hyperlight_host/src/hypervisor/handlers.rs

@@ -20,39 +20,40 @@ use tracing::{Span, instrument};
 
 use crate::{Result, new_error};
 
-/// The trait representing custom logic to handle the case when
-/// a Hypervisor's virtual CPU (vCPU) informs Hyperlight the guest
-/// has initiated an outb operation.
-pub trait OutBHandlerCaller: Sync + Send {
-    /// Function that gets called when an outb operation has occurred.
-    fn call(&mut self, port: u16, payload: u32) -> Result<()>;
-}
+/// Type alias for the function that handles outb operations
+type OutBHandlerFunction = Box<dyn FnMut(u16, u32) -> Result<()> + Send>;
 
-pub(crate) type OutBHandlerFunction = Box<dyn FnMut(u16, u32) -> Result<()> + Send>;
-
-/// A `OutBHandler` implementation using a `OutBHandlerFunction`
+/// A `OutBHandler` implementation using a function closure
 ///
 /// Note: This handler must live no longer than the `Sandbox` to which it belongs
-pub(crate) struct OutBHandler(Arc<Mutex<OutBHandlerFunction>>);
+pub(crate) struct OutBHandler {
+    func: Arc<Mutex<OutBHandlerFunction>>,
+}
 
-impl From<OutBHandlerFunction> for OutBHandler {
-    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
-    fn from(func: OutBHandlerFunction) -> Self {
-        Self(Arc::new(Mutex::new(func)))
+impl OutBHandler {
+    pub fn new(func: OutBHandlerFunction) -> Self {
+        Self {
+            func: Arc::new(Mutex::new(func)),
+        }
     }
-}
 
-impl OutBHandlerCaller for OutBHandler {
     #[instrument(err(Debug), skip_all, parent = Span::current(), level= "Trace")]
-    fn call(&mut self, port: u16, payload: u32) -> Result<()> {
+    pub fn handle_outb(&self, port: u16, payload: u32) -> Result<()> {
         let mut func = self
-            .0
+            .func
             .try_lock()
             .map_err(|e| new_error!("Error locking at {}:{}: {}", file!(), line!(), e))?;
         func(port, payload)
     }
 }
 
+impl From<OutBHandlerFunction> for OutBHandler {
+    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
+    fn from(func: OutBHandlerFunction) -> Self {
+        Self::new(func)
+    }
+}
+
 /// The trait representing custom logic to handle the case when
 /// a Hypervisor's virtual CPU (vCPU) informs Hyperlight a memory access
 /// outside the designated address space has occurred.

src/hyperlight_host/src/hypervisor/hyperv_linux.rs

@@ -60,7 +60,7 @@ use super::gdb::{
 };
 #[cfg(gdb)]
 use super::handlers::DbgMemAccessHandlerWrapper;
-use super::handlers::{MemAccessHandlerWrapper, OutBHandler, OutBHandlerCaller};
+use super::handlers::{MemAccessHandlerWrapper, OutBHandler};
 #[cfg(feature = "init-paging")]
 use super::{
     CR0_AM, CR0_ET, CR0_MP, CR0_NE, CR0_PE, CR0_PG, CR0_WP, CR4_OSFXSR, CR4_OSXMMEXCPT, CR4_PAE,
@@ -668,7 +668,7 @@ impl Hypervisor for HypervLinuxDriver {
         outb_handle_fn
             .try_lock()
             .map_err(|e| new_error!("Error locking at {}:{}: {}", file!(), line!(), e))?
-            .call(port, val)?;
+            .handle_outb(port, val)?;
 
         // update rip
         self.vcpu_fd.set_reg(&[hv_register_assoc {

src/hyperlight_host/src/hypervisor/hyperv_windows.rs

@@ -41,11 +41,10 @@ use {
     super::handlers::DbgMemAccessHandlerWrapper,
     crate::HyperlightError,
     crate::hypervisor::handlers::DbgMemAccessHandlerCaller,
-    std::sync::Mutex,
 };
 
 use super::fpu::{FP_TAG_WORD_DEFAULT, MXCSR_DEFAULT};
-use super::handlers::{MemAccessHandlerWrapper, OutBHandler, OutBHandlerCaller};
+use super::handlers::{MemAccessHandlerWrapper, OutBHandler};
 use super::surrogate_process::SurrogateProcess;
 use super::surrogate_process_manager::*;
 use super::windows_hypervisor_platform::{VMPartition, VMProcessor};
@@ -683,7 +682,7 @@ impl Hypervisor for HypervWindowsDriver {
         outb_handle_fn
             .try_lock()
             .map_err(|e| new_error!("Error locking at {}:{}: {}", file!(), line!(), e))?
-            .call(port, val)?;
+            .handle_outb(port, val)?;
 
         let mut regs = self.processor.get_regs()?;
         regs.rip = rip + instruction_length;

src/hyperlight_host/src/hypervisor/kvm.rs

@@ -32,7 +32,7 @@ use super::fpu::{FP_CONTROL_WORD_DEFAULT, FP_TAG_WORD_DEFAULT, MXCSR_DEFAULT};
 use super::gdb::{DebugCommChannel, DebugMsg, DebugResponse, GuestDebug, KvmDebug, VcpuStopReason};
 #[cfg(gdb)]
 use super::handlers::DbgMemAccessHandlerWrapper;
-use super::handlers::{MemAccessHandlerWrapper, OutBHandler, OutBHandlerCaller};
+use super::handlers::{MemAccessHandlerWrapper, OutBHandler};
 #[cfg(feature = "init-paging")]
 use super::{
     CR0_AM, CR0_ET, CR0_MP, CR0_NE, CR0_PE, CR0_PG, CR0_WP, CR4_OSFXSR, CR4_OSXMMEXCPT, CR4_PAE,
@@ -584,7 +584,7 @@ impl Hypervisor for KVMDriver {
             outb_handle_fn
                 .try_lock()
                 .map_err(|e| new_error!("Error locking at {}:{}: {}", file!(), line!(), e))?
-                .call(port, value)?;
+                .handle_outb(port, value)?;
         }
 
         Ok(())

src/hyperlight_host/src/sandbox/outb.rs

@@ -26,7 +26,7 @@ use tracing_log::format_trace;
 
 use super::host_funcs::FunctionRegistry;
 use super::mem_mgr::MemMgrWrapper;
-use crate::hypervisor::handlers::{OutBHandler, OutBHandlerFunction};
+use crate::hypervisor::handlers::OutBHandler;
 use crate::mem::mgr::SandboxMemoryManager;
 use crate::mem::shared_mem::HostSharedMemory;
 use crate::{HyperlightError, Result, new_error};
@@ -146,7 +146,7 @@ fn outb_abort(mem_mgr: &mut MemMgrWrapper<HostSharedMemory>, data: u32) -> Resul
 
 /// Handles OutB operations from the guest.
 #[instrument(err(Debug), skip_all, parent = Span::current(), level= "Trace")]
-fn handle_outb_impl(
+fn handle_outb(
     mem_mgr: &mut MemMgrWrapper<HostSharedMemory>,
     host_funcs: Arc<Mutex<FunctionRegistry>>,
     port: u16,
@@ -192,8 +192,8 @@ pub(crate) fn outb_handler_wrapper(
     mut mem_mgr_wrapper: MemMgrWrapper<HostSharedMemory>,
     host_funcs_wrapper: Arc<Mutex<FunctionRegistry>>,
 ) -> Arc<Mutex<OutBHandler>> {
-    let outb_func: OutBHandlerFunction = Box::new(move |port, payload| {
-        handle_outb_impl(
+    let outb_func: Box<dyn FnMut(u16, u32) -> Result<()> + Send> = Box::new(move |port, payload| {
+        handle_outb(
             &mut mem_mgr_wrapper,
             host_funcs_wrapper.clone(),
             port,