add guest debug port to sandbox configuration

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

Author: dblnz

src/hyperlight_host/src/hypervisor/hypervisor_handler.rs

@@ -49,6 +49,8 @@ use crate::mem::shared_mem::{GuestSharedMemory, HostSharedMemory, SharedMemory};
 use crate::sandbox::hypervisor::{get_available_hypervisor, HypervisorType};
 #[cfg(feature = "function_call_metrics")]
 use crate::sandbox::metrics::SandboxMetric::GuestFunctionCallDurationMicroseconds;
+#[cfg(gdb)]
+use crate::sandbox::uninitialized::DebugInfo;
 #[cfg(target_os = "linux")]
 use crate::signal_handlers::setup_signal_handlers;
 use crate::HyperlightError::{
@@ -232,6 +234,7 @@ impl HypervisorHandler {
     pub(crate) fn start_hypervisor_handler(
         &mut self,
         sandbox_memory_manager: SandboxMemoryManager<GuestSharedMemory>,
+        #[cfg(gdb)] debug_info: Option<DebugInfo>,
     ) -> Result<()> {
         let configuration = self.configuration.clone();
         #[cfg(target_os = "windows")]
@@ -292,6 +295,8 @@ impl HypervisorHandler {
                                     hv = Some(set_up_hypervisor_partition(
                                         execution_variables.shm.try_lock().unwrap().deref_mut().as_mut().unwrap(),
                                         configuration.outb_handler.clone(),
+                                        #[cfg(gdb)]
+                                        &debug_info,
                                     )?);
                                 }
                                 let hv = hv.as_mut().unwrap();
@@ -827,6 +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>,
 ) -> 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)?;

src/hyperlight_host/src/hypervisor/mod.rs

@@ -336,7 +336,11 @@ pub(crate) mod tests {
         // whether we can configure the shared memory region, load a binary
         // into it, and run the CPU to completion (e.g., a HLT interrupt)
 
-        hv_handler.start_hypervisor_handler(gshm)?;
+        hv_handler.start_hypervisor_handler(
+            gshm,
+            #[cfg(gdb)]
+            None,
+        )?;
 
         hv_handler.execute_hypervisor_handler_action(HypervisorHandlerAction::Initialise)
     }

src/hyperlight_host/src/sandbox/config.rs

@@ -25,6 +25,9 @@ use crate::mem::exe::ExeInfo;
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 #[repr(C)]
 pub struct SandboxConfiguration {
+    #[cfg(gdb)]
+    /// Guest gdb debug port
+    guest_debug_port: Option<u16>,
     /// The maximum size of the guest error buffer.
     guest_error_buffer_size: usize,
     /// The size of the memory buffer that is made available for Guest Function
@@ -136,6 +139,9 @@ impl SandboxConfiguration {
     pub const MIN_KERNEL_STACK_SIZE: usize = 0x1000;
     /// The default value for kernel stack size
     pub const DEFAULT_KERNEL_STACK_SIZE: usize = Self::MIN_KERNEL_STACK_SIZE;
+    #[cfg(gdb)]
+    /// The minimum value for debug port
+    pub const MIN_GUEST_DEBUG_PORT: u16 = 9000;
 
     #[allow(clippy::too_many_arguments)]
     /// Create a new configuration for a sandbox with the given sizes.
@@ -153,6 +159,7 @@ impl SandboxConfiguration {
         max_initialization_time: Option<Duration>,
         max_wait_for_cancellation: Option<Duration>,
         guest_panic_context_buffer_size: usize,
+        #[cfg(gdb)] guest_debug_port: Option<u16>,
     ) -> Self {
         Self {
             input_data_size: max(input_data_size, Self::MIN_INPUT_SIZE),
@@ -220,6 +227,8 @@ impl SandboxConfiguration {
                 guest_panic_context_buffer_size,
                 Self::MIN_GUEST_PANIC_CONTEXT_BUFFER_SIZE,
             ),
+            #[cfg(gdb)]
+            guest_debug_port,
         }
     }
 
@@ -346,6 +355,13 @@ impl SandboxConfiguration {
         );
     }
 
+    #[cfg(gdb)]
+    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
+    /// Sets the configuration for the guest debug
+    pub fn set_guest_debug_port(&mut self, port: u16) {
+        self.guest_debug_port = Some(max(port, Self::MIN_GUEST_DEBUG_PORT));
+    }
+
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     pub(crate) fn get_guest_error_buffer_size(&self) -> usize {
         self.guest_error_buffer_size
@@ -390,6 +406,12 @@ impl SandboxConfiguration {
         self.max_initialization_time
     }
 
+    #[cfg(gdb)]
+    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
+    pub(crate) fn get_guest_debug_port(&self) -> Option<u16> {
+        self.guest_debug_port
+    }
+
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn stack_size_override_opt(&self) -> Option<u64> {
         (self.stack_size_override > 0).then_some(self.stack_size_override)
@@ -438,6 +460,8 @@ impl Default for SandboxConfiguration {
             None,
             None,
             Self::DEFAULT_GUEST_PANIC_CONTEXT_BUFFER_SIZE,
+            #[cfg(gdb)]
+            None,
         )
     }
 }
@@ -480,6 +504,8 @@ mod tests {
                 MAX_WAIT_FOR_CANCELLATION_OVERRIDE as u64,
             )),
             GUEST_PANIC_CONTEXT_BUFFER_SIZE_OVERRIDE,
+            #[cfg(gdb)]
+            None,
         );
         let exe_infos = vec![
             simple_guest_exe_info().unwrap(),
@@ -543,6 +569,8 @@ mod tests {
                 SandboxConfiguration::MIN_MAX_WAIT_FOR_CANCELLATION as u64 - 1,
             )),
             SandboxConfiguration::MIN_GUEST_PANIC_CONTEXT_BUFFER_SIZE - 1,
