g3log/crashhandler_windows.cpp - openbmc/bmcweb - Gitiles

 /** ==========================================================================
  * 2011 by KjellKod.cc. 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
  * ============================================================================*/

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

 #include <windows.h>
 #include <csignal>
 #include <sstream>
 #include <atomic>
 #include <process.h> // getpid
 #include "g3log/crashhandler.hpp"
 #include "g3log/stacktrace_windows.hpp"
 #include "g3log/logcapture.hpp"

 #define getpid _getpid

 namespace {
    std::atomic<bool> gBlockForFatal {true};
    LPTOP_LEVEL_EXCEPTION_FILTER g_previous_unexpected_exception_handler = nullptr;

 #if !(defined(DISABLE_FATAL_SIGNALHANDLING))
    thread_local bool g_installed_thread_signal_handler = false;
 #endif

 #if !(defined(DISABLE_VECTORED_EXCEPTIONHANDLING))
    void *g_vector_exception_handler = nullptr;
 #endif


    // Restore back to default fatal event handling
    void ReverseToOriginalFatalHandling() {
       SetUnhandledExceptionFilter (g_previous_unexpected_exception_handler);

 #if !(defined(DISABLE_VECTORED_EXCEPTIONHANDLING))
       RemoveVectoredExceptionHandler (g_vector_exception_handler);
 #endif

 #if !(defined(DISABLE_FATAL_SIGNALHANDLING))
       if (SIG_ERR == signal(SIGABRT, SIG_DFL))
          perror("signal - SIGABRT");

       if (SIG_ERR == signal(SIGFPE, SIG_DFL))
          perror("signal - SIGABRT");

       if (SIG_ERR == signal(SIGSEGV, SIG_DFL))
          perror("signal - SIGABRT");

       if (SIG_ERR == signal(SIGILL, SIG_DFL))
          perror("signal - SIGABRT");

       if (SIG_ERR == signal(SIGTERM, SIG_DFL))
          perror("signal - SIGABRT");
 #endif
    }


    // called for fatal signals SIGABRT, SIGFPE, SIGSEGV, SIGILL, SIGTERM
    void signalHandler(int signal_number) {
       using namespace g3::internal;
       std::string dump = stacktrace::stackdump();

       std::ostringstream fatal_stream;
       fatal_stream << "\n***** Received fatal signal " << g3::internal::exitReasonName(g3::internal::FATAL_SIGNAL, signal_number);
       fatal_stream << "(" << signal_number << ")\tPID: " << getpid() << std::endl;


       LogCapture trigger(FATAL_SIGNAL, static_cast<g3::SignalType>(signal_number), dump.c_str());
       trigger.stream() << fatal_stream.str();

       // Trigger debug break point, if we're in debug. This breakpoint CAN cause a slowdown when it happens.
       // Be patient. The "Debug" dialogue should pop-up eventually if you doing it in Visual Studio.
       // For fatal signals only, not exceptions.
       // This is a way to tell the IDE (if in dev mode) that it can stop at this breakpoint
       // Note that at this time the fatal log event with stack trace is NOT yet flushed to the logger
       // This call will do nothing unless we're in DEBUG and "DEBUG_BREAK_AT_FATAL_SIGNAL" is enabled
       // ref: g3log/Options.cmake
 #if (!defined(NDEBUG) && defined(DEBUG_BREAK_AT_FATAL_SIGNAL))
       __debugbreak();
 #endif
    } // scope exit - message sent to LogWorker, wait to die...


    // Unhandled exception catching
    LONG WINAPI exceptionHandling(EXCEPTION_POINTERS *info, const std::string &handler) {
       std::string dump = stacktrace::stackdump(info);

       std::ostringstream fatal_stream;
       const g3::SignalType exception_code = info->ExceptionRecord->ExceptionCode;
       fatal_stream << "\n***** " << handler << ": Received fatal exception " << g3::internal::exitReasonName(g3::internal::FATAL_EXCEPTION, exception_code);
       fatal_stream << "\tPID: " << getpid() << std::endl;

       const auto fatal_id = static_cast<g3::SignalType>(exception_code);
       LogCapture trigger(g3::internal::FATAL_EXCEPTION, fatal_id, dump.c_str());
       trigger.stream() << fatal_stream.str();
       // FATAL Exception: It doesn't necessarily stop here we pass on continue search
       // if no one else will catch that then it's goodbye anyhow.
       // The RISK here is if someone is cathing this and returning "EXCEPTION_EXECUTE_HANDLER"
       // but does not shutdown then the software will be running with g3log shutdown.
       // .... However... this must be seen as a bug from standard handling of fatal exceptions
       // https://msdn.microsoft.com/en-us/library/6wxdsc38.aspx
       return EXCEPTION_CONTINUE_SEARCH;
    }


    // Unhandled exception catching
    LONG WINAPI unexpectedExceptionHandling(EXCEPTION_POINTERS *info) {
       ReverseToOriginalFatalHandling();
       return exceptionHandling(info, "Unexpected Exception Handler");
    }


    /// Setup through (Windows API) AddVectoredExceptionHandler
    /// Ref: http://blogs.msdn.com/b/zhanli/archive/2010/06/25/c-tips-addvectoredexceptionhandler-addvectoredcontinuehandler-and-setunhandledexceptionfilter.aspx
 #if !(defined(DISABLE_VECTORED_EXCEPTIONHANDLING))
    LONG WINAPI vectorExceptionHandling(PEXCEPTION_POINTERS p) {
       const g3::SignalType exception_code = p->ExceptionRecord->ExceptionCode;
       if (false == stacktrace::isKnownException(exception_code)) {
          // The unknown exception is ignored. Since it is not a Windows
          // fatal exception generated by the OS we leave the
          // responsibility to deal with this by the client software.
          return EXCEPTION_CONTINUE_SEARCH;
       } else {
          ReverseToOriginalFatalHandling();
          return exceptionHandling(p, "Vectored Exception Handler");
       }
    }
 #endif


 } // end anonymous namespace


 namespace g3 {
    namespace internal {
       // For windows exceptions this might ONCE be set to false, in case of a
       // windows exceptions and not a signal
       bool shouldBlockForFatalHandling() {
          return gBlockForFatal;
       }


       /// Generate stackdump. Or in case a stackdump was pre-generated and
       /// non-empty just use that one.   i.e. the latter case is only for
       /// Windows and test purposes
       std::string stackdump(const char *dump) {
          if (nullptr != dump && !std::string(dump).empty()) {
             return {dump};
          }

          return stacktrace::stackdump();
       }


       /// string representation of signal ID or Windows exception id
       std::string exitReasonName(const LEVELS &level, g3::SignalType fatal_id) {
          if (level == g3::internal::FATAL_EXCEPTION) {
             return stacktrace::exceptionIdToText(fatal_id);
          }

          switch (fatal_id) {
          case SIGABRT: return "SIGABRT"; break;
          case SIGFPE: return "SIGFPE"; break;
          case SIGSEGV: return "SIGSEGV"; break;
          case SIGILL: return "SIGILL"; break;
          case SIGTERM: return "SIGTERM"; break;
          default:
             std::ostringstream oss;
             oss << "UNKNOWN SIGNAL(" << fatal_id << ")";
             return oss.str();
          }
       }


       // Triggered by g3log::LogWorker after receiving a FATAL trigger
       // which is LOG(FATAL), CHECK(false) or a fatal signal our signalhandler caught.
       // --- If LOG(FATAL) or CHECK(false) the signal_number will be SIGABRT
       void exitWithDefaultSignalHandler(const LEVELS &level, g3::SignalType fatal_signal_id) {

          ReverseToOriginalFatalHandling();
          // For windows exceptions we want to continue the possibility of
          // exception handling now when the log and stacktrace are flushed
          // to sinks. We therefore avoid to kill the preocess here. Instead
          //  it will be the exceptionHandling functions above that
          // will let exception handling continue with: EXCEPTION_CONTINUE_SEARCH
          if (g3::internal::FATAL_EXCEPTION == level) {
             gBlockForFatal = false;
             return;
          }

          // for a sigal however, we exit through that fatal signal
          const int signal_number = static_cast<int>(fatal_signal_id);
          raise(signal_number);
       }


       void installSignalHandler() {
          g3::installSignalHandlerForThread();
       }


    } // end g3::internal


    ///  SIGFPE, SIGILL, and SIGSEGV handling must be installed per thread
    /// on Windows. This is automatically done if you do at least one LOG(...) call
    /// you can also use this function call, per thread so make sure these three
    /// fatal signals are covered in your thread (even if you don't do a LOG(...) call
    void installSignalHandlerForThread() {
 #if !(defined(DISABLE_FATAL_SIGNALHANDLING))
       if (!g_installed_thread_signal_handler) {
          g_installed_thread_signal_handler = true;
          if (SIG_ERR == signal(SIGTERM, signalHandler))
             perror("signal - SIGTERM");
          if (SIG_ERR == signal(SIGABRT, signalHandler))
             perror("signal - SIGABRT");
          if (SIG_ERR == signal(SIGFPE, signalHandler))
             perror("signal - SIGFPE");
          if (SIG_ERR == signal(SIGSEGV, signalHandler))
             perror("signal - SIGSEGV");
          if (SIG_ERR == signal(SIGILL, signalHandler))
             perror("signal - SIGILL");
       }
 #endif
    }

    void installCrashHandler() {
       internal::installSignalHandler();
       g_previous_unexpected_exception_handler = SetUnhandledExceptionFilter(unexpectedExceptionHandling);

 #if !(defined(DISABLE_VECTORED_EXCEPTIONHANDLING))
       // const size_t kFirstExceptionHandler = 1;
       // kFirstExeptionsHandler is kept here for documentational purposes.
       // The last exception seems more what we want
       const size_t kLastExceptionHandler = 0;
       g_vector_exception_handler = AddVectoredExceptionHandler(kLastExceptionHandler, vectorExceptionHandling);
 #endif
    }

 } // end namespace g3
	/** ==========================================================================
	* 2011 by KjellKod.cc. 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
	* ============================================================================*/

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

	#include <windows.h>
	#include <csignal>
	#include <sstream>
	#include <atomic>
	#include <process.h> // getpid
	#include "g3log/crashhandler.hpp"
	#include "g3log/stacktrace_windows.hpp"
	#include "g3log/logcapture.hpp"

	#define getpid _getpid

	namespace {
	std::atomic<bool> gBlockForFatal {true};
	LPTOP_LEVEL_EXCEPTION_FILTER g_previous_unexpected_exception_handler = nullptr;

	#if !(defined(DISABLE_FATAL_SIGNALHANDLING))
	thread_local bool g_installed_thread_signal_handler = false;
	#endif

	#if !(defined(DISABLE_VECTORED_EXCEPTIONHANDLING))
	void *g_vector_exception_handler = nullptr;
	#endif



	// Restore back to default fatal event handling
	void ReverseToOriginalFatalHandling() {
	SetUnhandledExceptionFilter (g_previous_unexpected_exception_handler);

	#if !(defined(DISABLE_VECTORED_EXCEPTIONHANDLING))
	RemoveVectoredExceptionHandler (g_vector_exception_handler);
	#endif

	#if !(defined(DISABLE_FATAL_SIGNALHANDLING))
	if (SIG_ERR == signal(SIGABRT, SIG_DFL))
	perror("signal - SIGABRT");

	if (SIG_ERR == signal(SIGFPE, SIG_DFL))
	perror("signal - SIGABRT");

	if (SIG_ERR == signal(SIGSEGV, SIG_DFL))
	perror("signal - SIGABRT");

	if (SIG_ERR == signal(SIGILL, SIG_DFL))
	perror("signal - SIGABRT");

	if (SIG_ERR == signal(SIGTERM, SIG_DFL))
	perror("signal - SIGABRT");
	#endif
	}



	// called for fatal signals SIGABRT, SIGFPE, SIGSEGV, SIGILL, SIGTERM
	void signalHandler(int signal_number) {
	using namespace g3::internal;
	std::string dump = stacktrace::stackdump();

	std::ostringstream fatal_stream;
	fatal_stream << "\n***** Received fatal signal " << g3::internal::exitReasonName(g3::internal::FATAL_SIGNAL, signal_number);
	fatal_stream << "(" << signal_number << ")\tPID: " << getpid() << std::endl;


	LogCapture trigger(FATAL_SIGNAL, static_cast<g3::SignalType>(signal_number), dump.c_str());
	trigger.stream() << fatal_stream.str();

	// Trigger debug break point, if we're in debug. This breakpoint CAN cause a slowdown when it happens.
	// Be patient. The "Debug" dialogue should pop-up eventually if you doing it in Visual Studio.
	// For fatal signals only, not exceptions.
	// This is a way to tell the IDE (if in dev mode) that it can stop at this breakpoint
	// Note that at this time the fatal log event with stack trace is NOT yet flushed to the logger
	// This call will do nothing unless we're in DEBUG and "DEBUG_BREAK_AT_FATAL_SIGNAL" is enabled
	// ref: g3log/Options.cmake
	#if (!defined(NDEBUG) && defined(DEBUG_BREAK_AT_FATAL_SIGNAL))
	__debugbreak();
	#endif
	} // scope exit - message sent to LogWorker, wait to die...



	// Unhandled exception catching
	LONG WINAPI exceptionHandling(EXCEPTION_POINTERS *info, const std::string &handler) {
	std::string dump = stacktrace::stackdump(info);

	std::ostringstream fatal_stream;
	const g3::SignalType exception_code = info->ExceptionRecord->ExceptionCode;
	fatal_stream << "\n***** " << handler << ": Received fatal exception " << g3::internal::exitReasonName(g3::internal::FATAL_EXCEPTION, exception_code);
	fatal_stream << "\tPID: " << getpid() << std::endl;

	const auto fatal_id = static_cast<g3::SignalType>(exception_code);
	LogCapture trigger(g3::internal::FATAL_EXCEPTION, fatal_id, dump.c_str());
	trigger.stream() << fatal_stream.str();
	// FATAL Exception: It doesn't necessarily stop here we pass on continue search
	// if no one else will catch that then it's goodbye anyhow.
	// The RISK here is if someone is cathing this and returning "EXCEPTION_EXECUTE_HANDLER"
	// but does not shutdown then the software will be running with g3log shutdown.
	// .... However... this must be seen as a bug from standard handling of fatal exceptions
	// https://msdn.microsoft.com/en-us/library/6wxdsc38.aspx
	return EXCEPTION_CONTINUE_SEARCH;
	}


	// Unhandled exception catching
	LONG WINAPI unexpectedExceptionHandling(EXCEPTION_POINTERS *info) {
	ReverseToOriginalFatalHandling();
	return exceptionHandling(info, "Unexpected Exception Handler");
	}


	/// Setup through (Windows API) AddVectoredExceptionHandler
	/// Ref: http://blogs.msdn.com/b/zhanli/archive/2010/06/25/c-tips-addvectoredexceptionhandler-addvectoredcontinuehandler-and-setunhandledexceptionfilter.aspx
	#if !(defined(DISABLE_VECTORED_EXCEPTIONHANDLING))
	LONG WINAPI vectorExceptionHandling(PEXCEPTION_POINTERS p) {
	const g3::SignalType exception_code = p->ExceptionRecord->ExceptionCode;
	if (false == stacktrace::isKnownException(exception_code)) {
	// The unknown exception is ignored. Since it is not a Windows
	// fatal exception generated by the OS we leave the
	// responsibility to deal with this by the client software.
	return EXCEPTION_CONTINUE_SEARCH;
	} else {
	ReverseToOriginalFatalHandling();
	return exceptionHandling(p, "Vectored Exception Handler");
	}
	}
	#endif




	} // end anonymous namespace


	namespace g3 {
	namespace internal {
	// For windows exceptions this might ONCE be set to false, in case of a
	// windows exceptions and not a signal
	bool shouldBlockForFatalHandling() {
	return gBlockForFatal;
	}


	/// Generate stackdump. Or in case a stackdump was pre-generated and
	/// non-empty just use that one. i.e. the latter case is only for
	/// Windows and test purposes
	std::string stackdump(const char *dump) {
	if (nullptr != dump && !std::string(dump).empty()) {
	return {dump};
	}

	return stacktrace::stackdump();
	}



	/// string representation of signal ID or Windows exception id
	std::string exitReasonName(const LEVELS &level, g3::SignalType fatal_id) {
	if (level == g3::internal::FATAL_EXCEPTION) {
	return stacktrace::exceptionIdToText(fatal_id);
	}

	switch (fatal_id) {
	case SIGABRT: return "SIGABRT"; break;
	case SIGFPE: return "SIGFPE"; break;
	case SIGSEGV: return "SIGSEGV"; break;
	case SIGILL: return "SIGILL"; break;
	case SIGTERM: return "SIGTERM"; break;
	default:
	std::ostringstream oss;
	oss << "UNKNOWN SIGNAL(" << fatal_id << ")";
	return oss.str();
	}
	}


	// Triggered by g3log::LogWorker after receiving a FATAL trigger
	// which is LOG(FATAL), CHECK(false) or a fatal signal our signalhandler caught.
	// --- If LOG(FATAL) or CHECK(false) the signal_number will be SIGABRT
	void exitWithDefaultSignalHandler(const LEVELS &level, g3::SignalType fatal_signal_id) {

	ReverseToOriginalFatalHandling();
	// For windows exceptions we want to continue the possibility of
	// exception handling now when the log and stacktrace are flushed
	// to sinks. We therefore avoid to kill the preocess here. Instead
	// it will be the exceptionHandling functions above that
	// will let exception handling continue with: EXCEPTION_CONTINUE_SEARCH
	if (g3::internal::FATAL_EXCEPTION == level) {
	gBlockForFatal = false;
	return;
	}

	// for a sigal however, we exit through that fatal signal
	const int signal_number = static_cast<int>(fatal_signal_id);
	raise(signal_number);
	}



	void installSignalHandler() {
	g3::installSignalHandlerForThread();
	}


	} // end g3::internal


	/// SIGFPE, SIGILL, and SIGSEGV handling must be installed per thread
	/// on Windows. This is automatically done if you do at least one LOG(...) call
	/// you can also use this function call, per thread so make sure these three
	/// fatal signals are covered in your thread (even if you don't do a LOG(...) call
	void installSignalHandlerForThread() {
	#if !(defined(DISABLE_FATAL_SIGNALHANDLING))
	if (!g_installed_thread_signal_handler) {
	g_installed_thread_signal_handler = true;
	if (SIG_ERR == signal(SIGTERM, signalHandler))
	perror("signal - SIGTERM");
	if (SIG_ERR == signal(SIGABRT, signalHandler))
	perror("signal - SIGABRT");
	if (SIG_ERR == signal(SIGFPE, signalHandler))
	perror("signal - SIGFPE");
	if (SIG_ERR == signal(SIGSEGV, signalHandler))
	perror("signal - SIGSEGV");
	if (SIG_ERR == signal(SIGILL, signalHandler))
	perror("signal - SIGILL");
	}
	#endif
	}

	void installCrashHandler() {
	internal::installSignalHandler();
	g_previous_unexpected_exception_handler = SetUnhandledExceptionFilter(unexpectedExceptionHandling);

	#if !(defined(DISABLE_VECTORED_EXCEPTIONHANDLING))
	// const size_t kFirstExceptionHandler = 1;
	// kFirstExeptionsHandler is kept here for documentational purposes.
	// The last exception seems more what we want
	const size_t kLastExceptionHandler = 0;
	g_vector_exception_handler = AddVectoredExceptionHandler(kLastExceptionHandler, vectorExceptionHandling);
	#endif
	}

	} // end namespace g3