add gdb debug tread creation method

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

Author: dblnz

Cargo.lock

@@ -71,6 +71,8 @@ sha256 = "1.4.0"
 windows-version = "0.1"
 
 [target.'cfg(unix)'.dependencies]
+gdbstub = "0.7.3"
+gdbstub_arch = "0.3.1"
 seccompiler = { version = "0.4.0", optional = true }
 kvm-bindings = { version = "0.11", features = ["fam-wrappers"], optional = true }
 kvm-ioctls = { version = "0.20", optional = true }

src/hyperlight_host/Cargo.toml

@@ -0,0 +1,46 @@
+use std::io::{self, ErrorKind};
+use std::net::TcpListener;
+use std::thread;
+use thiserror::Error;
+#[derive(Debug, Error)]
+pub enum GdbTargetError {
+    #[error("Error encountered while binding to address and port")]
+    CannotBind,
+    #[error("Error encountered while listening for connections")]
+    ListenerError,
+    #[error("Unexpected error encountered")]
+    UnexpectedError,
+}
+
+impl From<io::Error> for GdbTargetError {
+    fn from(err: io::Error) -> Self {
+        match err.kind() {
+            ErrorKind::AddrInUse => Self::CannotBind,
+            ErrorKind::AddrNotAvailable => Self::CannotBind,
+            ErrorKind::ConnectionReset
+            | ErrorKind::ConnectionAborted
+            | ErrorKind::ConnectionRefused => Self::ListenerError,
+            _ => Self::UnexpectedError,
+        }
+    }
+}
+/// Creates a thread that handles gdb protocol
+pub fn create_gdb_thread(
+    port: u16,
+) -> Result<(), GdbTargetError> {
+    let socket = format!("localhost:{}", port);
+
+    log::info!("Listening on {:?}", socket);
+    let listener = TcpListener::bind(socket)?;
+
+    log::info!("Starting GDB thread");
+    let _handle = thread::Builder::new()
+        .name("GDB handler".to_string())
+        .spawn(move || -> Result<(), GdbTargetError> {
+            log::info!("Waiting for GDB connection ... ");
+            let (_, _) = listener.accept()?;
+            Ok(())
+        });
+
+    Ok(())
+}

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

@@ -832,7 +832,7 @@ fn set_up_hypervisor_partition(
     mgr: &mut SandboxMemoryManager<GuestSharedMemory>,
     #[allow(unused_variables)] // parameter only used for in-process mode
     outb_handler: OutBHandlerWrapper,
-    #[cfg(gdb)] _debug_info: &Option<DebugInfo>,
+    #[cfg(gdb)] debug_info: &Option<DebugInfo>,
 ) -> Result<Box<dyn Hypervisor>> {
     let mem_size = u64::try_from(mgr.shared_mem.mem_size())?;
     let mut regions = mgr.layout.get_memory_regions(&mgr.shared_mem)?;
@@ -911,6 +911,8 @@ fn set_up_hypervisor_partition(
                     pml4_ptr.absolute()?,
                     entrypoint_ptr.absolute()?,
                     rsp_ptr.absolute()?,
+                    #[cfg(gdb)]
+                    debug_info,
                 )?;
                 Ok(Box::new(hv))
             }

src/hyperlight_host/src/hypervisor/hypervisor_handler.rs

@@ -23,6 +23,8 @@ use kvm_ioctls::{Kvm, VcpuExit, VcpuFd, VmFd};
 use tracing::{instrument, Span};
 
 use super::fpu::{FP_CONTROL_WORD_DEFAULT, FP_TAG_WORD_DEFAULT, MXCSR_DEFAULT};
+#[cfg(gdb)]
+use super::gdb::create_gdb_thread;
 use super::handlers::{MemAccessHandlerWrapper, OutBHandlerWrapper};
 use super::{
     HyperlightExit, Hypervisor, VirtualCPU, CR0_AM, CR0_ET, CR0_MP, CR0_NE, CR0_PE, CR0_PG, CR0_WP,
@@ -31,6 +33,8 @@ use super::{
 use crate::hypervisor::hypervisor_handler::HypervisorHandler;
 use crate::mem::memory_region::{MemoryRegion, MemoryRegionFlags};
 use crate::mem::ptr::{GuestPtr, RawPtr};
+#[cfg(gdb)]
+use crate::sandbox::uninitialized::DebugInfo;
 use crate::{log_then_return, new_error, Result};
 
 /// Return `true` if the KVM API is available, version 12, and has UserMemory capability, or `false` otherwise
@@ -75,6 +79,7 @@ impl KVMDriver {
         pml4_addr: u64,
         entrypoint: u64,
         rsp: u64,
+        #[cfg(gdb)] debug_info: &Option<DebugInfo>,
     ) -> Result<Self> {
         let kvm = Kvm::new()?;
 
@@ -101,6 +106,11 @@ impl KVMDriver {
         let mut vcpu_fd = vm_fd.create_vcpu(0)?;
         Self::setup_initial_sregs(&mut vcpu_fd, pml4_addr)?;
 
+        #[cfg(gdb)]
+        if let Some(DebugInfo { port }) = debug_info {
+            create_gdb_thread(*port).map_err(|_| new_error!("Cannot create GDB thread"))?;
+        }
+
         let rsp_gp = GuestPtr::try_from(RawPtr::from(rsp))?;
         Ok(Self {
             _kvm: kvm,

src/hyperlight_host/src/hypervisor/kvm.rs

@@ -34,6 +34,10 @@ pub mod hyperv_linux;
 pub(crate) mod hyperv_windows;
 pub(crate) mod hypervisor_handler;
 
+/// GDB debugging support
+#[cfg(gdb)]
+mod gdb;
+
 /// Driver for running in process instead of using hypervisor
 #[cfg(inprocess)]
 pub mod inprocess;

src/hyperlight_host/src/hypervisor/mod.rs

@@ -36,7 +36,6 @@ use crate::sandbox_state::sandbox::EvolvableSandbox;
 use crate::sandbox_state::transition::Noop;
 use crate::{log_build_details, log_then_return, new_error, MultiUseSandbox, Result};
 
-#[allow(dead_code)]
 #[cfg(gdb)]
 /// Used for passing debug configuration to a sandbox
 pub struct DebugInfo {