#include "Python.h"

#include "pycore_ceval.h" // _PyEval_IsGILEnabled()

#include "pycore_initconfig.h" // _PyStatus_ERR()

#include "pycore_pyerrors.h" // _Py_DumpExtensionModules()

#include "pycore_fileutils.h" // _PyFile_Flush

#include "pycore_pystate.h" // _PyThreadState_GET()

#include "pycore_runtime.h" // _Py_ID()

#include "pycore_signal.h" // Py_NSIG

#include "pycore_time.h" // _PyTime_FromSecondsObject()

#include "pycore_traceback.h" // _Py_DumpStack()

#ifdef HAVE_UNISTD_H

# include <unistd.h> // _exit()

#include <signal.h> // sigaction()

#include <stdlib.h> // abort()

#if defined(HAVE_PTHREAD_SIGMASK) && !defined(HAVE_BROKEN_PTHREAD_SIGMASK) && defined(HAVE_PTHREAD_H)

# include <pthread.h>

#ifdef MS_WINDOWS

# include <windows.h>

#ifdef HAVE_SYS_RESOURCE_H

# include <sys/resource.h> // setrlimit()

#if defined(FAULTHANDLER_USE_ALT_STACK) && defined(HAVE_LINUX_AUXVEC_H) && defined(HAVE_SYS_AUXV_H)

# include <linux/auxvec.h> // AT_MINSIGSTKSZ

# include <sys/auxv.h> // getauxval()

#include "clinic/faulthandler.c.h"

#define FT_IGNORE_ALL_THREADS 2

#define STACK_OVERFLOW_MAX_SIZE (100 * 1024 * 1024)

#define PUTS(fd, str) (void)_Py_write_noraise(fd, str, strlen(str))

typedef struct {

int signum;

int enabled;

const char* name;

_Py_sighandler_t previous;

int all_threads;

} fault_handler_t;

#define fatal_error _PyRuntime.faulthandler.fatal_error

#define thread _PyRuntime.faulthandler.thread

#ifdef FAULTHANDLER_USER

#define user_signals _PyRuntime.faulthandler.user_signals

typedef struct faulthandler_user_signal user_signal_t;

static void faulthandler_user(int signum);

#endif /* FAULTHANDLER_USER */

static fault_handler_t faulthandler_handlers[] = {

#ifdef SIGBUS

{SIGBUS, 0, "Bus error", },

#ifdef SIGILL

{SIGILL, 0, "Illegal instruction", },

{SIGFPE, 0, "Floating-point exception", },

{SIGABRT, 0, "Aborted", },

/* define SIGSEGV at the end to make it the default choice if searching the

{SIGSEGV, 0, "Segmentation fault", }

};

static const size_t faulthandler_nsignals = \

Py_ARRAY_LENGTH(faulthandler_handlers);

#ifdef FAULTHANDLER_USE_ALT_STACK

# define stack _PyRuntime.faulthandler.stack

# define old_stack _PyRuntime.faulthandler.old_stack

static int

faulthandler_get_fileno(PyObject **file_ptr)

{

PyObject *result;

PyObject *file = *file_ptr;

if (file == NULL || file == Py_None) {

file = PySys_GetAttr(&_Py_ID(stderr));

if (file == NULL) {

return -1;

}

if (file == Py_None) {

PyErr_SetString(PyExc_RuntimeError, "sys.stderr is None");

Py_DECREF(file);

return -1;

}

}

else if (PyLong_Check(file)) {

if (PyBool_Check(file)) {

if (PyErr_WarnEx(PyExc_RuntimeWarning,

"bool is used as a file descriptor", 1))

{

return -1;

}

}

int fd = PyLong_AsInt(file);

if (fd == -1 && PyErr_Occurred())

return -1;

if (fd < 0) {

PyErr_SetString(PyExc_ValueError,

"file is not a valid file descriptor");

return -1;

}

*file_ptr = NULL;

return fd;

}

else {

Py_INCREF(file);

}

result = PyObject_CallMethodNoArgs(file, &_Py_ID(fileno));

if (result == NULL) {

Py_DECREF(file);

return -1;

}

int fd;

if (PyLong_Check(result)) {

fd = PyLong_AsInt(result);

}

else {

fd = -1;

}

Py_DECREF(result);

if (fd < 0) {

PyErr_SetString(PyExc_RuntimeError,

"file.fileno() is not a valid file descriptor");

Py_DECREF(file);

return -1;

}

if (_PyFile_Flush(file) < 0) {

/* ignore flush() error */

PyErr_Clear();

}

