feat(gdb): stop all vCPUs on a debug event (all-stop)

When one vCPU stopped at a debug event the others kept running, so
querying a running vCPU (info threads, per-vCPU backtraces) blocked
indefinitely. Pause the sibling vCPUs on every stop (initial entry stop,
breakpoint stops, and Ctrl-C), like QEMU's all-stop, reusing the
existing per-vCPU pause (which kicks a running or halted vCPU out of
KVM_RUN).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Signed-off-by: Nikita Kalyazin <nikita.kalyazin@e2b.dev>

Author: kalyazin

src/vmm/src/gdb/event_loop.rs

@@ -24,7 +24,7 @@ pub fn event_loop(
     gdb_event_receiver: Receiver<usize>,
     entry_addr: GuestAddress,
 ) {
-    let target = FirecrackerTarget::new(vmm, gdb_event_receiver, entry_addr);
+    let mut target = FirecrackerTarget::new(vmm, gdb_event_receiver, entry_addr);
     let connection: Box<dyn ConnectionExt<Error = std::io::Error>> = { Box::new(connection) };
     let debugger = GdbStub::new(connection);
 
@@ -34,6 +34,13 @@ pub fn event_loop(
         .recv()
         .expect("Error getting initial gdb event");
 
+    // All-stop: the initial breakpoint only stops the triggering vCPU; halt the
+    // others too so the whole VM is stopped when gdb attaches (this initial stop is
+    // consumed here rather than in `wait_for_stop_reason`).
+    target
+        .pause_all_vcpus()
+        .expect("Error pausing vcpus on initial stop");
+
     gdb_event_loop_thread(debugger, target);
 }
 
@@ -85,6 +92,13 @@ impl run_blocking::BlockingEventLoop for GdbBlockingEventLoop {
                         continue;
                     };
 
+                    // All-stop: halt the still-running sibling vCPUs so GDB sees a
+                    // fully-stopped VM. Without this, querying a running vCPU (e.g.
+                    // `info threads`) blocks indefinitely.
+                    target
+                        .pause_all_vcpus()
+                        .map_err(WaitForStopReasonError::Target)?;
+
                     trace!("Returned stop reason to gdb: {stop_response:?}");
                     return Ok(run_blocking::Event::TargetStopped(stop_response));
                 }
@@ -112,7 +126,9 @@ impl run_blocking::BlockingEventLoop for GdbBlockingEventLoop {
         // notify the target that a ctrl-c interrupt has occurred.
         let main_core = vcpuid_to_tid(0)?;
 
-        target.pause_vcpu(main_core)?;
+        // All-stop: pause every vCPU, not just the main one, so the whole VM is
+        // halted while GDB inspects it.
+        target.pause_all_vcpus()?;
         target.set_paused_vcpu(main_core);
 
         let exit_reason = MultiThreadStopReason::SignalWithThread {

src/vmm/src/gdb/target.rs

@@ -233,6 +233,23 @@ impl FirecrackerTarget {
         Ok(())
     }
 
+    /// Pauses every vcpu that is still running so the whole VM is stopped while GDB
+    /// is in control (all-stop semantics, as QEMU does via `pause_all_vcpus`). The
+    /// vcpu that triggered the stop is already paused; this halts its still-running
+    /// siblings so they can be enumerated and inspected (`info threads`, `thread N`,
+    /// per-vCPU backtraces). `send_event` kicks a running or halted vcpu out of
+    /// `KVM_RUN`, so this completes even for idle siblings.
+    pub fn pause_all_vcpus(&mut self) -> Result<(), GdbTargetError> {
+        for cpu_id in 0..self.vcpu_state.len() {
+            if !self.vcpu_state[cpu_id].paused {
+                let tid = vcpuid_to_tid(cpu_id)?;
+                self.pause_vcpu(tid)?;
+            }
+        }
+
+        Ok(())
+    }
+
     /// Resets all Vcpus to their base state
     fn reset_all_vcpu_states(&mut self) {
         for value in self.vcpu_state.iter_mut() {