dbg: mshv guest debugging support for memory inspection

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

Author: dblnz

src/hyperlight_host/src/hypervisor/gdb/hyp_debug.rs

@@ -492,6 +492,8 @@ pub mod kvm {
 
 #[cfg(mshv)]
 pub mod mshv {
+    use std::collections::HashMap;
+
     use mshv_bindings::{
         DebugRegisters, StandardRegisters, HV_TRANSLATE_GVA_VALIDATE_READ,
         HV_TRANSLATE_GVA_VALIDATE_WRITE,
@@ -508,6 +510,9 @@ pub mod mshv {
 
         /// Array of addresses for HW breakpoints
         hw_breakpoints: Vec<u64>,
+        /// Saves the bytes modified to enable SW breakpoints
+        sw_breakpoints: HashMap<u64, [u8; SW_BP_SIZE]>,
+
         /// Debug registers
         pub dbg_cfg: DebugRegisters,
     }
@@ -517,6 +522,7 @@ pub mod mshv {
             Self {
                 single_step: false,
                 hw_breakpoints: vec![],
+                sw_breakpoints: HashMap::new(),
                 dbg_cfg: DebugRegisters::default(),
             }
         }
@@ -621,6 +627,14 @@ pub mod mshv {
                 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);
+            }
+
             Ok(VcpuStopReason::Unknown)
         }
     }
@@ -715,4 +729,16 @@ pub mod mshv {
                 .map_err(|e| new_error!("Could not write guest registers: {:?}", e))
         }
     }
+
+    impl GuestMemoryDebug for MshvDebug {
+        fn is_sw_breakpoint(&self, addr: &u64) -> bool {
+            self.sw_breakpoints.contains_key(addr)
+        }
+        fn save_sw_breakpoint_data(&mut self, addr: u64, data: [u8; 1]) {
+            _ = self.sw_breakpoints.insert(addr, data);
+        }
+        fn delete_sw_breakpoint_data(&mut self, addr: &u64) -> Option<[u8; 1]> {
+            self.sw_breakpoints.remove(addr)
+        }
+    }
 }

src/hyperlight_host/src/hypervisor/hyperv_linux.rs

@@ -72,7 +72,9 @@ mod debug {
     use std::sync::{Arc, Mutex};
 
     use super::{HypervLinuxDriver, *};
-    use crate::hypervisor::gdb::{DebugMsg, DebugResponse, VcpuStopReason, X86_64Regs};
+    use crate::hypervisor::gdb::{
+        DebugMsg, DebugResponse, GuestMemoryDebug, VcpuStopReason, X86_64Regs,
+    };
     use crate::hypervisor::handlers::DbgMemAccessHandlerCaller;
     use crate::{new_error, Result};
 
@@ -112,6 +114,9 @@ mod debug {
 
                         Ok(DebugResponse::AddHwBreakpoint(res))
                     }
+                    DebugMsg::AddSwBreakpoint(addr) => debug
+                        .add_sw_breakpoint(&self.vcpu_fd, addr, dbg_mem_access_fn)
+                        .map(DebugResponse::AddSwBreakpoint),
                     DebugMsg::Continue => {
                         debug.set_single_step(&self.vcpu_fd, false)?;
                         Ok(DebugResponse::Continue)
@@ -131,6 +136,13 @@ mod debug {
 
                         Ok(DebugResponse::GetCodeSectionOffset(offset as u64))
                     }
+                    DebugMsg::ReadAddr(addr, len) => {
+                        let mut data = vec![0u8; len];
+
+                        debug.read_addrs(&self.vcpu_fd, addr, &mut data, dbg_mem_access_fn)?;
+
+                        Ok(DebugResponse::ReadAddr(data))
+                    }
                     DebugMsg::ReadRegisters => {
                         let mut regs = X86_64Regs::default();
                         debug.read_regs(&self.vcpu_fd, &mut regs)?;
@@ -144,16 +156,23 @@ mod debug {
 
                         Ok(DebugResponse::RemoveHwBreakpoint(res))
                     }
+                    DebugMsg::RemoveSwBreakpoint(addr) => debug
+                        .remove_sw_breakpoint(&self.vcpu_fd, addr, dbg_mem_access_fn)
+                        .map(DebugResponse::RemoveSwBreakpoint),
                     DebugMsg::Step => {
                         debug.set_single_step(&self.vcpu_fd, true)?;
                         Ok(DebugResponse::Step)
                     }
+                    DebugMsg::WriteAddr(addr, data) => {
+                        debug.write_addrs(&self.vcpu_fd, addr, &data, dbg_mem_access_fn)?;
+
+                        Ok(DebugResponse::WriteAddr)
+                    }
                     DebugMsg::WriteRegisters(regs) => {
                         debug.write_regs(&self.vcpu_fd, &regs)?;
 
                         Ok(DebugResponse::WriteRegisters)
                     }
-                    _ => Err(new_error!("Not yet implemented")),
                 }
             } else {
                 Err(new_error!("Debugging is not enabled"))