add gdb resume capabilities

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

Author: dblnz

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

@@ -34,7 +34,12 @@ impl run_blocking::BlockingEventLoop for GdbBlockingEventLoop {
                         .get_stop_reason()
                         .map_err(WaitForStopReasonError::Target)?;
 
+                    // Resume execution if unknown reason for stop
                     let Some(stop_response) = stop_reason else {
+                        target
+                            .resume_vcpu()
+                            .map_err(WaitForStopReasonError::Target)?;
+
                         continue;
                     };
 

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

@@ -18,6 +18,7 @@ pub enum GdbTargetError {
     QueueError,
     ReadRegistersError,
     ReceiveMsgError,
+    CannotResume,
     SendMsgError,
     SetGuestDebugError,
     SpawnThreadError,
@@ -26,7 +27,6 @@ pub enum GdbTargetError {
     WriteRegistersError,
 }
 
-#[allow(dead_code)]
 /// Trait that provides common communication methods for targets
 pub trait GdbDebug {
     /// Sends a message to the Hypervisor
@@ -37,7 +37,6 @@ pub trait GdbDebug {
     fn try_recv(&self) -> Result<DebugMessage, TryRecvError>;
 }
 
-#[allow(dead_code)]
 /// Event sent to the VCPU execution loop
 #[derive(Debug)]
 pub enum DebugMessage {

src/hyperlight_host/src/hypervisor/gdb/target.rs

@@ -2,9 +2,11 @@ use std::sync::{Arc, Mutex};
 
 use crossbeam_channel::TryRecvError;
 use gdbstub::arch::Arch;
+use gdbstub::common::Signal;
 use gdbstub::stub::{BaseStopReason, SingleThreadStopReason};
 use gdbstub::target::ext::base::singlethread::{
     SingleThreadBase,
+    SingleThreadResume, SingleThreadResumeOps,
 };
 use gdbstub::target::ext::base::BaseOps;
 use gdbstub::target::ext::breakpoints::{
@@ -185,6 +187,31 @@ impl HyperlightKvmSandboxTarget {
         self.paused = true;
     }
 
+    /// Sends an event to the Hypervisor that tells it to resume vCPU execution
+    /// Note: The method waits for a confirmation message
+    pub fn resume_vcpu(&mut self) -> Result<(), GdbTargetError> {
+        if self.paused {
+            log::info!("Attempted to resume running vCPU");
+
+            self.send(DebugMessage::VcpuResumeEv)
+                .map_err(|_| GdbTargetError::CannotResume)?;
+
+            // TODO: Maybe add timeout here because if the confirmation is not
+            // sent right away, it means something is not right
+            let response = self.recv().map_err(|_| GdbTargetError::CannotResume)?;
+            log::info!("Got message {:?}", response);
+
+            if let DebugMessage::RspOk = response {
+                self.paused = false;
+            } else {
+                log::error!("Error when resuming");
+                return Err(GdbTargetError::CannotResume);
+            }
+        }
+
+        Ok(())
+    }
+
     /// Add new breakpoint at provided address if there is enough space
     fn add_breakpoint(&mut self, addr: u64) -> Result<bool, GdbTargetError> {
         log::debug!("Add breakpoint at address {:X}", addr);
@@ -399,6 +426,10 @@ impl SingleThreadBase for HyperlightKvmSandboxTarget {
     ) -> TargetResult<(), Self> {
         self.write_regs(regs).map_err(TargetError::Fatal)
     }
+
+    fn support_resume(&mut self) -> Option<SingleThreadResumeOps<Self>> {
+        Some(self)
+    }
 }
 
 impl SectionOffsets for HyperlightKvmSandboxTarget {
@@ -436,4 +467,11 @@ impl HwBreakpoint for HyperlightKvmSandboxTarget {
     ) -> TargetResult<bool, Self> {
         self.remove_breakpoint(addr).map_err(TargetError::Fatal)
     }
+}
+
+impl SingleThreadResume for HyperlightKvmSandboxTarget {
+    fn resume(&mut self, _signal: Option<Signal>) -> Result<(), Self::Error> {
+        log::debug!("Resume");
+        self.resume_vcpu()
+    }
 }