#include "Python.h"

#include "pycore_initconfig.h" // _PyStatus_ERR

#include "pycore_pyerrors.h" // _Py_DumpExtensionModules

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

#include "pycore_signal.h" // Py_NSIG

#include "pycore_sysmodule.h" // _PySys_GetAttr()

#include "pycore_traceback.h" // _Py_DumpTracebackThreads

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

#define STACK_OVERFLOW_MAX_SIZE (100 * 1024 * 1024)

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

#if defined(__has_feature) // Clang

# if __has_feature(undefined_behavior_sanitizer)

# define _Py_NO_SANITIZE_UNDEFINED __attribute__((no_sanitize("undefined")))

#if defined(__GNUC__) \

&& ((__GNUC__ >= 5) || (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9))

# define _Py_NO_SANITIZE_UNDEFINED __attribute__((no_sanitize_undefined))

#ifndef _Py_NO_SANITIZE_UNDEFINED

# define _Py_NO_SANITIZE_UNDEFINED

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;

long fd_long;

int fd;

PyObject *file = *file_ptr;

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

PyThreadState *tstate = _PyThreadState_GET();

file = _PySys_GetAttr(tstate, &_Py_ID(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 descriptor");

return -1;

}

*file_ptr = NULL;

return fd;

}

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

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;

}

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)

{

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

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

"|Op: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;

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 {

char unknown_signum[23] = {0,};

snprintf(unknown_signum, 23, "%d", signum);

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

PUTS(fd, unknown_signum);

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

}

faulthandler_dump_traceback(fd, fatal_error.all_threads,

fatal_error.interp);

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

DWORD flags = exc_info->ExceptionRecord->ExceptionFlags;

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

fatal_error.interp);

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

}

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

assert(fatal_error.exc_handler == NULL);

fatal_error.exc_handler = 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,

"|Op: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 = PyThreadState_GetInterpreter(tstate);

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

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

{

if (!fatal_error.enabled) {

Py_RETURN_FALSE;

}

faulthandler_disable();

Py_RETURN_TRUE;

}

static PyObject*

faulthandler_is_enabled(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return PyBool_FromLong(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, (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)

{

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

PyObject *args, PyObject *kwargs)

{

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

PyObject *timeout_obj;

_PyTime_t timeout, 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,

"O|iOi:dump_traceback_later", kwlist,

&timeout_obj, &repeat, &file, &exit))

return NULL;

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

return PyErr_NoMemory();

}

}

if (!thread.cancel_event) {

thread.cancel_event = PyThread_allocate_lock();

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

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

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;

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

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

PyObject *Py_UNUSED(ignored))

{

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

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

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|Opp: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_Calloc(Py_NSIG, sizeof(user_signal_t));

if (user_signals == NULL)

return PyErr_NoMemory();

}

user = &user_signals[signum];

if (!user->enabled) {

#ifdef FAULTHANDLER_USE_ALT_STACK

if (faulthandler_allocate_stack() < 0) {

return NULL;

}

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 = PyThreadState_GetInterpreter(tstate);

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_DESKTOP

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* _Py_NO_SANITIZE_UNDEFINED

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