obs-studio/libobs/obs-win-crash-handler.c

/******************************************************************************
    Copyright (C) 2015 by Hugh Bailey <obs.jim@gmail.com>

    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);
	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;
	}
}