gdb: update comments

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

Author: dblnz

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

@@ -55,14 +55,23 @@ impl run_blocking::BlockingEventLoop for GdbBlockingEventLoop {
                         VcpuStopReason::EntryPointBp => BaseStopReason::HwBreak(()),
                         // This is a consequence of the GDB client sending an interrupt signal
                         // to the target thread
-                        VcpuStopReason::Interrupt => BaseStopReason::SignalWithThread {
-                            tid: (),
+                        VcpuStopReason::Interrupt => {
                             #[cfg(target_os = "linux")]
-                            signal: Signal(SIGRTMIN() as u8),
+                            let rsp = BaseStopReason::SignalWithThread {
+                                tid: (),
+                                signal: Signal(SIGRTMIN() as u8),
+                            };
+
+                            // For Windows we don't send a signal, this should not be happen
                             #[cfg(target_os = "windows")]
-                            // TODO: Handle the signal properly
-                            signal: Signal(53u8),
-                        },
+                            let rsp = BaseStopReason::SignalWithThread {
+                                tid: (),
+                                // This is a placeholder signal, we don't have a real signal
+                                signal: Signal(53u8),
+                            };
+
+                            rsp
+                        }
                         VcpuStopReason::Unknown => {
                             log::warn!("Unknown stop reason received");
 
@@ -111,8 +120,15 @@ impl run_blocking::BlockingEventLoop for GdbBlockingEventLoop {
 
         #[cfg(target_os = "windows")]
         let ret = {
-            // TODO: Implement Windows signal sending
-            libc::ESRCH
+            // pthread_kill is not implemented on Windows
+            // We need to use a different method to send a signal to the target thread
+            // For now, we just log a warning and return an error
+            // NOTE: The way we make a vCPU stop on windows is to make a windows API call
+            // to suspend the thread, but for that we need a handle to the thread which we don't have
+            log::warn!("Windows signal sending not implemented");
+
+            // For now, we just return an error
+            -1
         };
 
         log::info!("pthread_kill returned {}", ret);

src/hyperlight_host/src/hypervisor/hypervisor_handler.rs

@@ -901,7 +901,9 @@ fn set_up_hypervisor_partition(
             #[cfg(target_os = "linux")]
             let thread_id = unsafe { pthread_self() };
             #[cfg(target_os = "windows")]
-            // TODO: Implement Windows thread id retrieval
+            // On Windows, we need to get the thread id from the thread handle because
+            // we cannot send a signal to the thread without a handle
+            // This is a placeholder, as we don't have the actual thread handle here
             let thread_id = 0;
 
             let gdb_conn = create_gdb_thread(*port, thread_id);

src/hyperlight_host/src/hypervisor/windows_hypervisor_platform.rs

@@ -498,42 +498,16 @@ impl VMProcessor {
 
     #[cfg(gdb)]
     pub(super) fn set_debug_regs(&self, regs: &WHvDebugRegisters) -> Result<()> {
-        const LEN: usize = 6;
-
-        let names: [WHV_REGISTER_NAME; LEN] = [
-            WHvX64RegisterDr0,
-            WHvX64RegisterDr1,
-            WHvX64RegisterDr2,
-            WHvX64RegisterDr3,
-            WHvX64RegisterDr6,
-            WHvX64RegisterDr7,
-        ];
-
-        let values: [WHV_REGISTER_VALUE; LEN] = [
-            WHV_REGISTER_VALUE { Reg64: regs.dr0 },
-            WHV_REGISTER_VALUE { Reg64: regs.dr1 },
-            WHV_REGISTER_VALUE { Reg64: regs.dr2 },
-            WHV_REGISTER_VALUE { Reg64: regs.dr3 },
-            WHV_REGISTER_VALUE { Reg64: regs.dr6 },
-            WHV_REGISTER_VALUE { Reg64: regs.dr7 },
+        let registers = vec![
+            (WHvX64RegisterDr0, WHV_REGISTER_VALUE { Reg64: regs.dr0 }),
+            (WHvX64RegisterDr1, WHV_REGISTER_VALUE { Reg64: regs.dr1 }),
+            (WHvX64RegisterDr2, WHV_REGISTER_VALUE { Reg64: regs.dr2 }),
+            (WHvX64RegisterDr3, WHV_REGISTER_VALUE { Reg64: regs.dr3 }),
+            (WHvX64RegisterDr6, WHV_REGISTER_VALUE { Reg64: regs.dr6 }),
+            (WHvX64RegisterDr7, WHV_REGISTER_VALUE { Reg64: regs.dr7 }),
         ];
 
-        let ret_val = unsafe {
-            WHvSetVirtualProcessorRegisters(
-                self.get_partition_hdl(),
-                0,
-                names.as_ptr(),
-                LEN as u32,
-                values.as_ptr(),
-            )
-        };
-
-        if ret_val.is_err() {
-            println!("Failed to set debug registers: {:?}", ret_val);
-            return Err(new_error!("Call to WHvSetVirtualProcessorRegisters failed"));
-        }
-
-        Ok(())
+        self.set_registers(&registers)
     }
 
     #[cfg(gdb)]