*file_ptr = file;

return fd;

}

static PyThreadState*

get_thread_state(void)

{

PyThreadState *tstate = _PyThreadState_GET();

if (tstate == NULL) {

/* just in case but very unlikely... */

PyErr_SetString(PyExc_RuntimeError,

"unable to get the current thread state");

return NULL;

}

return tstate;

}

static void

faulthandler_dump_traceback(int fd, int all_threads,

PyInterpreterState *interp,

Py_ssize_t max_threads)

{

static volatile int reentrant = 0;

if (reentrant)

return;

reentrant = 1;

/* SIGSEGV, SIGFPE, SIGABRT, SIGBUS and SIGILL are synchronous signals and

PyThreadState *tstate = PyGILState_GetThisThreadState();

if (all_threads == 1) {

(void)PyUnstable_DumpTracebackThreads(fd, NULL, tstate, max_threads);

}

else {

if (all_threads == FT_IGNORE_ALL_THREADS) {

PUTS(fd, "<Cannot show all threads while the GIL is disabled>\n");

}

if (tstate != NULL) {

PyUnstable_DumpTraceback(fd, tstate);

}

}

reentrant = 0;

}

static void

faulthandler_dump_c_stack(int fd)

{

static volatile int reentrant = 0;

if (reentrant) {

return;

}

reentrant = 1;

if (fatal_error.c_stack) {

PUTS(fd, "\n");

_Py_DumpStack(fd);

}

reentrant = 0;

}

static PyObject *

faulthandler_dump_traceback_py_impl(PyObject *module, PyObject *file,

int all_threads, Py_ssize_t max_threads)

{

PyThreadState *tstate;

const char *errmsg;

int fd;

fd = faulthandler_get_fileno(&file);

if (fd < 0)

return NULL;

tstate = get_thread_state();

if (tstate == NULL) {

Py_XDECREF(file);

return NULL;

}

if (all_threads) {

PyInterpreterState *interp = _PyInterpreterState_GET();

/* gh-128400: Accessing other thread states while they're running

_PyEval_StopTheWorld(interp);

errmsg = PyUnstable_DumpTracebackThreads(fd, NULL, tstate, max_threads);

_PyEval_StartTheWorld(interp);

}

else {

errmsg = PyUnstable_DumpTraceback(fd, tstate);

}

if (errmsg != NULL) {

PyErr_SetString(PyExc_RuntimeError, errmsg);

Py_XDECREF(file);

return NULL;

}

Py_XDECREF(file);

if (PyErr_CheckSignals())

return NULL;

Py_RETURN_NONE;

}

static PyObject *

faulthandler_dump_c_stack_py_impl(PyObject *module, PyObject *file)

{

int fd = faulthandler_get_fileno(&file);

if (fd < 0) {

return NULL;

}

_Py_DumpStack(fd);

Py_XDECREF(file);

if (PyErr_CheckSignals()) {

return NULL;

}

Py_RETURN_NONE;

}

static void

faulthandler_disable_fatal_handler(fault_handler_t *handler)

{

if (!handler->enabled)

return;

handler->enabled = 0;

#ifdef HAVE_SIGACTION

(void)sigaction(handler->signum, &handler->previous, NULL);

(void)signal(handler->signum, handler->previous);

}

static int

deduce_all_threads(void)

{

#ifndef Py_GIL_DISABLED

return fatal_error.all_threads;

if (fatal_error.all_threads == 0) {

return 0;

}

// We can't use _PyThreadState_GET, so use the stored GILstate one

PyThreadState *tstate = PyGILState_GetThisThreadState();

if (tstate == NULL) {

return 0;

}

/* In theory, it's safe to dump all threads if the GIL is enabled */

return _PyEval_IsGILEnabled(tstate)

? fatal_error.all_threads

: FT_IGNORE_ALL_THREADS;

}

