Generic approach to gdb support

- To be easier to add Hyper-V gdb support

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

Author: dblnz

src/hyperlight_host/Cargo.toml

@@ -115,7 +115,7 @@ cfg_aliases = "0.2.1"
 built = { version = "0.7.0", features = ["chrono", "git2"] }
 
 [features]
-default = ["kvm", "mshv", "seccomp"]
+default = ["gdb", "kvm", "mshv", "seccomp"]
 seccomp = ["dep:seccompiler"]
 function_call_metrics = []
 executable_heap = []

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

@@ -1,18 +1,25 @@
+use std::marker::PhantomData;
+
+use gdbstub::arch::Arch;
 use gdbstub::common::Signal;
 use gdbstub::conn::ConnectionExt;
 use gdbstub::stub::run_blocking::{self, WaitForStopReasonError};
 use gdbstub::stub::{DisconnectReason, GdbStub, SingleThreadStopReason};
+use gdbstub::target::Target;
 
-use super::target::HyperlightKvmSandboxTarget;
-use super::GdbTargetError;
 use crate::hypervisor::gdb::GdbDebug;
 
-pub struct GdbBlockingEventLoop;
+pub struct GdbBlockingEventLoop<T> {
+    _phantom: PhantomData<T>,
+}
 
-impl run_blocking::BlockingEventLoop for GdbBlockingEventLoop {
+impl<T: GdbDebug> run_blocking::BlockingEventLoop for GdbBlockingEventLoop<T>
+where
+    <T as Target>::Error: From<crossbeam_channel::TryRecvError>,
+{
     type Connection = Box<dyn ConnectionExt<Error = std::io::Error>>;
-    type StopReason = SingleThreadStopReason<u64>;
-    type Target = HyperlightKvmSandboxTarget;
+    type StopReason = SingleThreadStopReason<<T::Arch as Arch>::Usize>;
+    type Target = T;
 
     fn wait_for_stop_reason(
         target: &mut Self::Target,
@@ -46,10 +53,8 @@ impl run_blocking::BlockingEventLoop for GdbBlockingEventLoop {
                     return Ok(run_blocking::Event::TargetStopped(stop_response));
                 }
                 Err(crossbeam_channel::TryRecvError::Empty) => (),
-                Err(_) => {
-                    return Err(run_blocking::WaitForStopReasonError::Target(
-                        GdbTargetError::QueueError,
-                    ));
+                Err(e) => {
+                    return Err(run_blocking::WaitForStopReasonError::Target(e.into()));
                 }
             }
 
@@ -75,11 +80,14 @@ impl run_blocking::BlockingEventLoop for GdbBlockingEventLoop {
     }
 }
 
-pub fn event_loop_thread(
-    debugger: GdbStub<HyperlightKvmSandboxTarget, Box<dyn ConnectionExt<Error = std::io::Error>>>,
-    target: &mut HyperlightKvmSandboxTarget,
-) {
-    match debugger.run_blocking::<GdbBlockingEventLoop>(target) {
+pub fn event_loop_thread<T: GdbDebug>(
+    debugger: GdbStub<T, Box<dyn ConnectionExt<Error = std::io::Error>>>,
+    target: &mut T,
+) where
+    <T as Target>::Error: std::fmt::Debug,
+    <T as Target>::Error: From<crossbeam_channel::TryRecvError>,
+{
+    match debugger.run_blocking::<GdbBlockingEventLoop<T>>(target) {
         Ok(disconnect_reason) => match disconnect_reason {
             DisconnectReason::Disconnect => log::info!("Gdb client disconnected"),
             DisconnectReason::TargetExited(code) => {
@@ -94,9 +102,9 @@ pub fn event_loop_thread(
             if e.is_target_error() {
                 log::error!("Target encountered a fatal error: {e:?}");
             } else if e.is_connection_error() {
-                log::error!("connection error: {:?}", e);
+                log::error!("connection error: {e:?}");
             } else {
-                log::error!("gdbstub got a fatal error {:?}", e);
+                log::error!("gdbstub got a fatal error: {e:?}");
             }
         }
     }

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

@@ -1,40 +1,80 @@
 mod event_loop;
 pub mod target;
 
+use std::io::{self, ErrorKind};
 use std::net::TcpListener;
 use std::thread;
 
 use crossbeam_channel::{Receiver, Sender, TryRecvError};
 use event_loop::event_loop_thread;
+use gdbstub::arch::Arch;
 use gdbstub::conn::ConnectionExt;
-use gdbstub::stub::GdbStub;
-use target::HyperlightKvmSandboxTarget;
+use gdbstub::stub::{BaseStopReason, GdbStub};
+use gdbstub::target::Target;
 
 #[derive(Debug)]
 pub enum GdbTargetError {
     BindError,
     InstructionPointerError,
     ListenerError,
-    QueueError,
     ReadRegistersError,
     ReceiveMsgError,
     CannotResume,
+    QueueError,
     SendMsgError,
     SetGuestDebugError,
-    SpawnThreadError,
     InvalidGva,
     UnexpectedMessageError,
     WriteRegistersError,
+    UnexpectedError,
+}
+
+impl From<io::Error> for GdbTargetError {
+    fn from(err: io::Error) -> Self {
+        match err.kind() {
+            ErrorKind::AddrInUse => Self::BindError,
+            ErrorKind::AddrNotAvailable => Self::BindError,
+            ErrorKind::ConnectionReset
+            | ErrorKind::ConnectionAborted
+            | ErrorKind::ConnectionRefused => Self::ListenerError,
+            _ => Self::UnexpectedError,
+        }
+    }
+}
+
+impl From<DebugMessage> for GdbTargetError {
+    fn from(value: DebugMessage) -> Self {
+        match value {
+            DebugMessage::VcpuStoppedEv => GdbTargetError::UnexpectedMessageError,
+            _ => GdbTargetError::UnexpectedMessageError,
+        }
+    }
+}
+
+impl From<TryRecvError> for GdbTargetError {
+    fn from(_value: TryRecvError) -> Self {
+        GdbTargetError::QueueError
+    }
 }
 
 /// Trait that provides common communication methods for targets
-pub trait GdbDebug {
+pub trait GdbDebug: Target {
     /// Sends a message to the Hypervisor
-    fn send(&self, ev: DebugMessage) -> Result<(), GdbTargetError>;
+    fn send(&self, ev: DebugMessage) -> Result<(), <Self as Target>::Error>;
     /// Waits for a message from the Hypervisor
-    fn recv(&self) -> Result<DebugMessage, GdbTargetError>;
+    fn recv(&self) -> Result<DebugMessage, <Self as Target>::Error>;
     /// Checks for a pending message from the Hypervisor
     fn try_recv(&self) -> Result<DebugMessage, TryRecvError>;
+
+    /// Marks the vCPU as paused
+    fn pause_vcpu(&mut self);
+    /// Resumes the vCPU 
+    fn resume_vcpu(&mut self) -> Result<(), <Self as Target>::Error>;
+    /// Returns the reason why vCPU stopped
+    #[allow(clippy::type_complexity)]
+    fn get_stop_reason(
+        &self,
+    ) -> Result<Option<BaseStopReason<(), <Self::Arch as Arch>::Usize>>, Self::Error>;
 }
 
 /// Event sent to the VCPU execution loop
@@ -93,46 +133,52 @@ impl GdbConnection {
 }
 
 /// Creates a thread that handles gdb protocol
-pub fn create_gdb_thread(mut target: HyperlightKvmSandboxTarget) -> Result<(), GdbTargetError> {
+pub fn create_gdb_thread<T: GdbDebug + Send + 'static>(
+    mut target: T,
+) -> Result<(), <T as Target>::Error>
+where
+    <T as Target>::Error:
+        std::fmt::Debug + Send + From<io::Error> + From<DebugMessage> + From<TryRecvError>,
+{
     // TODO: Address multiple sandboxes scenario
     let socket = format!("localhost:{}", 8081);
 
     log::info!("Listening on {:?}", socket);
-    let listener = TcpListener::bind(socket).map_err(|_| GdbTargetError::BindError)?;
+    let listener = TcpListener::bind(socket)?;
 
     log::info!("Starting GDB thread");
     let _handle = thread::Builder::new()
         .name("GDB handler".to_string())
-        .spawn(move || -> Result<(), GdbTargetError> {
-            let mut initial_conn = true;
-            let result = loop {
-                log::info!("Waiting for GDB connection ... ");
-                let (conn, _) = listener
-                    .accept()
-                    .map_err(|_| GdbTargetError::ListenerError)?;
-
-                let conn: Box<dyn ConnectionExt<Error = std::io::Error>> = Box::new(conn);
-                let debugger = GdbStub::new(conn);
-
-                if initial_conn {
-                    // Waits for vCPU to stop at entrypoint breakpoint
-                    if let DebugMessage::VcpuStoppedEv = target.recv()? {
-                        target.pause_vcpu();
-
-                        event_loop_thread(debugger, &mut target);
-                        initial_conn = false;
+        .spawn(
+            move || -> Result<(), <T as gdbstub::target::Target>::Error> {
+                let mut initial_conn = true;
+                let result = loop {
+                    log::info!("Waiting for GDB connection ... ");
+                    let (conn, _) = listener.accept().map_err(<T as Target>::Error::from)?;
+
+                    let conn: Box<dyn ConnectionExt<Error = io::Error>> = Box::new(conn);
+                    let debugger = GdbStub::new(conn);
+
+                    if initial_conn {
+                        // Waits for vCPU to stop at entrypoint breakpoint
+                        let res = target.recv()?;
+                        if let DebugMessage::VcpuStoppedEv = res {
+                            target.pause_vcpu();
+
+                            event_loop_thread(debugger, &mut target);
+                            initial_conn = false;
+                        } else {
+                            break Err(res)?;
+                        }
                     } else {
-                        break Err(GdbTargetError::UnexpectedMessageError);
+                        log::info!("Reattaching GDB connection ... ");
+                        event_loop_thread(debugger, &mut target);
                     }
-                } else {
-                    log::info!("Reattaching GDB connection ... ");
-                    event_loop_thread(debugger, &mut target);
-                }
-            };
-
-            result
-        })
-        .map_err(|_| GdbTargetError::SpawnThreadError)?;
+                };
+
+                result
+            },
+        );
 
     Ok(())
 }