spawnSync: make signal-forwarding register/unregister safe for concurrent callers

src/jsc/bindings/c-bindings.cpp

@@ -937,11 +937,14 @@ extern "C" int ffi_fileno(FILE* file)
 #if OS(LINUX) || OS(DARWIN) || OS(FREEBSD)
 #include <signal.h>
 #include <pthread.h>
+#include <mutex>
 
-// Note: We only ever use bun.spawnSync on the main thread.
+// Bun.openInEditor runs spawnSync on detached threads, so register/unregister can overlap.
 extern "C" int64_t Bun__currentSyncPID = 0;
 static int Bun__pendingSignalToSend = 0;
 static struct sigaction previous_actions[NSIG];
+static std::mutex signalForwardingLock;
+static int signalForwardingDepth = 0;
 
 // npm's signal list minus SIGIOT/SIGPOLL (aliases of SIGABRT/SIGIO; listing both would overwrite previous_actions[N]).
 // https://github.com/npm/cli/blob/fefd509992a05c2dfddbe7bc46931c42f1da69d7/workspaces/arborist/lib/signals.js#L26-L57
@@ -1004,6 +1007,10 @@ extern "C" void Bun__sendPendingSignalIfNecessary()
 
 extern "C" void Bun__registerSignalsForForwarding()
 {
+    std::lock_guard<std::mutex> lock(signalForwardingLock);
+    if (signalForwardingDepth++ != 0)
+        return;
+
     Bun__pendingSignalToSend = 0;
     struct sigaction sa;
     memset(&sa, 0, sizeof(sa));
@@ -1032,6 +1039,10 @@ extern "C" void Bun__unregisterSignalsForForwarding()
 {
     Bun__currentSyncPID = 0;
 
+    std::lock_guard<std::mutex> lock(signalForwardingLock);
+    if (--signalForwardingDepth != 0)
+        return;
+
 #define UNREGISTER_SIGNAL(SIG)                                \
     if (sigaction(SIG, &previous_actions[SIG], NULL) == -1) { \
     }

test/js/bun/util/open-in-editor-gc.test.ts

@@ -152,3 +152,50 @@
 
   await Promise.all(runs);
 });
+
+// Each detached editor thread goes through bun.spawnSync's signal-forwarding
+// register/unregister, which swaps every forwarded signal's disposition in a
+// process-global table. With many threads overlapping, an unsynchronized
+// table ends up restoring SIG_DFL (or the forwarding handler itself) instead
+// of the handler that was installed before the burst, so a JS signal
+// listener registered beforehand silently stops working or kills the process.
+test.skipIf(!isLinux)("Bun.openInEditor bursts do not drop previously installed signal handlers", async () => {
+  const sleep = ["/usr/bin/sleep", "/bin/sleep"].find(p => existsSync(p));
+  expect(sleep).toBeDefined();
+
+  using dir = tempDir("open-in-editor-signal-table", {
+    "run.js": `
+      let fired = false;
+      process.on("SIGUSR2", () => { fired = true; });
+
+      let spawned = 0;
+      for (let i = 0; i < 64; i++) {
+        try { Bun.openInEditor("0.1", { editor: ${JSON.stringify(sleep)} }); spawned++; } catch {}
+      }
+      if (spawned === 0) { console.log("no editor threads spawned"); process.exit(2); }
+
+      // Let every detached thread finish its sleep and unregister.
+      await Bun.sleep(500);
+
+      process.kill(process.pid, "SIGUSR2");
+      const deadline = Date.now() + 2000;
+      while (!fired && Date.now() < deadline) await Bun.sleep(5);
+      console.log(fired ? "ok" : "handler lost");
+    `,
+  });
+
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "run.js"],
+    env: bunEnv,
+    cwd: String(dir),
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+
+  expect(stderr).toBe("");
+  expect(stdout.trim()).toBe("ok");
+  expect(proc.signalCode).toBeNull();
+  expect(exitCode).toBe(0);
+});