Acquire GIL or stop the world when calling _Py_DumpTracebackThreads from faulthandler_thread

Author: sergey-miryanov

Include/internal/pycore_traceback.h

@@ -56,12 +56,16 @@ extern void _Py_DumpTraceback(
    It is better to pass NULL to interp and current_tstate, the function tries
    different options to retrieve this information.
 
+   If skip_current_tstate is 1 then first tstate (current_tstate) will be skiped.
+   This flag used in faulthandler_thread to skip self.
+
    This function is signal safe. */
 
 extern const char* _Py_DumpTracebackThreads(
     int fd,
     PyInterpreterState *interp,
-    PyThreadState *current_tstate);
+    PyThreadState *current_tstate,
+    int skip_current_tstate);
 
 /* Write a Unicode object into the file descriptor fd. Encode the string to
    ASCII using the backslashreplace error handler.

Modules/faulthandler.c

@@ -205,7 +205,7 @@ faulthandler_dump_traceback(int fd, int all_threads,
     PyThreadState *tstate = PyGILState_GetThisThreadState();
 
     if (all_threads == 1) {
-        (void)_Py_DumpTracebackThreads(fd, NULL, tstate);
+        (void)_Py_DumpTracebackThreads(fd, NULL, tstate, 0);
     }
     else {
         if (all_threads == FT_IGNORE_ALL_THREADS) {
@@ -273,7 +273,7 @@ faulthandler_dump_traceback_py_impl(PyObject *module, PyObject *file,
         /* gh-128400: Accessing other thread states while they're running
          * isn't safe if those threads are running. */
         _PyEval_StopTheWorld(interp);
-        errmsg = _Py_DumpTracebackThreads(fd, NULL, tstate);
+        errmsg = _Py_DumpTracebackThreads(fd, NULL, tstate, 0);
         _PyEval_StartTheWorld(interp);
         if (errmsg != NULL) {
             PyErr_SetString(PyExc_RuntimeError, errmsg);
@@ -677,6 +677,13 @@ faulthandler_is_enabled_impl(PyObject *module)
     return fatal_error.enabled;
 }
 
+// TODO: remove
+static int
+interp_is_freed(PyInterpreterState *interp)
+{
+    return _PyMem_IsPtrFreed(interp);
+}
+
 static void
 faulthandler_thread(void *unused)
 {
@@ -703,7 +710,25 @@ faulthandler_thread(void *unused)
 
         (void)_Py_write_noraise(thread.fd, thread.header, (int)thread.header_len);
 
-        errmsg = _Py_DumpTracebackThreads(thread.fd, thread.interp, NULL);
+        PyInterpreterState *interp = thread.interp;
+        assert(interp != NULL);
+
+        if (!interp_is_freed(interp)) {
+
+#ifdef Py_GIL_DISABLED
+            _PyEval_StopTheWorld(interp);
+#else
+            PyGILState_STATE gil_state = PyGILState_Ensure();
+#endif
+            errmsg = _Py_DumpTracebackThreads(thread.fd, interp, NULL, 1);
+
+#ifdef Py_GIL_DISABLED
+            _PyEval_StartTheWorld(interp);
+#else
+            PyGILState_Release(gil_state);
+#endif
+        }
+
         ok = (errmsg == NULL);
 
         if (thread.exit)

Python/pylifecycle.c

@@ -3139,7 +3139,7 @@ _Py_FatalError_DumpTracebacks(int fd, PyInterpreterState *interp,
 
     /* display the current Python stack */
 #ifndef Py_GIL_DISABLED
-    _Py_DumpTracebackThreads(fd, interp, tstate);
+    _Py_DumpTracebackThreads(fd, interp, tstate, 0);
 #else
     _Py_DumpTraceback(fd, tstate);
 #endif

Python/traceback.c

@@ -1239,7 +1239,8 @@ write_thread_id(int fd, PyThreadState *tstate, int is_current)
    handlers if signals were received. */
 const char*
 _Py_DumpTracebackThreads(int fd, PyInterpreterState *interp,
-                         PyThreadState *current_tstate)
+                         PyThreadState *current_tstate,
+                         int skip_current_tstate)
 {
     if (current_tstate == NULL) {
         /* _Py_DumpTracebackThreads() is called from signal handlers by
@@ -1289,6 +1290,12 @@ _Py_DumpTracebackThreads(int fd, PyInterpreterState *interp,
     _Py_BEGIN_SUPPRESS_IPH
     do
     {
+        if (skip_current_tstate && current_tstate == tstate) {
+            tstate = PyThreadState_Next(tstate);
+            skip_current_tstate = 0;
+            continue;
+        }
+
         if (nthreads != 0)
             PUTS(fd, "\n");
         if (nthreads >= MAX_NTHREADS) {