Use std::sync for thread start/ready events

youknowone · youknowone · commit ca4157737c82 · 2026-03-08T17:15:56.000+09:00
Replace parking_lot Mutex/Condvar with std::sync (pthread-based)
for started_event and handle_ready_event. This prevents hangs
in forked children where parking_lot's global HASHTABLE may be
corrupted.
diff --git a/crates/vm/src/stdlib/thread.rs b/crates/vm/src/stdlib/thread.rs
@@ -1625,10 +1625,12 @@ pub(crate) mod _thread {
         let handle_clone = handle.clone();
         let inner_clone = handle.inner.clone();
         let done_event_clone = handle.done_event.clone();
-        let started_event = Arc::new((parking_lot::Mutex::new(false), parking_lot::Condvar::new()));
+        // Use std::sync (pthread-based) instead of parking_lot for these
+        // events so they remain fork-safe without the parking_lot_core patch.
+        let started_event = Arc::new((std::sync::Mutex::new(false), std::sync::Condvar::new()));
         let started_event_clone = Arc::clone(&started_event);
         let handle_ready_event =
-            Arc::new((parking_lot::Mutex::new(false), parking_lot::Condvar::new()));
+            Arc::new((std::sync::Mutex::new(false), std::sync::Condvar::new()));
         let handle_ready_event_clone = Arc::clone(&handle_ready_event);
 
         let mut thread_builder = thread::Builder::new();
@@ -1645,16 +1647,20 @@ pub(crate) mod _thread {
                 }
                 {
                     let (started_lock, started_cvar) = &*started_event_clone;
-                    *started_lock.lock() = true;
+                    *started_lock.lock().unwrap() = true;
                     started_cvar.notify_all();
                 }
-                // Match CPython handle_ready behavior class: don't execute the
-                // target function until parent marks the handle as running.
+                // Don't execute the target function until parent marks the
+                // handle as running.
                 {
                     let (ready_lock, ready_cvar) = &*handle_ready_event_clone;
-                    let mut ready = ready_lock.lock();
+                    let mut ready = ready_lock.lock().unwrap();
                     while !*ready {
-                        vm.allow_threads(|| ready_cvar.wait(&mut ready));
+                        // Short timeout so we stay responsive to STW requests.
+                        let (guard, _) = ready_cvar
+                            .wait_timeout(ready, core::time::Duration::from_millis(1))
+                            .unwrap();
+                        ready = guard;
                     }
                 }
 
@@ -1732,9 +1738,12 @@ pub(crate) mod _thread {
         // Wait until the new thread has reported its ident.
         {
             let (started_lock, started_cvar) = &*started_event;
-            let mut started = started_lock.lock();
+            let mut started = started_lock.lock().unwrap();
             while !*started {
-                vm.allow_threads(|| started_cvar.wait(&mut started));
+                let (guard, _) = started_cvar
+                    .wait_timeout(started, core::time::Duration::from_millis(1))
+                    .unwrap();
+                started = guard;
             }
         }
 
@@ -1749,7 +1758,7 @@ pub(crate) mod _thread {
         // Unblock the started thread once handle state is fully published.
         {
             let (ready_lock, ready_cvar) = &*handle_ready_event;
-            *ready_lock.lock() = true;
+            *ready_lock.lock().unwrap() = true;
             ready_cvar.notify_all();
         }
 

Original file line number	Diff line number	Diff line change
`@@ -1625,10 +1625,12 @@ pub(crate) mod _thread {`
`1625`	`1625`	`let handle_clone = handle.clone();`
`1626`	`1626`	`let inner_clone = handle.inner.clone();`
`1627`	`1627`	`let done_event_clone = handle.done_event.clone();`
`1628`		`- let started_event = Arc::new((parking_lot::Mutex::new(false), parking_lot::Condvar::new()));`
	`1628`	`+ // Use std::sync (pthread-based) instead of parking_lot for these`
	`1629`	`+ // events so they remain fork-safe without the parking_lot_core patch.`
	`1630`	`+ let started_event = Arc::new((std::sync::Mutex::new(false), std::sync::Condvar::new()));`
`1629`	`1631`	`let started_event_clone = Arc::clone(&started_event);`
`1630`	`1632`	`let handle_ready_event =`
`1631`		`- Arc::new((parking_lot::Mutex::new(false), parking_lot::Condvar::new()));`
	`1633`	`+ Arc::new((std::sync::Mutex::new(false), std::sync::Condvar::new()));`
`1632`	`1634`	`let handle_ready_event_clone = Arc::clone(&handle_ready_event);`
`1633`	`1635`
`1634`	`1636`	`let mut thread_builder = thread::Builder::new();`
`@@ -1645,16 +1647,20 @@ pub(crate) mod _thread {`
`1645`	`1647`	`}`
`1646`	`1648`	`{`
`1647`	`1649`	`let (started_lock, started_cvar) = &*started_event_clone;`
`1648`		`- *started_lock.lock() = true;`
	`1650`	`+ *started_lock.lock().unwrap() = true;`
`1649`	`1651`	`started_cvar.notify_all();`
`1650`	`1652`	`}`
`1651`		`- // Match CPython handle_ready behavior class: don't execute the`
`1652`		`- // target function until parent marks the handle as running.`
	`1653`	`+ // Don't execute the target function until parent marks the`
	`1654`	`+ // handle as running.`
`1653`	`1655`	`{`
`1654`	`1656`	`let (ready_lock, ready_cvar) = &*handle_ready_event_clone;`
`1655`		`- let mut ready = ready_lock.lock();`
	`1657`	`+ let mut ready = ready_lock.lock().unwrap();`
`1656`	`1658`	`while !*ready {`
`1657`		`- vm.allow_threads(\|\| ready_cvar.wait(&mut ready));`
	`1659`	`+ // Short timeout so we stay responsive to STW requests.`
	`1660`	`+ let (guard, _) = ready_cvar`
	`1661`	`+ .wait_timeout(ready, core::time::Duration::from_millis(1))`
	`1662`	`+ .unwrap();`
	`1663`	`+ ready = guard;`
`1658`	`1664`	`}`
`1659`	`1665`	`}`
`1660`	`1666`
`@@ -1732,9 +1738,12 @@ pub(crate) mod _thread {`
`1732`	`1738`	`// Wait until the new thread has reported its ident.`
`1733`	`1739`	`{`
`1734`	`1740`	`let (started_lock, started_cvar) = &*started_event;`
`1735`		`- let mut started = started_lock.lock();`
	`1741`	`+ let mut started = started_lock.lock().unwrap();`
`1736`	`1742`	`while !*started {`
`1737`		`- vm.allow_threads(\|\| started_cvar.wait(&mut started));`
	`1743`	`+ let (guard, _) = started_cvar`
	`1744`	`+ .wait_timeout(started, core::time::Duration::from_millis(1))`
	`1745`	`+ .unwrap();`
	`1746`	`+ started = guard;`
`1738`	`1747`	`}`
`1739`	`1748`	`}`
`1740`	`1749`
`@@ -1749,7 +1758,7 @@ pub(crate) mod _thread {`
`1749`	`1758`	`// Unblock the started thread once handle state is fully published.`
`1750`	`1759`	`{`
`1751`	`1760`	`let (ready_lock, ready_cvar) = &*handle_ready_event;`
`1752`		`- *ready_lock.lock() = true;`
	`1761`	`+ *ready_lock.lock().unwrap() = true;`
`1753`	`1762`	`ready_cvar.notify_all();`
`1754`	`1763`	`}`
`1755`	`1764`