From c0ca1a5aad4fafd89bcaf48ae837575561f0447c Mon Sep 17 00:00:00 2001 From: Gioacchino Mazzurco Date: Mon, 5 Nov 2018 00:19:45 +0100 Subject: [PATCH] Print stack trace on crash --- libretroshare/src/util/stacktrace.h | 113 ++++++++++++++++--- retroshare-gui/src/main.cpp | 4 + retroshare-service/src/retroshare-service.cc | 4 + 3 files changed, 104 insertions(+), 17 deletions(-) diff --git a/libretroshare/src/util/stacktrace.h b/libretroshare/src/util/stacktrace.h index f7284e7f9..b7babbc40 100644 --- a/libretroshare/src/util/stacktrace.h +++ b/libretroshare/src/util/stacktrace.h @@ -1,9 +1,7 @@ /******************************************************************************* - * libretroshare/src/util: smallobject.h * + * libretroshare * * * - * libretroshare: retroshare core library * - * * - * Copyright (C) 2016 Gioacchino Mazzurco * + * Copyright (C) 2016-2018 Gioacchino Mazzurco * * Copyright (C) 2008 Timo Bingmann http://idlebox.net/ * * * * This program is free software: you can redistribute it and/or modify * @@ -20,10 +18,10 @@ * along with this program. If not, see . * * * *******************************************************************************/ -#ifndef _STACKTRACE_H_ -#define _STACKTRACE_H_ +#pragma once #include +#include #if defined(__linux__) && defined(__GLIBC__) @@ -31,13 +29,28 @@ #include #include -/** Print a demangled stack backtrace of the caller function to FILE* out. */ -static inline void print_stacktrace(FILE *out = stderr, unsigned int max_frames = 63) +/** + * @brief Print a backtrace to FILE* out. + * @param[in] demangle true to demangle C++ symbols requires malloc working, in + * some patological cases like a SIGSEGV received during a malloc this would + * cause deadlock so pass false if you may be in such situation (like in a + * SIGSEGV handler ) + * @param[in] out output file + * @param[in] maxFrames maximum number of stack frames you want to bu printed + */ +static inline void print_stacktrace( + bool demangle = true, FILE *out = stderr, unsigned int maxFrames = 63 ) { + if(!out) + { + fprintf(stderr, "print_stacktrace invalid output file!\n"); + return; + } + fprintf(out, "stack trace:\n"); // storage array for stack trace address data - void* addrlist[max_frames+1]; + void* addrlist[maxFrames+1]; // retrieve current stack addresses int addrlen = backtrace(addrlist, sizeof(addrlist) / sizeof(void*)); @@ -48,6 +61,19 @@ static inline void print_stacktrace(FILE *out = stderr, unsigned int max_frames return; } + if(!demangle) + { + int outFd = fileno(out); + if(outFd < 0) + { + fprintf(stderr, "print_stacktrace invalid output file descriptor!\n"); + return; + } + + backtrace_symbols_fd(addrlist, addrlen, outFd); + return; + } + // resolve addresses into strings containing "filename(function+address)", // this array must be free()-ed char** symbollist = backtrace_symbols(addrlist, addrlen); @@ -62,8 +88,8 @@ static inline void print_stacktrace(FILE *out = stderr, unsigned int max_frames { char *begin_name = 0, *begin_offset = 0, *end_offset = 0; - // find parentheses and +address offset surrounding the mangled name: - // ./module(function+0x15c) [0x8048a6d] + /* find parentheses and +address offset surrounding the mangled + * name: ./module(function+0x15c) [0x8048a6d] */ for (char *p = symbollist[i]; *p; ++p) { if (*p == '(') begin_name = p; @@ -75,7 +101,8 @@ static inline void print_stacktrace(FILE *out = stderr, unsigned int max_frames } } - if (begin_name && begin_offset && end_offset && begin_name < begin_offset) + if ( begin_name && begin_offset && end_offset + && begin_name < begin_offset ) { *begin_name++ = '\0'; *begin_offset++ = '\0'; @@ -86,17 +113,20 @@ static inline void print_stacktrace(FILE *out = stderr, unsigned int max_frames // __cxa_demangle(): int status; - char* ret = abi::__cxa_demangle(begin_name, funcname, &funcnamesize, &status); + char* ret = abi::__cxa_demangle( + begin_name, funcname, &funcnamesize, &status ); if (status == 0) { funcname = ret; // use possibly realloc()-ed string - fprintf(out, " %s : %s+%s\n", symbollist[i], funcname, begin_offset); + fprintf( out, " %s : %s+%s\n", + symbollist[i], funcname, begin_offset ); } else { // demangling failed. Output function name as a C function with // no arguments. - fprintf(out, " %s : %s()+%s\n", symbollist[i], begin_name, begin_offset); + fprintf( out, " %s : %s()+%s\n", + symbollist[i], begin_name, begin_offset ); } } else @@ -111,12 +141,61 @@ static inline void print_stacktrace(FILE *out = stderr, unsigned int max_frames } #else // defined(__linux__) && defined(__GLIBC__) -static inline void print_stacktrace(FILE *out = stderr, unsigned int max_frames = 63) +static inline void print_stacktrace( + bool demangle = true, FILE *out = stderr, unsigned int max_frames = 63 ) { + (void) demangle; (void) max_frames; fprintf(out, "TODO: 2016/01/01 print_stacktrace not implemented yet for WINDOWS_SYS and ANDROID\n"); } #endif // defined(__linux__) && defined(__GLIBC__) -#endif // _STACKTRACE_H_ +/** + * @brief CrashStackTrace catch crash signals and print stack trace + * Inspired too https://oroboro.com/stack-trace-on-crash/ + */ +struct CrashStackTrace +{ + CrashStackTrace() + { + signal(SIGABRT, &CrashStackTrace::abortHandler); + signal(SIGSEGV, &CrashStackTrace::abortHandler); + signal(SIGILL, &CrashStackTrace::abortHandler); + signal(SIGFPE, &CrashStackTrace::abortHandler); +#ifdef SIGBUS + signal(SIGBUS, &CrashStackTrace::abortHandler); +#endif + } + + static void abortHandler(int signum) + { + // associate each signal with a signal name string. + const char* name = nullptr; + switch(signum) + { + case SIGABRT: name = "SIGABRT"; break; + case SIGSEGV: name = "SIGSEGV"; break; + case SIGILL: name = "SIGILL"; break; + case SIGFPE: name = "SIGFPE"; break; +#ifdef SIGBUS + case SIGBUS: name = "SIGBUS"; break; +#endif + } + + /** Notify the user which signal was caught. We use printf, because this + * is the most basic output function. Once you get a crash, it is + * possible that more complex output systems like streams and the like + * may be corrupted. So we make the most basic call possible to the + * lowest level, most standard print function. */ + if(name) + fprintf(stderr, "Caught signal %d (%s)\n", signum, name); + else + fprintf(stderr, "Caught signal %d\n", signum); + + print_stacktrace(false); + + exit(-signum); + } +}; + diff --git a/retroshare-gui/src/main.cpp b/retroshare-gui/src/main.cpp index ae0019e80..acb8d390d 100644 --- a/retroshare-gui/src/main.cpp +++ b/retroshare-gui/src/main.cpp @@ -19,6 +19,10 @@ * Boston, MA 02110-1301, USA. ****************************************************************/ +#include "util/stacktrace.h" + +CrashStackTrace gCrashStackTrace; + #include #include #include diff --git a/retroshare-service/src/retroshare-service.cc b/retroshare-service/src/retroshare-service.cc index 9b7bc7d65..bcacb5880 100644 --- a/retroshare-service/src/retroshare-service.cc +++ b/retroshare-service/src/retroshare-service.cc @@ -16,6 +16,10 @@ * along with this program. If not, see . */ +#include "util/stacktrace.h" + +CrashStackTrace gCrashStackTrace; + #include #include #include