libobs: Add win32 crash handler

A slightly refactored version of R1CH's crash handler, allows crash
handling for windows which provides stack traces of all threads and a
list of all loaded modules.  Also shows the processor, windows version,
and current libobs version.

libobs/CMakeLists.txt

@@ -41,6 +41,7 @@ include_directories(${OBS_JANSSON_INCLUDE_DIRS})
 
 if(WIN32)
 	set(libobs_PLATFORM_SOURCES
+		obs-win-crash-handler.c
 		obs-windows.c
 		util/threading-windows.c
 		util/pipe-windows.c

libobs/obs-win-crash-handler.c

@@ -0,0 +1,495 @@
+/******************************************************************************
+    Copyright (C) 2015 by Hugh Bailey <[email protected]>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+******************************************************************************/
+
+#include <windows.h>
+#include <dbghelp.h>
+#include <shellapi.h>
+#include <tlhelp32.h>
+#include <inttypes.h>
+
+#include "obs-config.h"
+#include "util/dstr.h"
+#include "util/platform.h"
+
+typedef BOOL (WINAPI *ENUMERATELOADEDMODULES64)(HANDLE process,
+		PENUMLOADED_MODULES_CALLBACK64 enum_loaded_modules_callback,
+		PVOID user_context);
+typedef DWORD (WINAPI *SYMSETOPTIONS)(DWORD sym_options);
+typedef BOOL (WINAPI *SYMINITIALIZE)(HANDLE process, PCTSTR user_search_path,
+		BOOL invade_process);
+typedef BOOL (WINAPI *SYMCLEANUP)(HANDLE process);
+typedef BOOL (WINAPI *STACKWALK64)(DWORD machine_type, HANDLE process,
+		HANDLE thread, LPSTACKFRAME64 stack_frame,
+		PVOID context_record,
+		PREAD_PROCESS_MEMORY_ROUTINE64 read_memory_routine,
+		PFUNCTION_TABLE_ACCESS_ROUTINE64 function_table_access_routine,
+		PGET_MODULE_BASE_ROUTINE64 get_module_base_routine,
+		PTRANSLATE_ADDRESS_ROUTINE64 translate_address);
+
+typedef PVOID (WINAPI *SYMFUNCTIONTABLEACCESS64)(HANDLE process,
+		DWORD64 addr_base);
+typedef DWORD64 (WINAPI *SYMGETMODULEBASE64)(HANDLE process, DWORD64 addr);
+typedef BOOL (WINAPI *SYMFROMADDR)(HANDLE process, DWORD64 address,
+		PDWORD64 displacement, PSYMBOL_INFOW symbol);
+typedef BOOL (WINAPI *SYMGETMODULEINFO64)(HANDLE process, DWORD64 addr,
+		PIMAGEHLP_MODULE64 module_info);
+
+typedef DWORD64 (WINAPI *SYMLOADMODULE64)(HANDLE process, HANDLE file,
+		PSTR image_name, PSTR module_name, DWORD64 base_of_dll,
+		DWORD size_of_dll);
+
+typedef BOOL (WINAPI *MINIDUMPWRITEDUMP)(HANDLE process, DWORD process_id,
+		HANDLE file, MINIDUMP_TYPE dump_type,
+		PMINIDUMP_EXCEPTION_INFORMATION exception_param,
+		PMINIDUMP_USER_STREAM_INFORMATION user_stream_param,
+		PMINIDUMP_CALLBACK_INFORMATION callback_param);
+
+typedef HINSTANCE (WINAPI *SHELLEXECUTEA)(HWND hwnd, LPCTSTR operation,
+		LPCTSTR file, LPCTSTR parameters, LPCTSTR directory,
+		INT show_flags);
+
+struct stack_trace {
+	CONTEXT                               context;
+	DWORD64                               instruction_ptr;
+	STACKFRAME64                          frame;
+	DWORD                                 image_type;
+};
+
+struct exception_handler_data {
+	SYMINITIALIZE                         sym_initialize;
+	SYMCLEANUP                            sym_cleanup;
+	SYMSETOPTIONS                         sym_set_options;
+	SYMFUNCTIONTABLEACCESS64              sym_function_table_access64;
+	SYMGETMODULEBASE64                    sym_get_module_base64;
+	SYMFROMADDR                           sym_from_addr;
+	SYMGETMODULEINFO64                    sym_get_module_info64;
+	STACKWALK64                           stack_walk64;
+	ENUMERATELOADEDMODULES64              enumerate_loaded_modules64;
+	MINIDUMPWRITEDUMP                     minidump_write_dump;
+
+	HMODULE                               dbghelp;
+	SYMBOL_INFOW                          *sym_info;
+	PEXCEPTION_POINTERS                   exception;
+	OSVERSIONINFOEX                       osvi;
+	SYSTEMTIME                            time_info;
+	HANDLE                                process;
+
+	struct stack_trace                    main_trace;
+
+	struct dstr                           str;
+	struct dstr                           cpu_info;
+	struct dstr                           module_name;
+	struct dstr                           module_list;
+};
+
+static inline void exception_handler_data_free(
+		struct exception_handler_data *data)
+{
+	LocalFree(data->sym_info);
+	dstr_free(&data->str);
+	dstr_free(&data->cpu_info);
+	dstr_free(&data->module_name);
+	dstr_free(&data->module_list);
+	FreeLibrary(data->dbghelp);
+}
+
+static inline void *get_proc(HMODULE module, const char *func)
+{
+	return (void*)GetProcAddress(module, func);
+}
+
+#define GET_DBGHELP_IMPORT(target, str) \
+	do { \
+		data->target = get_proc(data->dbghelp, str); \
+		if (!data->target) \
+			return false; \
+	} while (false)
+
+static inline bool get_dbghelp_imports(struct exception_handler_data *data)
+{
+	data->dbghelp = LoadLibraryW(L"DbgHelp");
+	if (!data->dbghelp)
+		return false;
+
+	GET_DBGHELP_IMPORT(sym_initialize, "SymInitialize");
+	GET_DBGHELP_IMPORT(sym_cleanup, "SymCleanup");
+	GET_DBGHELP_IMPORT(sym_set_options, "SymSetOptions");
+	GET_DBGHELP_IMPORT(sym_function_table_access64,
+			"SymFunctionTableAccess64");
+	GET_DBGHELP_IMPORT(sym_get_module_base64, "SymGetModuleBase64");
+	GET_DBGHELP_IMPORT(sym_from_addr, "SymFromAddrW");
+	GET_DBGHELP_IMPORT(sym_get_module_info64, "SymGetModuleInfo64");
+	GET_DBGHELP_IMPORT(stack_walk64, "StackWalk64");
+	GET_DBGHELP_IMPORT(enumerate_loaded_modules64,
+			"EnumerateLoadedModulesW64");
+	GET_DBGHELP_IMPORT(minidump_write_dump, "MiniDumpWriteDump");
+
+	return true;
+}
+
+static inline void init_instruction_data(struct stack_trace *trace)
+{
+#ifdef _WIN64
+	trace->instruction_ptr = trace->context.Rip;
+	trace->frame.AddrPC.Offset = trace->instruction_ptr;
+	trace->frame.AddrFrame.Offset = trace->context.Rbp;
+	trace->frame.AddrStack.Offset = trace->context.Rsp;
+	trace->image_type = IMAGE_FILE_MACHINE_AMD64;
+#else
+	trace->instruction_ptr = trace->context.Eip;
+	trace->frame.AddrPC.Offset = trace->instruction_ptr;
+	trace->frame.AddrFrame.Offset = trace->context.Ebp;
+	trace->frame.AddrStack.Offset = trace->context.Esp;
+	trace->image_type = IMAGE_FILE_MACHINE_I386;
+#endif
+
+	trace->frame.AddrFrame.Mode = AddrModeFlat;
+	trace->frame.AddrPC.Mode = AddrModeFlat;
+	trace->frame.AddrStack.Mode = AddrModeFlat;
+}
+
+static inline void init_sym_info(struct exception_handler_data *data)
+{
+	data->sym_set_options(
+			SYMOPT_UNDNAME |
+			SYMOPT_FAIL_CRITICAL_ERRORS |
+			SYMOPT_LOAD_ANYTHING);
+
+	data->sym_initialize(data->process, NULL, true);
+
+	data->sym_info = LocalAlloc(LPTR, sizeof(*data->sym_info) + 256);
+	data->sym_info->SizeOfStruct = sizeof(SYMBOL_INFO);
+	data->sym_info->MaxNameLen = 256;
+}
+
+static inline void init_version_info(struct exception_handler_data *data)
+{
+	data->osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
+
+	if (!GetVersionEx((OSVERSIONINFO*)&data->osvi)) {
+		data->osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+		GetVersionEx((OSVERSIONINFO*)&data->osvi);
+	}
+}
+
+#define PROCESSOR_REG_KEY L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0"
+#define CPU_ERROR "<unable to query>"
+
+static inline void init_cpu_info(struct exception_handler_data *data)
+{
+	HKEY key;
+	LSTATUS status;
+
+	status = RegOpenKeyW(HKEY_LOCAL_MACHINE, PROCESSOR_REG_KEY, &key);
+	if (status == ERROR_SUCCESS) {
+		wchar_t str[1024];
+		DWORD size = 1024;
+
+		status = RegQueryValueExW(key, L"ProcessorNameString", NULL,
+				NULL, (LPBYTE)str, &size);
+		if (status == ERROR_SUCCESS)
+			dstr_from_wcs(&data->cpu_info, str);
+		else
+			dstr_copy(&data->cpu_info, CPU_ERROR);
+	} else {
+		dstr_copy(&data->cpu_info, CPU_ERROR);
+	}
+}
+
+static BOOL CALLBACK enum_all_modules(PCTSTR module_name, DWORD64 module_base,
+		ULONG module_size, struct exception_handler_data *data)
+{
+	char name_utf8[MAX_PATH];
+	os_wcs_to_utf8(module_name, 0, name_utf8, MAX_PATH);
+
+	if (data->main_trace.instruction_ptr >= module_base &&
+	    data->main_trace.instruction_ptr <  module_base + module_size) {
+
+		dstr_copy(&data->module_name, name_utf8);
+		strlwr(data->module_name.array);
+	}
+
+#ifdef _WIN64
+	dstr_catf(&data->module_list, "%016"PRIX64"-%016"PRIX64" %s\n",
+			module_base, module_base + module_size,
+			name_utf8);
+#else
+	dstr_catf(&data->module_list, "%08"PRIX64"-%08"PRIX64" %s\n",
+			module_base, module_base + module_size,
+			name_utf8);
+#endif
+	return true;
+}
+
+static inline void init_module_info(struct exception_handler_data *data)
+{
+	data->enumerate_loaded_modules64(data->process,
+			(PENUMLOADED_MODULES_CALLBACK64)enum_all_modules,
+			data);
+}
+
+static inline void write_header(struct exception_handler_data *data)
+{
+	dstr_catf(&data->str, "Unhandled exception: %x\n"
+			"Fault address: %"PRIX64" (%s)\n"
+			"libobs version: "OBS_VERSION"\n"
+			"Windows version: %d.%d (build %d) %s\n"
+			"CPU: %s\n\n",
+			data->exception->ExceptionRecord->ExceptionCode,
+			data->main_trace.instruction_ptr,
+			data->module_name.array,
+			data->osvi.dwMajorVersion, data->osvi.dwMinorVersion,
+			data->osvi.dwBuildNumber, data->osvi.szCSDVersion,
+			data->cpu_info.array);
+}
+
+struct module_info {
+	DWORD64 addr;
+	char name_utf8[MAX_PATH];
+};
+
+static BOOL CALLBACK enum_module(PCTSTR module_name, DWORD64 module_base,
+		ULONG module_size, struct module_info *info)
+{
+	if (info->addr >= module_base &&
+	    info->addr <  module_base + module_size) {
+
+		os_wcs_to_utf8(module_name, 0, info->name_utf8, MAX_PATH);
+		strlwr(info->name_utf8);
+		return false;
+	}
+
+	return true;
+}
+
+static inline void get_module_name(struct exception_handler_data *data,
+		struct module_info *info)
+{
+	data->enumerate_loaded_modules64(data->process,
+			(PENUMLOADED_MODULES_CALLBACK64)enum_module, info);
+}
+
+static inline bool walk_stack(struct exception_handler_data *data,
+		HANDLE thread, struct stack_trace *trace)
+{
+	struct module_info module_info = {0};
+	DWORD64 func_offset;
+	char sym_name[256];
+	char *p;
+
+	bool success = data->stack_walk64(trace->image_type,
+			data->process, thread, &trace->frame, &trace->context,
+			NULL, data->sym_function_table_access64,
+			data->sym_get_module_base64, NULL);
+
+	int last_error = GetLastError();
+
+	if (!success)
+		return false;
+
+	module_info.addr = trace->frame.AddrPC.Offset;
+	get_module_name(data, &module_info);
+
+	if (!!module_info.name_utf8[0]) {
+		p = strrchr(module_info.name_utf8, '\\');
+		p = p ? (p + 1) : module_info.name_utf8;
+	} else {
+		strcpy(module_info.name_utf8, "<unknown>");
+		p = module_info.name_utf8;
+	}
+
+	success = !!data->sym_from_addr(data->process,
+			trace->frame.AddrPC.Offset, &func_offset,
+			data->sym_info);
+
+	if (success)
+		os_wcs_to_utf8(data->sym_info->Name, 0, sym_name, 256);
+
+#ifdef _WIN64
+#define SUCCESS_FORMAT \
+	"%016I64X %016I64X %016I64X %016I64X " \
+	"%016I64X %016I64X %s!%s+0x%I64x\n"
+#define FAIL_FORMAT \
+	"%016I64X %016I64X %016I64X %016I64X " \
+	"%016I64X %016I64X %s!0x%I64x\n"
+#else
+#define SUCCESS_FORMAT \
+	"%08.8I64X %08.8I64X %08.8I64X %08.8I64X " \
+	"%08.8I64X %08.8I64X %s!%s+0x%I64x\n"
+#define FAIL_FORMAT \
+	"%08.8I64X %08.8I64X %08.8I64X %08.8I64X " \
+	"%08.8I64X %08.8I64X %s!0x%I64x\n"
+
+	trace->frame.AddrStack.Offset &= 0xFFFFFFFFF;
+	trace->frame.AddrPC.Offset &= 0xFFFFFFFFF;
+	trace->frame.Params[0] &= 0xFFFFFFFF;
+	trace->frame.Params[1] &= 0xFFFFFFFF;
+	trace->frame.Params[2] &= 0xFFFFFFFF;
+	trace->frame.Params[3] &= 0xFFFFFFFF;
+#endif
+
+	if (success && (data->sym_info->Flags & SYMFLAG_EXPORT) == 0) {
+		dstr_catf(&data->str, SUCCESS_FORMAT,
+				trace->frame.AddrStack.Offset,
+				trace->frame.AddrPC.Offset,
+				trace->frame.Params[0],
+				trace->frame.Params[1],
+				trace->frame.Params[2],
+				trace->frame.Params[3],
+				p, sym_name, func_offset);
+	} else {
+		dstr_catf(&data->str, FAIL_FORMAT,
+				trace->frame.AddrStack.Offset,
+				trace->frame.AddrPC.Offset,
+				trace->frame.Params[0],
+				trace->frame.Params[1],
+				trace->frame.Params[2],
+				trace->frame.Params[3],
+				p, trace->frame.AddrPC.Offset);
+	}
+
+	return true;
+}
+
+#ifdef _WIN64
+#define TRACE_TOP \
+	"Stack            EIP              Arg0             " \
+	"Arg1             Arg2             Arg3             Address\n"
+#else
+#define TRACE_TOP \
+	"Stack    EIP      Arg0     " \
+	"Arg1     Arg2     Arg3     Address\n"
+#endif
+
+static inline void write_thread_trace(struct exception_handler_data *data,
+		THREADENTRY32 *entry)
+{
+	bool crash_thread = entry->th32ThreadID == GetCurrentThreadId();
+	struct stack_trace trace = {0};
+	struct stack_trace *ptrace;
+	HANDLE thread;
+
+	if (entry->th32OwnerProcessID != GetCurrentProcessId())
+		return;
+
+	thread = OpenThread(THREAD_ALL_ACCESS, false, entry->th32ThreadID);
+	if (!thread)
+		return;
+
+	trace.context.ContextFlags = CONTEXT_ALL;
+	GetThreadContext(thread, &trace.context);
+	init_instruction_data(&trace);
+
+	dstr_catf(&data->str, "\nThread %lX%s\n"TRACE_TOP,
+			entry->th32ThreadID,
+			crash_thread ? " (Crashed)" : "");
+
+	ptrace = crash_thread ? &data->main_trace : &trace;
+
+	while (walk_stack(data, thread, ptrace));
+
+	CloseHandle(thread);
+}
+
+static inline void write_thread_traces(struct exception_handler_data *data)
+{
+	THREADENTRY32 entry = {0};
+	HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD,
+			GetCurrentProcessId());
+	bool success;
+
+	if (snapshot == INVALID_HANDLE_VALUE)
+		return;
+
+	entry.dwSize = sizeof(entry);
+	success = !!Thread32First(snapshot, &entry);
+
+	while (success) {
+		write_thread_trace(data, &entry);
+		success = !!Thread32Next(snapshot, &entry);
+	}
+
+	CloseHandle(snapshot);
+}
+
+static inline void write_module_list(struct exception_handler_data *data)
+{
+	dstr_cat(&data->str, "\nLoaded modules:\n");
+#ifdef _WIN64
+	dstr_cat(&data->str, "Base Address                      Module\n");
+#else
+	dstr_cat(&data->str, "Base Address      Module\n");
+#endif
+	dstr_cat_dstr(&data->str, &data->module_list);
+}
+
+/* ------------------------------------------------------------------------- */
+
+static inline void handle_exception(struct exception_handler_data *data,
+		PEXCEPTION_POINTERS exception)
+{
+	if (!get_dbghelp_imports(data))
+		return;
+
+	data->exception = exception;
+	data->process = GetCurrentProcess();
+	data->main_trace.context = *exception->ContextRecord;
+	GetSystemTime(&data->time_info);
+
+	init_sym_info(data);
+	init_version_info(data);
+	init_cpu_info(data);
+	init_instruction_data(&data->main_trace);
+	init_module_info(data);
+
+	write_header(data);
+	write_thread_traces(data);
+	write_module_list(data);
+}
+
+static LONG CALLBACK exception_handler(PEXCEPTION_POINTERS exception)
+{
+	struct exception_handler_data data = {0};
+	static bool inside_handler = false;
+
+	/* don't use if a debugger is present */
+	if (IsDebuggerPresent())
+		return EXCEPTION_CONTINUE_SEARCH;
+
+	if (inside_handler)
+		return EXCEPTION_CONTINUE_SEARCH;
+
+	inside_handler = true;
+
+	handle_exception(&data, exception);
+	bcrash(data.str.array);
+	exception_handler_data_free(&data);
+
+	inside_handler = false;
+
+	return EXCEPTION_CONTINUE_SEARCH;
+}
+
+void initialize_crash_handler(void)
+{
+	static bool initialized = false;
+
+	if (!initialized) {
+		SetUnhandledExceptionFilter(exception_handler);
+		initialized = true;
+	}
+}

libobs/obs.c

@@ -587,6 +587,10 @@ static bool obs_init(const char *locale)
 	return true;
 }
 
+#ifdef _WIN32
+extern void initialize_crash_handler(void);
+#endif
+
 bool obs_startup(const char *locale)
 {
 	bool success;
@@ -596,6 +600,10 @@ bool obs_startup(const char *locale)
 		return false;
 	}
 
+#ifdef _WIN32
+	initialize_crash_handler();
+#endif
+
 	success = obs_init(locale);
 	if (!success)
 		obs_shutdown();