Stowage/cpython
2
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2026-01-04 06:22:20 +00:00
Code Issues Projects Releases Packages Wiki Activity

[3.8] bpo-38070: Py_FatalError() logs runtime state (GH-16258)

Browse source 
* bpo-38070: _Py_DumpTraceback() writes <no Python frame> (GH-16244)

When a Python thread has no frame, _Py_DumpTraceback() and
_Py_DumpTracebackThreads() now write "<no Python frame>", rather than
writing nothing.

(cherry picked from commit 8fa3e1740b)

* bpo-38070: Enhance _PyObject_Dump() (GH-16243)

_PyObject_Dump() now dumps the object address for freed objects and
objects with ob_type=NULL.

(cherry picked from commit b39afb7876)

* bpo-38070: Add _PyRuntimeState.preinitializing (GH-16245)

Add _PyRuntimeState.preinitializing field: set to 1 while
Py_PreInitialize() is running.

_PyRuntimeState: rename also pre_initialized field to preinitialized.

(cherry picked from commit d3b904144e)

* bpo-38070: Py_FatalError() logs runtime state (GH-16246)


(cherry picked from commit 1ce16fb097)
This commit is contained in:
Victor Stinner 2019-09-18 14:10:16 +02:00 • committed by GitHub
parent 7a2f68776a
commit 47bbab9f76
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 104 additions and 49 deletions
Download patch file Download diff file Expand all files Collapse all files

96
Python/pylifecycle.c
View file

