2 * win32_crashrpt.c : provides information after a crash
4 * ====================================================================
5 * Licensed to the Apache Software Foundation (ASF) under one
6 * or more contributor license agreements. See the NOTICE file
7 * distributed with this work for additional information
8 * regarding copyright ownership. The ASF licenses this file
9 * to you under the Apache License, Version 2.0 (the
10 * "License"); you may not use this file except in compliance
11 * with the License. You may obtain a copy of the License at
13 * http://www.apache.org/licenses/LICENSE-2.0
15 * Unless required by applicable law or agreed to in writing,
16 * software distributed under the License is distributed on an
17 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
18 * KIND, either express or implied. See the License for the
19 * specific language governing permissions and limitations
21 * ====================================================================
24 /* prevent "empty compilation unit" warning on e.g. UNIX */
25 typedef int win32_crashrpt__dummy;
28 #ifdef SVN_USE_WIN32_CRASHHANDLER
38 #include "svn_version.h"
42 #include "win32_crashrpt.h"
43 #include "win32_crashrpt_dll.h"
45 /*** Global variables ***/
46 HANDLE dbghelp_dll = INVALID_HANDLE_VALUE;
48 /* Email address where the crash reports should be sent too. */
49 #define CRASHREPORT_EMAIL "users@subversion.apache.org"
51 #define DBGHELP_DLL "dbghelp.dll"
53 #define LOGFILE_PREFIX "svn-crash-log"
56 #define FORMAT_PTR "0x%08Ix"
58 #define FORMAT_PTR "0x%016Ix"
63 /* Convert a wide-character string to the current windows locale, suitable
64 * for directly using stdio. This function will create a buffer large
65 * enough to hold the result string, the caller should free this buffer.
66 * If the string can't be converted, NULL is returned.
69 convert_wbcs_to_ansi(const wchar_t *str)
71 size_t len = wcslen(str);
72 char *utf8_str = malloc(sizeof(wchar_t) * len + 1);
73 len = wcstombs(utf8_str, str, len);
83 /* Convert the exception code to a string */
85 exception_string(int exception)
87 #define EXCEPTION(x) case EXCEPTION_##x: return (#x);
91 EXCEPTION(ACCESS_VIOLATION)
92 EXCEPTION(DATATYPE_MISALIGNMENT)
94 EXCEPTION(SINGLE_STEP)
95 EXCEPTION(ARRAY_BOUNDS_EXCEEDED)
96 EXCEPTION(FLT_DENORMAL_OPERAND)
97 EXCEPTION(FLT_DIVIDE_BY_ZERO)
98 EXCEPTION(FLT_INEXACT_RESULT)
99 EXCEPTION(FLT_INVALID_OPERATION)
100 EXCEPTION(FLT_OVERFLOW)
101 EXCEPTION(FLT_STACK_CHECK)
102 EXCEPTION(FLT_UNDERFLOW)
103 EXCEPTION(INT_DIVIDE_BY_ZERO)
104 EXCEPTION(INT_OVERFLOW)
105 EXCEPTION(PRIV_INSTRUCTION)
106 EXCEPTION(IN_PAGE_ERROR)
107 EXCEPTION(ILLEGAL_INSTRUCTION)
108 EXCEPTION(NONCONTINUABLE_EXCEPTION)
109 EXCEPTION(STACK_OVERFLOW)
110 EXCEPTION(INVALID_DISPOSITION)
111 EXCEPTION(GUARD_PAGE)
112 EXCEPTION(INVALID_HANDLE)
115 return "UNKNOWN_ERROR";
120 /* Write the minidump to file. The callback function will at the same time
121 write the list of modules to the log file. */
123 write_minidump_file(const char *file, PEXCEPTION_POINTERS ptrs,
124 MINIDUMP_CALLBACK_ROUTINE module_callback,
127 /* open minidump file */
128 HANDLE minidump_file = CreateFile(file, GENERIC_WRITE, 0, NULL,
130 FILE_ATTRIBUTE_NORMAL,
133 if (minidump_file != INVALID_HANDLE_VALUE)
135 MINIDUMP_EXCEPTION_INFORMATION expt_info;
136 MINIDUMP_CALLBACK_INFORMATION dump_cb_info;
138 expt_info.ThreadId = GetCurrentThreadId();
139 expt_info.ExceptionPointers = ptrs;
140 expt_info.ClientPointers = FALSE;
142 dump_cb_info.CallbackRoutine = module_callback;
143 dump_cb_info.CallbackParam = data;
145 MiniDumpWriteDump_(GetCurrentProcess(),
146 GetCurrentProcessId(),
149 ptrs ? &expt_info : NULL,
153 CloseHandle(minidump_file);
160 /* Write module information to the log file */
162 write_module_info_callback(void *data,
163 CONST PMINIDUMP_CALLBACK_INPUT callback_input,
164 PMINIDUMP_CALLBACK_OUTPUT callback_output)
167 callback_input != NULL &&
168 callback_input->CallbackType == ModuleCallback)
170 FILE *log_file = (FILE *)data;
171 MINIDUMP_MODULE_CALLBACK module = callback_input->Module;
173 char *buf = convert_wbcs_to_ansi(module.FullPath);
174 fprintf(log_file, FORMAT_PTR, (UINT_PTR)module.BaseOfImage);
175 fprintf(log_file, " %s", buf);
178 fprintf(log_file, " (%d.%d.%d.%d, %d bytes)\n",
179 HIWORD(module.VersionInfo.dwFileVersionMS),
180 LOWORD(module.VersionInfo.dwFileVersionMS),
181 HIWORD(module.VersionInfo.dwFileVersionLS),
182 LOWORD(module.VersionInfo.dwFileVersionLS),
189 /* Write details about the current process, platform and the exception */
191 write_process_info(EXCEPTION_RECORD *exception, CONTEXT *context,
195 const char *cmd_line;
196 char workingdir[8192];
198 /* write the command line */
199 cmd_line = GetCommandLine();
201 "Cmd line: %s\n", cmd_line);
203 _getcwd(workingdir, sizeof(workingdir));
205 "Working Dir: %s\n", workingdir);
207 /* write the svn version number info. */
209 "Version: %s, compiled %s, %s\n",
210 SVN_VERSION, __DATE__, __TIME__);
212 /* write information about the OS */
213 if (svn_sysinfo___fill_windows_version(&oi))
215 "Platform: Windows OS version %d.%d build %d %S\n\n",
216 oi.dwMajorVersion, oi.dwMinorVersion, oi.dwBuildNumber,
219 /* write the exception code */
222 exception_string(exception->ExceptionCode));
224 /* write the register info. */
229 "eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x\n",
230 context->Eax, context->Ebx, context->Ecx,
231 context->Edx, context->Esi, context->Edi);
233 "eip=%08x esp=%08x ebp=%08x efl=%08x\n",
234 context->Eip, context->Esp,
235 context->Ebp, context->EFlags);
237 "cs=%04x ss=%04x ds=%04x es=%04x fs=%04x gs=%04x\n",
238 context->SegCs, context->SegSs, context->SegDs,
239 context->SegEs, context->SegFs, context->SegGs);
240 #elif defined(_M_X64)
242 "Rax=%016I64x Rcx=%016I64x Rdx=%016I64x Rbx=%016I64x\n",
243 context->Rax, context->Rcx, context->Rdx, context->Rbx);
245 "Rsp=%016I64x Rbp=%016I64x Rsi=%016I64x Rdi=%016I64x\n",
246 context->Rsp, context->Rbp, context->Rsi, context->Rdi);
248 "R8= %016I64x R9= %016I64x R10=%016I64x R11=%016I64x\n",
249 context->R8, context->R9, context->R10, context->R11);
251 "R12=%016I64x R13=%016I64x R14=%016I64x R15=%016I64x\n",
252 context->R12, context->R13, context->R14, context->R15);
255 "cs=%04x ss=%04x ds=%04x es=%04x fs=%04x gs=%04x\n",
256 context->SegCs, context->SegSs, context->SegDs,
257 context->SegEs, context->SegFs, context->SegGs);
259 #error Unknown processortype, please disable SVN_USE_WIN32_CRASHHANDLER
263 /* Writes the value at address based on the specified basic type
264 * (char, int, long ...) to LOG_FILE. */
266 write_basic_type(FILE *log_file, DWORD basic_type, DWORD64 length,
272 fprintf(log_file, "0x%02x", (int)*(unsigned char *)address);
275 fprintf(log_file, "0x%04x", (int)*(unsigned short *)address);
282 if (!IsBadStringPtr(*(PSTR*)address, 32))
283 fprintf(log_file, "\"%.31s\"", *(const char **)address);
285 fprintf(log_file, FORMAT_PTR, *(DWORD_PTR *)address);
288 fprintf(log_file, "%d", *(int *)address);
290 case 8: /* btFloat */
291 fprintf(log_file, "%f", *(float *)address);
294 fprintf(log_file, FORMAT_PTR, *(DWORD_PTR *)address);
299 if (basic_type == 8) /* btFloat */
300 fprintf(log_file, "%lf", *(double *)address);
302 fprintf(log_file, "0x%016I64X", *(unsigned __int64 *)address);
305 fprintf(log_file, "[unhandled type 0x%08x of length " FORMAT_PTR "]",
306 basic_type, (UINT_PTR)length);
311 /* Writes the value at address based on the type (pointer, user defined,
312 * basic type) to LOG_FILE. */
314 write_value(FILE *log_file, DWORD64 mod_base, DWORD type, void *value_addr)
318 HANDLE proc = GetCurrentProcess();
320 while (SymGetTypeInfo_(proc, mod_base, type, TI_GET_SYMTAG, &tag))
322 /* SymTagPointerType */
326 SymGetTypeInfo_(proc, mod_base, type, TI_GET_TYPE, &type);
334 case 11: /* SymTagUDT */
336 WCHAR *type_name_wbcs;
337 if (SymGetTypeInfo_(proc, mod_base, type, TI_GET_SYMNAME,
340 char *type_name = convert_wbcs_to_ansi(type_name_wbcs);
341 LocalFree(type_name_wbcs);
344 fprintf(log_file, "(%s) " FORMAT_PTR,
345 type_name, (UINT_PTR)(DWORD_PTR *)value_addr);
347 fprintf(log_file, "(%s *) " FORMAT_PTR,
348 type_name, *(DWORD_PTR *)value_addr);
350 fprintf(log_file, "(%s **) " FORMAT_PTR,
351 type_name, *(DWORD_PTR *)value_addr);
356 fprintf(log_file, "[no symbol tag]");
359 case 16: /* SymTagBaseType */
363 SymGetTypeInfo_(proc, mod_base, type, TI_GET_LENGTH, &length);
365 /* print a char * as a string */
366 if (ptr == 1 && length == 1)
368 fprintf(log_file, FORMAT_PTR " \"%s\"",
369 *(DWORD_PTR *)value_addr, *(const char **)value_addr);
373 fprintf(log_file, FORMAT_PTR, *(DWORD_PTR *)value_addr);
375 else if (SymGetTypeInfo_(proc, mod_base, type, TI_GET_BASETYPE, &bt))
377 write_basic_type(log_file, bt, length, value_addr);
381 case 12: /* SymTagEnum */
382 fprintf(log_file, "%d", *(DWORD_PTR *)value_addr);
384 case 13: /* SymTagFunctionType */
385 fprintf(log_file, FORMAT_PTR, *(DWORD_PTR *)value_addr);
388 fprintf(log_file, "[unhandled tag: %d]", tag);
393 /* Internal structure used to pass some data to the enumerate symbols
395 typedef struct symbols_baton_t {
396 STACKFRAME64 *stack_frame;
402 /* Write the details of one parameter or local variable to the log file */
404 write_var_values(PSYMBOL_INFO sym_info, ULONG sym_size, void *baton)
406 static int last_nr_of_frame = 0;
407 DWORD_PTR var_data = 0; /* Will point to the variable's data in memory */
408 STACKFRAME64 *stack_frame = ((symbols_baton_t*)baton)->stack_frame;
409 FILE *log_file = ((symbols_baton_t*)baton)->log_file;
410 int nr_of_frame = ((symbols_baton_t*)baton)->nr_of_frame;
411 BOOL log_params = ((symbols_baton_t*)baton)->log_params;
413 /* get the variable's data */
414 if (sym_info->Flags & SYMFLAG_REGREL)
416 var_data = (DWORD_PTR)stack_frame->AddrFrame.Offset;
417 var_data += (DWORD_PTR)sym_info->Address;
422 if (log_params && sym_info->Flags & SYMFLAG_PARAMETER)
424 if (last_nr_of_frame == nr_of_frame)
425 fprintf(log_file, ", ");
427 last_nr_of_frame = nr_of_frame;
429 fprintf(log_file, "%.*s=", (int)sym_info->NameLen, sym_info->Name);
430 write_value(log_file, sym_info->ModBase, sym_info->TypeIndex,
433 if (!log_params && sym_info->Flags & SYMFLAG_LOCAL)
435 fprintf(log_file, " %.*s = ", (int)sym_info->NameLen,
437 write_value(log_file, sym_info->ModBase, sym_info->TypeIndex,
439 fprintf(log_file, "\n");
445 /* Write the details of one function to the log file */
447 write_function_detail(STACKFRAME64 stack_frame, int nr_of_frame, FILE *log_file)
449 ULONG64 symbolBuffer[(sizeof(SYMBOL_INFO) +
451 sizeof(ULONG64) - 1) /
453 PSYMBOL_INFO pIHS = (PSYMBOL_INFO)symbolBuffer;
456 IMAGEHLP_STACK_FRAME ih_stack_frame;
457 IMAGEHLP_LINE64 ih_line;
460 HANDLE proc = GetCurrentProcess();
462 symbols_baton_t ensym;
464 nr_of_frame++; /* We need a 1 based index here */
466 /* log the function name */
467 pIHS->SizeOfStruct = sizeof(SYMBOL_INFO);
468 pIHS->MaxNameLen = MAX_SYM_NAME;
469 if (SymFromAddr_(proc, stack_frame.AddrPC.Offset, &func_disp, pIHS))
472 "#%d 0x%08I64x in %.*s(",
473 nr_of_frame, stack_frame.AddrPC.Offset,
474 pIHS->NameLen > 200 ? 200 : (int)pIHS->NameLen,
477 /* restrict symbol enumeration to this frame only */
478 ih_stack_frame.InstructionOffset = stack_frame.AddrPC.Offset;
479 SymSetContext_(proc, &ih_stack_frame, 0);
481 ensym.log_file = log_file;
482 ensym.stack_frame = &stack_frame;
483 ensym.nr_of_frame = nr_of_frame;
485 /* log all function parameters */
486 ensym.log_params = TRUE;
487 SymEnumSymbols_(proc, 0, 0, write_var_values, &ensym);
489 fprintf(log_file, ")");
494 "#%d 0x%08I64x in (unknown function)",
495 nr_of_frame, stack_frame.AddrPC.Offset);
498 /* find the source line for this function. */
499 ih_line.SizeOfStruct = sizeof(IMAGEHLP_LINE);
500 if (SymGetLineFromAddr64_(proc, stack_frame.AddrPC.Offset,
501 &line_disp, &ih_line) != 0)
504 " at %s:%d\n", ih_line.FileName, ih_line.LineNumber);
508 fprintf(log_file, "\n");
511 /* log all function local variables */
512 ensym.log_params = FALSE;
513 SymEnumSymbols_(proc, 0, 0, write_var_values, &ensym);
516 /* Walk over the stack and log all relevant information to the log file */
518 write_stacktrace(CONTEXT *context, FILE *log_file)
520 #if defined (_M_IX86) || defined(_M_X64) || defined(_M_IA64)
521 HANDLE proc = GetCurrentProcess();
522 STACKFRAME64 stack_frame;
527 /* The thread information - if not supplied. */
530 /* If no context is supplied, skip 1 frame */
533 ctx.ContextFlags = CONTEXT_FULL;
534 if (!GetThreadContext(GetCurrentThread(), &ctx))
545 /* Write the stack trace */
546 ZeroMemory(&stack_frame, sizeof(STACKFRAME64));
547 stack_frame.AddrPC.Mode = AddrModeFlat;
548 stack_frame.AddrStack.Mode = AddrModeFlat;
549 stack_frame.AddrFrame.Mode = AddrModeFlat;
552 machine = IMAGE_FILE_MACHINE_I386;
553 stack_frame.AddrPC.Offset = context->Eip;
554 stack_frame.AddrStack.Offset = context->Esp;
555 stack_frame.AddrFrame.Offset = context->Ebp;
556 #elif defined(_M_X64)
557 machine = IMAGE_FILE_MACHINE_AMD64;
558 stack_frame.AddrPC.Offset = context->Rip;
559 stack_frame.AddrStack.Offset = context->Rsp;
560 stack_frame.AddrFrame.Offset = context->Rbp;
561 #elif defined(_M_IA64)
562 machine = IMAGE_FILE_MACHINE_IA64;
563 stack_frame.AddrPC.Offset = context->StIIP;
564 stack_frame.AddrStack.Offset = context->SP;
565 stack_frame.AddrBStore.Mode = AddrModeFlat;
566 stack_frame.AddrBStore.Offset = context->RsBSP;
568 #error Unknown processortype, please disable SVN_USE_WIN32_CRASHHANDLER
573 if (! StackWalk64_(machine, proc, GetCurrentThread(),
574 &stack_frame, &ctx, NULL,
575 SymFunctionTableAccess64_, SymGetModuleBase64_, NULL))
582 /* Try to include symbolic information.
583 Also check that the address is not zero. Sometimes StackWalk
584 returns TRUE with a frame of zero. */
585 if (stack_frame.AddrPC.Offset != 0)
587 write_function_detail(stack_frame, i, log_file);
593 #error Unknown processortype, please disable SVN_USE_WIN32_CRASHHANDLER
597 /* Check if a debugger is attached to this process */
599 is_debugger_present()
601 HANDLE kernel32_dll = LoadLibrary("kernel32.dll");
604 ISDEBUGGERPRESENT IsDebuggerPresent_ =
605 (ISDEBUGGERPRESENT)GetProcAddress(kernel32_dll, "IsDebuggerPresent");
607 if (IsDebuggerPresent_ && IsDebuggerPresent_())
612 FreeLibrary(kernel32_dll);
617 /* Load the dbghelp.dll file, try to find a version that matches our
622 dbghelp_dll = LoadLibrary(DBGHELP_DLL);
623 if (dbghelp_dll != INVALID_HANDLE_VALUE)
627 /* load the functions */
629 (MINIDUMPWRITEDUMP)GetProcAddress(dbghelp_dll, "MiniDumpWriteDump");
631 (SYMINITIALIZE)GetProcAddress(dbghelp_dll, "SymInitialize");
633 (SYMSETOPTIONS)GetProcAddress(dbghelp_dll, "SymSetOptions");
635 (SYMGETOPTIONS)GetProcAddress(dbghelp_dll, "SymGetOptions");
637 (SYMCLEANUP)GetProcAddress(dbghelp_dll, "SymCleanup");
639 (SYMGETTYPEINFO)GetProcAddress(dbghelp_dll, "SymGetTypeInfo");
640 SymGetLineFromAddr64_ =
641 (SYMGETLINEFROMADDR64)GetProcAddress(dbghelp_dll,
642 "SymGetLineFromAddr64");
644 (SYMENUMSYMBOLS)GetProcAddress(dbghelp_dll, "SymEnumSymbols");
646 (SYMSETCONTEXT)GetProcAddress(dbghelp_dll, "SymSetContext");
647 SymFromAddr_ = (SYMFROMADDR)GetProcAddress(dbghelp_dll, "SymFromAddr");
648 StackWalk64_ = (STACKWALK64)GetProcAddress(dbghelp_dll, "StackWalk64");
649 SymFunctionTableAccess64_ =
650 (SYMFUNCTIONTABLEACCESS64)GetProcAddress(dbghelp_dll,
651 "SymFunctionTableAccess64");
652 SymGetModuleBase64_ =
653 (SYMGETMODULEBASE64)GetProcAddress(dbghelp_dll, "SymGetModuleBase64");
655 if (! (MiniDumpWriteDump_ &&
656 SymInitialize_ && SymSetOptions_ && SymGetOptions_ &&
657 SymCleanup_ && SymGetTypeInfo_ && SymGetLineFromAddr64_ &&
658 SymEnumSymbols_ && SymSetContext_ && SymFromAddr_ &&
659 SymGetModuleBase64_ && StackWalk64_ &&
660 SymFunctionTableAccess64_))
663 /* initialize the symbol loading code */
664 opts = SymGetOptions_();
666 /* Set the 'load lines' option to retrieve line number information;
667 set the Deferred Loads option to map the debug info in memory only
669 SymSetOptions_(opts | SYMOPT_LOAD_LINES | SYMOPT_DEFERRED_LOADS);
671 /* Initialize the debughlp DLL with the default path and automatic
672 module enumeration (and loading of symbol tables) for this process.
674 SymInitialize_(GetCurrentProcess(), NULL, TRUE);
681 FreeLibrary(dbghelp_dll);
686 /* Cleanup the dbghelp.dll library */
690 SymCleanup_(GetCurrentProcess());
692 FreeLibrary(dbghelp_dll);
695 /* Create a filename based on a prefix, the timestamp and an extension.
696 check if the filename was already taken, retry 3 times. */
698 get_temp_filename(char *filename, const char *prefix, const char *ext)
700 char temp_dir[MAX_PATH - 64];
703 if (! GetTempPath(MAX_PATH - 64, temp_dir))
706 for (i = 0;i < 3;i++)
713 strftime(time_str, 64, "%Y%m%d%H%M%S", localtime(&now));
714 sprintf(filename, "%s%s%s.%s", temp_dir, prefix, time_str, ext);
716 file = CreateFile(filename, GENERIC_WRITE, 0, NULL, CREATE_NEW,
717 FILE_ATTRIBUTE_NORMAL, NULL);
718 if (file != INVALID_HANDLE_VALUE)
729 /* Unhandled exception callback set with SetUnhandledExceptionFilter() */
731 svn__unhandled_exception_filter(PEXCEPTION_POINTERS ptrs)
733 char dmp_filename[MAX_PATH];
734 char log_filename[MAX_PATH];
737 /* Check if the crash handler was already loaded (crash while handling the
739 if (dbghelp_dll != INVALID_HANDLE_VALUE)
740 return EXCEPTION_CONTINUE_SEARCH;
742 /* don't log anything if we're running inside a debugger ... */
743 if (is_debugger_present())
744 return EXCEPTION_CONTINUE_SEARCH;
746 /* ... or if we can't create the log files ... */
747 if (!get_temp_filename(dmp_filename, LOGFILE_PREFIX, "dmp") ||
748 !get_temp_filename(log_filename, LOGFILE_PREFIX, "log"))
749 return EXCEPTION_CONTINUE_SEARCH;
751 /* If we can't load a recent version of the dbghelp.dll, pass on this
753 if (!load_dbghelp_dll())
754 return EXCEPTION_CONTINUE_SEARCH;
757 log_file = fopen(log_filename, "w+");
759 /* write information about the process */
760 fprintf(log_file, "\nProcess info:\n");
761 write_process_info(ptrs ? ptrs->ExceptionRecord : NULL,
762 ptrs ? ptrs->ContextRecord : NULL,
765 /* write the stacktrace, if available */
766 fprintf(log_file, "\nStacktrace:\n");
767 write_stacktrace(ptrs ? ptrs->ContextRecord : NULL, log_file);
769 /* write the minidump file and use the callback to write the list of modules
771 fprintf(log_file, "\n\nLoaded modules:\n");
772 write_minidump_file(dmp_filename, ptrs,
773 write_module_info_callback, (void *)log_file);
777 /* inform the user */
778 fprintf(stderr, "This application has halted due to an unexpected error.\n"
779 "A crash report and minidump file were saved to disk, you"
780 " can find them here:\n"
782 "Please send the log file to %s to help us analyze\nand "
783 "solve this problem.\n\n"
784 "NOTE: The crash report and minidump files can contain some"
785 " sensitive information\n(filenames, partial file content, "
786 "usernames and passwords etc.)\n",
791 if (getenv("SVN_DBG_STACKTRACES_TO_STDERR") != NULL)
793 fprintf(stderr, "\nProcess info:\n");
794 write_process_info(ptrs ? ptrs->ExceptionRecord : NULL,
795 ptrs ? ptrs->ContextRecord : NULL,
797 fprintf(stderr, "\nStacktrace:\n");
798 write_stacktrace(ptrs ? ptrs->ContextRecord : NULL, stderr);
806 /* terminate the application */
807 return EXCEPTION_EXECUTE_HANDLER;
809 #endif /* SVN_USE_WIN32_CRASHHANDLER */