gdb: update mshv hypervisor to use the arch specific logic to determine stop reason

Signed-off-by: Doru Blânzeanu <[email protected]>

Author: dblnz

src/hyperlight_host/src/hypervisor/gdb/mshv_debug.rs

@@ -32,7 +32,7 @@ use mshv_bindings::{
 };
 use mshv_ioctls::VcpuFd;
 
-use super::arch::{DR6_BS_FLAG_MASK, DR6_HW_BP_FLAGS_MASK, MAX_NO_OF_HW_BP, SW_BP_SIZE};
+use super::arch::{vcpu_stop_reason, MAX_NO_OF_HW_BP, SW_BP_SIZE};
 use super::{GuestDebug, VcpuStopReason, X86_64Regs};
 use crate::{new_error, HyperlightError, Result};
 
@@ -131,52 +131,38 @@ impl MshvDebug {
     pub(crate) fn get_stop_reason(
         &mut self,
         vcpu_fd: &VcpuFd,
+        exception: u16,
         entrypoint: u64,
     ) -> Result<VcpuStopReason> {
-        // MSHV does not provide info on the vCPU exits but the debug
-        // information can be retrieved from the DEBUG REGISTERS
         let regs = vcpu_fd
             .get_debug_regs()
             .map_err(|e| new_error!("Cannot retrieve debug registers from vCPU: {}", e))?;
 
         // DR6 register contains debug state related information
         let debug_status = regs.dr6;
 
-        // If the BS flag in DR6 register is set, it means a single step
-        // instruction triggered the exit
-        // Check page 19-4 Vol. 3B of Intel 64 and IA-32
-        // Architectures Software Developer's Manual
-        if debug_status & DR6_BS_FLAG_MASK != 0 && self.single_step {
-            return Ok(VcpuStopReason::DoneStep);
-        }
+        let rip = self.get_instruction_pointer(vcpu_fd)?;
+        let rip = self.translate_gva(vcpu_fd, rip)?;
 
-        let ip = self.get_instruction_pointer(vcpu_fd)?;
-        let gpa = self.translate_gva(vcpu_fd, ip)?;
+        let reason = vcpu_stop_reason(
+            self.single_step,
+            rip,
+            debug_status,
+            entrypoint,
+            exception as u32,
+            &self.hw_breakpoints,
+            &self.sw_breakpoints,
+        );
 
-        // If any of the B0-B3 flags in DR6 register is set, it means a
-        // hardware breakpoint triggered the exit
-        // Check page 19-4 Vol. 3B of Intel 64 and IA-32
-        // Architectures Software Developer's Manual
-        if debug_status & DR6_HW_BP_FLAGS_MASK != 0 && self.hw_breakpoints.contains(&gpa) {
+        if let VcpuStopReason::EntryPointBp = reason {
             // In case the hw breakpoint is the entry point, remove it to
             // avoid hanging here as gdb does not remove breakpoints it
             // has not set.
             // Gdb expects the target to be stopped when connected.
-            if gpa == entrypoint {
-                self.remove_hw_breakpoint(vcpu_fd, entrypoint)?;
-            }
-            return Ok(VcpuStopReason::HwBp);
-        }
-
-        // mshv does not provide a way to specify which exception triggered the
-        // vCPU exit as the mshv intercepts both #DB and #BP
-        // We check against the SW breakpoints Hashmap to detect whether the
-        // vCPU exited due to a SW breakpoint
-        if self.sw_breakpoints.contains_key(&gpa) {
-            return Ok(VcpuStopReason::SwBp);
+            self.remove_hw_breakpoint(vcpu_fd, entrypoint)?;
         }
 
-        Ok(VcpuStopReason::Unknown)
+        Ok(reason)
     }
 }
 

src/hyperlight_host/src/hypervisor/hyperv_linux.rs

@@ -71,6 +71,7 @@ use crate::{log_then_return, new_error, Result};
 mod debug {
     use std::sync::{Arc, Mutex};
 
+    use super::mshv_bindings::hv_x64_exception_intercept_message;
     use super::{HypervLinuxDriver, *};
     use crate::hypervisor::gdb::{DebugMsg, DebugResponse, VcpuStopReason, X86_64Regs};
     use crate::hypervisor::handlers::DbgMemAccessHandlerCaller;
@@ -89,13 +90,16 @@ mod debug {
         }
 
         /// Get the reason the vCPU has stopped
-        pub(crate) fn get_stop_reason(&mut self) -> Result<VcpuStopReason> {
+        pub(crate) fn get_stop_reason(
+            &mut self,
+            ex_info: hv_x64_exception_intercept_message,
+        ) -> Result<VcpuStopReason> {
             let debug = self
                 .debug
                 .as_mut()
                 .ok_or_else(|| new_error!("Debug is not enabled"))?;
 
-            debug.get_stop_reason(&self.vcpu_fd, self.entrypoint)
+            debug.get_stop_reason(&self.vcpu_fd, ex_info.exception_vector, self.entrypoint)
         }
 
         pub(crate) fn process_dbg_request(
@@ -626,14 +630,27 @@ impl Hypervisor for HypervLinuxDriver {
                     }
                 }
                 // The only case an intercept exit is expected is when debugging is enabled
-                // and the intercepts are installed
+                // and the intercepts are installed.
+                // Provide the extra information about the exception to accurately determine
+                // the stop reason
                 #[cfg(gdb)]
-                EXCEPTION_INTERCEPT => match self.get_stop_reason() {
-                    Ok(reason) => HyperlightExit::Debug(reason),
-                    Err(e) => {
-                        log_then_return!("Error getting stop reason: {:?}", e);
+                EXCEPTION_INTERCEPT => {
+                    // Extract exception info from the message so we can figure out
+                    // more information about the vCPU state
+                    let ex_info = match m.to_exception_info() {
+                        Ok(info) => info,
+                        Err(e) => {
+                            log_then_return!("Error converting to exception info: {:?}", e);
+                        }
+                    };
+
+                    match self.get_stop_reason(ex_info) {
+                        Ok(reason) => HyperlightExit::Debug(reason),
+                        Err(e) => {
+                            log_then_return!("Error getting stop reason: {:?}", e);
+                        }
                     }
-                },
+                }
                 other => {
                     crate::debug!("mshv Other Exit: Exit: {:#?} \n {:#?}", other, &self);
                     log_then_return!("unknown Hyper-V run message type {:?}", other);