gh-158973: Reset the warnings lock after fork in the child

Author: nascheme

Include/internal/pycore_interp_structs.h

@@ -649,6 +649,10 @@ struct _warnings_runtime_state {
     PyObject *once_registry;  /* Dict */
     PyObject *default_action; /* String */
     _PyRecursiveMutex lock;
+#ifdef HAVE_FORK
+    // Whether the thread calling fork() owns the warnings lock.
+    bool lock_held_at_fork;
+#endif
     long filters_version;
     PyObject *context;
 };

Include/internal/pycore_warnings.h

@@ -12,6 +12,11 @@ extern int _PyWarnings_InitState(PyInterpreterState *interp);
 
 extern PyObject* _PyWarnings_Init(void);
 
+#ifdef HAVE_FORK
+extern void _PyWarnings_BeforeFork(PyInterpreterState *interp);
+extern void _PyWarnings_AfterFork(PyInterpreterState *interp);
+#endif
+
 extern void _PyErr_WarnUnawaitedCoroutine(PyObject *coro);
 extern void _PyErr_WarnUnawaitedAgenMethod(PyAsyncGenObject *agen, PyObject *method);
 

Lib/test/test_warnings/__init__.py

@@ -15,6 +15,7 @@
 from test.support import import_helper
 from test.support import isolation
 from test.support import os_helper
+from test.support import threading_helper
 from test.support import warnings_helper
 from test.support import force_not_colorized
 from test.support.script_helper import assert_python_ok, assert_python_failure
@@ -1632,6 +1633,100 @@ def test_release_lock_no_lock(self):
         ):
             c_warnings._release_lock()
 
+    @support.cpython_only
+    @unittest.skipUnless(support.has_fork_support, 'requires working os.fork')
+    @threading_helper.requires_working_threading()
+    def test_fork_other_thread_holds_lock(self):
+        code = textwrap.dedent('''
+            import _warnings
+            import os
+            import threading
+            import warnings
+            from test import support
+
+            parent_pid = os.getpid()
+            read_fd, write_fd = os.pipe()
+            local = threading.local()
+            ready = threading.Event()
+            release = threading.Event()
+            warnings.simplefilter('ignore', DeprecationWarning)
+            warnings.simplefilter('ignore', ResourceWarning)
+
+            class WarnOnDelete:
+                def __del__(self):
+                    if os.getpid() != parent_pid:
+                        # Even an ignored warning must acquire the lock.
+                        warnings.warn('child cleanup', ResourceWarning)
+                        os.write(write_fd, b'finalized')
+
+            def worker():
+                local.obj = WarnOnDelete()
+                _warnings._acquire_lock()
+                _warnings._acquire_lock()
+                try:
+                    ready.set()
+                    release.wait()
+                finally:
+                    _warnings._release_lock()
+                    _warnings._release_lock()
+
+            thread = threading.Thread(target=worker)
+            thread.start()
+            # Release the worker before fork's parent-side warning attempts
+            # to acquire the warnings lock.
+            os.register_at_fork(after_in_parent=release.set)
+            try:
+                assert ready.wait(support.LONG_TIMEOUT)
+                pid = os.fork()
+                if pid == 0:
+                    # The finalizer must run before os.fork() returns.
+                    os._exit(0)
+                support.wait_process(pid, exitcode=0)
+            finally:
+                release.set()
+                thread.join()
+                os.close(write_fd)
+            assert os.read(read_fd, 100) == b'finalized'
+            os.close(read_fd)
+        ''')
+        assert_python_ok('-c', code)
+
+    @support.cpython_only
+    @unittest.skipUnless(support.has_fork_support, 'requires working os.fork')
+    def test_fork_current_thread_holds_lock(self):
+        code = textwrap.dedent('''
+            import _warnings
+            import os
+            import warnings
+            from test import support
+
+            warnings.simplefilter('ignore')
+            for _ in range(3):
+                _warnings._acquire_lock()
+            pid = os.fork()
+            try:
+                # A warning must not change the inherited recursion depth.
+                warnings.warn('after fork')
+                for _ in range(3):
+                    _warnings._release_lock()
+                try:
+                    _warnings._release_lock()
+                except RuntimeError:
+                    pass
+                else:
+                    raise AssertionError('unexpected recursion depth')
+                _warnings._acquire_lock()
+                _warnings._release_lock()
+            except BaseException:
+                if pid == 0:
+                    os._exit(1)
+                raise
+            if pid == 0:
+                os._exit(0)
+            support.wait_process(pid, exitcode=0)
+        ''')
+        assert_python_ok('-c', code)
+
 
 class _DeprecatedTest(BaseTest, unittest.TestCase):
 

