[hyperlight_host/trace] Add HV interface for reading trace registers

This adds a new interface which tracing code can use to request the
values of registers from the hypervisor supervising a sandbox.

Signed-off-by: Lucy Menon <[email protected]>

Author: syntactically

src/hyperlight_host/Cargo.toml

@@ -129,6 +129,9 @@ print_debug = []
 # Dumps the VM state to a file on unexpected errors or crashes. The path of the file will be printed on stdout and logged.
 crashdump = ["dep:chrono"]
 trace_guest = []
+# This feature enables unwinding the guest stack from the host, in
+# order to produce stack traces for debugging or profiling.
+unwind_guest = [ "trace_guest" ]
 kvm = ["dep:kvm-bindings", "dep:kvm-ioctls"]
 mshv2 = ["dep:mshv-bindings2", "dep:mshv-ioctls2"]
 mshv3 = ["dep:mshv-bindings3", "dep:mshv-ioctls3"]

src/hyperlight_host/src/hypervisor/hyperv_linux.rs

@@ -48,11 +48,18 @@ use mshv_bindings::{
     hv_partition_property_code_HV_PARTITION_PROPERTY_SYNTHETIC_PROC_FEATURES,
     hv_partition_synthetic_processor_features,
 };
+#[cfg(feature = "unwind_guest")]
+use mshv_bindings::{
+    hv_register_name, hv_register_name_HV_X64_REGISTER_RAX, hv_register_name_HV_X64_REGISTER_RBP,
+    hv_register_name_HV_X64_REGISTER_RCX, hv_register_name_HV_X64_REGISTER_RSP,
+};
 use mshv_ioctls::{Mshv, MshvError, VcpuFd, VmFd};
 use tracing::{Span, instrument};
 #[cfg(crashdump)]
 use {super::crashdump, std::path::Path};
 
+#[cfg(feature = "unwind_guest")]
+use super::TraceRegister;
 use super::fpu::{FP_CONTROL_WORD_DEFAULT, FP_TAG_WORD_DEFAULT, MXCSR_DEFAULT};
 #[cfg(gdb)]
 use super::gdb::{
@@ -522,6 +529,19 @@ impl Debug for HypervLinuxDriver {
     }
 }
 