@ -719,11 +719,15 @@ _Py_PreInitializeFromPyArgv(const PyPreConfig *src_config, const _PyArgv *args)
}
_PyRuntimeState *runtime = &_PyRuntime;
if (runtime->pre_initialized) {
if (runtime->preinitialized) {
/* If it's already configured: ignored the new configuration */
return _PyStatus_OK();
}
/* Note: preinitialized remains 1 on error, it is only set to 0
at exit on success. */
runtime->preinitializing = 1;
PyPreConfig config;
_PyPreConfig_InitFromPreConfig(&config, src_config);
@ -737,7 +741,8 @@ _Py_PreInitializeFromPyArgv(const PyPreConfig *src_config, const _PyArgv *args)
return status;
}
runtime->pre_initialized = 1;
runtime->preinitializing = 0;
runtime->preinitialized = 1;
return _PyStatus_OK();
}
@ -777,7 +782,7 @@ _Py_PreInitializeFromConfig(const PyConfig *config,
}
_PyRuntimeState *runtime = &_PyRuntime;
if (runtime->pre_initialized) {
if (runtime->preinitialized) {
/* Already initialized: do nothing */
return _PyStatus_OK();
}
@ -1961,13 +1966,14 @@ init_sys_streams(PyInterpreterState *interp)
static void
_Py_FatalError_DumpTracebacks(int fd)
_Py_FatalError_DumpTracebacks(int fd, PyInterpreterState *interp,
PyThreadState *tstate)
{
fputc('\n', stderr);
fflush(stderr);
/* display the current Python stack */
_Py_DumpTracebackThreads(fd, NULL, NULL);
_Py_DumpTracebackThreads(fd, interp, tstate);
}
/* Print the current exception (if an exception is set) with its traceback,
@ -2062,10 +2068,39 @@ fatal_output_debug(const char *msg)
}
#endif
static void
fatal_error_dump_runtime(FILE *stream, _PyRuntimeState *runtime)
{
fprintf(stream, "Python runtime state: ");
if (runtime->finalizing) {
fprintf(stream, "finalizing (tstate=%p)", runtime->finalizing);
}
else if (runtime->initialized) {
fprintf(stream, "initialized");
}
else if (runtime->core_initialized) {
fprintf(stream, "core initialized");
}
else if (runtime->preinitialized) {
fprintf(stream, "preinitialized");
}
else if (runtime->preinitializing) {
fprintf(stream, "preinitializing");
}
else {
fprintf(stream, "unknown");
}
fprintf(stream, "\n");
fflush(stream);
}
static void _Py_NO_RETURN
fatal_error(const char *prefix, const char *msg, int status)
{
const int fd = fileno(stderr);
FILE *stream = stderr;
const int fd = fileno(stream);
static int reentrant = 0;
if (reentrant) {
@ -2075,45 +2110,48 @@ fatal_error(const char *prefix, const char *msg, int status)
}
reentrant = 1;
fprintf(stderr, "Fatal Python error: ");
fprintf(stream, "Fatal Python error: ");
if (prefix) {
fputs(prefix, stderr);
fputs(": ", stderr);
fputs(prefix, stream);
fputs(": ", stream);
}
if (msg) {
fputs(msg, stderr);
fputs(msg, stream);
}
else {
fprintf(stderr, "<message not set>");
fprintf(stream, "<message not set>");
}
fputs("\n", stream);
fflush(stream); /* it helps in Windows debug build */
_PyRuntimeState *runtime = &_PyRuntime;
fatal_error_dump_runtime(stream, runtime);
PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime);
PyInterpreterState *interp = NULL;
if (tstate != NULL) {
interp = tstate->interp;
}
fputs("\n", stderr);
fflush(stderr); /* it helps in Windows debug build */
/* Check if the current thread has a Python thread state
and holds the GIL */
PyThreadState *tss_tstate = PyGILState_GetThisThreadState();
if (tss_tstate != NULL) {
PyThreadState *tstate = _PyThreadState_GET();
if (tss_tstate != tstate) {
/* The Python thread does not hold the GIL */
tss_tstate = NULL;
}
}
else {
/* Py_FatalError() has been called from a C thread
which has no Python thread state. */
}
int has_tstate_and_gil = (tss_tstate != NULL);
and holds the GIL.
tss_tstate is NULL if Py_FatalError() is called from a C thread which
has no Python thread state.
tss_tstate != tstate if the current Python thread does not hold the GIL.
*/
PyThreadState *tss_tstate = PyGILState_GetThisThreadState();
int has_tstate_and_gil = (tss_tstate != NULL && tss_tstate == tstate);
if (has_tstate_and_gil) {
/* If an exception is set, print the exception with its traceback */
if (!_Py_FatalError_PrintExc(fd)) {
/* No exception is set, or an exception is set without traceback */
_Py_FatalError_DumpTracebacks(fd);
_Py_FatalError_DumpTracebacks(fd, interp, tss_tstate);
}
}
else {
_Py_FatalError_DumpTracebacks(fd);
_Py_FatalError_DumpTracebacks(fd, interp, tss_tstate);
}
/* The main purpose of faulthandler is to display the traceback.

13
Python/traceback.c
View file

@ -797,12 +797,15 @@ dump_traceback(int fd, PyThreadState *tstate, int write_header)
PyFrameObject *frame;
unsigned int depth;
if (write_header)
if (write_header) {
PUTS(fd, "Stack (most recent call first):\n");
}
frame = _PyThreadState_GetFrame(tstate);
if (frame == NULL)
if (frame == NULL) {
PUTS(fd, "<no Python frame>\n");
return;
}
depth = 0;
while (frame != NULL) {
@ -870,9 +873,9 @@ _Py_DumpTracebackThreads(int fd, PyInterpreterState *interp,
Python thread state of the current thread.
PyThreadState_Get() doesn't give the state of the thread that caused
the fault if the thread released the GIL, and so this function
cannot be used. Read the thread specific storage (TSS) instead: call
PyGILState_GetThisThreadState(). */
the fault if the thread released the GIL, and so
_PyThreadState_GET() cannot be used. Read the thread specific
storage (TSS) instead: call PyGILState_GetThisThreadState(). */
current_tstate = PyGILState_GetThisThreadState();
}