Chiebot-Mirror
/
grpc
mirror of https://github.com/grpc/grpc.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Enable Abseil crash handler on Windows

Browse Source
pull/24303/head
Esun Kim 4 years ago
parent ce4870d159
commit 4563ff9780
1 changed files with 0 additions and 227 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 227
      test/core/util/test_config.cc

227
test/core/util/test_config.cc
Unescape View File

@ -52,226 +52,6 @@ static unsigned seed(void) { return static_cast<unsigned>(getpid()); }
static unsigned seed(void) { return (unsigned)_getpid(); }
#endif
#if GPR_WINDOWS_CRASH_HANDLER
#include <windows.h>
#include <tchar.h>
// disable warning 4091 - dbghelp.h is broken for msvc2015
#pragma warning(disable : 4091)
#define DBGHELP_TRANSLATE_TCHAR
#include <dbghelp.h>
#ifdef _MSC_VER
#pragma comment(lib, "dbghelp.lib")
#endif
static void print_stack_from_context(HANDLE thread, CONTEXT c) {
STACKFRAME s; // in/out stackframe
memset(&s, 0, sizeof(s));
DWORD imageType;
#ifdef _M_IX86
// normally, call ImageNtHeader() and use machine info from PE header
imageType = IMAGE_FILE_MACHINE_I386;
s.AddrPC.Offset = c.Eip;
s.AddrPC.Mode = AddrModeFlat;
s.AddrFrame.Offset = c.Ebp;
s.AddrFrame.Mode = AddrModeFlat;
s.AddrStack.Offset = c.Esp;
s.AddrStack.Mode = AddrModeFlat;
#elif _M_X64
imageType = IMAGE_FILE_MACHINE_AMD64;
s.AddrPC.Offset = c.Rip;
s.AddrPC.Mode = AddrModeFlat;
s.AddrFrame.Offset = c.Rbp;
s.AddrFrame.Mode = AddrModeFlat;
s.AddrStack.Offset = c.Rsp;
s.AddrStack.Mode = AddrModeFlat;
#elif _M_IA64
imageType = IMAGE_FILE_MACHINE_IA64;
s.AddrPC.Offset = c.StIIP;
s.AddrPC.Mode = AddrModeFlat;
s.AddrFrame.Offset = c.IntSp;
s.AddrFrame.Mode = AddrModeFlat;
s.AddrBStore.Offset = c.RsBSP;
s.AddrBStore.Mode = AddrModeFlat;
s.AddrStack.Offset = c.IntSp;
s.AddrStack.Mode = AddrModeFlat;
#else
#error "Platform not supported!"
#endif
HANDLE process = GetCurrentProcess();
SYMBOL_INFOW* symbol =
(SYMBOL_INFOW*)calloc(sizeof(SYMBOL_INFOW) + 256 * sizeof(wchar_t), 1);
symbol->MaxNameLen = 255;
symbol->SizeOfStruct = sizeof(SYMBOL_INFOW);
const unsigned short MAX_CALLERS_SHOWN =
8192; // avoid flooding the stderr if stacktrace is way too long
for (int frame = 0; frame < MAX_CALLERS_SHOWN &&
StackWalk(imageType, process, thread, &s, &c, 0,
SymFunctionTableAccess, SymGetModuleBase, 0);
frame++) {
PWSTR symbol_name = L"<<no symbol>>";
DWORD64 symbol_address = 0;
if (SymFromAddrW(process, (DWORD64)(s.AddrPC.Offset), 0, symbol)) {
symbol_name = symbol->Name;
symbol_address = (DWORD64)symbol->Address;
}
PWSTR file_name = L"<<no line info>>";
int line_number = 0;
IMAGEHLP_LINE64 line;
line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
DWORD displacement = 0;
if (SymGetLineFromAddrW64(process, (DWORD64)(s.AddrPC.Offset),
&displacement, &line)) {
file_name = line.FileName;
line_number = (int)line.LineNumber;
}
fwprintf(stderr, L"*** %d: %016I64X %ls - %016I64X (%ls:%d)\n", frame,
(DWORD64)(s.AddrPC.Offset), symbol_name, symbol_address, file_name,
line_number);
fflush(stderr);
}
free(symbol);
}
static void print_current_stack() {
CONTEXT context;
RtlCaptureContext(&context);
print_stack_from_context(GetCurrentThread(), context);
}
static LONG crash_handler(struct _EXCEPTION_POINTERS* ex_info) {
fprintf(stderr, "Exception handler called, dumping information\n");
bool try_to_print_stack = true;
PEXCEPTION_RECORD exrec = ex_info->ExceptionRecord;
while (exrec) {
DWORD code = exrec->ExceptionCode;
DWORD flgs = exrec->ExceptionFlags;
PVOID addr = exrec->ExceptionAddress;
if (code == EXCEPTION_STACK_OVERFLOW) try_to_print_stack = false;
fprintf(stderr, "code: %x - flags: %d - address: %p\n", code, flgs, addr);
exrec = exrec->ExceptionRecord;
}
if (try_to_print_stack) {
print_stack_from_context(GetCurrentThread(), *ex_info->ContextRecord);
}
if (IsDebuggerPresent()) {
__debugbreak();
} else {
_exit(1);
}
return EXCEPTION_EXECUTE_HANDLER;
}
static void abort_handler(int sig) {
fprintf(stderr, "Abort handler called.\n");
print_current_stack();
if (IsDebuggerPresent()) {
__debugbreak();
} else {
_exit(1);
}
}
static void install_crash_handler() {
if (!SymInitialize(GetCurrentProcess(), NULL, TRUE)) {
fprintf(stderr, "SymInitialize failed: %d\n", GetLastError());
}
SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)crash_handler);
_set_abort_behavior(0, _WRITE_ABORT_MSG);
_set_abort_behavior(0, _CALL_REPORTFAULT);
signal(SIGABRT, abort_handler);
}
#elif GPR_POSIX_CRASH_HANDLER
#include <errno.h>
#include <execinfo.h>
#include <stdio.h>
#include <string.h>
#define SIGNAL_NAMES_LENGTH 32
static const char* const signal_names[] = {
nullptr, "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL", "SIGTRAP",
"SIGABRT", "SIGBUS", "SIGFPE", "SIGKILL", "SIGUSR1", "SIGSEGV",
"SIGUSR2", "SIGPIPE", "SIGALRM", "SIGTERM", "SIGSTKFLT", "SIGCHLD",
"SIGCONT", "SIGSTOP", "SIGTSTP", "SIGTTIN", "SIGTTOU", "SIGURG",
"SIGXCPU", "SIGXFSZ", "SIGVTALRM", "SIGPROF", "SIGWINCH", "SIGIO",
"SIGPWR", "SIGSYS"};
static char g_alt_stack[GPR_MAX(MINSIGSTKSZ, 65536)];
#define MAX_FRAMES 32
/* signal safe output */
static void output_string(const char* string) {
size_t len = strlen(string);
ssize_t r;
do {
r = write(STDERR_FILENO, string, len);
} while (r == -1 && errno == EINTR);
}
static void output_num(long num) {
char buf[GPR_LTOA_MIN_BUFSIZE];
gpr_ltoa(num, buf);
output_string(buf);
}
static void crash_handler(int signum, siginfo_t* /*info*/, void* /*data*/) {
void* addrlist[MAX_FRAMES + 1];
int addrlen;
output_string("\n\n\n*******************************\nCaught signal ");
if (signum > 0 && signum < SIGNAL_NAMES_LENGTH) {
output_string(signal_names[signum]);
} else {
output_num(signum);
}
output_string("\n");
addrlen = backtrace(addrlist, GPR_ARRAY_SIZE(addrlist));
if (addrlen == 0) {
output_string(" no backtrace\n");
} else {
backtrace_symbols_fd(addrlist, addrlen, STDERR_FILENO);
}
/* try to get a core dump for SIGTERM */
if (signum == SIGTERM) signum = SIGQUIT;
raise(signum);
}
static void install_crash_handler() {
stack_t ss;
struct sigaction sa;
memset(&ss, 0, sizeof(ss));
memset(&sa, 0, sizeof(sa));
ss.ss_size = sizeof(g_alt_stack);
ss.ss_sp = g_alt_stack;
GPR_ASSERT(sigaltstack(&ss, nullptr) == 0);
sa.sa_flags = static_cast<int>(SA_SIGINFO | SA_ONSTACK | SA_RESETHAND);
sa.sa_sigaction = crash_handler;
GPR_ASSERT(sigaction(SIGILL, &sa, nullptr) == 0);
GPR_ASSERT(sigaction(SIGABRT, &sa, nullptr) == 0);
GPR_ASSERT(sigaction(SIGBUS, &sa, nullptr) == 0);
GPR_ASSERT(sigaction(SIGSEGV, &sa, nullptr) == 0);
GPR_ASSERT(sigaction(SIGTERM, &sa, nullptr) == 0);
GPR_ASSERT(sigaction(SIGQUIT, &sa, nullptr) == 0);
}
#else
static void install_crash_handler() {}
#endif
bool BuiltUnderValgrind() {
#ifdef RUNNING_ON_VALGRIND
return true;
@ -374,16 +154,9 @@ gpr_timespec grpc_timeout_milliseconds_to_deadline(int64_t time_ms) {
}
void grpc_test_init(int argc, char** argv) {
#if GPR_WINDOWS
// Windows cannot use absl::InitializeSymbolizer until it fixes mysterious
// SymInitialize failure using Bazel RBE on Windows
// https://github.com/grpc/grpc/issues/24178
install_crash_handler();
#else
grpc_core::testing::InitializeStackTracer(argv[0]);
absl::FailureSignalHandlerOptions options;
absl::InstallFailureSignalHandler(options);
#endif
gpr_log(GPR_DEBUG,
"test slowdown factor: sanitizer=%" PRId64 ", fixture=%" PRId64
", poller=%" PRId64 ", total=%" PRId64,

Write Preview
Loading…
Cancel
Save