Behavior changed to raise an exception when fork is used within a thread. Started to fix tests.

Author: rani-pinchuk

Lib/test/_test_multiprocessing.py

@@ -39,7 +39,7 @@
 from test.support import socket_helper
 from test.support import threading_helper
 from test.support import warnings_helper
-from test.support.script_helper import run_python_until_end
+from test.support.script_helper import assert_python_failure, assert_python_ok
 
 # Skip tests if _multiprocessing wasn't built.
 _multiprocessing = import_helper.import_module('_multiprocessing')
@@ -6284,7 +6284,15 @@ def test_list(self):
 
     def setUp(self):
         self.manager = self.manager_class()
-        self.manager.start()
+        # gh-135427
+        # In some of the tests, a forked child forks another child of itself. In that case, using
+        # warnings_helper.ignore_warnings decorator does not actually ignore the warning from that
+        # child of child, and a warnings_helper.ignore_warnings exception is raised.
+        with warnings.catch_warnings():
+            warnings.filterwarnings('ignore',
+                                    message=".*fork.*may lead to deadlocks in the child.*",
+                                    category=DeprecationWarning)
+            self.manager.start()
         self.proc = None
 
     def tearDown(self):
@@ -7165,15 +7173,13 @@ def test_fork(self):
         print("In parent")
         """
 
-        res, _ = run_python_until_end("-c", code, PYTHONWARNINGS='always')
+        res = assert_python_ok("-c", code, PYTHONWARNINGS='always')
         self.assertIn(b'In child', res.out)
         self.assertIn(b'In parent', res.out)
         self.assertIn(b'DeprecationWarning', res.err)
         self.assertIn(b'is multi-threaded, use of fork() may lead to deadlocks in the child', res.err)
 
-        res, _ = run_python_until_end("-c", code, PYTHONWARNINGS='error')
-        self.assertIn(b'In child', res.out)
-        self.assertIn(b'In parent', res.out)
+        res = assert_python_failure("-c", code, PYTHONWARNINGS='error')
         self.assertIn(b'DeprecationWarning', res.err)
         self.assertIn(b'is multi-threaded, use of fork() may lead to deadlocks in the child', res.err)
 
@@ -7195,14 +7201,11 @@ def test_forkpty(self):
         print(f"In parent")
         """
 
-        res, _ = run_python_until_end("-c", code, PYTHONWARNINGS='always')
-        print(res)
+        res = assert_python_ok("-c", code, PYTHONWARNINGS='always')
         self.assertIn(b'In parent', res.out)
         self.assertIn(b'DeprecationWarning', res.err)
         self.assertIn(b'is multi-threaded, use of forkpty() may lead to deadlocks in the child', res.err)
 
-        res, _ = run_python_until_end("-c", code, PYTHONWARNINGS='error')
-        print(res)
-        self.assertIn(b'In parent', res.out)
+        res = assert_python_failure("-c", code, PYTHONWARNINGS='error')
         self.assertIn(b'DeprecationWarning', res.err)
         self.assertIn(b'is multi-threaded, use of forkpty() may lead to deadlocks in the child', res.err)

Modules/posixmodule.c

@@ -7992,7 +7992,7 @@ os_register_at_fork_impl(PyObject *module, PyObject *before,
 //
 // This should only be called from the parent process after
 // PyOS_AfterFork_Parent().
-static void
+static int
 warn_about_fork_with_threads(const char* name)
 {
     // It's not safe to issue the warning while the world is stopped, because
@@ -8043,22 +8043,22 @@ warn_about_fork_with_threads(const char* name)
         PyObject *threading = PyImport_GetModule(&_Py_ID(threading));
         if (!threading) {
             PyErr_Clear();
-            return;
+            return 0;
         }
         PyObject *threading_active =
                 PyObject_GetAttr(threading, &_Py_ID(_active));
         if (!threading_active) {
             PyErr_Clear();
             Py_DECREF(threading);
-            return;
+            return 0;
         }
         PyObject *threading_limbo =
                 PyObject_GetAttr(threading, &_Py_ID(_limbo));
         if (!threading_limbo) {
             PyErr_Clear();
             Py_DECREF(threading);
             Py_DECREF(threading_active);
-            return;
+            return 0;
         }
         Py_DECREF(threading);
         // Duplicating what threading.active_count() does but without holding
@@ -8074,7 +8074,7 @@ warn_about_fork_with_threads(const char* name)
         Py_DECREF(threading_limbo);
     }
     if (num_python_threads > 1) {
-        PyErr_WarnFormat(
+        return PyErr_WarnFormat(
                 PyExc_DeprecationWarning, 1,
 #ifdef HAVE_GETPID
                 "This process (pid=%d) is multi-threaded, "
@@ -8086,11 +8086,8 @@ warn_about_fork_with_threads(const char* name)
                 getpid(),
 #endif
                 name);
-        if (PyErr_Occurred()) {
-            PyErr_WriteUnraisable(NULL);
-            PyErr_Clear();
-        }
     }
+    return 0;
 }
 #endif  // HAVE_FORK1 || HAVE_FORKPTY || HAVE_FORK
 
@@ -8129,7 +8126,8 @@ os_fork1_impl(PyObject *module)
         /* parent: release the import lock. */
         PyOS_AfterFork_Parent();
         // After PyOS_AfterFork_Parent() starts the world to avoid deadlock.
-        warn_about_fork_with_threads("fork1");
+        if (warn_about_fork_with_threads("fork1") < 0)
+            return NULL;
     }
     if (pid == -1) {
         errno = saved_errno;
@@ -8178,7 +8176,8 @@ os_fork_impl(PyObject *module)
         /* parent: release the import lock. */
         PyOS_AfterFork_Parent();
         // After PyOS_AfterFork_Parent() starts the world to avoid deadlock.
-        warn_about_fork_with_threads("fork");
+        if (warn_about_fork_with_threads("fork") < 0)
+            return NULL;
     }
     if (pid == -1) {
         errno = saved_errno;
@@ -9033,7 +9032,8 @@ os_forkpty_impl(PyObject *module)
         /* parent: release the import lock. */
         PyOS_AfterFork_Parent();
         // After PyOS_AfterFork_Parent() starts the world to avoid deadlock.
-        warn_about_fork_with_threads("forkpty");
+        if (warn_about_fork_with_threads("forkpty") < 0)
+            return NULL;
     }
     if (pid == -1) {
         return posix_error();