From 9e5d1327f8a6f3a266b76118e0c660c7bcb12ce9 Mon Sep 17 00:00:00 2001 From: "Gregory P. Smith" Date: Mon, 1 Mar 2010 01:22:39 +0000 Subject: [PATCH] Issue #7242: On Solaris 9 and earlier calling os.fork() from within a thread could raise an incorrect RuntimeError about not holding the import lock. The import lock is now reinitialized after fork. --- Lib/test/test_thread.py | 42 ++++++++++++++++++++++++++++++++++++++++- Misc/NEWS | 4 ++++ Modules/posixmodule.c | 29 ++++++++++++++++++---------- Python/import.c | 12 ++++++++---- 4 files changed, 72 insertions(+), 15 deletions(-) diff --git a/Lib/test/test_thread.py b/Lib/test/test_thread.py index 134ac3b7ca..4e707e5a13 100644 --- a/Lib/test/test_thread.py +++ b/Lib/test/test_thread.py @@ -4,6 +4,7 @@ import random from test import test_support import thread import time +import sys import weakref from test import lock_tests @@ -196,8 +197,47 @@ class LockTests(lock_tests.LockTests): locktype = thread.allocate_lock +class TestForkInThread(unittest.TestCase): + def setUp(self): + self.read_fd, self.write_fd = os.pipe() + + def test_forkinthread(self): + if sys.platform.startswith('win'): + from test.test_support import TestSkipped + raise TestSkipped("This test is only appropriate for " + "POSIX-like systems.") + def thread1(): + try: + pid = os.fork() # fork in a thread + except RuntimeError: + sys.exit(0) # exit the child + + if pid == 0: # child + os.close(self.read_fd) + os.write(self.write_fd, "OK") + sys.exit(0) + else: # parent + os.close(self.write_fd) + + thread.start_new_thread(thread1, ()) + self.assertEqual(os.read(self.read_fd, 2), "OK", + "Unable to fork() in thread") + + def tearDown(self): + try: + os.close(self.read_fd) + except OSError: + pass + + try: + os.close(self.write_fd) + except OSError: + pass + + def test_main(): - test_support.run_unittest(ThreadRunningTests, BarrierTest, LockTests) + test_support.run_unittest(ThreadRunningTests, BarrierTest, LockTests, + TestForkInThread) if __name__ == "__main__": test_main() diff --git a/Misc/NEWS b/Misc/NEWS index 2e765a93c9..184c028f66 100644 --- a/Misc/NEWS +++ b/Misc/NEWS @@ -87,6 +87,10 @@ Extension Modules - Stop providing crtassem.h symbols when compiling with Visual Studio 2010, as msvcr100.dll is not a platform assembly anymore. +- Issue #7242: On Solaris 9 and earlier calling os.fork() from within a + thread could raise an incorrect RuntimeError about not holding the import + lock. The import lock is now reinitialized after fork. + Tests ----- diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c index 46053febdb..45128d32b8 100644 --- a/Modules/posixmodule.c +++ b/Modules/posixmodule.c @@ -3605,14 +3605,18 @@ static PyObject * posix_fork1(PyObject *self, PyObject *noargs) { pid_t pid; - int result; + int result = 0; _PyImport_AcquireLock(); pid = fork1(); - result = _PyImport_ReleaseLock(); + if (pid == 0) { + /* child: this clobbers and resets the import lock. */ + PyOS_AfterFork(); + } else { + /* parent: release the import lock. */ + result = _PyImport_ReleaseLock(); + } if (pid == -1) return posix_error(); - if (pid == 0) - PyOS_AfterFork(); if (result < 0) { /* Don't clobber the OSError if the fork failed. */ PyErr_SetString(PyExc_RuntimeError, @@ -3634,14 +3638,18 @@ static PyObject * posix_fork(PyObject *self, PyObject *noargs) { pid_t pid; - int result; + int result = 0; _PyImport_AcquireLock(); pid = fork(); - result = _PyImport_ReleaseLock(); + if (pid == 0) { + /* child: this clobbers and resets the import lock. */ + PyOS_AfterFork(); + } else { + /* parent: release the import lock. */ + result = _PyImport_ReleaseLock(); + } if (pid == -1) return posix_error(); - if (pid == 0) - PyOS_AfterFork(); if (result < 0) { /* Don't clobber the OSError if the fork failed. */ PyErr_SetString(PyExc_RuntimeError, @@ -3759,11 +3767,12 @@ posix_forkpty(PyObject *self, PyObject *noargs) _PyImport_AcquireLock(); pid = forkpty(&master_fd, NULL, NULL, NULL); + if (pid == 0) + PyOS_AfterFork(); + result = _PyImport_ReleaseLock(); if (pid == -1) return posix_error(); - if (pid == 0) - PyOS_AfterFork(); if (result < 0) { /* Don't clobber the OSError if the fork failed. */ PyErr_SetString(PyExc_RuntimeError, diff --git a/Python/import.c b/Python/import.c index c25c4f0345..eb50bc56f1 100644 --- a/Python/import.c +++ b/Python/import.c @@ -301,14 +301,18 @@ _PyImport_ReleaseLock(void) return 1; } -/* This function used to be called from PyOS_AfterFork to ensure that newly - created child processes do not share locks with the parent, but for some - reason only on AIX systems. Instead of re-initializing the lock, we now - acquire the import lock around fork() calls. */ +/* This function is called from PyOS_AfterFork to ensure that newly + created child processes do not share locks with the parent. + We now acquire the import lock around fork() calls but on some platforms + (Solaris 9 and earlier? see isue7242) that still left us with problems. */ void _PyImport_ReInitLock(void) { + if (import_lock != NULL) + import_lock = PyThread_allocate_lock(); + import_lock_thread = -1; + import_lock_level = 0; } #endif -- 2.40.0