add stepping support

- also adds handling of gdb client disconnect by resuming execution

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

Author: dblnz

src/hyperlight_host/src/hypervisor/gdb/event_loop.rs

@@ -83,6 +83,9 @@ pub fn event_loop_thread(
         Ok(disconnect_reason) => match disconnect_reason {
             DisconnectReason::Disconnect => { 
                 log::info!("Gdb client disconnected");
+                if let Err(e) = target.disable_debug() {
+                    log::error!("Cannot disable debugging: {:?}", e);
+                }
             }
             DisconnectReason::TargetExited(_) => {
                 log::info!("Guest finalized execution and disconnected");

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

@@ -85,8 +85,10 @@ pub enum VcpuStopReason {
 pub enum DebugMsg {
     AddHwBreakpoint(u64),
     Continue,
+    DisableDebug,
     ReadRegisters,
     RemoveHwBreakpoint(u64),
+    Step,
     WriteRegisters(X86_64Regs),
 }
 
@@ -95,8 +97,10 @@ pub enum DebugMsg {
 pub enum DebugResponse {
     AddHwBreakpoint(bool),
     Continue,
+    DisableDebug,
     ReadRegisters(X86_64Regs),
     RemoveHwBreakpoint(bool),
+    Step,
     VcpuStopped(VcpuStopReason),
     WriteRegisters,
 }

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

@@ -2,7 +2,8 @@ use crossbeam_channel::TryRecvError;
 use gdbstub::arch::Arch;
 use gdbstub::common::Signal;
 use gdbstub::target::ext::base::singlethread::{
-    SingleThreadBase, SingleThreadResume, SingleThreadResumeOps,
+    SingleThreadBase, SingleThreadResume, SingleThreadResumeOps, SingleThreadSingleStep,
+    SingleThreadSingleStepOps,
 };
 use gdbstub::target::ext::base::BaseOps;
 use gdbstub::target::ext::breakpoints::{
@@ -61,6 +62,20 @@ impl HyperlightSandboxTarget {
         }
     }
 
+    /// Sends an event to the Hypervisor that tells it to disable debugging
+    /// and continue executing until end
+    /// Note: The method waits for a confirmation message
+    pub fn disable_debug(&mut self) -> Result<(), GdbTargetError> {
+        log::info!("Disable debugging and continue until end");
+
+        match self.send_command(DebugMsg::DisableDebug)? {
+            DebugResponse::DisableDebug => Ok(()),
+            msg => {
+                log::error!("Unexpected message received: {:?}", msg);
+                Err(GdbTargetError::UnexpectedMessage)
+            }
+        }
+    }
 }
 
 impl Target for HyperlightSandboxTarget {
@@ -222,4 +237,23 @@ impl SingleThreadResume for HyperlightSandboxTarget {
         log::debug!("Resume");
         self.resume_vcpu()
     }
+    fn support_single_step(&mut self) -> Option<SingleThreadSingleStepOps<Self>> {
+        Some(self)
+    }
+}
+
+impl SingleThreadSingleStep for HyperlightSandboxTarget {
+    fn step(&mut self, signal: Option<Signal>) -> Result<(), Self::Error> {
+        assert!(signal.is_none());
+
+        log::debug!("Step");
+        match self.send_command(DebugMsg::Step)? {
+            DebugResponse::Step => Ok(()),
+            msg => {
+                log::error!("Unexpected message received: {:?}", msg);
+
+                Err(GdbTargetError::UnexpectedMessage)
+            }
+        }
+    }
 }

src/hyperlight_host/src/hypervisor/kvm.rs

@@ -74,6 +74,7 @@ mod debug {
     /// KVM Debug struct
     /// This struct is used to abstract the internal details of the kvm
     /// guest debugging settings
+    #[derive(Default)]
     pub struct KvmDebug {
         /// vCPU stepping state
         single_step: bool,
@@ -144,6 +145,12 @@ mod debug {
     }
 
     impl KVMDriver {
+        /// Resets the debug information to disable debugging
+        fn disable_debug(&mut self) -> Result<()> {
+            self.debug = Some(KvmDebug::default());
+
+            self.set_single_step(false)
+        }
 
         /// Returns the instruction pointer from the stopped vCPU
         pub fn get_instruction_pointer(&self) -> Result<u64> {
@@ -341,6 +348,11 @@ mod debug {
                     self.set_single_step(false)?;
                     Ok(DebugResponse::Continue)
                 }
+                DebugMsg::DisableDebug => {
+                    self.disable_debug()?;
+
+                    Ok(DebugResponse::DisableDebug)
+                }
                 DebugMsg::ReadRegisters => {
                     let mut regs = X86_64Regs::default();
                     self.read_regs(&mut regs).expect("Read Regs error");
@@ -352,6 +364,10 @@ mod debug {
                         .expect("Remove hw breakpoint error");
                     Ok(DebugResponse::RemoveHwBreakpoint(res))
                 }
+                DebugMsg::Step => {
+                    self.set_single_step(true)?;
+                    Ok(DebugResponse::Step)
+                }
                 DebugMsg::WriteRegisters(regs) => {
                     self.write_regs(&regs).expect("Write Regs error");
                     Ok(DebugResponse::WriteRegisters)
@@ -713,7 +729,7 @@ impl Hypervisor for KVMDriver {
             // If the command was either step or continue, we need to run the vcpu
             let cont = matches!(
                 response,
-                DebugResponse::Continue
+                DebugResponse::Step | DebugResponse::Continue | DebugResponse::DisableDebug
             );
 
             self.send_dbg_msg(response)