#include "Python.h"

#include "pythread.h"

#include <signal.h>

#include <object.h>

#include <frameobject.h>

#include <signal.h>

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

# include <pthread.h>

#ifdef MS_WINDOWS

# include <windows.h>

#ifdef HAVE_SYS_RESOURCE_H

# include <sys/resource.h>

#define STACK_OVERFLOW_MAX_SIZE (100*1024*1024)

#ifdef WITH_THREAD

# define FAULTHANDLER_LATER

#ifndef MS_WINDOWS

/* register() is useless on Windows, because only SIGSEGV, SIGABRT and

# define FAULTHANDLER_USER

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

_Py_IDENTIFIER(enable);

_Py_IDENTIFIER(fileno);

_Py_IDENTIFIER(flush);

_Py_IDENTIFIER(stderr);

#ifdef HAVE_SIGACTION

typedef struct sigaction _Py_sighandler_t;

typedef PyOS_sighandler_t _Py_sighandler_t;

typedef struct {

int signum;

int enabled;

const char* name;

_Py_sighandler_t previous;

int all_threads;

} fault_handler_t;

static struct {

int enabled;

PyObject *file;

int fd;

int all_threads;

PyInterpreterState *interp;

} fatal_error = {0, NULL, -1, 0};

#ifdef FAULTHANDLER_LATER

static struct {

PyObject *file;

int fd;

PY_TIMEOUT_T timeout_us; /* timeout in microseconds */

int repeat;

PyInterpreterState *interp;

int exit;

char *header;

size_t header_len;

/* The main thread always holds this lock. It is only released when

PyThread_type_lock cancel_event;

/* released by child thread when joined */

PyThread_type_lock running;

} thread;

#ifdef FAULTHANDLER_USER

typedef struct {

int enabled;

PyObject *file;

int fd;

int all_threads;

int chain;

_Py_sighandler_t previous;

PyInterpreterState *interp;

} user_signal_t;

static user_signal_t *user_signals;

#ifndef NSIG

# if defined(_NSIG)

# define NSIG _NSIG /* For BSD/SysV */

# elif defined(_SIGMAX)

# define NSIG (_SIGMAX + 1) /* For QNX */

# elif defined(SIGMAX)

# define NSIG (SIGMAX + 1) /* For djgpp */

# define NSIG 64 /* Use a reasonable default value */

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 HAVE_SIGALTSTACK

static stack_t stack;

static int

faulthandler_get_fileno(PyObject **file_ptr)

{

PyObject *result;

long fd_long;

int fd;

PyObject *file = *file_ptr;

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

file = _PySys_GetObjectId(&PyId_stderr);

if (file == NULL) {

PyErr_SetString(PyExc_RuntimeError, "unable to get sys.stderr");

return -1;

}

if (file == Py_None) {

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

return -1;

}

}

else if (PyLong_Check(file)) {

fd = _PyLong_AsInt(file);

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

return -1;

if (fd < 0) {

PyErr_SetString(PyExc_ValueError,

"file is not a valid file descripter");

return -1;

}

*file_ptr = NULL;

return fd;

}

result = _PyObject_CallMethodId(file, &PyId_fileno, NULL);

if (result == NULL)

return -1;

fd = -1;

if (PyLong_Check(result)) {

fd_long = PyLong_AsLong(result);

if (0 <= fd_long && fd_long < INT_MAX)

fd = (int)fd_long;

}

Py_DECREF(result);

if (fd == -1) {

PyErr_SetString(PyExc_RuntimeError,

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

return -1;

}

result = _PyObject_CallMethodId(file, &PyId_flush, NULL);

if (result != NULL)

Py_DECREF(result);

else {

/* ignore flush() error */

PyErr_Clear();

}

*file_ptr = file;

return fd;

}

static PyThreadState*

get_thread_state(void)

{

PyThreadState *tstate = _PyThreadState_UncheckedGet();

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)

