Skip to content

Commit 26881c8

Browse files
vstinnervstinner
authored
PyOS_AfterFork_Child() uses PyStatus (pythonGH-20596)
PyOS_AfterFork_Child() helper functions now return a PyStatus: PyOS_AfterFork_Child() is now responsible to handle errors. * Move _PySignal_AfterFork() to the internal C API * Add #ifdef HAVE_FORK on _PyGILState_Reinit(), _PySignal_AfterFork() and _PyInterpreterState_DeleteExceptMain().
1 parent 297257f commit 26881c8

10 files changed

Lines changed: 84 additions & 50 deletions

File tree

‎Include/internal/pycore_ceval.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ PyAPI_FUNC(int) _PyEval_AddPendingCall(
2525
void *arg);
2626
PyAPI_FUNC(void) _PyEval_SignalAsyncExc(PyThreadState *tstate);
2727
#ifdef HAVE_FORK
28-
extern void _PyEval_ReInitThreads(struct pyruntimestate *runtime);
28+
extern PyStatus _PyEval_ReInitThreads(struct pyruntimestate *runtime);
2929
#endif
3030
PyAPI_FUNC(void) _PyEval_SetCoroutineOriginTrackingDepth(
3131
PyThreadState *tstate,

‎Include/internal/pycore_import.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ PyAPI_FUNC(PyObject *) _PyImport_FindBuiltin(
1111
);
1212

1313
#ifdef HAVE_FORK
14-
extern void _PyImport_ReInitLock(void);
14+
extern PyStatus _PyImport_ReInitLock(void);
1515
#endif
1616
extern void _PyImport_Cleanup(PyThreadState *tstate);
1717

‎Include/internal/pycore_pystate.h‎

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -131,9 +131,12 @@ PyAPI_FUNC(PyThreadState *) _PyThreadState_Swap(
131131
PyThreadState *newts);
132132

133133
PyAPI_FUNC(PyStatus) _PyInterpreterState_Enable(_PyRuntimeState *runtime);
134-
PyAPI_FUNC(void) _PyInterpreterState_DeleteExceptMain(_PyRuntimeState *runtime);
135134

136-
PyAPI_FUNC(void) _PyGILState_Reinit(_PyRuntimeState *runtime);
135+
#ifdef HAVE_FORK
136+
extern PyStatus _PyInterpreterState_DeleteExceptMain(_PyRuntimeState *runtime);
137+
extern PyStatus _PyGILState_Reinit(_PyRuntimeState *runtime);
138+
extern void _PySignal_AfterFork(void);
139+
#endif
137140

138141

139142
PyAPI_FUNC(int) _PyState_AddModule(

‎Include/internal/pycore_runtime.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -120,7 +120,7 @@ PyAPI_FUNC(PyStatus) _PyRuntimeState_Init(_PyRuntimeState *runtime);
120120
PyAPI_FUNC(void) _PyRuntimeState_Fini(_PyRuntimeState *runtime);
121121

122122
#ifdef HAVE_FORK
123-
PyAPI_FUNC(void) _PyRuntimeState_ReInitThreads(_PyRuntimeState *runtime);
123+
extern PyStatus _PyRuntimeState_ReInitThreads(_PyRuntimeState *runtime);
124124
#endif
125125

126126
/* Initialize _PyRuntimeState.

‎Include/intrcheck.h‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,3 @@
1-
21
#ifndef Py_INTRCHECK_H
32
#define Py_INTRCHECK_H
43
#ifdef __cplusplus
@@ -19,7 +18,6 @@ Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyOS_AfterFork(void);
1918

2019
#ifndef Py_LIMITED_API
2120
PyAPI_FUNC(int) _PyOS_IsMainThread(void);
22-
PyAPI_FUNC(void) _PySignal_AfterFork(void);
2321

2422
#ifdef MS_WINDOWS
2523
/* windows.h is not included by Python.h so use void* instead of HANDLE */

‎Modules/posixmodule.c‎

Lines changed: 32 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -34,6 +34,7 @@
3434

3535
#include "pycore_ceval.h" // _PyEval_ReInitThreads()
3636
#include "pycore_import.h" // _PyImport_ReInitLock()
37+
#include "pycore_initconfig.h" // _PyStatus_EXCEPTION()
3738
#include "pycore_pystate.h" // _PyInterpreterState_GET()
3839
#include "structmember.h" // PyMemberDef
3940
#ifndef MS_WINDOWS
@@ -461,15 +462,41 @@ PyOS_AfterFork_Parent(void)
461462
void
462463
PyOS_AfterFork_Child(void)
463464
{
465+
PyStatus status;
464466
_PyRuntimeState *runtime = &_PyRuntime;
465-
_PyGILState_Reinit(runtime);
466-
_PyEval_ReInitThreads(runtime);
467-
_PyImport_ReInitLock();
467+
468+
status = _PyGILState_Reinit(runtime);
469+
if (_PyStatus_EXCEPTION(status)) {
470+
goto fatal_error;
471+
}
472+
473+
status = _PyEval_ReInitThreads(runtime);
474+
if (_PyStatus_EXCEPTION(status)) {
475+
goto fatal_error;
476+
}
477+
478+
status = _PyImport_ReInitLock();
479+
if (_PyStatus_EXCEPTION(status)) {
480+
goto fatal_error;
481+
}
482+
468483
_PySignal_AfterFork();
469-
_PyRuntimeState_ReInitThreads(runtime);
470-
_PyInterpreterState_DeleteExceptMain(runtime);
484+
485+
status = _PyRuntimeState_ReInitThreads(runtime);
486+
if (_PyStatus_EXCEPTION(status)) {
487+
goto fatal_error;
488+
}
489+
490+
status = _PyInterpreterState_DeleteExceptMain(runtime);
491+
if (_PyStatus_EXCEPTION(status)) {
492+
goto fatal_error;
493+
}
471494

472495
run_at_forkers(_PyInterpreterState_GET()->after_forkers_child, 0);
496+
return;
497+
498+
fatal_error:
499+
Py_ExitStatusException(status);
473500
}
474501

475502
static int

‎Modules/signalmodule.c‎

Lines changed: 8 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1796,14 +1796,17 @@ PyOS_InterruptOccurred(void)
17961796
return 1;
17971797
}
17981798

1799+
1800+
#ifdef HAVE_FORK
17991801
static void
18001802
_clear_pending_signals(void)
18011803
{
1802-
int i;
1803-
if (!_Py_atomic_load(&is_tripped))
1804+
if (!_Py_atomic_load(&is_tripped)) {
18041805
return;
1806+
}
1807+
18051808
_Py_atomic_store(&is_tripped, 0);
1806-
for (i = 1; i < NSIG; ++i) {
1809+
for (int i = 1; i < NSIG; ++i) {
18071810
_Py_atomic_store_relaxed(&Handlers[i].tripped, 0);
18081811
}
18091812
}
@@ -1816,6 +1819,8 @@ _PySignal_AfterFork(void)
18161819
* the interpreter had an opportunity to call the handlers. issue9535. */
18171820
_clear_pending_signals();
18181821
}
1822+
#endif /* HAVE_FORK */
1823+
18191824

18201825
int
18211826
_PyOS_IsMainThread(void)

‎Python/ceval.c‎

Lines changed: 6 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -433,11 +433,9 @@ PyEval_ReleaseThread(PyThreadState *tstate)
433433

434434
#ifdef HAVE_FORK
435435
/* This function is called from PyOS_AfterFork_Child to destroy all threads
436-
* which are not running in the child process, and clear internal locks
437-
* which might be held by those threads.
438-
*/
439-
440-
void
436+
which are not running in the child process, and clear internal locks
437+
which might be held by those threads. */
438+
PyStatus
441439
_PyEval_ReInitThreads(_PyRuntimeState *runtime)
442440
{
443441
PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime);
@@ -449,19 +447,20 @@ _PyEval_ReInitThreads(_PyRuntimeState *runtime)
449447
struct _gil_runtime_state *gil = &runtime->ceval.gil;
450448
#endif
451449
if (!gil_created(gil)) {
452-
return;
450+
return _PyStatus_OK();
453451
}
454452
recreate_gil(gil);
455453

456454
take_gil(tstate);
457455

458456
struct _pending_calls *pending = &tstate->interp->ceval.pending;
459457
if (_PyThread_at_fork_reinit(&pending->lock) < 0) {
460-
Py_FatalError("Can't initialize threads for pending calls");
458+
return _PyStatus_ERR("Can't reinitialize pending calls lock");
461459
}
462460

463461
/* Destroy all threads except the current one */
464462
_PyThreadState_DeleteExcept(runtime, tstate);
463+
return _PyStatus_OK();
465464
}
466465
#endif
467466