static void

faulthandler_fatal_error(int signum)

{

const int fd = fatal_error.fd;

size_t i;

fault_handler_t *handler = NULL;

int save_errno = errno;

int found = 0;

if (!fatal_error.enabled)

return;

for (i=0; i < faulthandler_nsignals; i++) {

handler = &faulthandler_handlers[i];

if (handler->signum == signum) {

found = 1;

break;

}

}

if (handler == NULL) {

/* faulthandler_nsignals == 0 (unlikely) */

return;

}

/* restore the previous handler */

faulthandler_disable_fatal_handler(handler);

if (found) {

PUTS(fd, "Fatal Python error: ");

PUTS(fd, handler->name);

PUTS(fd, "\n\n");

}

else {

PUTS(fd, "Fatal Python error from unexpected signum: ");

_Py_DumpDecimal(fd, signum);

PUTS(fd, "\n\n");

}

faulthandler_dump_traceback(fd, deduce_all_threads(),

fatal_error.interp,

fatal_error.max_threads);

faulthandler_dump_c_stack(fd);

_Py_DumpExtensionModules(fd, fatal_error.interp);

errno = save_errno;

#ifdef MS_WINDOWS

if (signum == SIGSEGV) {

/* don't explicitly call the previous handler for SIGSEGV in this signal

return;

}

/* call the previous signal handler: it is called immediately if we use

raise(signum);

}

#ifdef MS_WINDOWS

static int

faulthandler_ignore_exception(DWORD code)

{

/* bpo-30557: ignore exceptions which are not errors */

if (!(code & 0x80000000)) {

return 1;

}

/* bpo-31701: ignore MSC and COM exceptions

if (code == 0xE06D7363 /* MSC exception ("Emsc") */

|| code == 0xE0434352 /* COM Callable Runtime exception ("ECCR") */) {

return 1;

}

/* Interesting exception: log it with the Python traceback */

return 0;

}

static LONG WINAPI

faulthandler_exc_handler(struct _EXCEPTION_POINTERS *exc_info)

{

const int fd = fatal_error.fd;

DWORD code = exc_info->ExceptionRecord->ExceptionCode;

if (faulthandler_ignore_exception(code)) {

/* ignore the exception: call the next exception handler */

return EXCEPTION_CONTINUE_SEARCH;

}

PUTS(fd, "Windows fatal exception: ");

switch (code)

{

/* only format most common errors */

case EXCEPTION_ACCESS_VIOLATION: PUTS(fd, "access violation"); break;

case EXCEPTION_FLT_DIVIDE_BY_ZERO: PUTS(fd, "float divide by zero"); break;

case EXCEPTION_FLT_OVERFLOW: PUTS(fd, "float overflow"); break;

case EXCEPTION_INT_DIVIDE_BY_ZERO: PUTS(fd, "int divide by zero"); break;

case EXCEPTION_INT_OVERFLOW: PUTS(fd, "integer overflow"); break;

case EXCEPTION_IN_PAGE_ERROR: PUTS(fd, "page error"); break;

case EXCEPTION_STACK_OVERFLOW: PUTS(fd, "stack overflow"); break;

default:

PUTS(fd, "code 0x");

_Py_DumpHexadecimal(fd, code, 8);

}

PUTS(fd, "\n\n");

if (code == EXCEPTION_ACCESS_VIOLATION) {

/* disable signal handler for SIGSEGV */

for (size_t i=0; i < faulthandler_nsignals; i++) {

fault_handler_t *handler = &faulthandler_handlers[i];

if (handler->signum == SIGSEGV) {

faulthandler_disable_fatal_handler(handler);

break;

}

}

}

faulthandler_dump_traceback(fd, deduce_all_threads(),

fatal_error.interp,

fatal_error.max_threads);

faulthandler_dump_c_stack(fd);

/* call the next exception handler */

return EXCEPTION_CONTINUE_SEARCH;

}

