Merge branch 'stacktrace_on_crash' into hotfix_udp_crash

libretroshare/src/util/stacktrace.h

@@ -1,9 +1,7 @@
 /*******************************************************************************
- * libretroshare/src/util: smallobject.h                                       *
+ * libretroshare                                                               *
  *                                                                             *
- * libretroshare: retroshare core library                                      *
+ * Copyright (C) 2016-2018 Gioacchino Mazzurco <gio@eigenlab.org>              *
- *                                                                             *
- * Copyright (C) 2016 Gioacchino Mazzurco <gio@eigenlab.org>                   *
  * 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 <https://www.gnu.org/licenses/>.       *
  *                                                                             *
  *******************************************************************************/
-#ifndef _STACKTRACE_H_
+#pragma once
-#define _STACKTRACE_H_
 
 #include <stdio.h>
+#include <csignal>
 
 #if defined(__linux__) && defined(__GLIBC__)
 
@@ -31,13 +29,28 @@
 #include <execinfo.h>
 #include <cxxabi.h>
 
-/** 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:
+		/* find parentheses and +address offset surrounding the mangled
-		// ./module(function+0x15c) [0x8048a6d]
+		 * 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);
+	}
+};
+

retroshare-gui/src/main.cpp

@@ -19,6 +19,10 @@
  *  Boston, MA  02110-1301, USA.
  ****************************************************************/
 
+#include "util/stacktrace.h"
+
+CrashStackTrace gCrashStackTrace;
+
 #include <QObject>
 #include <QMessageBox>
 #include <QSplashScreen>

retroshare-service/src/retroshare-service.cc

@@ -16,6 +16,10 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "util/stacktrace.h"
+
+CrashStackTrace gCrashStackTrace;
+
 #include <QCoreApplication>
 #include <csignal>
 #include <QObject>