‎Python/import.c‎

Lines changed: 7 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -148,7 +148,7 @@ _PyImportZip_Init(PyThreadState *tstate)
148148
in different threads to return with a partially loaded module.
149149
These calls are serialized by the global interpreter lock. */
150150

151-
static PyThread_type_lock import_lock = 0;
151+
static PyThread_type_lock import_lock = NULL;
152152
static unsigned long import_lock_thread = PYTHREAD_INVALID_THREAD_ID;
153153
static int import_lock_level = 0;
154154

@@ -171,7 +171,7 @@ _PyImport_AcquireLock(void)
171171
!PyThread_acquire_lock(import_lock, 0))
172172
{
173173
PyThreadState *tstate = PyEval_SaveThread();
174-
PyThread_acquire_lock(import_lock, 1);
174+
PyThread_acquire_lock(import_lock, WAIT_LOCK);
175175
PyEval_RestoreThread(tstate);
176176
}
177177
assert(import_lock_level == 0);
@@ -197,19 +197,19 @@ _PyImport_ReleaseLock(void)
197197
}
198198

199199
#ifdef HAVE_FORK
200-
/* This function is called from PyOS_AfterFork_Child to ensure that newly
200+
/* This function is called from PyOS_AfterFork_Child() to ensure that newly
201201
created child processes do not share locks with the parent.
202202
We now acquire the import lock around fork() calls but on some platforms
203203
(Solaris 9 and earlier? see isue7242) that still left us with problems. */
204-
205-
void
204+
PyStatus
206205
_PyImport_ReInitLock(void)
207206
{
208207
if (import_lock != NULL) {
209208
if (_PyThread_at_fork_reinit(&import_lock) < 0) {
210-
_Py_FatalErrorFunc(__func__, "failed to create a new lock");
209+
return _PyStatus_ERR("failed to create a new lock");
211210
}
212211
}
212+
213213
if (import_lock_level > 1) {
214214
/* Forked as a side effect of import */
215215
unsigned long me = PyThread_get_thread_ident();
@@ -224,6 +224,7 @@ _PyImport_ReInitLock(void)
224224
import_lock_thread = PYTHREAD_INVALID_THREAD_ID;
225225
import_lock_level = 0;
226226
}
227+
return _PyStatus_OK();
227228
}
228229
#endif
229230

