Move hypervisor-related functions out of sandbox module

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

Author: ludfjig

src/hyperlight_host/src/hypervisor/hyperlight_vm.rs

@@ -41,8 +41,10 @@ use crate::hypervisor::LinuxInterruptHandle;
 #[cfg(crashdump)]
 use crate::hypervisor::crashdump;
 use crate::hypervisor::regs::CommonSpecialRegisters;
+use crate::hypervisor::vm::HypervisorType;
 #[cfg(not(gdb))]
 use crate::hypervisor::vm::Vm;
+use crate::hypervisor::vm::get_available_hypervisor;
 #[cfg(kvm)]
 use crate::hypervisor::vm::kvm::KvmVm;
 #[cfg(mshv3)]
@@ -59,7 +61,6 @@ use crate::mem::shared_mem::HostSharedMemory;
 use crate::metrics::{METRIC_ERRONEOUS_VCPU_KICKS, METRIC_GUEST_CANCELLATION};
 use crate::sandbox::SandboxConfiguration;
 use crate::sandbox::host_funcs::FunctionRegistry;
-use crate::sandbox::hypervisor::{HypervisorType, get_available_hypervisor};
 use crate::sandbox::outb::handle_outb;
 #[cfg(feature = "mem_profile")]
 use crate::sandbox::trace::MemTraceInfo;

src/hyperlight_host/src/hypervisor/vm/mod.rs

@@ -1,3 +1,5 @@
+use tracing::{Span, instrument};
+
 use crate::Result;
 use crate::hypervisor::regs::{CommonFpu, CommonRegisters, CommonSpecialRegisters};
 use crate::mem::memory_region::MemoryRegion;
@@ -12,6 +14,77 @@ pub(crate) mod mshv;
 #[cfg(target_os = "windows")]
 pub(crate) mod whp;
 
+use std::sync::OnceLock;
+
+static AVAILABLE_HYPERVISOR: OnceLock<Option<HypervisorType>> = OnceLock::new();
+
+/// Returns which type of hypervisor is available, if any
+pub fn get_available_hypervisor() -> &'static Option<HypervisorType> {
+    AVAILABLE_HYPERVISOR.get_or_init(|| {
+        cfg_if::cfg_if! {
+            if #[cfg(all(kvm, mshv3))] {
+                // If both features are enabled, we need to determine hypervisor at runtime.
+                // Currently /dev/kvm and /dev/mshv cannot exist on the same machine, so the first one
+                // that works is guaranteed to be correct.
+                if mshv::is_hypervisor_present() {
+                    Some(HypervisorType::Mshv)
+                } else if kvm::is_hypervisor_present() {
+                    Some(HypervisorType::Kvm)
+                } else {
+                    None
+                }
+            } else if #[cfg(kvm)] {
+                if kvm::is_hypervisor_present() {
+                    Some(HypervisorType::Kvm)
+                } else {
+                    None
+                }
+            } else if #[cfg(mshv3)] {
+                if mshv::is_hypervisor_present() {
+                    Some(HypervisorType::Mshv)
+                } else {
+                    None
+                }
+            } else if #[cfg(target_os = "windows")] {
+                if whp::is_hypervisor_present() {
+                    Some(HypervisorType::Whp)
+                } else {
+                    None
+                }
+            } else {
+                None
+            }
+        }
+    })
+}
+
+/// Returns `true` if a suitable hypervisor is available.
+/// If this returns `false`, no hypervisor-backed sandboxes can be created.
+#[instrument(skip_all, parent = Span::current())]
+pub fn is_hypervisor_present() -> bool {
+    get_available_hypervisor().is_some()
+}
+
+/// The hypervisor types available for the current platform
+#[derive(PartialEq, Eq, Debug)]
+pub(crate) enum HypervisorType {
+    #[cfg(kvm)]
+    Kvm,
+
+    #[cfg(mshv3)]
+    Mshv,
+
+    #[cfg(target_os = "windows")]
+    Whp,
+}
+
+// Compiler error if no hypervisor type is available
+#[cfg(not(any(kvm, mshv3, target_os = "windows")))]
+compile_error!(
+    "No hypervisor type is available for the current platform. Please enable either the `kvm` or `mshv3` cargo feature."
+);
+
+/// The various reasons a VM's vCPU can exit
 pub(crate) enum VmExit {
     /// The vCPU has exited due to a debug event (usually breakpoint)
     #[cfg(gdb)]
@@ -88,3 +161,26 @@ pub(crate) trait Vm: Debug + Send {
     #[cfg(target_os = "windows")]
     fn complete_initial_memory_setup(&mut self);
 }
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    // TODO: add support for testing on WHP
+    #[cfg(target_os = "linux")]
+    fn is_hypervisor_present() {
+        use std::path::Path;
+
+        cfg_if::cfg_if! {
+            if #[cfg(all(kvm, mshv3))] {
+                assert_eq!(Path::new("/dev/kvm").exists() || Path::new("/dev/mshv").exists(), super::is_hypervisor_present());
+            } else if #[cfg(kvm)] {
+                assert_eq!(Path::new("/dev/kvm").exists(), super::is_hypervisor_present());
+            } else if #[cfg(mshv3)] {
+                assert_eq!(Path::new("/dev/mshv").exists(), super::is_hypervisor_present());
+            } else {
+                assert!(!super::is_hypervisor_present());
+            }
+        }
+    }
+}

