g3log/stacktrace_windows.cpp - openbmc/bmcweb - Gitiles

 /** ==========================================================================
  * Original code made by Robert Engeln. Given as a PUBLIC DOMAIN dedication for
  * the benefit of g3log.  It was originally published at:
  * http://code-freeze.blogspot.com/2012/01/generating-stack-traces-from-c.html

  * 2014-2015: adapted for g3log by Kjell Hedstrom (KjellKod).
  *
  * This is PUBLIC DOMAIN to use at your own risk and comes
  * with no warranties. This code is yours to share, use and modify with no
  * strings attached and no restrictions or obligations.
  *
  * For more information see g3log/LICENSE or refer refer to http://unlicense.org
  * ============================================================================*/

 #include "g3log/stacktrace_windows.hpp"

 #include <windows.h>
 #include <dbghelp.h>
 #include <map>
 #include <memory>
 #include <cassert>
 #include <vector>
 #include <mutex>
 #include <g3log/g3log.hpp>

 #pragma comment(lib, "dbghelp.lib")


 #if !(defined(WIN32) || defined(_WIN32) || defined(__WIN32__))
 #error "stacktrace_win.cpp used but not on a windows system"
 #endif


 #define g3_MAP_PAIR_STRINGIFY(x) {x, #x}

 namespace {
    thread_local size_t g_thread_local_recursive_crash_check = 0;

    const std::map<g3::SignalType, std::string> kExceptionsAsText = {
       g3_MAP_PAIR_STRINGIFY(EXCEPTION_ACCESS_VIOLATION)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_ARRAY_BOUNDS_EXCEEDED)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_DATATYPE_MISALIGNMENT)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_FLT_DENORMAL_OPERAND)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_FLT_DIVIDE_BY_ZERO)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_FLT_INEXACT_RESULT)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_FLT_INEXACT_RESULT)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_FLT_INVALID_OPERATION)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_FLT_OVERFLOW)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_FLT_STACK_CHECK)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_FLT_UNDERFLOW)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_ILLEGAL_INSTRUCTION)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_IN_PAGE_ERROR)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_INT_DIVIDE_BY_ZERO)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_INT_OVERFLOW)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_INVALID_DISPOSITION)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_NONCONTINUABLE_EXCEPTION)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_PRIV_INSTRUCTION)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_STACK_OVERFLOW)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_BREAKPOINT)
       , g3_MAP_PAIR_STRINGIFY(EXCEPTION_SINGLE_STEP)

    };


    // Using the given context, fill in all the stack frames.
    // Which then later can be interpreted to human readable text
    void captureStackTrace(CONTEXT *context, std::vector<uint64_t> &frame_pointers) {
       DWORD machine_type = 0;
       STACKFRAME64 frame = {}; // force zeroeing
       frame.AddrPC.Mode = AddrModeFlat;
       frame.AddrFrame.Mode = AddrModeFlat;
       frame.AddrStack.Mode = AddrModeFlat;
 #ifdef _M_X64
       frame.AddrPC.Offset = context->Rip;
       frame.AddrFrame.Offset = context->Rbp;
       frame.AddrStack.Offset = context->Rsp;
       machine_type = IMAGE_FILE_MACHINE_AMD64;
 #else
       frame.AddrPC.Offset = context->Eip;
       frame.AddrPC.Offset = context->Ebp;
       frame.AddrPC.Offset = context->Esp;
       machine_type = IMAGE_FILE_MACHINE_I386;
 #endif
       for (size_t index = 0; index < frame_pointers.size(); ++index)
       {
          if (StackWalk64(machine_type,
                          GetCurrentProcess(),
                          GetCurrentThread(),
                          &frame,
                          context,
                          NULL,
                          SymFunctionTableAccess64,
                          SymGetModuleBase64,
                          NULL)) {
             frame_pointers[index] = frame.AddrPC.Offset;
          } else {
             break;
          }
       }
    }


    // extract readable text from a given stack frame. All thanks to
    // using SymFromAddr and SymGetLineFromAddr64 with the stack pointer
    std::string getSymbolInformation(const size_t index, const std::vector<uint64_t> &frame_pointers) {
       auto addr = frame_pointers[index];
       std::string frame_dump = "stack dump [" + std::to_string(index) + "]\t";

       DWORD64 displacement64;
       DWORD displacement;
       char symbol_buffer[sizeof(SYMBOL_INFO) + 256];
       SYMBOL_INFO *symbol = reinterpret_cast<SYMBOL_INFO *>(symbol_buffer);
       symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
       symbol->MaxNameLen = MAX_SYM_NAME;

       IMAGEHLP_LINE64 line;
       line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
       std::string lineInformation;
       std::string callInformation;
       if (SymFromAddr(GetCurrentProcess(), addr, &displacement64, symbol)) {
          callInformation.append(" ").append({symbol->Name, symbol->NameLen});
          if (SymGetLineFromAddr64(GetCurrentProcess(), addr, &displacement, &line)) {
             lineInformation.append("\t").append(line.FileName).append(" L: ");
             lineInformation.append(std::to_string(line.LineNumber));
          }
       }
       frame_dump.append(lineInformation).append(callInformation);
       return frame_dump;
    }


    // Retrieves all the symbols for the stack frames, fills them witin a text representation and returns it
    std::string convertFramesToText(std::vector<uint64_t> &frame_pointers) {
       std::string dump; // slightly more efficient than ostringstream
       const size_t kSize = frame_pointers.size();
       for (size_t index = 0; index < kSize && frame_pointers[index]; ++index) {
          dump += getSymbolInformation(index, frame_pointers);
          dump += "\n";
       }
       return dump;
    }
 } // anonymous


 namespace stacktrace {
    const std::string kUnknown = {"UNKNOWN EXCEPTION"};
    /// return the text description of a Windows exception code
    /// From MSDN GetExceptionCode http://msdn.microsoft.com/en-us/library/windows/desktop/ms679356(v=vs.85).aspx
    std::string exceptionIdToText(g3::SignalType id) {
       const auto iter = kExceptionsAsText.find(id);
       if ( iter == kExceptionsAsText.end()) {
          std::string unknown = {kUnknown + ":" + std::to_string(id)};
          return unknown;
       }
       return iter->second;
    }

    /// Yes a double lookup: first for isKnownException and then exceptionIdToText
    /// for vectored exceptions we only deal with known exceptions so this tiny
    /// overhead we can live with
    bool isKnownException(g3::SignalType id) {
       return (kExceptionsAsText.end() != kExceptionsAsText.find(id));
    }

    /// helper function: retrieve stackdump from no excisting exception pointer
    std::string stackdump() {
       CONTEXT current_context;
       memset(&current_context, 0, sizeof(CONTEXT));
       RtlCaptureContext(&current_context);
       return stackdump(&current_context);
    }

    /// helper function: retrieve stackdump, starting from an exception pointer
    std::string stackdump(EXCEPTION_POINTERS *info) {
       auto context = info->ContextRecord;
       return stackdump(context);

    }


    /// main stackdump function. retrieve stackdump, from the given context
    std::string stackdump(CONTEXT *context) {

       if (g_thread_local_recursive_crash_check >= 2) { // In Debug scenarious we allow one extra pass
          std::string recursive_crash = {"\n\n\n***** Recursive crash detected"};
          recursive_crash.append(", cannot continue stackdump traversal. *****\n\n\n");
          return recursive_crash;
       }
       ++g_thread_local_recursive_crash_check;

       static std::mutex m;
       std::lock_guard<std::mutex> lock(m);
       {
          const BOOL kLoadSymModules = TRUE;
          const auto initialized = SymInitialize(GetCurrentProcess(), nullptr, kLoadSymModules);
          if (TRUE != initialized) {
             return { "Error: Cannot call SymInitialize(...) for retrieving symbols in stack" };
          }

          std::shared_ptr<void> RaiiSymCleaner(nullptr, [&](void *) {
             SymCleanup(GetCurrentProcess());
          }); // Raii sym cleanup


          const size_t kmax_frame_dump_size = 64;
          std::vector<uint64_t>  frame_pointers(kmax_frame_dump_size);
          // C++11: size set and values are zeroed

          assert(frame_pointers.size() == kmax_frame_dump_size);
          captureStackTrace(context, frame_pointers);
          return convertFramesToText(frame_pointers);
       }
    }

 } // stacktrace
	/** ==========================================================================
	* Original code made by Robert Engeln. Given as a PUBLIC DOMAIN dedication for
	* the benefit of g3log. It was originally published at:
	* http://code-freeze.blogspot.com/2012/01/generating-stack-traces-from-c.html

	* 2014-2015: adapted for g3log by Kjell Hedstrom (KjellKod).
	*
	* This is PUBLIC DOMAIN to use at your own risk and comes
	* with no warranties. This code is yours to share, use and modify with no
	* strings attached and no restrictions or obligations.
	*
	* For more information see g3log/LICENSE or refer refer to http://unlicense.org
	* ============================================================================*/

	#include "g3log/stacktrace_windows.hpp"

	#include <windows.h>
	#include <dbghelp.h>
	#include <map>
	#include <memory>
	#include <cassert>
	#include <vector>
	#include <mutex>
	#include <g3log/g3log.hpp>

	#pragma comment(lib, "dbghelp.lib")


	#if !(defined(WIN32) \|\| defined(_WIN32) \|\| defined(__WIN32__))
	#error "stacktrace_win.cpp used but not on a windows system"
	#endif



	#define g3_MAP_PAIR_STRINGIFY(x) {x, #x}

	namespace {
	thread_local size_t g_thread_local_recursive_crash_check = 0;

	const std::map<g3::SignalType, std::string> kExceptionsAsText = {
	g3_MAP_PAIR_STRINGIFY(EXCEPTION_ACCESS_VIOLATION)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_ARRAY_BOUNDS_EXCEEDED)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_DATATYPE_MISALIGNMENT)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_FLT_DENORMAL_OPERAND)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_FLT_DIVIDE_BY_ZERO)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_FLT_INEXACT_RESULT)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_FLT_INEXACT_RESULT)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_FLT_INVALID_OPERATION)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_FLT_OVERFLOW)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_FLT_STACK_CHECK)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_FLT_UNDERFLOW)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_ILLEGAL_INSTRUCTION)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_IN_PAGE_ERROR)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_INT_DIVIDE_BY_ZERO)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_INT_OVERFLOW)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_INVALID_DISPOSITION)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_NONCONTINUABLE_EXCEPTION)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_PRIV_INSTRUCTION)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_STACK_OVERFLOW)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_BREAKPOINT)
	, g3_MAP_PAIR_STRINGIFY(EXCEPTION_SINGLE_STEP)

	};


	// Using the given context, fill in all the stack frames.
	// Which then later can be interpreted to human readable text
	void captureStackTrace(CONTEXT *context, std::vector<uint64_t> &frame_pointers) {
	DWORD machine_type = 0;
	STACKFRAME64 frame = {}; // force zeroeing
	frame.AddrPC.Mode = AddrModeFlat;
	frame.AddrFrame.Mode = AddrModeFlat;
	frame.AddrStack.Mode = AddrModeFlat;
	#ifdef _M_X64
	frame.AddrPC.Offset = context->Rip;
	frame.AddrFrame.Offset = context->Rbp;
	frame.AddrStack.Offset = context->Rsp;
	machine_type = IMAGE_FILE_MACHINE_AMD64;
	#else
	frame.AddrPC.Offset = context->Eip;
	frame.AddrPC.Offset = context->Ebp;
	frame.AddrPC.Offset = context->Esp;
	machine_type = IMAGE_FILE_MACHINE_I386;
	#endif
	for (size_t index = 0; index < frame_pointers.size(); ++index)
	{
	if (StackWalk64(machine_type,
	GetCurrentProcess(),
	GetCurrentThread(),
	&frame,
	context,
	NULL,
	SymFunctionTableAccess64,
	SymGetModuleBase64,
	NULL)) {
	frame_pointers[index] = frame.AddrPC.Offset;
	} else {
	break;
	}
	}
	}



	// extract readable text from a given stack frame. All thanks to
	// using SymFromAddr and SymGetLineFromAddr64 with the stack pointer
	std::string getSymbolInformation(const size_t index, const std::vector<uint64_t> &frame_pointers) {
	auto addr = frame_pointers[index];
	std::string frame_dump = "stack dump [" + std::to_string(index) + "]\t";

	DWORD64 displacement64;
	DWORD displacement;
	char symbol_buffer[sizeof(SYMBOL_INFO) + 256];
	SYMBOL_INFO symbol = reinterpret_cast<SYMBOL_INFO >(symbol_buffer);
	symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
	symbol->MaxNameLen = MAX_SYM_NAME;

	IMAGEHLP_LINE64 line;
	line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
	std::string lineInformation;
	std::string callInformation;
	if (SymFromAddr(GetCurrentProcess(), addr, &displacement64, symbol)) {
	callInformation.append(" ").append({symbol->Name, symbol->NameLen});
	if (SymGetLineFromAddr64(GetCurrentProcess(), addr, &displacement, &line)) {
	lineInformation.append("\t").append(line.FileName).append(" L: ");
	lineInformation.append(std::to_string(line.LineNumber));
	}
	}
	frame_dump.append(lineInformation).append(callInformation);
	return frame_dump;
	}


	// Retrieves all the symbols for the stack frames, fills them witin a text representation and returns it
	std::string convertFramesToText(std::vector<uint64_t> &frame_pointers) {
	std::string dump; // slightly more efficient than ostringstream
	const size_t kSize = frame_pointers.size();
	for (size_t index = 0; index < kSize && frame_pointers[index]; ++index) {
	dump += getSymbolInformation(index, frame_pointers);
	dump += "\n";
	}
	return dump;
	}
	} // anonymous




	namespace stacktrace {
	const std::string kUnknown = {"UNKNOWN EXCEPTION"};
	/// return the text description of a Windows exception code
	/// From MSDN GetExceptionCode http://msdn.microsoft.com/en-us/library/windows/desktop/ms679356(v=vs.85).aspx
	std::string exceptionIdToText(g3::SignalType id) {
	const auto iter = kExceptionsAsText.find(id);
	if ( iter == kExceptionsAsText.end()) {
	std::string unknown = {kUnknown + ":" + std::to_string(id)};
	return unknown;
	}
	return iter->second;
	}

	/// Yes a double lookup: first for isKnownException and then exceptionIdToText
	/// for vectored exceptions we only deal with known exceptions so this tiny
	/// overhead we can live with
	bool isKnownException(g3::SignalType id) {
	return (kExceptionsAsText.end() != kExceptionsAsText.find(id));
	}

	/// helper function: retrieve stackdump from no excisting exception pointer
	std::string stackdump() {
	CONTEXT current_context;
	memset(&current_context, 0, sizeof(CONTEXT));
	RtlCaptureContext(&current_context);
	return stackdump(&current_context);
	}

	/// helper function: retrieve stackdump, starting from an exception pointer
	std::string stackdump(EXCEPTION_POINTERS *info) {
	auto context = info->ContextRecord;
	return stackdump(context);

	}


	/// main stackdump function. retrieve stackdump, from the given context
	std::string stackdump(CONTEXT *context) {

	if (g_thread_local_recursive_crash_check >= 2) { // In Debug scenarious we allow one extra pass
	std::string recursive_crash = {"\n\n\n***** Recursive crash detected"};
	recursive_crash.append(", cannot continue stackdump traversal. *****\n\n\n");
	return recursive_crash;
	}
	++g_thread_local_recursive_crash_check;

	static std::mutex m;
	std::lock_guard<std::mutex> lock(m);
	{
	const BOOL kLoadSymModules = TRUE;
	const auto initialized = SymInitialize(GetCurrentProcess(), nullptr, kLoadSymModules);
	if (TRUE != initialized) {
	return { "Error: Cannot call SymInitialize(...) for retrieving symbols in stack" };
	}

	std::shared_ptr<void> RaiiSymCleaner(nullptr, [&](void *) {
	SymCleanup(GetCurrentProcess());
	}); // Raii sym cleanup


	const size_t kmax_frame_dump_size = 64;
	std::vector<uint64_t> frame_pointers(kmax_frame_dump_size);
	// C++11: size set and values are zeroed

	assert(frame_pointers.size() == kmax_frame_dump_size);
	captureStackTrace(context, frame_pointers);
	return convertFramesToText(frame_pointers);
	}
	}

	} // stacktrace