‎Python/pystate.c‎

Lines changed: 23 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -124,10 +124,8 @@ _PyRuntimeState_Fini(_PyRuntimeState *runtime)
124124

125125
#ifdef HAVE_FORK
126126
/* This function is called from PyOS_AfterFork_Child to ensure that
127-
* newly created child processes do not share locks with the parent.
128-
*/
129-
130-
void
127+
newly created child processes do not share locks with the parent. */
128+
PyStatus
131129
_PyRuntimeState_ReInitThreads(_PyRuntimeState *runtime)
132130
{
133131
// This was initially set in _PyRuntimeState_Init().
@@ -138,23 +136,20 @@ _PyRuntimeState_ReInitThreads(_PyRuntimeState *runtime)
138136
PyMemAllocatorEx old_alloc;
139137
_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
140138

141-
int interp_mutex = _PyThread_at_fork_reinit(&runtime->interpreters.mutex);
142-
int main_interp_id_mutex = _PyThread_at_fork_reinit(&runtime->interpreters.main->id_mutex);
143-
int xidregistry_mutex = _PyThread_at_fork_reinit(&runtime->xidregistry.mutex);
139+
int reinit_interp = _PyThread_at_fork_reinit(&runtime->interpreters.mutex);
140+
int reinit_main_id = _PyThread_at_fork_reinit(&runtime->interpreters.main->id_mutex);
141+
int reinit_xidregistry = _PyThread_at_fork_reinit(&runtime->xidregistry.mutex);
144142

145143
PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
146144

147-
if (interp_mutex < 0) {
148-
Py_FatalError("Can't initialize lock for runtime interpreters");
149-
}
150-
151-
if (main_interp_id_mutex < 0) {
152-
Py_FatalError("Can't initialize ID lock for main interpreter");
153-
}
145+
if (reinit_interp < 0
146+
|| reinit_main_id < 0
147+
|| reinit_xidregistry < 0)
148+
{
149+
return _PyStatus_ERR("Failed to reinitialize runtime locks");
154150

155-
if (xidregistry_mutex < 0) {
156-
Py_FatalError("Can't initialize lock for cross-interpreter data registry");
157151
}
152+
return _PyStatus_OK();
158153
}
159154
#endif
160155

@@ -373,19 +368,20 @@ PyInterpreterState_Delete(PyInterpreterState *interp)
373368
}
374369

