fix: add process-wide mutex to stderr capture to prevent races

Signed-off-by: danbugs <danilochiarlone@gmail.com>

Author: danbugs

host/src/lib.rs

@@ -2215,7 +2215,11 @@ pub fn run_vm_capture_output(
     let setup_time = setup_start.elapsed();
 
     // Redirect stderr to a temp file before the call phase
-    let capture_file = std::env::temp_dir().join(format!("hl-capture-{}", std::process::id()));
+    let capture_file = std::env::temp_dir().join(format!(
+        "hl-capture-{}-{:?}",
+        std::process::id(),
+        std::thread::current().id()
+    ));
     let capture = stderr_capture::Capture::redirect_to_file(&capture_file)?;
 
     // Phase 2: restore + call — application runs and produces output

host/src/stderr_capture.rs

@@ -10,23 +10,37 @@ mod imp {
     use nix::unistd;
     use std::os::fd::{AsRawFd, FromRawFd, IntoRawFd, OwnedFd};
     use std::path::Path;
+    use std::sync::{Mutex, MutexGuard};
+
+    /// Process-wide lock protecting fd 2 (stderr) manipulation.
+    /// Held from `redirect_to_file` until `restore` to prevent concurrent
+    /// VMs from racing on dup2.
+    static STDERR_LOCK: Mutex<()> = Mutex::new(());
 
     pub struct Capture {
         original_stderr: OwnedFd,
+        _guard: MutexGuard<'static, ()>,
     }
 
     impl Capture {
         pub fn redirect_to_file(path: &Path) -> Result<Self> {
+            let guard = STDERR_LOCK
+                .lock()
+                .unwrap_or_else(|poisoned| poisoned.into_inner());
             let capture_fd = std::fs::File::create(path)?.into_raw_fd();
             let original_stderr_raw = unistd::dup(2)?;
             unistd::dup2(capture_fd, 2)?;
             unistd::close(capture_fd)?;
             let original_stderr = unsafe { OwnedFd::from_raw_fd(original_stderr_raw) };
-            Ok(Self { original_stderr })
+            Ok(Self {
+                original_stderr,
+                _guard: guard,
+            })
         }
 
         pub fn restore(self) -> Result<()> {
             unistd::dup2(self.original_stderr.as_raw_fd(), 2)?;
+            // _guard is dropped here, releasing STDERR_LOCK
             Ok(())
         }
     }