+            #[cfg(gdb)]
+            None,
         );
         assert_eq!(SandboxConfiguration::MIN_INPUT_SIZE, cfg.input_data_size);
         assert_eq!(SandboxConfiguration::MIN_OUTPUT_SIZE, cfg.output_data_size);
@@ -711,6 +739,14 @@ mod tests {
                 cfg.set_heap_size(size);
                 prop_assert_eq!(size, cfg.heap_size_override);
             }
+
+            #[test]
+            #[cfg(gdb)]
+            fn guest_debug_port(port in 9000..=u16::MAX) {
+                let mut cfg = SandboxConfiguration::default();
+                cfg.set_guest_debug_port(port);
+                prop_assert_eq!(port, *cfg.get_guest_debug_port().as_ref().unwrap());
+            }
         }
     }
 }

src/hyperlight_host/src/sandbox/uninitialized.rs

@@ -36,6 +36,14 @@ 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 {
+    /// Guest debug port
+    pub(crate) port: u16,
+}
+
 /// A preliminary `Sandbox`, not yet ready to execute guest code.
 ///
 /// Prior to initializing a full-fledged `Sandbox`, you must create one of
@@ -52,6 +60,8 @@ pub struct UninitializedSandbox {
     pub(crate) max_initialization_time: Duration,
     pub(crate) max_execution_time: Duration,
     pub(crate) max_wait_for_cancellation: Duration,
+    #[cfg(gdb)]
+    pub(crate) debug_info: Option<DebugInfo>,
 }
 
 impl crate::sandbox_state::sandbox::UninitializedSandbox for UninitializedSandbox {
@@ -161,6 +171,10 @@ impl UninitializedSandbox {
         }
 
         let sandbox_cfg = cfg.unwrap_or_default();
+        #[cfg(gdb)]
+        let debug_info = sandbox_cfg
+            .get_guest_debug_port()
+            .map(|port| DebugInfo { port });
         let mut mem_mgr_wrapper = {
             let mut mgr = UninitializedSandbox::load_guest_binary(
                 sandbox_cfg,
@@ -188,6 +202,8 @@ impl UninitializedSandbox {
             max_wait_for_cancellation: Duration::from_millis(
                 sandbox_cfg.get_max_wait_for_cancellation() as u64,
             ),
+            #[cfg(gdb)]
+            debug_info,
         };
 
         // TODO: These only here to accommodate some writer functions.

src/hyperlight_host/src/sandbox/uninitialized_evolve.rs

@@ -20,6 +20,8 @@ use std::sync::{Arc, Mutex};
 use rand::Rng;
 use tracing::{instrument, Span};
 
+#[cfg(gdb)]
+use super::uninitialized::DebugInfo;
 use crate::hypervisor::hypervisor_handler::{
     HvHandlerConfig, HypervisorHandler, HypervisorHandlerAction,
 };
@@ -66,6 +68,8 @@ where
             u_sbox.max_initialization_time,
             u_sbox.max_execution_time,
             u_sbox.max_wait_for_cancellation,
+            #[cfg(gdb)]
+            u_sbox.debug_info,
         )?;
 
         {
@@ -98,6 +102,7 @@ fn hv_init(
     max_init_time: Duration,
     max_exec_time: Duration,
     max_wait_for_cancellation: Duration,
+    #[cfg(gdb)] debug_info: Option<DebugInfo>,
 ) -> Result<HypervisorHandler> {
     let outb_hdl = outb_handler_wrapper(hshm.clone(), host_funcs);
     let mem_access_hdl = mem_access_handler_wrapper(hshm.clone());
@@ -126,7 +131,11 @@ fn hv_init(
 
     let mut hv_handler = HypervisorHandler::new(hv_handler_config);
 
-    hv_handler.start_hypervisor_handler(gshm)?;
+    hv_handler.start_hypervisor_handler(
+        gshm,
+        #[cfg(gdb)]
+        debug_info,
+    )?;
 
     hv_handler
         .execute_hypervisor_handler_action(HypervisorHandlerAction::Initialise)