375370

371+
#ifdef HAVE_FORK
376372
/*
377373
* Delete all interpreter states except the main interpreter. If there
378374
* is a current interpreter state, it *must* be the main interpreter.
379375
*/
380-
void
376+
PyStatus
381377
_PyInterpreterState_DeleteExceptMain(_PyRuntimeState *runtime)
382378
{
383379
struct _gilstate_runtime_state *gilstate = &runtime->gilstate;
384380
struct pyinterpreters *interpreters = &runtime->interpreters;
385381

386382
PyThreadState *tstate = _PyThreadState_Swap(gilstate, NULL);
387383
if (tstate != NULL && tstate->interp != interpreters->main) {
388-
Py_FatalError("not main interpreter");
384+
return _PyStatus_ERR("not main interpreter");
389385
}
390386

391387
HEAD_LOCK(runtime);
@@ -411,10 +407,12 @@ _PyInterpreterState_DeleteExceptMain(_PyRuntimeState *runtime)
411407
HEAD_UNLOCK(runtime);
412408

413409
if (interpreters->head == NULL) {
414-
Py_FatalError("missing main interpreter");
410+
return _PyStatus_ERR("missing main interpreter");
415411
}
416412
_PyThreadState_Swap(gilstate, tstate);
413+
return _PyStatus_OK();
417414
}
415+
#endif
418416

419417

420418
PyInterpreterState *
@@ -1259,29 +1257,32 @@ _PyGILState_Fini(PyThreadState *tstate)
12591257
gilstate->autoInterpreterState = NULL;
12601258
}
12611259

1260+
#ifdef HAVE_FORK
12621261
/* Reset the TSS key - called by PyOS_AfterFork_Child().
12631262
* This should not be necessary, but some - buggy - pthread implementations
12641263
* don't reset TSS upon fork(), see issue #10517.
12651264
*/
1266-
void
1265+
PyStatus
12671266
_PyGILState_Reinit(_PyRuntimeState *runtime)
12681267
{
12691268
struct _gilstate_runtime_state *gilstate = &runtime->gilstate;
12701269
PyThreadState *tstate = _PyGILState_GetThisThreadState(gilstate);
12711270

12721271
PyThread_tss_delete(&gilstate->autoTSSkey);
12731272
if (PyThread_tss_create(&gilstate->autoTSSkey) != 0) {
1274-
Py_FatalError("Could not allocate TSS entry");
1273+
return _PyStatus_NO_MEMORY();
12751274
}
12761275

12771276
/* If the thread had an associated auto thread state, reassociate it with
12781277
* the new key. */
12791278
if (tstate &&
12801279
PyThread_tss_set(&gilstate->autoTSSkey, (void *)tstate) != 0)
12811280
{
1282-
Py_FatalError("Couldn't create autoTSSkey mapping");
1281+
return _PyStatus_ERR("failed to set autoTSSkey");
12831282
}
1283+
return _PyStatus_OK();
12841284
}
1285+
#endif
12851286

12861287
/* When a thread state is created for a thread by some mechanism other than
12871288
PyGILState_Ensure, it's important that the GILState machinery knows about

0 commit comments

Comments
 (0)