Misc/NEWS.d/next/Core_and_Builtins/2026-10-07-00-00-00.gh-issue-158973.warnings-fork.rst

@@ -0,0 +1,3 @@
+Reset the warnings lock in the child after :func:`os.fork`, before clearing
+other threads' states, to avoid deadlocks when their finalizers issue warnings.
+Preserve the lock's recursion depth if the forking thread owns it.

Modules/posixmodule.c

@@ -31,6 +31,7 @@
 #include "pycore_time.h"          // _PyLong_FromTime_t()
 #include "pycore_tuple.h"         // _PyTuple_FromPairSteal
 #include "pycore_typeobject.h"    // _PyType_AddMethod()
+#include "pycore_warnings.h"      // _PyWarnings_AfterFork()
 
 #ifndef MS_WINDOWS
 #  include "posixmodule.h"        // _PyLong_FromUid()
@@ -716,6 +717,7 @@ PyOS_BeforeFork(void)
     _PyImport_AcquireLock(interp);
     _PyEval_StopTheWorldAll(&_PyRuntime);
     HEAD_LOCK(&_PyRuntime);
+    _PyWarnings_BeforeFork(interp);
 }
 
 void
@@ -786,6 +788,9 @@ PyOS_AfterFork_Child(void)
     _Py_jit_debug_mutex = (PyMutex){0};
 #endif
 
+    // Thread-state cleanup can run finalizers that issue warnings.
+    _PyWarnings_AfterFork(tstate->interp);
+
     reset_remotedebug_data(tstate);
 
     reset_asyncio_state((_PyThreadStateImpl *)tstate);

Python/_warnings.c

@@ -9,6 +9,7 @@
 #include "pycore_traceback.h"     // _Py_DisplaySourceLine()
 #include "pycore_tuple.h"         // _PyTuple_FromPair
 #include "pycore_unicodeobject.h" // _PyUnicode_EqualToASCIIString()
+#include "pycore_warnings.h"      // _PyWarnings_AfterFork()
 
 #include <stdbool.h>
 #include "clinic/_warnings.c.h"
@@ -276,6 +277,33 @@ warnings_lock_held(WarningsState *st)
     return PyMutex_IsLocked(&st->lock.mutex);
 }
 
+#ifdef HAVE_FORK
+void
+_PyWarnings_BeforeFork(PyInterpreterState *interp)
+{
+    WarningsState *st = warnings_get_state(interp);
+    // Record ownership before fork(): the thread ID can change in the child.
+    st->lock_held_at_fork = _PyRecursiveMutex_IsLockedByCurrentThread(&st->lock);
+}
+
+void
+_PyWarnings_AfterFork(PyInterpreterState *interp)
+{
+    WarningsState *st = warnings_get_state(interp);
+    if (st->lock_held_at_fork) {
+        // The surviving thread will still release the lock as its stack
+        // unwinds. Preserve the recursion depth, but discard dead waiters.
+        st->lock.mutex = (PyMutex){._bits = _Py_LOCKED};
+        st->lock.thread = PyThread_get_thread_ident_ex();
+    }
+    else {
+        // The owner (if any) no longer exists in the child.
+        st->lock = (_PyRecursiveMutex){0};
+    }
+    st->lock_held_at_fork = false;
+}
+#endif
+
 static PyObject *
 get_warnings_context(PyInterpreterState *interp)
 {