#ifdef FAULTHANDLER_USE_ALT_STACK

static int

faulthandler_allocate_stack(void)

{

if (stack.ss_sp != NULL) {

return 0;

}

/* Allocate an alternate stack for faulthandler() signal handler

stack.ss_sp = PyMem_Malloc(stack.ss_size);

if (stack.ss_sp == NULL) {

PyErr_NoMemory();

return -1;

}

int err = sigaltstack(&stack, &old_stack);

if (err) {

PyErr_SetFromErrno(PyExc_OSError);

/* Release the stack to retry sigaltstack() next time */

PyMem_Free(stack.ss_sp);

stack.ss_sp = NULL;

return -1;

}

return 0;

}

static int

faulthandler_enable(void)

{

if (fatal_error.enabled) {

return 0;

}

fatal_error.enabled = 1;

#ifdef FAULTHANDLER_USE_ALT_STACK

if (faulthandler_allocate_stack() < 0) {

return -1;

}

// gh-137185: Initialize C stack trace dumping outside of the signal

// handler. Specifically, we call backtrace() to ensure that libgcc is

// dynamically loaded outside of the signal handler.

_Py_InitDumpStack();

for (size_t i=0; i < faulthandler_nsignals; i++) {

fault_handler_t *handler;

int err;

handler = &faulthandler_handlers[i];

assert(!handler->enabled);

#ifdef HAVE_SIGACTION

struct sigaction action;

action.sa_handler = faulthandler_fatal_error;

sigemptyset(&action.sa_mask);

/* Do not prevent the signal from being received from within

action.sa_flags = SA_NODEFER;

#ifdef FAULTHANDLER_USE_ALT_STACK

assert(stack.ss_sp != NULL);

/* Call the signal handler on an alternate signal stack

action.sa_flags |= SA_ONSTACK;

err = sigaction(handler->signum, &action, &handler->previous);

handler->previous = signal(handler->signum,

faulthandler_fatal_error);

err = (handler->previous == SIG_ERR);

if (err) {

PyErr_SetFromErrno(PyExc_RuntimeError);

return -1;

}

handler->enabled = 1;

}

#ifdef MS_WINDOWS_DESKTOP

assert(fatal_error.exc_handler == NULL);

fatal_error.exc_handler = AddVectoredExceptionHandler(1, faulthandler_exc_handler);

return 0;

}

static PyObject *

faulthandler_py_enable_impl(PyObject *module, PyObject *file,

int all_threads, int c_stack,

Py_ssize_t max_threads)

{

int fd;

PyThreadState *tstate;

fd = faulthandler_get_fileno(&file);

if (fd < 0)

return NULL;

tstate = get_thread_state();

if (tstate == NULL) {

Py_XDECREF(file);

return NULL;

}

Py_XSETREF(fatal_error.file, file);

fatal_error.fd = fd;

fatal_error.all_threads = all_threads;

fatal_error.interp = PyThreadState_GetInterpreter(tstate);

fatal_error.c_stack = c_stack;

fatal_error.max_threads = max_threads;

if (faulthandler_enable() < 0) {

return NULL;

}

Py_RETURN_NONE;

}

static void

faulthandler_disable(void)

{

if (fatal_error.enabled) {

fatal_error.enabled = 0;

for (size_t i=0; i < faulthandler_nsignals; i++) {

fault_handler_t *handler;

handler = &faulthandler_handlers[i];

faulthandler_disable_fatal_handler(handler);

}

}

#ifdef MS_WINDOWS_DESKTOP

if (fatal_error.exc_handler != NULL) {

RemoveVectoredExceptionHandler(fatal_error.exc_handler);

fatal_error.exc_handler = NULL;

}

Py_CLEAR(fatal_error.file);

}

static PyObject *

faulthandler_disable_py_impl(PyObject *module)

{

if (!fatal_error.enabled) {

Py_RETURN_FALSE;

}

faulthandler_disable();

Py_RETURN_TRUE;

}

static int

faulthandler_is_enabled_impl(PyObject *module)

{

return fatal_error.enabled;

}

static void

faulthandler_thread(void *unused)

{

PyLockStatus st;

const char* errmsg;

int ok;

#if defined(HAVE_PTHREAD_SIGMASK) && !defined(HAVE_BROKEN_PTHREAD_SIGMASK)

sigset_t set;

/* we don't want to receive any signal */

sigfillset(&set);

pthread_sigmask(SIG_SETMASK, &set, NULL);

do {

st = PyThread_acquire_lock_timed(thread.cancel_event,

thread.timeout_us, 0);

if (st == PY_LOCK_ACQUIRED) {

PyThread_release_lock(thread.cancel_event);

break;

}

/* Timeout => dump traceback */

assert(st == PY_LOCK_FAILURE);

(void)_Py_write_noraise(thread.fd, thread.header, thread.header_len);

errmsg = PyUnstable_DumpTracebackThreads(thread.fd, thread.interp, NULL,

thread.max_threads);

ok = (errmsg == NULL);

if (thread.exit)

_exit(1);

} while (ok && thread.repeat);

/* The only way out */

PyThread_release_lock(thread.running);

}

static void

cancel_dump_traceback_later(void)

{

/* If not scheduled, nothing to cancel */

if (!thread.cancel_event) {

return;

}

/* Notify cancellation */

PyThread_release_lock(thread.cancel_event);

/* Wait for thread to join */

PyThread_acquire_lock(thread.running, 1);

PyThread_release_lock(thread.running);

/* The main thread should always hold the cancel_event lock */

PyThread_acquire_lock(thread.cancel_event, 1);

Py_CLEAR(thread.file);

if (thread.header) {

PyMem_Free(thread.header);

thread.header = NULL;

}

}

#define SEC_TO_US (1000 * 1000)

static char*

format_timeout(PyTime_t us)

{

unsigned long sec, min, hour;

char buffer[100];

/* the downcast is safe: the caller check that 0 < us <= LONG_MAX */

sec = (unsigned long)(us / SEC_TO_US);

us %= SEC_TO_US;

min = sec / 60;

sec %= 60;

hour = min / 60;

min %= 60;

if (us != 0) {

PyOS_snprintf(buffer, sizeof(buffer),

"Timeout (%lu:%02lu:%02lu.%06u)!\n",

hour, min, sec, (unsigned int)us);

}

else {

PyOS_snprintf(buffer, sizeof(buffer),

"Timeout (%lu:%02lu:%02lu)!\n",

hour, min, sec);

}

return _PyMem_Strdup(buffer);

}

static PyObject *

faulthandler_dump_traceback_later_impl(PyObject *module,

PyObject *timeout_obj, int repeat,

PyObject *file, int exit,

Py_ssize_t max_threads)

{

PyTime_t timeout, timeout_us;

int fd;

PyThreadState *tstate;

char *header;

size_t header_len;

if (_PyTime_FromSecondsObject(&timeout, timeout_obj,

_PyTime_ROUND_TIMEOUT) < 0) {

return NULL;

}

timeout_us = _PyTime_AsMicroseconds(timeout, _PyTime_ROUND_TIMEOUT);

if (timeout_us <= 0) {

PyErr_SetString(PyExc_ValueError, "timeout must be greater than 0");

return NULL;

}

/* Limit to LONG_MAX seconds for format_timeout() */

if (timeout_us > PY_TIMEOUT_MAX || timeout_us / SEC_TO_US > LONG_MAX) {

PyErr_SetString(PyExc_OverflowError,

"timeout value is too large");

return NULL;

}

tstate = get_thread_state();

if (tstate == NULL) {

return NULL;

}

fd = faulthandler_get_fileno(&file);

if (fd < 0) {

return NULL;

}

if (!thread.running) {

thread.running = PyThread_allocate_lock();

if (!thread.running) {

Py_XDECREF(file);

return PyErr_NoMemory();

}

}

if (!thread.cancel_event) {

thread.cancel_event = PyThread_allocate_lock();

if (!thread.cancel_event || !thread.running) {

Py_XDECREF(file);

return PyErr_NoMemory();

}

/* cancel_event starts to be acquired: it's only released to cancel

PyThread_acquire_lock(thread.cancel_event, 1);

}

/* format the timeout */

header = format_timeout(timeout_us);

if (header == NULL) {

Py_XDECREF(file);

return PyErr_NoMemory();

}

header_len = strlen(header);

/* Cancel previous thread, if running */

cancel_dump_traceback_later();

Py_XSETREF(thread.file, file);

thread.fd = fd;

/* the downcast is safe: we check that 0 < timeout_us < PY_TIMEOUT_MAX */

thread.timeout_us = (PY_TIMEOUT_T)timeout_us;

thread.repeat = repeat;

thread.interp = PyThreadState_GetInterpreter(tstate);

thread.exit = exit;

thread.header = header;

thread.header_len = header_len;

thread.max_threads = max_threads;

/* Arm these locks to serve as events when released */

PyThread_acquire_lock(thread.running, 1);

if (PyThread_start_new_thread(faulthandler_thread, NULL) == PYTHREAD_INVALID_THREAD_ID) {

PyThread_release_lock(thread.running);

Py_CLEAR(thread.file);

PyMem_Free(header);

thread.header = NULL;

PyErr_SetString(PyExc_RuntimeError,

"unable to start watchdog thread");

return NULL;

}

Py_RETURN_NONE;

}

static PyObject *

faulthandler_cancel_dump_traceback_later_py_impl(PyObject *module)

{

cancel_dump_traceback_later();

Py_RETURN_NONE;

}

#ifdef FAULTHANDLER_USER

static int

faulthandler_register(int signum, int chain, _Py_sighandler_t *previous_p)

{

#ifdef HAVE_SIGACTION

struct sigaction action;

action.sa_handler = faulthandler_user;

sigemptyset(&action.sa_mask);

/* if the signal is received while the kernel is executing a system

action.sa_flags = SA_RESTART;

if (chain) {

/* do not prevent the signal from being received from within its

action.sa_flags = SA_NODEFER;

}

#ifdef FAULTHANDLER_USE_ALT_STACK

assert(stack.ss_sp != NULL);

/* Call the signal handler on an alternate signal stack

action.sa_flags |= SA_ONSTACK;

return sigaction(signum, &action, previous_p);

_Py_sighandler_t previous;

previous = signal(signum, faulthandler_user);

if (previous_p != NULL) {

*previous_p = previous;

}

return (previous == SIG_ERR);

}

static void

faulthandler_user(int signum)

{

user_signal_t *user;

int save_errno = errno;

user = &user_signals[signum];

if (!user->enabled)

return;

faulthandler_dump_traceback(user->fd, user->all_threads, user->interp,

user->max_threads);

#ifdef HAVE_SIGACTION

if (user->chain) {

(void)sigaction(signum, &user->previous, NULL);

errno = save_errno;

/* call the previous signal handler */

raise(signum);

save_errno = errno;

(void)faulthandler_register(signum, user->chain, NULL);

errno = save_errno;

}

if (user->chain && user->previous != NULL) {

errno = save_errno;

/* call the previous signal handler */

user->previous(signum);

}

}

static int

check_signum(int signum)

{

for (size_t i=0; i < faulthandler_nsignals; i++) {

if (faulthandler_handlers[i].signum == signum) {

PyErr_Format(PyExc_RuntimeError,

"signal %i cannot be registered, "

"use enable() instead",

signum);

return 0;

}

}

if (signum < 1 || Py_NSIG <= signum) {

PyErr_SetString(PyExc_ValueError, "signal number out of range");