Introduce HyperlightVm as a transparent wrapper

Signed-off-by: Ludvig Liljenberg <4257730+ludfjig@users.noreply.github.com>

Author: ludfjig

src/hyperlight_host/src/hypervisor/hyperlight_vm.rs

@@ -0,0 +1,99 @@
+/*
+Copyright 2025 The Hyperlight Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+use crate::Result;
+
+use crate::hypervisor::{Hypervisor, InterruptHandle};
+use crate::mem::memory_region::MemoryRegion;
+use crate::mem::mgr::SandboxMemoryManager;
+use crate::mem::ptr::RawPtr;
+use crate::mem::shared_mem::HostSharedMemory;
+use crate::sandbox::host_funcs::FunctionRegistry;
+
+use log::LevelFilter;
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug)]
+pub(crate) struct HyperlightVm {
+    pub(crate) vm: Box<dyn Hypervisor>,
+}
+
+impl HyperlightVm {
+    pub(crate) fn new(inner: Box<dyn Hypervisor>) -> Self {
+        Self { vm: inner }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn initialise(
+        &mut self,
+        peb_addr: RawPtr,
+        seed: u64,
+        page_size: u32,
+        mem_mgr: &mut SandboxMemoryManager<HostSharedMemory>,
+        host_funcs: &Arc<Mutex<FunctionRegistry>>,
+        guest_max_log_level: Option<LevelFilter>,
+        #[cfg(gdb)] dbg_mem_access_fn: Arc<Mutex<SandboxMemoryManager<HostSharedMemory>>>,
+    ) -> Result<()> {
+        self.vm.initialise(
+            peb_addr,
+            seed,
+            page_size,
+            mem_mgr,
+            host_funcs,
+            guest_max_log_level,
+            #[cfg(gdb)]
+            dbg_mem_access_fn,
+        )
+    }
+
+    pub(crate) unsafe fn map_region(&mut self, rgn: &MemoryRegion) -> Result<()> {
+        unsafe { self.vm.map_region(rgn) }
+    }
+
+    pub(crate) unsafe fn unmap_region(&mut self, rgn: &MemoryRegion) -> Result<()> {
+        unsafe { self.vm.unmap_region(rgn) }
+    }
+
+    pub(crate) fn get_mapped_regions(
+        &self,
+    ) -> Box<dyn ExactSizeIterator<Item = &MemoryRegion> + '_> {
+        self.vm.get_mapped_regions()
+    }
+
+    pub(crate) fn dispatch_call_from_host(
+        &mut self,
+        dispatch_func_addr: RawPtr,
+        mem_mgr: &mut SandboxMemoryManager<HostSharedMemory>,
+        host_funcs: &Arc<Mutex<FunctionRegistry>>,
+        #[cfg(gdb)] dbg_mem_access_fn: Arc<Mutex<SandboxMemoryManager<HostSharedMemory>>>,
+    ) -> Result<()> {
+        self.vm.dispatch_call_from_host(
+            dispatch_func_addr,
+            mem_mgr,
+            host_funcs,
+            #[cfg(gdb)]
+            dbg_mem_access_fn,
+        )
+    }
+
+    pub(crate) fn interrupt_handle(&self) -> Arc<dyn InterruptHandle> {
+        self.vm.interrupt_handle()
+    }
+
+    pub(crate) fn clear_cancel(&self) {
+        self.vm.clear_cancel()
+    }
+}

src/hyperlight_host/src/hypervisor/mod.rs

@@ -59,6 +59,8 @@ pub(crate) mod wrappers;
 #[cfg(crashdump)]
 pub(crate) mod crashdump;
 
+pub(crate) mod hyperlight_vm;
+
 use std::fmt::Debug;
 use std::str::FromStr;
 #[cfg(any(kvm, mshv3))]

src/hyperlight_host/src/sandbox/initialized_multi_use.rs

@@ -37,6 +37,7 @@ use super::host_funcs::FunctionRegistry;
 use super::snapshot::Snapshot;
 use crate::HyperlightError::{self, SnapshotSandboxMismatch};
 use crate::func::{ParameterTuple, SupportedReturnType};
+use crate::hypervisor::hyperlight_vm::HyperlightVm;
 use crate::hypervisor::{Hypervisor, InterruptHandle};
 #[cfg(unix)]
 use crate::mem::memory_region::MemoryRegionType;
@@ -97,7 +98,7 @@ pub struct MultiUseSandbox {
     poisoned: bool,
     pub(super) host_funcs: Arc<Mutex<FunctionRegistry>>,
     pub(crate) mem_mgr: SandboxMemoryManager<HostSharedMemory>,
-    vm: Box<dyn Hypervisor>,
+    vm: HyperlightVm,
     dispatch_ptr: RawPtr,
     #[cfg(gdb)]
     dbg_mem_access_fn: Arc<Mutex<SandboxMemoryManager<HostSharedMemory>>>,
@@ -116,7 +117,7 @@ impl MultiUseSandbox {
     pub(super) fn from_uninit(
         host_funcs: Arc<Mutex<FunctionRegistry>>,
         mgr: SandboxMemoryManager<HostSharedMemory>,
-        vm: Box<dyn Hypervisor>,
+        vm: HyperlightVm,
         dispatch_ptr: RawPtr,
         #[cfg(gdb)] dbg_mem_access_fn: Arc<Mutex<SandboxMemoryManager<HostSharedMemory>>>,
     ) -> MultiUseSandbox {
@@ -711,7 +712,7 @@ impl MultiUseSandbox {
     #[cfg(crashdump)]
     #[instrument(err(Debug), skip_all, parent = Span::current())]
     pub fn generate_crashdump(&self) -> Result<()> {
-        crate::hypervisor::crashdump::generate_crashdump(self.vm.as_ref())
+        crate::hypervisor::crashdump::generate_crashdump(self.vm.vm.as_ref() as &dyn Hypervisor)
     }
 
     /// Returns whether the sandbox is currently poisoned.

src/hyperlight_host/src/sandbox/uninitialized_evolve.rs

@@ -26,6 +26,7 @@ use super::hypervisor::{HypervisorType, get_available_hypervisor};
 use super::uninitialized::SandboxRuntimeConfig;
 use crate::HyperlightError::NoHypervisorFound;
 use crate::hypervisor::Hypervisor;
+use crate::hypervisor::hyperlight_vm::HyperlightVm;
 use crate::mem::exe::LoadInfo;
 use crate::mem::layout::SandboxMemoryLayout;
 use crate::mem::mgr::SandboxMemoryManager;
@@ -106,7 +107,7 @@ pub(crate) fn set_up_hypervisor_partition(
     #[cfg_attr(target_os = "windows", allow(unused_variables))] config: &SandboxConfiguration,
     #[cfg(any(crashdump, gdb))] rt_cfg: &SandboxRuntimeConfig,
     _load_info: LoadInfo,
-) -> Result<Box<dyn Hypervisor>> {
+) -> Result<HyperlightVm> {
     #[cfg(feature = "init-paging")]
     let rsp_ptr = {
         let mut regions = mgr.layout.get_memory_regions(&mgr.shared_mem)?;
@@ -167,7 +168,7 @@ pub(crate) fn set_up_hypervisor_partition(
     #[cfg(feature = "mem_profile")]
     let trace_info = MemTraceInfo::new(_load_info)?;
 
-    match *get_available_hypervisor() {
+    let vm: Box<dyn Hypervisor> = match *get_available_hypervisor() {
         #[cfg(mshv3)]
         Some(HypervisorType::Mshv) => {
             let hv = crate::hypervisor::hyperv_linux::HypervLinuxDriver::new(
@@ -183,7 +184,7 @@ pub(crate) fn set_up_hypervisor_partition(
                 #[cfg(feature = "mem_profile")]
                 trace_info,
             )?;
-            Ok(Box::new(hv))
+            Box::new(hv)
         }
 
         #[cfg(kvm)]
@@ -201,7 +202,7 @@ pub(crate) fn set_up_hypervisor_partition(
                 #[cfg(feature = "mem_profile")]
                 trace_info,
             )?;
-            Ok(Box::new(hv))
+            Box::new(hv)
         }
 
         #[cfg(target_os = "windows")]
@@ -225,13 +226,15 @@ pub(crate) fn set_up_hypervisor_partition(
                 #[cfg(feature = "mem_profile")]
                 trace_info,
             )?;
-            Ok(Box::new(hv))
+            Box::new(hv)
         }
 
         _ => {
             log_then_return!(NoHypervisorFound());
         }
-    }
+    };
+
+    Ok(HyperlightVm::new(vm))
 }
 
 #[cfg(test)]