+#[cfg(feature = "unwind_guest")]
+impl From<TraceRegister> for hv_register_name {
+    fn from(r: TraceRegister) -> Self {
+        match r {
+            TraceRegister::RAX => hv_register_name_HV_X64_REGISTER_RAX,
+            TraceRegister::RCX => hv_register_name_HV_X64_REGISTER_RCX,
+            TraceRegister::RIP => hv_register_name_HV_X64_REGISTER_RIP,
+            TraceRegister::RSP => hv_register_name_HV_X64_REGISTER_RSP,
+            TraceRegister::RBP => hv_register_name_HV_X64_REGISTER_RBP,
+        }
+    }
+}
+
 impl Hypervisor for HypervLinuxDriver {
     #[instrument(err(Debug), skip_all, parent = Span::current(), level = "Trace")]
     fn initialise(
@@ -1037,6 +1057,17 @@ impl Hypervisor for HypervLinuxDriver {
 
         Ok(())
     }
+
+    #[cfg(feature = "unwind_guest")]
+    fn read_trace_reg(&self, reg: TraceRegister) -> Result<u64> {
+        let mut assoc = [hv_register_assoc {
+            name: reg.into(),
+            ..Default::default()
+        }];
+        self.vcpu_fd.get_reg(&mut assoc)?;
+        // safety: all registers that we currently support are 64-bit
+        unsafe { Ok(assoc[0].value.reg64) }
+    }
 }
 
 impl Drop for HypervLinuxDriver {

src/hyperlight_host/src/hypervisor/hyperv_windows.rs

@@ -22,6 +22,8 @@ use std::sync::atomic::{AtomicBool, Ordering};
 
 use log::LevelFilter;
 use tracing::{Span, instrument};
+#[cfg(feature = "trace_guest")]
+use windows::Win32::System::Hypervisor::WHV_REGISTER_NAME;
 use windows::Win32::System::Hypervisor::{
     WHV_MEMORY_ACCESS_TYPE, WHV_PARTITION_HANDLE, WHV_REGISTER_VALUE, WHV_RUN_VP_EXIT_CONTEXT,
     WHV_RUN_VP_EXIT_REASON, WHV_X64_SEGMENT_REGISTER, WHV_X64_SEGMENT_REGISTER_0,
@@ -41,6 +43,8 @@ use {
     std::sync::Mutex,
 };
 
+#[cfg(feature = "unwind_guest")]
+use super::TraceRegister;
 use super::fpu::{FP_TAG_WORD_DEFAULT, MXCSR_DEFAULT};
 use super::handlers::{MemAccessHandlerWrapper, OutBHandlerWrapper};
 use super::surrogate_process::SurrogateProcess;
@@ -571,6 +575,19 @@ impl Debug for HypervWindowsDriver {
     }
 }
 
+#[cfg(feature = "trace_guest")]
+impl From<TraceRegister> for WHV_REGISTER_NAME {
+    fn from(r: TraceRegister) -> Self {
+        match r {
+            TraceRegister::RAX => windows::Win32::System::Hypervisor::WHvX64RegisterRax,
+            TraceRegister::RCX => windows::Win32::System::Hypervisor::WHvX64RegisterRcx,
+            TraceRegister::RIP => windows::Win32::System::Hypervisor::WHvX64RegisterRip,
+            TraceRegister::RSP => windows::Win32::System::Hypervisor::WHvX64RegisterRsp,
+            TraceRegister::RBP => windows::Win32::System::Hypervisor::WHvX64RegisterRbp,
+        }
+    }
+}
+
 impl Hypervisor for HypervWindowsDriver {
     #[instrument(err(Debug), skip_all, parent = Span::current(), level = "Trace")]
     fn initialise(
@@ -1022,6 +1039,23 @@ impl Hypervisor for HypervWindowsDriver {
 
         Ok(())
     }
+
+    #[cfg(feature = "unwind_guest")]
+    fn read_trace_reg(&self, reg: TraceRegister) -> Result<u64> {
+        let register_names = [WHV_REGISTER_NAME::from(reg)];
+        let mut register_values: [WHV_REGISTER_VALUE; 1] = Default::default();
+        unsafe {
+            WHvGetVirtualProcessorRegisters(
+                self.get_partition_hdl(),
+                0,
+                register_names.as_ptr(),
+                register_names.len() as u32,
+                register_values.as_mut_ptr(),
+            )?;
+            // safety: all registers that we currently support are 64-bit
+            Ok(register_values[0].Reg64)
+        }
+    }
 }
 
 impl Drop for HypervWindowsDriver {

src/hyperlight_host/src/hypervisor/kvm.rs

@@ -29,6 +29,8 @@ use tracing::{Span, instrument};
 #[cfg(crashdump)]
 use {super::crashdump, std::path::Path};
 
+#[cfg(feature = "unwind_guest")]
+use super::TraceRegister;
 use super::fpu::{FP_CONTROL_WORD_DEFAULT, FP_TAG_WORD_DEFAULT, MXCSR_DEFAULT};
 #[cfg(gdb)]
 use super::gdb::{DebugCommChannel, DebugMsg, DebugResponse, GuestDebug, KvmDebug, VcpuStopReason};
@@ -934,6 +936,18 @@ impl Hypervisor for KVMDriver {
 
         Ok(())
     }
+
+    #[cfg(feature = "unwind_guest")]
+    fn read_trace_reg(&self, reg: TraceRegister) -> Result<u64> {
+        let regs = self.vcpu_fd.get_regs()?;
+        Ok(match reg {
+            TraceRegister::RAX => regs.rax,
+            TraceRegister::RCX => regs.rcx,
+            TraceRegister::RIP => regs.rip,
+            TraceRegister::RSP => regs.rsp,
+            TraceRegister::RBP => regs.rbp,
+        })
+    }
 }
 
 impl Drop for KVMDriver {

src/hyperlight_host/src/hypervisor/mod.rs

@@ -116,6 +116,21 @@ pub enum HyperlightExit {
     Retry(),
 }
 
+/// Registers which may be useful for tracing/stack unwinding
+#[cfg(feature = "trace_guest")]
+pub enum TraceRegister {
+    /// RAX
+    RAX,
+    /// RCX
+    RCX,
+    /// RIP
+    RIP,
+    /// RSP
+    RSP,
+    /// RBP
+    RBP,
+}
+
 /// A common set of hypervisor functionality
 pub(crate) trait Hypervisor: Debug + Sync + Send {
     /// Initialise the internally stored vCPU with the given PEB address and
@@ -242,6 +257,10 @@ pub(crate) trait Hypervisor: Debug + Sync + Send {
     ) -> Result<()> {
         unimplemented!()
     }
+
+    /// Read a register for trace/unwind purposes
+    #[cfg(feature = "unwind_guest")]
+    fn read_trace_reg(&self, reg: TraceRegister) -> Result<u64>;
 }
 
 /// A virtual CPU that can be run until an exit occurs