From 85f5a69ae1541271286bb0f0e0303aabf792dd5c Mon Sep 17 00:00:00 2001 From: Victor Stinner Date: Mon, 9 Mar 2020 22:12:04 +0100 Subject: bpo-39877: Refactor take_gil() function (GH-18885) * Remove ceval parameter of take_gil(): get it from tstate. * Move exit_thread_if_finalizing() call inside take_gil(). Replace exit_thread_if_finalizing() with tstate_must_exit(): the caller is now responsible to call PyThread_exit_thread(). * Move is_tstate_valid() assertion inside take_gil(). Remove is_tstate_valid(): inline code into take_gil(). * Move gil_created() assertion inside take_gil(). --- Python/ceval_gil.h | 41 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 40 insertions(+), 1 deletion(-) (limited to 'Python/ceval_gil.h') diff --git a/Python/ceval_gil.h b/Python/ceval_gil.h index 99d576d561..03f04b93e0 100644 --- a/Python/ceval_gil.h +++ b/Python/ceval_gil.h @@ -180,17 +180,55 @@ drop_gil(struct _ceval_runtime_state *ceval, PyThreadState *tstate) #endif } + +/* Check if a Python thread must exit immediately, rather than taking the GIL + if Py_Finalize() has been called. + + When this function is called by a daemon thread after Py_Finalize() has been + called, the GIL does no longer exist. + + tstate must be non-NULL. */ +static inline int +tstate_must_exit(PyThreadState *tstate) +{ + /* bpo-39877: Access _PyRuntime directly rather than using + tstate->interp->runtime to support calls from Python daemon threads. + After Py_Finalize() has been called, tstate can be a dangling pointer: + point to PyThreadState freed memory. */ + _PyRuntimeState *runtime = &_PyRuntime; + PyThreadState *finalizing = _PyRuntimeState_GetFinalizing(runtime); + return (finalizing != NULL && finalizing != tstate); +} + + /* Take the GIL. The function saves errno at entry and restores its value at exit. tstate must be non-NULL. */ static void -take_gil(struct _ceval_runtime_state *ceval, PyThreadState *tstate) +take_gil(PyThreadState *tstate) { int err = errno; + assert(tstate != NULL); + + /* Check if we should make a quick exit. */ + if (tstate_must_exit(tstate)) { + PyThread_exit_thread(); + } + + /* Ensure that tstate is valid: sanity check for PyEval_AcquireThread() and + PyEval_RestoreThread(). Detect if tstate memory was freed. */ + assert(!_PyMem_IsPtrFreed(tstate)); + assert(!_PyMem_IsPtrFreed(tstate->interp)); + + struct _ceval_runtime_state *ceval = &tstate->interp->runtime->ceval; struct _gil_runtime_state *gil = &ceval->gil; + + /* Check that _PyEval_InitThreads() was called to create the lock */ + assert(gil_created(gil)); + MUTEX_LOCK(gil->mutex); if (!_Py_atomic_load_relaxed(&gil->locked)) { @@ -215,6 +253,7 @@ take_gil(struct _ceval_runtime_state *ceval, PyThreadState *tstate) SET_GIL_DROP_REQUEST(ceval); } } + _ready: #ifdef FORCE_SWITCHING /* This mutex must be taken before modifying gil->last_holder: -- cgit v1.2.1