Returning const char* from PyUnstable_DumpTraceback, write errors to fd

Author: alexmalyshev

Doc/c-api/exceptions.rst

@@ -1347,7 +1347,7 @@ Tracebacks
    This function returns ``0`` on success, and returns ``-1`` with an
    exception set on failure.
 
-.. c:function:: void PyUnstable_DumpTraceback(int fd, PyThreadState *tstate)
+.. c:function:: const char* PyUnstable_DumpTraceback(int fd, PyThreadState *tstate)
 
    Write a trace of the Python stack in *tstate* into the file *fd*.  The format
    looks like::
@@ -1363,6 +1363,9 @@ Tracebacks
    backslashreplace and truncated to 500 characters. It writes only the first
    100 frames; further frames are truncated with the line ``...``.
 
+   This function will return ``NULL`` on success, or an error message on error.
+   It will also write this error message to *fd*.
+
    This function is safe to use from signal handlers.
 
    The caller does not need to hold an :term:`attached thread state`, nor does
@@ -1384,6 +1387,7 @@ Tracebacks
    error if the function is unable to get the current Python thread state.
 
    This function will return ``NULL`` on success, or an error message on error.
+   It will also write this error message to *fd*.
 
    This function is meant to debug debug situations such as segfaults, fatal
    errors, and similar. It calls :c:func:`PyUnstable_DumpTraceback` for each

Include/cpython/traceback.h

@@ -12,7 +12,7 @@ struct _traceback {
     int tb_lineno;
 };
 
-PyAPI_FUNC(void) PyUnstable_DumpTraceback(int fd, PyThreadState *tstate);
+PyAPI_FUNC(const char*) PyUnstable_DumpTraceback(int fd, PyThreadState *tstate);
 
 PyAPI_FUNC(const char*) PyUnstable_DumpTracebackThreads(
     int fd,

Include/traceback.h

@@ -13,6 +13,7 @@ PyAPI_FUNC(int) PyTraceBack_Print(PyObject *, PyObject *);
 PyAPI_DATA(PyTypeObject) PyTraceBack_Type;
 #define PyTraceBack_Check(v) Py_IS_TYPE((v), &PyTraceBack_Type)
 
+
 #ifndef Py_LIMITED_API
 #  define Py_CPYTHON_TRACEBACK_H
 #  include "cpython/traceback.h"

Modules/faulthandler.c

@@ -276,15 +276,16 @@ faulthandler_dump_traceback_py_impl(PyObject *module, PyObject *file,
         _PyEval_StopTheWorld(interp);
         errmsg = PyUnstable_DumpTracebackThreads(fd, NULL, tstate);
         _PyEval_StartTheWorld(interp);
-        if (errmsg != NULL) {
-            PyErr_SetString(PyExc_RuntimeError, errmsg);
-            Py_XDECREF(file);
-            return NULL;
-        }
     }
     else {
-        PyUnstable_DumpTraceback(fd, tstate);
+        errmsg = PyUnstable_DumpTraceback(fd, tstate);
     }
+    if (errmsg != NULL) {
+      PyErr_SetString(PyExc_RuntimeError, errmsg);
+      Py_XDECREF(file);
+      return NULL;
+    }
+
     Py_XDECREF(file);
 
     if (PyErr_CheckSignals())

Python/traceback.c

@@ -1167,10 +1167,11 @@ dump_traceback(int fd, PyThreadState *tstate, int write_header)
 
    The caller is responsible to call PyErr_CheckSignals() to call Python signal
    handlers if signals were received. */
-void
+const char*
 PyUnstable_DumpTraceback(int fd, PyThreadState *tstate)
 {
     dump_traceback(fd, tstate, 1);
+    return NULL;
 }
 
 #if defined(HAVE_PTHREAD_GETNAME_NP) || defined(HAVE_PTHREAD_GET_NAME_NP)
@@ -1257,6 +1258,14 @@ write_thread_id(int fd, PyThreadState *tstate, int is_current)
     PUTS(fd, " (most recent call first):\n");
 }
 
+/* Write an error string and also return it at the same time. */
+static const char*
+dump_error(int fd, const char *msg)
+{
+    PUTS(fd, msg);
+    return msg;
+}
+
 /* Dump the traceback of all Python threads into fd. Use write() to write the
    traceback and retry if write() is interrupted by a signal (failed with
    EINTR), but don't call the Python signal handler.
@@ -1283,15 +1292,15 @@ PyUnstable_DumpTracebackThreads(int fd, PyInterpreterState *interp,
     }
 
     if (current_tstate != NULL && tstate_is_freed(current_tstate)) {
-        return "tstate is freed";
+        return dump_error(fd, "tstate is freed");
     }
 
     if (interp == NULL) {
         if (current_tstate == NULL) {
             interp = _PyGILState_GetInterpreterStateUnsafe();
             if (interp == NULL) {
                 /* We need the interpreter state to get Python threads */
-                return "unable to get the interpreter state";
+                return dump_error(fd, "unable to get the interpreter state");
             }
         }
         else {
@@ -1301,13 +1310,13 @@ PyUnstable_DumpTracebackThreads(int fd, PyInterpreterState *interp,
     assert(interp != NULL);
 
     if (interp_is_freed(interp)) {
-        return "interp is freed";
+        return dump_error(fd, "interp is freed");
     }
 
     /* Get the current interpreter from the current thread */
     PyThreadState *tstate = PyInterpreterState_ThreadHead(interp);
     if (tstate == NULL)
-        return "unable to get the thread head state";
+        return dump_error(fd, "unable to get the thread head state");
 
     /* Dump the traceback of each thread */
     unsigned int nthreads = 0;