Address review: unsafe fn + decoder lock reinit

youknowone · youknowone · commit 874971c3853b · 2026-03-04T17:41:42.000+09:00
- Mark reinit_std_streams_after_fork as unsafe fn to encode
  fork-only precondition, update call site in posix.rs
- Reinit IncrementalNewlineDecoder's PyThreadMutex via
  TextIOWrapper's decoder field to prevent child deadlocks
diff --git a/crates/vm/src/stdlib/io.rs b/crates/vm/src/stdlib/io.rs
@@ -4988,8 +4988,13 @@ mod _io {
     }
 
     /// Reinit per-object IO buffer locks on std streams after `fork()`.
+    ///
+    /// # Safety
+    ///
+    /// Must only be called from the single-threaded child process immediately
+    /// after `fork()`, before any other thread is created.
     #[cfg(all(unix, feature = "threading"))]
-    pub fn reinit_std_streams_after_fork(vm: &VirtualMachine) {
+    pub unsafe fn reinit_std_streams_after_fork(vm: &VirtualMachine) {
         for name in ["stdin", "stdout", "stderr"] {
             let Ok(stream) = vm.sys_module.get_attr(name, vm) else {
                 continue;
@@ -5006,11 +5011,18 @@ mod _io {
             unsafe { reinit_thread_mutex_after_fork(&tio.data) };
             if let Some(guard) = tio.data.lock() {
                 if let Some(ref data) = *guard {
+                    if let Some(ref decoder) = data.decoder {
+                        reinit_io_locks(decoder);
+                    }
                     reinit_io_locks(&data.buffer);
                 }
             }
             return;
         }
+        if let Some(nl) = obj.downcast_ref::<IncrementalNewlineDecoder>() {
+            unsafe { reinit_thread_mutex_after_fork(&nl.data) };
+            return;
+        }
         if let Some(br) = obj.downcast_ref::<BufferedReader>() {
             unsafe { reinit_thread_mutex_after_fork(&br.data) };
             return;
diff --git a/crates/vm/src/stdlib/posix.rs b/crates/vm/src/stdlib/posix.rs
@@ -723,7 +723,7 @@ pub mod module {
         // BufferedReader/Writer/TextIOWrapper use PyThreadMutex which can be
         // held by dead parent threads, causing deadlocks on any IO in the child.
         #[cfg(feature = "threading")]
-        crate::stdlib::io::reinit_std_streams_after_fork(vm);
+        unsafe { crate::stdlib::io::reinit_std_streams_after_fork(vm) };
 
         // Phase 2: Reset low-level atomic state (no locks needed).
         crate::signal::clear_after_fork();
