add sw breakpoint support

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

Author: dblnz

src/hyperlight_host/src/hypervisor/gdb/mod.rs

@@ -84,27 +84,31 @@ pub enum VcpuStopReason {
 /// Enumerates the possible actions that a debugger can ask from a Hypervisor
 pub enum DebugMsg {
     AddHwBreakpoint(u64),
+    AddSwBreakpoint(u64),
     Continue,
     DisableDebug,
     GetCodeSectionOffset,
     ReadAddr(u64, usize),
     ReadRegisters,
     RemoveHwBreakpoint(u64),
+    RemoveSwBreakpoint(u64),
     Step,
     WriteAddr(u64, Vec<u8>),
     WriteRegisters(X86_64Regs),
 }
 
 #[derive(Debug)]
-/// Enumerates the possible responses that a hypervisor can provide to a debugger 
+/// Enumerates the possible responses that a hypervisor can provide to a debugger
 pub enum DebugResponse {
     AddHwBreakpoint(bool),
+    AddSwBreakpoint(bool),
     Continue,
     DisableDebug,
     GetCodeSectionOffset(u64),
     ReadAddr(Vec<u8>),
     ReadRegisters(X86_64Regs),
     RemoveHwBreakpoint(bool),
+    RemoveSwBreakpoint(bool),
     Step,
     VcpuStopped(VcpuStopReason),
     WriteAddr,

src/hyperlight_host/src/hypervisor/gdb/x86_64_target.rs

@@ -7,7 +7,7 @@ use gdbstub::target::ext::base::singlethread::{
 };
 use gdbstub::target::ext::base::BaseOps;
 use gdbstub::target::ext::breakpoints::{
-    Breakpoints, BreakpointsOps, HwBreakpoint, HwBreakpointOps,
+    Breakpoints, BreakpointsOps, HwBreakpoint, HwBreakpointOps, SwBreakpoint, SwBreakpointOps,
 };
 use gdbstub::target::ext::section_offsets::{Offsets, SectionOffsets};
 use gdbstub::target::{Target, TargetError, TargetResult};
@@ -83,6 +83,11 @@ impl Target for HyperlightSandboxTarget {
     type Arch = GdbTargetArch;
     type Error = GdbTargetError;
 
+    #[inline(always)]
+    fn guard_rail_implicit_sw_breakpoints(&self) -> bool {
+        true
+    }
+
     fn support_breakpoints(&mut self) -> Option<BreakpointsOps<Self>> {
         Some(self)
     }
@@ -215,6 +220,7 @@ impl SingleThreadBase for HyperlightSandboxTarget {
         Some(self)
     }
 }
+
 impl SectionOffsets for HyperlightSandboxTarget {
     fn get_section_offsets(&mut self) -> Result<Offsets<<Self::Arch as Arch>::Usize>, Self::Error> {
         log::debug!("Get section offsets");
@@ -236,6 +242,9 @@ impl Breakpoints for HyperlightSandboxTarget {
     fn support_hw_breakpoint(&mut self) -> Option<HwBreakpointOps<Self>> {
         Some(self)
     }
+    fn support_sw_breakpoint(&mut self) -> Option<SwBreakpointOps<'_, Self>> {
+        Some(self)
+    }
 }
 
 impl HwBreakpoint for HyperlightSandboxTarget {
@@ -272,6 +281,40 @@ impl HwBreakpoint for HyperlightSandboxTarget {
     }
 }
 
+impl SwBreakpoint for HyperlightSandboxTarget {
+    fn add_sw_breakpoint(
+        &mut self,
+        addr: <Self::Arch as Arch>::Usize,
+        _kind: <Self::Arch as Arch>::BreakpointKind,
+    ) -> TargetResult<bool, Self> {
+        log::debug!("Add sw breakpoint at address {:X}", addr);
+
+        match self.send_command(DebugMsg::AddSwBreakpoint(addr))? {
+            DebugResponse::AddSwBreakpoint(rsp) => Ok(rsp),
+            msg => {
+                log::error!("Unexpected message received: {:?}", msg);
+                Err(TargetError::Fatal(GdbTargetError::UnexpectedMessage))
+            }
+        }
+    }
+
+    fn remove_sw_breakpoint(
+        &mut self,
+        addr: <Self::Arch as Arch>::Usize,
+        _kind: <Self::Arch as Arch>::BreakpointKind,
+    ) -> TargetResult<bool, Self> {
+        log::debug!("Remove sw breakpoint at address {:X}", addr);
+
+        match self.send_command(DebugMsg::RemoveSwBreakpoint(addr))? {
+            DebugResponse::RemoveSwBreakpoint(rsp) => Ok(rsp),
+            msg => {
+                log::error!("Unexpected message received: {:?}", msg);
+                Err(TargetError::Fatal(GdbTargetError::UnexpectedMessage))
+            }
+        }
+    }
+}
+
 impl SingleThreadResume for HyperlightSandboxTarget {
     fn resume(&mut self, _signal: Option<Signal>) -> Result<(), Self::Error> {
         log::debug!("Resume");

src/hyperlight_host/src/hypervisor/kvm.rs

@@ -65,6 +65,7 @@ pub(crate) fn is_hypervisor_present() -> bool {
 
 #[cfg(gdb)]
 mod debug {
+    use std::collections::HashMap;
     use std::sync::{Arc, Mutex};
 
     use hyperlight_common::mem::PAGE_SIZE;
@@ -80,6 +81,13 @@ mod debug {
     use crate::mem::layout::SandboxMemoryLayout;
     use crate::{new_error, Result};
 
+    /// Software Breakpoint size in memory
+    pub const SW_BP_SIZE: usize = 1;
+    /// Software Breakpoinnt opcode
+    const SW_BP_OP: u8 = 0xCC;
+    /// Software Breakpoint written to memory
+    pub const SW_BP: [u8; SW_BP_SIZE] = [SW_BP_OP];
+
     /// KVM Debug struct
     /// This struct is used to abstract the internal details of the kvm
     /// guest debugging settings
@@ -90,6 +98,8 @@ mod debug {
 
         /// 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]>,
 
         /// Sent to KVM for enabling guest debug
         pub dbg_cfg: kvm_guest_debug,
@@ -107,6 +117,7 @@ mod debug {
             Self {
                 single_step: false,
                 hw_breakpoints: vec![],
+                sw_breakpoints: HashMap::new(),
                 dbg_cfg: dbg,
             }
         }
@@ -380,6 +391,69 @@ mod debug {
             }
         }
 
+        pub fn add_sw_breakpoint(
+            &mut self,
+            addr: u64,
+            dbg_mem_access_fn: Arc<Mutex<dyn DbgMemAccessHandlerCaller>>,
+        ) -> Result<bool> {
+            let addr = {
+                let debug = self
+                    .debug
+                    .as_ref()
+                    .ok_or_else(|| new_error!("Debug is not enabled"))?;
+                let addr = self.translate_gva(addr)?;
+                if debug.sw_breakpoints.contains_key(&addr) {
+                    return Ok(true);
+                }
+
+                addr
+            };
+
+            let mut save_data = [0; SW_BP_SIZE];
+            self.read_addrs(addr, &mut save_data[..], dbg_mem_access_fn.clone())?;
+            self.write_addrs(addr, &SW_BP, dbg_mem_access_fn.clone())?;
+
+            {
+                let debug = self
+                    .debug
+                    .as_mut()
+                    .ok_or_else(|| new_error!("Debug is not enabled"))?;
+                debug.sw_breakpoints.insert(addr, save_data);
+            }
+
+            Ok(true)
+        }
+
+        pub fn remove_sw_breakpoint(
+            &mut self,
+            addr: u64,
+            dbg_mem_access_fn: Arc<Mutex<dyn DbgMemAccessHandlerCaller>>,
+        ) -> Result<bool> {
+            let (ret, data) = {
+                let addr = self.translate_gva(addr)?;
+                let debug = self
+                    .debug
+                    .as_mut()
+                    .ok_or_else(|| new_error!("Debug is not enabled"))?;
+
+                if debug.sw_breakpoints.contains_key(&addr) {
+                    let save_data = debug
+                        .sw_breakpoints
+                        .remove(&addr)
+                        .expect("Expected the hashmap to contain the address");
+
+                    (true, Some(save_data))
+                } else {
+                    (false, None)
+                }
+            };
+
+            if ret {
+                self.write_addrs(addr, &data.unwrap(), dbg_mem_access_fn.clone())?;
+            }
+
+            Ok(ret)
+        }
 
         /// Get the reason the vCPU has stopped
         pub fn get_stop_reason(&self) -> Result<VcpuStopReason> {
@@ -394,6 +468,9 @@ mod debug {
 
             let ip = self.get_instruction_pointer()?;
             let gpa = self.translate_gva(ip)?;
+            if debug.sw_breakpoints.contains_key(&gpa) {
+                return Ok(VcpuStopReason::SwBp);
+            }
 
             if debug.hw_breakpoints.contains(&gpa) {
                 return Ok(VcpuStopReason::HwBp);
@@ -418,6 +495,13 @@ mod debug {
                         .expect("Add hw breakpoint error");
                     Ok(DebugResponse::AddHwBreakpoint(res))
                 }
+                DebugMsg::AddSwBreakpoint(addr) => {
+                    let res = self
+                        .add_sw_breakpoint(addr, dbg_mem_access_fn.clone())
+                        .expect("Add sw breakpoint error");
+
+                    Ok(DebugResponse::AddSwBreakpoint(res))
+                }
                 DebugMsg::Continue => {
                     self.set_single_step(false)?;
                     Ok(DebugResponse::Continue)
@@ -454,6 +538,12 @@ mod debug {
                         .expect("Remove hw breakpoint error");
                     Ok(DebugResponse::RemoveHwBreakpoint(res))
                 }
+                DebugMsg::RemoveSwBreakpoint(addr) => {
+                    let res = self
+                        .remove_sw_breakpoint(addr, dbg_mem_access_fn.clone())
+                        .expect("Remove sw breakpoint error");
+                    Ok(DebugResponse::RemoveSwBreakpoint(res))
+                }
                 DebugMsg::Step => {
                     self.set_single_step(true)?;
                     Ok(DebugResponse::Step)