{

static volatile int reentrant = 0;

PyThreadState *tstate;

if (reentrant)

return;

reentrant = 1;

#ifdef WITH_THREAD

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

tstate = PyGILState_GetThisThreadState();

tstate = _PyThreadState_UncheckedGet();

if (all_threads) {

(void)_Py_DumpTracebackThreads(fd, NULL, tstate);

}

else {

if (tstate != NULL)

_Py_DumpTraceback(fd, tstate);

}

reentrant = 0;

}

static PyObject*

faulthandler_dump_traceback_py(PyObject *self,

PyObject *args, PyObject *kwargs)

{

static char *kwlist[] = {"file", "all_threads", NULL};

PyObject *file = NULL;

int all_threads = 1;

PyThreadState *tstate;

const char *errmsg;

int fd;

if (!PyArg_ParseTupleAndKeywords(args, kwargs,

"|Oi:dump_traceback", kwlist,

&file, &all_threads))

return NULL;

fd = faulthandler_get_fileno(&file);

if (fd < 0)

return NULL;

tstate = get_thread_state();

if (tstate == NULL)

return NULL;

if (all_threads) {

errmsg = _Py_DumpTracebackThreads(fd, NULL, tstate);

if (errmsg != NULL) {

PyErr_SetString(PyExc_RuntimeError, errmsg);

return NULL;

}

}

else {

_Py_DumpTraceback(fd, tstate);

}

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 void

faulthandler_fatal_error(int signum)

{

const int fd = fatal_error.fd;

size_t i;

fault_handler_t *handler = NULL;

int save_errno = errno;

if (!fatal_error.enabled)

return;

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

handler = &faulthandler_handlers[i];

if (handler->signum == signum)

break;

}

if (handler == NULL) {

/* faulthandler_nsignals == 0 (unlikely) */

return;

}

/* restore the previous handler */

faulthandler_disable_fatal_handler(handler);

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

PUTS(fd, handler->name);

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

faulthandler_dump_traceback(fd, fatal_error.all_threads,

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 LONG WINAPI

faulthandler_exc_handler(struct _EXCEPTION_POINTERS *exc_info)

{

const int fd = fatal_error.fd;

DWORD code = exc_info->ExceptionRecord->ExceptionCode;

DWORD flags = exc_info->ExceptionRecord->ExceptionFlags;

/* only log fatal exceptions */

if (flags & EXCEPTION_NONCONTINUABLE) {

/* 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 ");

_Py_DumpDecimal(fd, code);

}

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

if (code == EXCEPTION_ACCESS_VIOLATION) {

/* disable signal handler for SIGSEGV */

size_t i;

for (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, fatal_error.all_threads,

fatal_error.interp);

/* call the next exception handler */

return EXCEPTION_CONTINUE_SEARCH;

}

static int

faulthandler_enable(void)

{

size_t i;

if (fatal_error.enabled) {

return 0;

}

fatal_error.enabled = 1;

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

fault_handler_t *handler;

#ifdef HAVE_SIGACTION

struct sigaction action;

int err;

handler = &faulthandler_handlers[i];

assert(!handler->enabled);

#ifdef HAVE_SIGACTION

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 HAVE_SIGALTSTACK

if (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

AddVectoredExceptionHandler(1, faulthandler_exc_handler);

return 0;

}

static PyObject*

faulthandler_py_enable(PyObject *self, PyObject *args, PyObject *kwargs)

{

static char *kwlist[] = {"file", "all_threads", NULL};

PyObject *file = NULL;

int all_threads = 1;

int fd;

PyThreadState *tstate;

if (!PyArg_ParseTupleAndKeywords(args, kwargs,

"|Oi:enable", kwlist, &file, &all_threads))

return NULL;

fd = faulthandler_get_fileno(&file);

if (fd < 0)

return NULL;

tstate = get_thread_state();

if (tstate == NULL)

return NULL;

Py_XINCREF(file);

Py_XSETREF(fatal_error.file, file);

fatal_error.fd = fd;

fatal_error.all_threads = all_threads;

fatal_error.interp = tstate->interp;

if (faulthandler_enable() < 0) {

return NULL;

}

Py_RETURN_NONE;

}

static void

faulthandler_disable(void)

{

unsigned int i;

fault_handler_t *handler;

if (fatal_error.enabled) {

fatal_error.enabled = 0;

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

handler = &faulthandler_handlers[i];

faulthandler_disable_fatal_handler(handler);

}

}

Py_CLEAR(fatal_error.file);

}

static PyObject*

faulthandler_disable_py(PyObject *self)

{

if (!fatal_error.enabled) {

Py_RETURN_FALSE;

}

faulthandler_disable();

Py_RETURN_TRUE;

}

static PyObject*

faulthandler_is_enabled(PyObject *self)

{

return PyBool_FromLong(fatal_error.enabled);

}

#ifdef FAULTHANDLER_LATER

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);

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

errmsg = _Py_DumpTracebackThreads(thread.fd, thread.interp, NULL);

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)

{

/* 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;

}

}

static char*

format_timeout(double timeout)

{

unsigned long us, sec, min, hour;

double intpart, fracpart;

char buffer[100];

fracpart = modf(timeout, &intpart);

sec = (unsigned long)intpart;

us = (unsigned long)(fracpart * 1e6);

min = sec / 60;

sec %= 60;

hour = min / 60;

min %= 60;

if (us != 0)

PyOS_snprintf(buffer, sizeof(buffer),

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

hour, min, sec, 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(PyObject *self,

PyObject *args, PyObject *kwargs)

{

static char *kwlist[] = {"timeout", "repeat", "file", "exit", NULL};

double timeout;

PY_TIMEOUT_T timeout_us;

int repeat = 0;

PyObject *file = NULL;

int fd;

int exit = 0;

PyThreadState *tstate;

char *header;

size_t header_len;

if (!PyArg_ParseTupleAndKeywords(args, kwargs,

"d|iOi:dump_traceback_later", kwlist,

&timeout, &repeat, &file, &exit))

return NULL;

if ((timeout * 1e6) >= (double) PY_TIMEOUT_MAX) {

PyErr_SetString(PyExc_OverflowError, "timeout value is too large");

return NULL;

}

timeout_us = (PY_TIMEOUT_T)(timeout * 1e6);

if (timeout_us <= 0) {

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

return NULL;

}

tstate = get_thread_state();

if (tstate == NULL)

return NULL;

fd = faulthandler_get_fileno(&file);

if (fd < 0)

return NULL;

/* format the timeout */

header = format_timeout(timeout);

if (header == NULL)

return PyErr_NoMemory();

header_len = strlen(header);

/* Cancel previous thread, if running */

cancel_dump_traceback_later();

Py_XINCREF(file);

Py_XSETREF(thread.file, file);

thread.fd = fd;

thread.timeout_us = timeout_us;

thread.repeat = repeat;

thread.interp = tstate->interp;

thread.exit = exit;

thread.header = header;

thread.header_len = header_len;

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

PyThread_acquire_lock(thread.running, 1);

if (PyThread_start_new_thread(faulthandler_thread, NULL) == -1) {

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(PyObject *self)

{

cancel_dump_traceback_later();

Py_RETURN_NONE;

}

#endif /* FAULTHANDLER_LATER */

#ifdef FAULTHANDLER_USER

static int

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

{

#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 HAVE_SIGALTSTACK

if (stack.ss_sp != NULL) {

/* Call the signal handler on an alternate signal stack

action.sa_flags |= SA_ONSTACK;

}

return sigaction(signum, &action, p_previous);

_Py_sighandler_t previous;

previous = signal(signum, faulthandler_user);

if (p_previous != NULL)

*p_previous = 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);

#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) {

errno = save_errno;

/* call the previous signal handler */

user->previous(signum);

}

}

static int

check_signum(int signum)

{

unsigned int i;

for (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 || NSIG <= signum) {

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

return 0;

}

return 1;

}

static PyObject*

faulthandler_register_py(PyObject *self,

PyObject *args, PyObject *kwargs)

{

static char *kwlist[] = {"signum", "file", "all_threads", "chain", NULL};

int signum;

PyObject *file = NULL;

int all_threads = 1;

int chain = 0;

int fd;

user_signal_t *user;

_Py_sighandler_t previous;

PyThreadState *tstate;

int err;

if (!PyArg_ParseTupleAndKeywords(args, kwargs,

"i|Oii:register", kwlist,

&signum, &file, &all_threads, &chain))

return NULL;

if (!check_signum(signum))

return NULL;

tstate = get_thread_state();

if (tstate == NULL)

return NULL;

fd = faulthandler_get_fileno(&file);

if (fd < 0)

return NULL;

if (user_signals == NULL) {

user_signals = PyMem_Malloc(NSIG * sizeof(user_signal_t));

if (user_signals == NULL)

return PyErr_NoMemory();

memset(user_signals, 0, NSIG * sizeof(user_signal_t));

}

user = &user_signals[signum];

if (!user->enabled) {

err = faulthandler_register(signum, chain, &previous);

if (err) {

PyErr_SetFromErrno(PyExc_OSError);

return NULL;

}

user->previous = previous;

}

Py_XINCREF(file);

Py_XSETREF(user->file, file);

user->fd = fd;

user->all_threads = all_threads;

user->chain = chain;

user->interp = tstate->interp;

user->enabled = 1;

Py_RETURN_NONE;

}

static int

faulthandler_unregister(user_signal_t *user, int signum)

{

if (!user->enabled)

return 0;

user->enabled = 0;

#ifdef HAVE_SIGACTION

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

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

Py_CLEAR(user->file);

user->fd = -1;

return 1;

}

static PyObject*

faulthandler_unregister_py(PyObject *self, PyObject *args)

{

int signum;

user_signal_t *user;

int change;

if (!PyArg_ParseTuple(args, "i:unregister", &signum))

return NULL;

if (!check_signum(signum))

return NULL;

if (user_signals == NULL)

Py_RETURN_FALSE;

user = &user_signals[signum];

change = faulthandler_unregister(user, signum);

return PyBool_FromLong(change);

}

#endif /* FAULTHANDLER_USER */

static void

faulthandler_suppress_crash_report(void)

{

#ifdef MS_WINDOWS

UINT mode;

/* Configure Windows to not display the Windows Error Reporting dialog */

mode = SetErrorMode(SEM_NOGPFAULTERRORBOX);

SetErrorMode(mode | SEM_NOGPFAULTERRORBOX);

#ifdef HAVE_SYS_RESOURCE_H

struct rlimit rl;

/* Disable creation of core dump */

if (getrlimit(RLIMIT_CORE, &rl) != 0) {

rl.rlim_cur = 0;

setrlimit(RLIMIT_CORE, &rl);

}

#ifdef _MSC_VER

/* Visual Studio: configure abort() to not display an error message nor

_set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);

}

static PyObject *

faulthandler_read_null(PyObject *self, PyObject *args)

{

volatile int *x;

volatile int y;

faulthandler_suppress_crash_report();

x = NULL;

y = *x;

return PyLong_FromLong(y);

}

static void

faulthandler_raise_sigsegv(void)

{

faulthandler_suppress_crash_report();

#if defined(MS_WINDOWS)

/* For SIGSEGV, faulthandler_fatal_error() restores the previous signal

while(1)

raise(SIGSEGV);

raise(SIGSEGV);

}

static PyObject *

faulthandler_sigsegv(PyObject *self, PyObject *args)

{

int release_gil = 0;

if (!PyArg_ParseTuple(args, "|i:_sigsegv", &release_gil))

return NULL;

if (release_gil) {

Py_BEGIN_ALLOW_THREADS

faulthandler_raise_sigsegv();

Py_END_ALLOW_THREADS

} else {

faulthandler_raise_sigsegv();

}

Py_RETURN_NONE;

}

#ifdef WITH_THREAD

static void

faulthandler_fatal_error_thread(void *plock)

{

#ifndef __clang__

PyThread_type_lock *lock = (PyThread_type_lock *)plock;

Py_FatalError("in new thread");

#ifndef __clang__

/* Issue #28152: Py_FatalError() is declared with

/* notify the caller that we are done */

PyThread_release_lock(lock);

}

static PyObject *

faulthandler_fatal_error_c_thread(PyObject *self, PyObject *args)

{