tor/src/lib/err/backtrace.h

/* Copyright (c) 2013-2018, The Tor Project, Inc. */
/* See LICENSE for licensing information */

#ifndef TOR_BACKTRACE_H
#define TOR_BACKTRACE_H

#include "orconfig.h"
#include "lib/cc/compat_compiler.h"

typedef void (*tor_log_fn)(int, unsigned, const char *fmt, ...)
  CHECK_PRINTF(3,4);

void log_backtrace_impl(int severity, int domain, const char *msg,
                        tor_log_fn logger);
int configure_backtrace_handler(const char *tor_version);
void clean_up_backtrace_handler(void);
void dump_stack_symbols_to_error_fds(void);

#define log_backtrace(sev, dom, msg) \
  log_backtrace_impl((sev), (dom), (msg), tor_log)

#ifdef EXPOSE_CLEAN_BACKTRACE
#if defined(HAVE_EXECINFO_H) && defined(HAVE_BACKTRACE) && \
  defined(HAVE_BACKTRACE_SYMBOLS_FD) && defined(HAVE_SIGACTION)
void clean_backtrace(void **stack, size_t depth, const ucontext_t *ctx);
#endif
#endif /* defined(EXPOSE_CLEAN_BACKTRACE) */

#endif /* !defined(TOR_BACKTRACE_H) */
Update copyrights to 2018. 2018-06-20 08:13:28 -04:00			`/* Copyright (c) 2013-2018, The Tor Project, Inc. */`
Basic backtrace ability On platforms with the backtrace/backtrace_symbols_fd interface, Tor can now dump stack traces on assertion failure. By default, I log them to DataDir/stack_dump and to stderr. 2013-07-19 14:09:58 -04:00			`/* See LICENSE for licensing information */`

			`#ifndef TOR_BACKTRACE_H`
			`#define TOR_BACKTRACE_H`

Log a backtrace when the sandbox finds a failure This involves some duplicate code between backtrace.c and sandbox.c, but I don't see a way around it: calling more functions would mean adding more steps to our call stack, and running clean_backtrace() against the wrong point on the stack. 2014-04-10 15:44:52 -04:00			`#include "orconfig.h"`
Rectify include paths (automated) 2018-06-21 12:20:52 -04:00			`#include "lib/cc/compat_compiler.h"`
Log a backtrace when the sandbox finds a failure This involves some duplicate code between backtrace.c and sandbox.c, but I don't see a way around it: calling more functions would mean adding more steps to our call stack, and running clean_backtrace() against the wrong point on the stack. 2014-04-10 15:44:52 -04:00
Remove log dependency from backtrace.[ch] 2018-06-20 13:51:49 -04:00			`typedef void (tor_log_fn)(int, unsigned, const char fmt, ...)`
			`CHECK_PRINTF(3,4);`

			`void log_backtrace_impl(int severity, int domain, const char *msg,`
			`tor_log_fn logger);`
Add a sighandler-safe logging mechanism We had accidentially grown two fake ones: one for backtrace.c, and one for sandbox.c. Let's do this properly instead. Now, when we configure logs, we keep track of fds that should get told about bad stuff happening from signal handlers. There's another entry point for these that avoids using non-signal-handler-safe functions. 2013-07-19 22:47:49 -04:00			`int configure_backtrace_handler(const char *tor_version);`
Basic backtrace ability On platforms with the backtrace/backtrace_symbols_fd interface, Tor can now dump stack traces on assertion failure. By default, I log them to DataDir/stack_dump and to stderr. 2013-07-19 14:09:58 -04:00			`void clean_up_backtrace_handler(void);`
Allow raw_assert() to dump stack traces. It doesn't do this as beautifully as tor_assert(), but it doesn't depend on any higher-level code. 2018-06-20 14:04:03 -04:00			`void dump_stack_symbols_to_error_fds(void);`
Basic backtrace ability On platforms with the backtrace/backtrace_symbols_fd interface, Tor can now dump stack traces on assertion failure. By default, I log them to DataDir/stack_dump and to stderr. 2013-07-19 14:09:58 -04:00
Remove log dependency from backtrace.[ch] 2018-06-20 13:51:49 -04:00			`#define log_backtrace(sev, dom, msg) \`
			`log_backtrace_impl((sev), (dom), (msg), tor_log)`

Log a backtrace when the sandbox finds a failure This involves some duplicate code between backtrace.c and sandbox.c, but I don't see a way around it: calling more functions would mean adding more steps to our call stack, and running clean_backtrace() against the wrong point on the stack. 2014-04-10 15:44:52 -04:00			`#ifdef EXPOSE_CLEAN_BACKTRACE`
Only expose clean_backtrace() if we'll implement it Fixes windows compilation; bug not in any released Tor. Bugfix on cc9e86db. 2014-04-16 22:00:13 -04:00			`#if defined(HAVE_EXECINFO_H) && defined(HAVE_BACKTRACE) && \`
			`defined(HAVE_BACKTRACE_SYMBOLS_FD) && defined(HAVE_SIGACTION)`
Fix backtrace compilation on FreeBSD On FreeBSD backtrace(3) uses size_t instead of int (as glibc does). This causes integer precision loss errors when we used int to store its results. The issue is fixed by using size_t to store the results of backtrace(3). The manual page of glibc does not mention that backtrace(3) returns negative values. Therefore, no unsigned integer wrapping occurs when its result is stored in an unsigned data type. 2015-12-15 16:30:04 +01:00			`void clean_backtrace(void *stack, size_t depth, const ucontext_t ctx);`
Log a backtrace when the sandbox finds a failure This involves some duplicate code between backtrace.c and sandbox.c, but I don't see a way around it: calling more functions would mean adding more steps to our call stack, and running clean_backtrace() against the wrong point on the stack. 2014-04-10 15:44:52 -04:00			`#endif`
Run our #else/#endif annotator on our source code. 2017-09-15 16:24:44 -04:00			`#endif /* defined(EXPOSE_CLEAN_BACKTRACE) */`
Log a backtrace when the sandbox finds a failure This involves some duplicate code between backtrace.c and sandbox.c, but I don't see a way around it: calling more functions would mean adding more steps to our call stack, and running clean_backtrace() against the wrong point on the stack. 2014-04-10 15:44:52 -04:00
Run our #else/#endif annotator on our source code. 2017-09-15 16:24:44 -04:00			`#endif /* !defined(TOR_BACKTRACE_H) */`