src/hyperlight_host/src/lib.rs

@@ -85,13 +85,13 @@ pub(crate) mod testing;
 
 /// The re-export for the `HyperlightError` type
 pub use error::HyperlightError;
+/// The re-export for the `is_hypervisor_present` type
+pub use hypervisor::vm::is_hypervisor_present;
 /// A sandbox that can call be used to make multiple calls to guest functions,
 /// and otherwise reused multiple times
 pub use sandbox::MultiUseSandbox;
 /// The re-export for the `UninitializedSandbox` type
 pub use sandbox::UninitializedSandbox;
-/// The re-export for the `is_hypervisor_present` type
-pub use sandbox::is_hypervisor_present;
 /// The re-export for the `GuestBinary` type
 pub use sandbox::uninitialized::GuestBinary;
 

src/hyperlight_host/src/sandbox/hypervisor.rs

@@ -18,8 +18,6 @@ limitations under the License.
 pub mod config;
 /// Functionality for reading, but not modifying host functions
 pub(crate) mod host_funcs;
-/// Functionality for dealing with `Sandbox`es that contain Hypervisors
-pub(crate) mod hypervisor;
 /// Functionality for dealing with initialized sandboxes that can
 /// call 0 or more guest functions
 pub mod initialized_multi_use;
@@ -47,21 +45,11 @@ pub use callable::Callable;
 pub use config::SandboxConfiguration;
 /// Re-export for the `MultiUseSandbox` type
 pub use initialized_multi_use::MultiUseSandbox;
-use tracing::{Span, instrument};
 /// Re-export for `GuestBinary` type
 pub use uninitialized::GuestBinary;
 /// Re-export for `UninitializedSandbox` type
 pub use uninitialized::UninitializedSandbox;
 
-/// Determine whether a suitable hypervisor is available to run
-/// this sandbox.
-///
-///  Returns a boolean indicating whether a suitable hypervisor is present.
-#[instrument(skip_all, parent = Span::current())]
-pub fn is_hypervisor_present() -> bool {
-    hypervisor::get_available_hypervisor().is_some()
-}
-
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;
@@ -73,25 +61,6 @@ mod tests {
     use crate::sandbox::uninitialized::GuestBinary;
     use crate::{MultiUseSandbox, UninitializedSandbox, new_error};
 
-    #[test]
-    // TODO: add support for testing on WHP
-    #[cfg(target_os = "linux")]
-    fn is_hypervisor_present() {
-        use std::path::Path;
-
-        cfg_if::cfg_if! {
-            if #[cfg(all(kvm, mshv3))] {
-                assert_eq!(Path::new("/dev/kvm").exists() || Path::new("/dev/mshv").exists(), super::is_hypervisor_present());
-            } else if #[cfg(kvm)] {
-                assert_eq!(Path::new("/dev/kvm").exists(), super::is_hypervisor_present());
-            } else if #[cfg(mshv3)] {
-                assert_eq!(Path::new("/dev/mshv").exists(), super::is_hypervisor_present());
-            } else {
-                assert!(!super::is_hypervisor_present());
-            }
-        }
-    }
-
     #[test]
     fn check_create_and_use_sandbox_on_different_threads() {
         let unintializedsandbox_queue = Arc::new(ArrayQueue::<UninitializedSandbox>::new(10));