Merge pull request #536 from NotAdam/develop

dump stack trace when a server crashes

CMakeLists.txt

@@ -44,6 +44,7 @@ add_subdirectory( "deps/MySQL" )
 add_subdirectory( "deps/datReader" )
 add_subdirectory( "deps/mysqlConnector" )
 add_subdirectory( "deps/recastnavigation" )
+add_subdirectory( "deps/stackwalker" )
 
 ##############################
 #  Main Sapphire Components  #

deps/stackwalker/CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.0.2)
+project(Sapphire)
+
+if( WIN32 )
+
+  file( GLOB STACKWALKER_INCLUDE_FILES "${CMAKE_CURRENT_SOURCE_DIR}/*.h*" )
+  file( GLOB STACKWALKER_SOURCE_FILES "${CMAKE_CURRENT_SOURCE_DIR}/*.c*" )
+
+  add_library( stackwalker ${STACKWALKER_INCLUDE_FILES} ${STACKWALKER_SOURCE_FILES} )
+
+endif()

deps/stackwalker/StackWalker.h

@@ -0,0 +1,255 @@
+#ifndef __STACKWALKER_H__
+#define __STACKWALKER_H__
+
+#if defined(_MSC_VER)
+
+/**********************************************************************
+ *
+ * StackWalker.h
+ *
+ *
+ *
+ * LICENSE (http://www.opensource.org/licenses/bsd-license.php)
+ *
+ *   Copyright (c) 2005-2009, Jochen Kalmbach
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with or without modification,
+ *   are permitted provided that the following conditions are met:
+ *
+ *   Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ *   Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *   Neither the name of Jochen Kalmbach nor the names of its contributors may be
+ *   used to endorse or promote products derived from this software without
+ *   specific prior written permission.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ *   THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ *   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ *   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ *   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ *   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ *   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * **********************************************************************/
+// #pragma once is supported starting with _MSC_VER 1000,
+// so we need not to check the version (because we only support _MSC_VER >= 1100)!
+#pragma once
+
+#include <windows.h>
+
+#if _MSC_VER >= 1900
+#pragma warning(disable : 4091)
+#endif
+
+// special defines for VC5/6 (if no actual PSDK is installed):
+#if _MSC_VER < 1300
+typedef unsigned __int64 DWORD64, *PDWORD64;
+#if defined(_WIN64)
+typedef unsigned __int64 SIZE_T, *PSIZE_T;
+#else
+typedef unsigned long SIZE_T, *PSIZE_T;
+#endif
+#endif // _MSC_VER < 1300
+
+class StackWalkerInternal; // forward
+class StackWalker
+{
+public:
+  typedef enum StackWalkOptions
+  {
+    // No addition info will be retrieved
+    // (only the address is available)
+    RetrieveNone = 0,
+
+    // Try to get the symbol-name
+    RetrieveSymbol = 1,
+
+    // Try to get the line for this symbol
+    RetrieveLine = 2,
+
+    // Try to retrieve the module-infos
+    RetrieveModuleInfo = 4,
+
+    // Also retrieve the version for the DLL/EXE
+    RetrieveFileVersion = 8,
+
+    // Contains all the above
+    RetrieveVerbose = 0xF,
+
+    // Generate a "good" symbol-search-path
+    SymBuildPath = 0x10,
+
+    // Also use the public Microsoft-Symbol-Server
+    SymUseSymSrv = 0x20,
+
+    // Contains all the above "Sym"-options
+    SymAll = 0x30,
+
+    // Contains all options (default)
+    OptionsAll = 0x3F
+  } StackWalkOptions;
+
+  StackWalker(int    options = OptionsAll, // 'int' is by design, to combine the enum-flags
+              LPCSTR szSymPath = NULL,
+              DWORD  dwProcessId = GetCurrentProcessId(),
+              HANDLE hProcess = GetCurrentProcess());
+  StackWalker(DWORD dwProcessId, HANDLE hProcess);
+  virtual ~StackWalker();
+
+  typedef BOOL(__stdcall* PReadProcessMemoryRoutine)(
+      HANDLE  hProcess,
+      DWORD64 qwBaseAddress,
+      PVOID   lpBuffer,
+      DWORD   nSize,
+      LPDWORD lpNumberOfBytesRead,
+      LPVOID  pUserData // optional data, which was passed in "ShowCallstack"
+  );
+
+  BOOL LoadModules();
+
+  BOOL ShowCallstack(
+      HANDLE                    hThread = GetCurrentThread(),
+      const CONTEXT*            context = NULL,
+      PReadProcessMemoryRoutine readMemoryFunction = NULL,
+      LPVOID pUserData = NULL // optional to identify some data in the 'readMemoryFunction'-callback
+  );
+
+  BOOL ShowObject(LPVOID pObject);
+
+#if _MSC_VER >= 1300
+  // due to some reasons, the "STACKWALK_MAX_NAMELEN" must be declared as "public"
+  // in older compilers in order to use it... starting with VC7 we can declare it as "protected"
+protected:
+#endif
+  enum
+  {
+    STACKWALK_MAX_NAMELEN = 1024
+  }; // max name length for found symbols
+
+protected:
+  // Entry for each Callstack-Entry
+  typedef struct CallstackEntry
+  {
+    DWORD64 offset; // if 0, we have no valid entry
+    CHAR    name[STACKWALK_MAX_NAMELEN];
+    CHAR    undName[STACKWALK_MAX_NAMELEN];
+    CHAR    undFullName[STACKWALK_MAX_NAMELEN];
+    DWORD64 offsetFromSmybol;
+    DWORD   offsetFromLine;
+    DWORD   lineNumber;
+    CHAR    lineFileName[STACKWALK_MAX_NAMELEN];
+    DWORD   symType;
+    LPCSTR  symTypeString;
+    CHAR    moduleName[STACKWALK_MAX_NAMELEN];
+    DWORD64 baseOfImage;
+    CHAR    loadedImageName[STACKWALK_MAX_NAMELEN];
+  } CallstackEntry;
+
+  typedef enum CallstackEntryType
+  {
+    firstEntry,
+    nextEntry,
+    lastEntry
+  } CallstackEntryType;
+
+  virtual void OnSymInit(LPCSTR szSearchPath, DWORD symOptions, LPCSTR szUserName);
+  virtual void OnLoadModule(LPCSTR    img,
+                            LPCSTR    mod,
+                            DWORD64   baseAddr,
+                            DWORD     size,
+                            DWORD     result,
+                            LPCSTR    symType,
+                            LPCSTR    pdbName,
+                            ULONGLONG fileVersion);
+  virtual void OnCallstackEntry(CallstackEntryType eType, CallstackEntry& entry);
+  virtual void OnDbgHelpErr(LPCSTR szFuncName, DWORD gle, DWORD64 addr);
+  virtual void OnOutput(LPCSTR szText);
+
+  StackWalkerInternal* m_sw;
+  HANDLE               m_hProcess;
+  DWORD                m_dwProcessId;
+  BOOL                 m_modulesLoaded;
+  LPSTR                m_szSymPath;
+
+  int m_options;
+  int m_MaxRecursionCount;
+
+  static BOOL __stdcall myReadProcMem(HANDLE  hProcess,
+                                      DWORD64 qwBaseAddress,
+                                      PVOID   lpBuffer,
+                                      DWORD   nSize,
+                                      LPDWORD lpNumberOfBytesRead);
+
+  friend StackWalkerInternal;
+}; // class StackWalker
+
+// The "ugly" assembler-implementation is needed for systems before XP
+// If you have a new PSDK and you only compile for XP and later, then you can use
+// the "RtlCaptureContext"
+// Currently there is no define which determines the PSDK-Version...
+// So we just use the compiler-version (and assumes that the PSDK is
+// the one which was installed by the VS-IDE)
+
+// INFO: If you want, you can use the RtlCaptureContext if you only target XP and later...
+//       But I currently use it in x64/IA64 environments...
+//#if defined(_M_IX86) && (_WIN32_WINNT <= 0x0500) && (_MSC_VER < 1400)
+
+#if defined(_M_IX86)
+#ifdef CURRENT_THREAD_VIA_EXCEPTION
+// TODO: The following is not a "good" implementation,
+// because the callstack is only valid in the "__except" block...
+#define GET_CURRENT_CONTEXT_STACKWALKER_CODEPLEX(c, contextFlags)               \
+  do                                                                            \
+  {                                                                             \
+    memset(&c, 0, sizeof(CONTEXT));                                             \
+    EXCEPTION_POINTERS* pExp = NULL;                                            \
+    __try                                                                       \
+    {                                                                           \
+      throw 0;                                                                  \
+    }                                                                           \
+    __except (((pExp = GetExceptionInformation()) ? EXCEPTION_EXECUTE_HANDLER   \
+                                                  : EXCEPTION_EXECUTE_HANDLER)) \
+    {                                                                           \
+    }                                                                           \
+    if (pExp != NULL)                                                           \
+      memcpy(&c, pExp->ContextRecord, sizeof(CONTEXT));                         \
+    c.ContextFlags = contextFlags;                                              \
+  } while (0);
+#else
+// clang-format off
+// The following should be enough for walking the callstack...
+#define GET_CURRENT_CONTEXT_STACKWALKER_CODEPLEX(c, contextFlags) \
+  do                                                              \
+  {                                                               \
+    memset(&c, 0, sizeof(CONTEXT));                               \
+    c.ContextFlags = contextFlags;                                \
+    __asm    call x                                               \
+    __asm x: pop eax                                              \
+    __asm    mov c.Eip, eax                                       \
+    __asm    mov c.Ebp, ebp                                       \
+    __asm    mov c.Esp, esp                                       \
+  } while (0)
+// clang-format on
+#endif
+
+#else
+
+// The following is defined for x86 (XP and higher), x64 and IA64:
+#define GET_CURRENT_CONTEXT_STACKWALKER_CODEPLEX(c, contextFlags) \
+  do                                                              \
+  {                                                               \
+    memset(&c, 0, sizeof(CONTEXT));                               \
+    c.ContextFlags = contextFlags;                                \
+    RtlCaptureContext(&c);                                        \
+  } while (0);
+#endif
+
+#endif //defined(_MSC_VER)
+
+#endif // __STACKWALKER_H__

