try

youknowone · youknowone · commit a8747e62a1ef · 2026-01-12T08:11:36.000+09:00
diff --git a/crates/vm/src/stdlib/thread.rs b/crates/vm/src/stdlib/thread.rs
@@ -904,41 +904,65 @@ pub(crate) mod _thread {
         // Update main thread ident - after fork, the current thread becomes the main thread
         MAIN_THREAD_IDENT.store(current_ident);
 
-        // Clean up THREAD_FRAMES - only keep current thread's frame slot
-        THREAD_FRAMES.lock().retain(|&id, _| id == current_ident);
-
-        let mut handles = THREAD_HANDLES.lock();
+        // Reinitialize THREAD_FRAMES for child process.
+        // After fork, the old mutex/Arc state from parent threads is invalid.
+        // We need to create a fresh slot for the current (only) thread.
+        //
+        // Note: We try_lock() because the mutex might have been held by a thread
+        // that no longer exists in the child. If we can't acquire it, we still
+        // reinitialize the thread-local which is sufficient for the child process.
+        let new_slot = Arc::new(parking_lot::Mutex::new(None));
+        if let Some(mut registry) = THREAD_FRAMES.try_lock() {
+            registry.clear();
+            registry.insert(current_ident, new_slot.clone());
+        }
+        // Always update thread-local to point to the new slot
+        CURRENT_FRAME_SLOT.with(|s| {
+            *s.borrow_mut() = Some(new_slot);
+        });
 
-        // Clean up dead weak refs and mark non-current threads as done
-        handles.retain(|(inner_weak, done_event_weak)| {
-            let Some(inner) = inner_weak.upgrade() else {
-                return false; // Remove dead entries
-            };
-            let Some(done_event) = done_event_weak.upgrade() else {
-                return false;
-            };
+        // Clean up thread handles if we can acquire the lock.
+        // Use try_lock because the mutex might have been held during fork.
+        // If we can't acquire it, just skip - the child process will work
+        // correctly with new handles it creates.
+        if let Some(mut handles) = THREAD_HANDLES.try_lock() {
+            // Clean up dead weak refs and mark non-current threads as done
+            handles.retain(|(inner_weak, done_event_weak)| {
+                let Some(inner) = inner_weak.upgrade() else {
+                    return false; // Remove dead entries
+                };
+                let Some(done_event) = done_event_weak.upgrade() else {
+                    return false;
+                };
 
-            let mut inner_guard = inner.lock();
+                // Try to lock the inner state - skip if we can't
+                let Some(mut inner_guard) = inner.try_lock() else {
+                    return false;
+                };
 
-            // Skip current thread and not-started threads
-            if inner_guard.ident == current_ident {
-                return true;
-            }
-            if inner_guard.state == ThreadHandleState::NotStarted {
-                return true;
-            }
+                // Skip current thread and not-started threads
+                if inner_guard.ident == current_ident {
+                    return true;
+                }
+                if inner_guard.state == ThreadHandleState::NotStarted {
+                    return true;
+                }
 
-            // Mark as done and notify waiters
-            inner_guard.state = ThreadHandleState::Done;
-            inner_guard.join_handle = None; // Can't join OS thread from child
-            drop(inner_guard);
+                // Mark as done and notify waiters
+                inner_guard.state = ThreadHandleState::Done;
+                inner_guard.join_handle = None; // Can't join OS thread from child
+                drop(inner_guard);
 
-            let (lock, cvar) = &*done_event;
-            *lock.lock() = true;
-            cvar.notify_all();
+                // Try to notify waiters - skip if we can't acquire the lock
+                let (lock, cvar) = &*done_event;
+                if let Some(mut done) = lock.try_lock() {
+                    *done = true;
+                    cvar.notify_all();
+                }
 
-            true
-        });
+                true
+            });
+        }
     }
 
     // Thread handle state enum
