[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"]
 # This feature is deprecated in favor of mshv3
 mshv2 = ["dep:mshv-bindings2", "dep:mshv-ioctls2"]

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::{
@@ -547,6 +554,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(
@@ -1093,6 +1113,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

@@ -44,6 +44,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;
@@ -1043,6 +1045,18 @@ impl Hypervisor for HypervWindowsDriver {
 
         Ok(())
     }
+
+    #[cfg(feature = "unwind_guest")]
+    fn read_trace_reg(&self, reg: TraceRegister) -> Result<u64> {
+        let regs = self.processor.get_regs()?;
+        match reg {
+            TraceRegister::RAX => Ok(regs.rax),
+            TraceRegister::RCX => Ok(regs.rcx),
+            TraceRegister::RIP => Ok(regs.rip),
+            TraceRegister::RSP => Ok(regs.rsp),
+            TraceRegister::RBP => Ok(regs.rbp),
+        }
+    }
 }
 
 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};
@@ -962,6 +964,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
@@ -251,6 +266,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