src/api/main.cpp

@@ -32,6 +32,10 @@
 #include "Forwards.h"
 #include "SapphireAPI.h"
 
+#include <Util/CrashHandler.h>
+
+Sapphire::Common::Util::CrashHandler crashHandler;
+
 Sapphire::Db::DbWorkerPool< Sapphire::Db::ZoneDbConnection > g_charaDb;
 Sapphire::Data::ExdDataGenerated g_exdDataGen;
 Sapphire::Network::SapphireAPI g_sapphireAPI;

src/common/CMakeLists.txt

@@ -26,6 +26,10 @@ if( UNIX )
                            PUBLIC
                              pthread
                              stdc++fs )
+else()
+  target_link_libraries( common
+                           PUBLIC
+                             stackwalker )
 endif()
 
 target_include_directories( common

src/common/Util/CrashHandler.cpp

@@ -0,0 +1,144 @@
+#include "CrashHandler.h"
+
+#include <signal.h>
+#include <Logging/Logger.h>
+
+#ifndef _WIN32
+#include <execinfo.h>
+#include <cxxabi.h>
+#else
+#include <stackwalker/StackWalker.h>
+#endif
+
+using namespace Sapphire::Common;
+
+Util::CrashHandler::CrashHandler()
+{
+  signal( SIGABRT, signalHandler );
+  signal( SIGSEGV, signalHandler );
+  signal( SIGILL, signalHandler );
+  signal( SIGFPE, signalHandler );
+
+#ifndef _WIN32
+  // SIGBUS not supported on windows
+  signal( SIGBUS, signalHandler );
+#endif
+
+#undef REGISTER_SIGNAL
+}
+
+void Util::CrashHandler::signalHandler( int sigNum )
+{
+#define ADD_SIGNAL_MAP( x ) case x: name = #x; break;
+  const char* name = nullptr;
+  switch( sigNum )
+  {
+    ADD_SIGNAL_MAP( SIGABRT );
+    ADD_SIGNAL_MAP( SIGSEGV );
+    ADD_SIGNAL_MAP( SIGILL );
+    ADD_SIGNAL_MAP( SIGFPE );
+#ifndef _WIN32
+    // SIGBUS not supported on windows
+    ADD_SIGNAL_MAP( SIGBUS );
+#endif
+  }
+#undef ADD_SIGNAL_MAP
+
+  if( name )
+  {
+    Logger::fatal( "Caught signal {} ({})", sigNum, name );
+  }
+  else
+  {
+    Logger::fatal( "Caught signal {}", sigNum );
+  }
+
+  printStackTrace();
+
+  exit( sigNum );
+}
+
+
+void Util::CrashHandler::printStackTrace( unsigned int max_frames )
+{
+  Logger::fatal( "Stack trace:" );
+
+#ifndef _WIN32
+
+  // used as is from: https://oroboro.com/stack-trace-on-crash/
+  // only changes output slightly
+
+  void* addrlist[ max_frames + 1 ];
+
+  int addrlen = backtrace( addrlist, sizeof( addrlist ) / sizeof( void* ) );
+
+  if ( addrlen == 0 )
+  {
+    Logger::fatal( "No stack addresses available." );
+    return;
+  }
+
+  char** symbollist = backtrace_symbols( addrlist, addrlen );
+
+  size_t funcnamesize = 1024;
+  char funcname[1024];
+
+  // iterate over the returned symbol lines. skip the first, it is the
+  // address of this function.
+  for ( unsigned int i = 0; i < addrlen; i++ )
+  {
+    char* begin_name   = NULL;
+    char* begin_offset = NULL;
+    char* end_offset   = NULL;
+
+    // find parentheses and +address offset surrounding the mangled name
+    for ( char *p = symbollist[i]; *p; ++p )
+    {
+      if ( *p == '(' )
+        begin_name = p;
+      else if ( *p == '+' )
+        begin_offset = p;
+      else if ( *p == ')' && ( begin_offset || begin_name ))
+        end_offset = p;
+    }
+
+    if ( begin_name && end_offset && ( begin_name < end_offset ))
+    {
+      *begin_name++ = '\0';
+      *end_offset++ = '\0';
+      if( begin_offset )
+        *begin_offset++ = '\0';
+
+      // mangled name is now in [begin_name, begin_offset) and caller
+      // offset in [begin_offset, end_offset). now apply
+      // __cxa_demangle():
+
+      int status = 0;
+      char* ret = abi::__cxa_demangle( begin_name, funcname,
+                                       &funcnamesize, &status );
+      char* fname = begin_name;
+      if( status == 0 )
+        fname = ret;
+
+      const char* format = " {} {:40} {} + {}";
+
+      if( begin_offset )
+      {
+        Logger::fatal( format, end_offset, symbollist[ i ], fname, begin_offset );
+      }
+      else
+      {
+        Logger::fatal( format, end_offset, symbollist[ i ], fname, "" );
+      }
+    }
+  }
+
+  free( symbollist );
+
+#else
+
+  StackWalker sw;
+  sw.ShowCallstack();
+
+#endif
+}

src/common/Util/CrashHandler.h

@@ -0,0 +1,28 @@
+#ifndef SAPPHIRE_SIGNALHANDLER_H
+#define SAPPHIRE_SIGNALHANDLER_H
+
+
+// based on: https://oroboro.com/stack-trace-on-crash/
+
+namespace Sapphire::Common::Util
+{
+
+  /*!
+   * @brief Provides cross platform stack trace dumping.
+   *
+   * Statically init it somewhere so it registers the signal handlers before main runs and you're good to go.
+   */
+  class CrashHandler
+  {
+  public:
+    CrashHandler();
+    virtual ~CrashHandler() = default;
+
+  private:
+    static void signalHandler( int sigNum );
+
+    static void printStackTrace( unsigned int max_frames = 63 );
+  };
+}
+
+#endif //SAPPHIRE_CRASHHANDLER_H

src/lobby/mainLobbyServer.cpp

@@ -1,5 +1,9 @@
 #include "ServerLobby.h"
 
+#include <Util/CrashHandler.h>
+
+Sapphire::Common::Util::CrashHandler crashHandler;
+
 Sapphire::ServerLobby g_serverLobby( "lobby.ini" );
 
 int main( int32_t argc, char* argv[] )

src/tools/exd_struct_test/main.cpp

@@ -16,6 +16,10 @@
 #include <streambuf>
 #include <regex>
 
+#include <Util/CrashHandler.h>
+
+Sapphire::Common::Util::CrashHandler crashHandler;
+
 Sapphire::Data::ExdDataGenerated g_exdData;
 
 using namespace Sapphire;
@@ -23,7 +27,6 @@ using namespace Sapphire;
 //const std::string datLocation( "/opt/sapphire_3_15_0/bin/sqpack" );
 const std::string datLocation( "/mnt/c/Program Files (x86)/Steam/steamapps/common/FINAL FANTASY XIV Online/game/sqpack" );
 
-
 int main()
 {
 

src/world/mainGameServer.cpp

@@ -3,9 +3,13 @@
 #include "ServerMgr.h"
 #include <Framework.h>
 
+#include <Util/CrashHandler.h>
+
 using namespace Sapphire;
 using namespace Sapphire::World;
 
+Common::Util::CrashHandler crashHandler;
+
 int main( int32_t argc, char* argv[] )
 {
   auto pFramework = Sapphire::make_Framework();