gh-128360: Add `_Py_AssertHoldsTstate` as assertion for holding a thread state (...

Co-authored-by: Kumar Aditya <kumaraditya@python.org>

diff --git a/Include/internal/pycore_pystate.h b/Include/internal/pycore_pystate.h
index 1e73e541ef8de03efefbb91399ed12d0a14edcc8..ff3b222b1578104346ab47def90b78ecb0043e27 100644 (file)
--- a/Include/internal/pycore_pystate.h
+++ b/Include/internal/pycore_pystate.h
@@ -300,6 +300,19 @@ PyAPI_FUNC(const PyConfig*) _Py_GetConfig(void);
 // See also PyInterpreterState_Get() and _PyInterpreterState_GET().
 extern PyInterpreterState* _PyGILState_GetInterpreterStateUnsafe(void);
 
+#ifndef NDEBUG
+/* Modern equivalent of assert(PyGILState_Check()) */
+static inline void
+_Py_AssertHoldsTstateFunc(const char *func)
+{
+    PyThreadState *tstate = _PyThreadState_GET();
+    _Py_EnsureFuncTstateNotNULL(func, tstate);
+}
+#define _Py_AssertHoldsTstate() _Py_AssertHoldsTstateFunc(__func__)
+#else
+#define _Py_AssertHoldsTstate()
+#endif
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c
index e70aa304f2f3a391c703bcbf30e12b6e9890c7b5..5e81253ca4a591c61571a1d212654bf1871e7dee 100644 (file)
--- a/Modules/socketmodule.c
+++ b/Modules/socketmodule.c
@@ -110,6 +110,7 @@ Local naming conventions:
 #include "pycore_fileutils.h"     // _Py_set_inheritable()
 #include "pycore_moduleobject.h"  // _PyModule_GetState
 #include "pycore_time.h"          // _PyTime_AsMilliseconds()
+#include "pycore_pystate.h"       // _Py_AssertHoldsTstate()
 #include "pycore_pyatomic_ft_wrappers.h"
 
 #ifdef _Py_MEMORY_SANITIZER
@@ -822,8 +823,8 @@ internal_select(PySocketSockObject *s, int writing, PyTime_t interval,
     struct timeval tv, *tvp;
 #endif
 
-    /* must be called with the GIL held */
-    assert(PyGILState_Check());
+    /* must be called with a thread state */
+    _Py_AssertHoldsTstate();
 
     /* Error condition is for output only */
     assert(!(connect && !writing));
@@ -936,8 +937,8 @@ sock_call_ex(PySocketSockObject *s,
     int deadline_initialized = 0;
     int res;
 
-    /* sock_call() must be called with the GIL held. */
-    assert(PyGILState_Check());
+    /* sock_call() must be called with a thread state. */
+    _Py_AssertHoldsTstate();
 
     /* outer loop to retry select() when select() is interrupted by a signal
        or to retry select()+sock_func() on false positive (see above) */

diff --git a/Objects/object.c b/Objects/object.c
index 4e900d8e79d91a97d3c0fcd5429c18cbfd7ccd21..51b6016b9c191c85fcdef7b0b3514367674fca30 100644 (file)
--- a/Objects/object.c
+++ b/Objects/object.c
@@ -3073,14 +3073,14 @@ _Py_SetRefcnt(PyObject *ob, Py_ssize_t refcnt)
 }
 
 int PyRefTracer_SetTracer(PyRefTracer tracer, void *data) {
-    assert(PyGILState_Check());
+    _Py_AssertHoldsTstate();
     _PyRuntime.ref_tracer.tracer_func = tracer;
     _PyRuntime.ref_tracer.tracer_data = data;
     return 0;
 }
 
 PyRefTracer PyRefTracer_GetTracer(void** data) {
-    assert(PyGILState_Check());
+    _Py_AssertHoldsTstate();
     if (data != NULL) {
         *data = _PyRuntime.ref_tracer.tracer_data;
     }

diff --git a/Objects/obmalloc.c b/Objects/obmalloc.c
index b103deb01ca7129c9b210c777f5411ada0add284..5688049b02469675814f1f268ff5f59792598c39 100644 (file)
--- a/Objects/obmalloc.c
+++ b/Objects/obmalloc.c
@@ -2909,7 +2909,8 @@ _PyMem_DebugRawRealloc(void *ctx, void *p, size_t nbytes)
 static inline void
 _PyMem_DebugCheckGIL(const char *func)
 {
-    if (!PyGILState_Check()) {
+    PyThreadState *tstate = _PyThreadState_GET();
+    if (tstate == NULL) {
 #ifndef Py_GIL_DISABLED
         _Py_FatalErrorFunc(func,
                            "Python memory allocator called "

diff --git a/Python/ceval_gil.c b/Python/ceval_gil.c
index 1f811e7240613039ce017655da0cbabb25e8c540..416eec01052224855e3aef4c6f1c4b0c5686ca3e 100644 (file)
--- a/Python/ceval_gil.c
+++ b/Python/ceval_gil.c
@@ -995,7 +995,7 @@ _Py_unset_eval_breaker_bit_all(PyInterpreterState *interp, uintptr_t bit)
 void
 _Py_FinishPendingCalls(PyThreadState *tstate)
 {
-    assert(PyGILState_Check());
+    _Py_AssertHoldsTstate();
     assert(_PyThreadState_CheckConsistency(tstate));
 
     struct _pending_calls *pending = &tstate->interp->ceval.pending;
@@ -1056,7 +1056,7 @@ _PyEval_MakePendingCalls(PyThreadState *tstate)
 int
 Py_MakePendingCalls(void)
 {
-    assert(PyGILState_Check());
+    _Py_AssertHoldsTstate();
 
     PyThreadState *tstate = _PyThreadState_GET();
     assert(_PyThreadState_CheckConsistency(tstate));

diff --git a/Python/errors.c b/Python/errors.c
index b6ac2f767a283b0442777830f679f10b1279e496..9c7b771133dcf46aab028de9dbcce9dc6ff6dd7d 100644 (file)
--- a/Python/errors.c
+++ b/Python/errors.c
@@ -314,8 +314,8 @@ _PyErr_SetLocaleString(PyObject *exception, const char *string)
 PyObject* _Py_HOT_FUNCTION
 PyErr_Occurred(void)
 {
-    /* The caller must hold the GIL. */
-    assert(PyGILState_Check());
+    /* The caller must hold a thread state. */
+    _Py_AssertHoldsTstate();
 
     PyThreadState *tstate = _PyThreadState_GET();
     return _PyErr_Occurred(tstate);

diff --git a/Python/fileutils.c b/Python/fileutils.c
index 6bc3a44c3c13130377809cff17ec602c5a771673..72804c39220591fc55a4374633c8dc588a214b34 100644 (file)
--- a/Python/fileutils.c
+++ b/Python/fileutils.c
@@ -1,6 +1,7 @@
 #include "Python.h"
 #include "pycore_fileutils.h"     // fileutils definitions
 #include "pycore_runtime.h"       // _PyRuntime
+#include "pycore_pystate.h"       // _Py_AssertHoldsTstate()
 #include "osdefs.h"               // SEP
 
 #include <stdlib.h>               // mbstowcs()
@@ -1311,7 +1312,7 @@ _Py_fstat(int fd, struct _Py_stat_struct *status)
 {
     int res;
 
-    assert(PyGILState_Check());
+    _Py_AssertHoldsTstate();
 
     Py_BEGIN_ALLOW_THREADS
     res = _Py_fstat_noraise(fd, status);
@@ -1691,7 +1692,7 @@ int
 _Py_open(const char *pathname, int flags)
 {
     /* _Py_open() must be called with the GIL held. */
-    assert(PyGILState_Check());
+    _Py_AssertHoldsTstate();
     return _Py_open_impl(pathname, flags, 1);
 }
 
@@ -1766,7 +1767,7 @@ _Py_wfopen(const wchar_t *path, const wchar_t *mode)
 FILE*
 Py_fopen(PyObject *path, const char *mode)
 {
-    assert(PyGILState_Check());
+    _Py_AssertHoldsTstate();
 
     if (PySys_Audit("open", "Osi", path, mode, 0) < 0) {
         return NULL;
@@ -1881,7 +1882,7 @@ _Py_read(int fd, void *buf, size_t count)
     int err;
     int async_err = 0;
 
-    assert(PyGILState_Check());
+    _Py_AssertHoldsTstate();
 
     /* _Py_read() must not be called with an exception set, otherwise the
      * caller may think that read() was interrupted by a signal and the signal
@@ -2047,7 +2048,7 @@ _Py_write_impl(int fd, const void *buf, size_t count, int gil_held)
 Py_ssize_t
 _Py_write(int fd, const void *buf, size_t count)
 {
-    assert(PyGILState_Check());
+    _Py_AssertHoldsTstate();
 
     /* _Py_write() must not be called with an exception set, otherwise the
      * caller may think that write() was interrupted by a signal and the signal
@@ -2675,7 +2676,7 @@ _Py_dup(int fd)
     HANDLE handle;
 #endif
 
-    assert(PyGILState_Check());
+    _Py_AssertHoldsTstate();
 
 #ifdef MS_WINDOWS
     handle = _Py_get_osfhandle(fd);

diff --git a/Python/legacy_tracing.c b/Python/legacy_tracing.c
index 45af275f1f6dce03718cbaa917ba04c0daeaa4e5..97634f9183c7d547075705599dbd9bf8c9c235d8 100644 (file)
--- a/Python/legacy_tracing.c
+++ b/Python/legacy_tracing.c
@@ -491,8 +491,8 @@ int
 _PyEval_SetProfile(PyThreadState *tstate, Py_tracefunc func, PyObject *arg)
 {
     assert(is_tstate_valid(tstate));
-    /* The caller must hold the GIL */
-    assert(PyGILState_Check());
+    /* The caller must hold a thread state */
+    _Py_AssertHoldsTstate();
 
     /* Call _PySys_Audit() in the context of the current thread state,
        even if tstate is not the current thread state. */
@@ -586,8 +586,8 @@ int
 _PyEval_SetTrace(PyThreadState *tstate, Py_tracefunc func, PyObject *arg)
 {
     assert(is_tstate_valid(tstate));
-    /* The caller must hold the GIL */
-    assert(PyGILState_Check());
+    /* The caller must hold a thread state */
+    _Py_AssertHoldsTstate();
 
     /* Call _PySys_Audit() in the context of the current thread state,
        even if tstate is not the current thread state. */

diff --git a/Python/pystate.c b/Python/pystate.c
index c546b7c3a9f10e2cbe88e1d7527a6dd8b7d07c66..52703b048d6022951a0342ab0bbe5ff7164fc29d 100644 (file)
--- a/Python/pystate.c
+++ b/Python/pystate.c
@@ -2897,7 +2897,6 @@ _PyInterpreterState_GetConfigCopy(PyConfig *config)
 const PyConfig*
 _Py_GetConfig(void)
 {
-    assert(PyGILState_Check());
     PyThreadState *tstate = current_fast_get();
     _Py_EnsureTstateNotNULL(tstate);
     return _PyInterpreterState_GetConfig(tstate->interp);

diff --git a/Python/pytime.c b/Python/pytime.c
index 2b37cd991ef4e44af1155bd59f8719fe011549a5..c039fc98ce4bde792e6ded6c494c8e53697509c5 100644 (file)
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -1,5 +1,6 @@
 #include "Python.h"
 #include "pycore_time.h"          // PyTime_t
+#include "pycore_pystate.h"       // _Py_AssertHoldsTstate()
 
 #include <time.h>                 // gmtime_r()
 #ifdef HAVE_SYS_TIME_H
@@ -897,14 +898,14 @@ _PyTime_AsTimespec(PyTime_t t, struct timespec *ts)
 #endif
 
 
-// N.B. If raise_exc=0, this may be called without the GIL.
+// N.B. If raise_exc=0, this may be called without a thread state.
 static int
 py_get_system_clock(PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
 {
     assert(info == NULL || raise_exc);
     if (raise_exc) {
-        // raise_exc requires to hold the GIL
-        assert(PyGILState_Check());
+        // raise_exc requires to hold a thread state
+        _Py_AssertHoldsTstate();
     }
 
 #ifdef MS_WINDOWS
@@ -1142,14 +1143,14 @@ py_mach_timebase_info(_PyTimeFraction *base, int raise_exc)
 #endif
 
 
-// N.B. If raise_exc=0, this may be called without the GIL.
+// N.B. If raise_exc=0, this may be called without a thread state.
 static int
 py_get_monotonic_clock(PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
 {
     assert(info == NULL || raise_exc);
     if (raise_exc) {
-        // raise_exc requires to hold the GIL
-        assert(PyGILState_Check());
+        // raise_exc requires to hold a thread state
+        _Py_AssertHoldsTstate();
     }
 
 #if defined(MS_WINDOWS)

diff --git a/Python/tracemalloc.c b/Python/tracemalloc.c
index 919c564ee729670e44159e5915491c474aa9f511..a9f45e5ead1a11d58b0dca6b0de613bfab33e7df 100644 (file)
--- a/Python/tracemalloc.c
+++ b/Python/tracemalloc.c
@@ -367,7 +367,7 @@ traceback_new(void)
     traceback_t *traceback;
     _Py_hashtable_entry_t *entry;
 
-    assert(PyGILState_Check());
+    _Py_AssertHoldsTstate();
 
     /* get frames */
     traceback = tracemalloc_traceback;
@@ -749,7 +749,7 @@ static void
 tracemalloc_clear_traces_unlocked(void)
 {
     // Clearing tracemalloc_filenames requires the GIL to call Py_DECREF()
-    assert(PyGILState_Check());
+    _Py_AssertHoldsTstate();
 
     set_reentrant(1);
 
@@ -1302,7 +1302,7 @@ PyTraceMalloc_Untrack(unsigned int domain, uintptr_t ptr)
 void
 _PyTraceMalloc_Fini(void)
 {
-    assert(PyGILState_Check());
+    _Py_AssertHoldsTstate();
     tracemalloc_deinit();
 }
 
@@ -1323,7 +1323,7 @@ _PyTraceMalloc_TraceRef(PyObject *op, PyRefTracerEvent event,
         return 0;
     }
 
-    assert(PyGILState_Check());
+    _Py_AssertHoldsTstate();
     TABLES_LOCK();
 
     if (!tracemalloc_config.tracing) {