Dump the traceback
------------------
-.. function:: dump_traceback(file=sys.stderr, all_threads=False)
+.. function:: dump_traceback(file=sys.stderr, all_threads=True)
- Dump the traceback of the current thread, or of all threads if *all_threads*
- is ``True``, into *file*.
+ Dump the traceback of all threads, or of the current thread if *all_threads*
+ is ``False``, into *file*.
Fault handler state
-------------------
-.. function:: enable(file=sys.stderr, all_threads=False)
+.. function:: enable(file=sys.stderr, all_threads=True)
Enable the fault handler: install handlers for :const:`SIGSEGV`,
:const:`SIGFPE`, :const:`SIGABRT`, :const:`SIGBUS` and :const:`SIGILL`
- signals to dump the Python traceback. It dumps the traceback of the current
- thread, or all threads if *all_threads* is ``True``, into *file*.
+ signals to dump the Python traceback. It dumps the traceback of the all
+ threads, or of the current thread if *all_threads* is ``False``, into
+ *file*.
.. function:: disable()
Dump the traceback on a user signal
-----------------------------------
-.. function:: register(signum, file=sys.stderr, all_threads=False)
+.. function:: register(signum, file=sys.stderr, all_threads=True)
Register a user signal: install a handler for the *signum* signal to dump
- the traceback of the current thread, or of all threads if *all_threads* is
- ``True``, into *file*.
+ the traceback of all threads, or of the current thread if *all_threads* is
+ ``False``, into *file*.
Not available on Windows.
>>> ctypes.string_at(0)
Fatal Python error: Segmentation fault
- Traceback (most recent call first):
+ Current thread 0x00007fb899f39700:
File "/home/python/cpython/Lib/ctypes/__init__.py", line 486 in string_at
File "<stdin>", line 1 in <module>
Segmentation fault
return output.splitlines(), exitcode
def check_fatal_error(self, code, line_number, name_regex,
- filename=None, all_threads=False, other_regex=None):
+ filename=None, all_threads=True, other_regex=None):
"""
Check that the fault handler for fatal errors is enabled and check the
traceback from the child process output.
'(?:Segmentation fault|Bus error)',
filename=filename)
- def test_enable_threads(self):
+ def test_enable_single_thread(self):
self.check_fatal_error("""
import faulthandler
-faulthandler.enable(all_threads=True)
+faulthandler.enable(all_threads=False)
faulthandler._read_null()
""".strip(),
3,
'(?:Segmentation fault|Bus error)',
- all_threads=True)
+ all_threads=False)
def test_disable(self):
code = """
def funcB():
if {has_filename}:
with open({filename}, "wb") as fp:
- faulthandler.dump_traceback(fp)
+ faulthandler.dump_traceback(fp, all_threads=False)
else:
- faulthandler.dump_traceback()
+ faulthandler.dump_traceback(all_threads=False)
def funcA():
funcB()
{
static char *kwlist[] = {"file", "all_threads", NULL};
PyObject *file = NULL;
- int all_threads = 0;
+ int all_threads = 1;
PyThreadState *tstate;
const char *errmsg;
int fd;
{
static char *kwlist[] = {"file", "all_threads", NULL};
PyObject *file = NULL;
- int all_threads = 0;
+ int all_threads = 1;
unsigned int i;
fault_handler_t *handler;
#ifdef HAVE_SIGACTION
static char *kwlist[] = {"signum", "file", "all_threads", NULL};
int signum;
PyObject *file = NULL;
- int all_threads = 0;
+ int all_threads = 1;
int fd;
user_signal_t *user;
_Py_sighandler_t previous;
static PyMethodDef module_methods[] = {
{"enable",
(PyCFunction)faulthandler_enable, METH_VARARGS|METH_KEYWORDS,
- PyDoc_STR("enable(file=sys.stderr, all_threads=False): "
+ PyDoc_STR("enable(file=sys.stderr, all_threads=True): "
"enable the fault handler")},
{"disable", (PyCFunction)faulthandler_disable_py, METH_NOARGS,
PyDoc_STR("disable(): disable the fault handler")},
PyDoc_STR("is_enabled()->bool: check if the handler is enabled")},
{"dump_traceback",
(PyCFunction)faulthandler_dump_traceback_py, METH_VARARGS|METH_KEYWORDS,
- PyDoc_STR("dump_traceback(file=sys.stderr, all_threads=False): "
+ PyDoc_STR("dump_traceback(file=sys.stderr, all_threads=True): "
"dump the traceback of the current thread, or of all threads "
"if all_threads is True, into file")},
#ifdef FAULTHANDLER_LATER
#ifdef FAULTHANDLER_USER
{"register",
(PyCFunction)faulthandler_register, METH_VARARGS|METH_KEYWORDS,
- PyDoc_STR("register(signum, file=sys.stderr, all_threads=False): "
+ PyDoc_STR("register(signum, file=sys.stderr, all_threads=True): "
"register an handler for the signal 'signum': dump the "
"traceback of the current thread, or of all threads if "
"all_threads is True, into file")},
if (tstate != NULL) {
fputc('\n', stderr);
fflush(stderr);
- _Py_DumpTraceback(fd, tstate);
+ _Py_DumpTracebackThreads(fd, tstate->interp, tstate);
}
_PyFaulthandler_Fini();
}