1 /******************************************************************************
2 Copyright (C) 2015 by Hugh Bailey <obs.jim@gmail.com>
3
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 2 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>.
16 ******************************************************************************/
17
18 #include <windows.h>
19 #include <time.h>
20 #include <dbghelp.h>
21 #include <shellapi.h>
22 #include <tlhelp32.h>
23 #include <inttypes.h>
24
25 #include "obs-config.h"
26 #include "util/dstr.h"
27 #include "util/platform.h"
28 #include "util/windows/win-version.h"
29
30 typedef BOOL(WINAPI *ENUMERATELOADEDMODULES64)(
31 HANDLE process,
32 PENUMLOADED_MODULES_CALLBACK64 enum_loaded_modules_callback,
33 PVOID user_context);
34 typedef DWORD(WINAPI *SYMSETOPTIONS)(DWORD sym_options);
35 typedef BOOL(WINAPI *SYMINITIALIZE)(HANDLE process, PCTSTR user_search_path,
36 BOOL invade_process);
37 typedef BOOL(WINAPI *SYMCLEANUP)(HANDLE process);
38 typedef BOOL(WINAPI *STACKWALK64)(
39 DWORD machine_type, HANDLE process, HANDLE thread,
40 LPSTACKFRAME64 stack_frame, PVOID context_record,
41 PREAD_PROCESS_MEMORY_ROUTINE64 read_memory_routine,
42 PFUNCTION_TABLE_ACCESS_ROUTINE64 function_table_access_routine,
43 PGET_MODULE_BASE_ROUTINE64 get_module_base_routine,
44 PTRANSLATE_ADDRESS_ROUTINE64 translate_address);
45 typedef BOOL(WINAPI *SYMREFRESHMODULELIST)(HANDLE process);
46
47 typedef PVOID(WINAPI *SYMFUNCTIONTABLEACCESS64)(HANDLE process,
48 DWORD64 addr_base);
49 typedef DWORD64(WINAPI *SYMGETMODULEBASE64)(HANDLE process, DWORD64 addr);
50 typedef BOOL(WINAPI *SYMFROMADDR)(HANDLE process, DWORD64 address,
51 PDWORD64 displacement, PSYMBOL_INFOW symbol);
52 typedef BOOL(WINAPI *SYMGETMODULEINFO64)(HANDLE process, DWORD64 addr,
53 PIMAGEHLP_MODULE64 module_info);
54
55 typedef DWORD64(WINAPI *SYMLOADMODULE64)(HANDLE process, HANDLE file,
56 PSTR image_name, PSTR module_name,
57 DWORD64 base_of_dll,
58 DWORD size_of_dll);
59
60 typedef BOOL(WINAPI *MINIDUMPWRITEDUMP)(
61 HANDLE process, DWORD process_id, HANDLE file, MINIDUMP_TYPE dump_type,
62 PMINIDUMP_EXCEPTION_INFORMATION exception_param,
63 PMINIDUMP_USER_STREAM_INFORMATION user_stream_param,
64 PMINIDUMP_CALLBACK_INFORMATION callback_param);
65
66 typedef HINSTANCE(WINAPI *SHELLEXECUTEA)(HWND hwnd, LPCTSTR operation,
67 LPCTSTR file, LPCTSTR parameters,
68 LPCTSTR directory, INT show_flags);
69
70 typedef HRESULT(WINAPI *GETTHREADDESCRIPTION)(HANDLE thread, PWSTR *desc);
71
72 struct stack_trace {
73 CONTEXT context;
74 DWORD64 instruction_ptr;
75 STACKFRAME64 frame;
76 DWORD image_type;
77 };
78
79 struct exception_handler_data {
80 SYMINITIALIZE sym_initialize;
81 SYMCLEANUP sym_cleanup;
82 SYMSETOPTIONS sym_set_options;
83 SYMFUNCTIONTABLEACCESS64 sym_function_table_access64;
84 SYMGETMODULEBASE64 sym_get_module_base64;
85 SYMFROMADDR sym_from_addr;
86 SYMGETMODULEINFO64 sym_get_module_info64;
87 SYMREFRESHMODULELIST sym_refresh_module_list;
88 STACKWALK64 stack_walk64;
89 ENUMERATELOADEDMODULES64 enumerate_loaded_modules64;
90 MINIDUMPWRITEDUMP minidump_write_dump;
91
92 HMODULE dbghelp;
93 SYMBOL_INFOW *sym_info;
94 PEXCEPTION_POINTERS exception;
95 struct win_version_info win_version;
96 SYSTEMTIME time_info;
97 HANDLE process;
98
99 struct stack_trace main_trace;
100
101 struct dstr str;
102 struct dstr cpu_info;
103 struct dstr module_name;
104 struct dstr module_list;
105 };
106
107 static inline void
exception_handler_data_free(struct exception_handler_data * data)108 exception_handler_data_free(struct exception_handler_data *data)
109 {
110 LocalFree(data->sym_info);
111 dstr_free(&data->str);
112 dstr_free(&data->cpu_info);
113 dstr_free(&data->module_name);
114 dstr_free(&data->module_list);
115 FreeLibrary(data->dbghelp);
116 }
117
get_proc(HMODULE module,const char * func)118 static inline void *get_proc(HMODULE module, const char *func)
119 {
120 return (void *)GetProcAddress(module, func);
121 }
122
123 #define GET_DBGHELP_IMPORT(target, str) \
124 do { \
125 data->target = get_proc(data->dbghelp, str); \
126 if (!data->target) \
127 return false; \
128 } while (false)
129
get_dbghelp_imports(struct exception_handler_data * data)130 static inline bool get_dbghelp_imports(struct exception_handler_data *data)
131 {
132 data->dbghelp = LoadLibraryW(L"DbgHelp");
133 if (!data->dbghelp)
134 return false;
135
136 GET_DBGHELP_IMPORT(sym_initialize, "SymInitialize");
137 GET_DBGHELP_IMPORT(sym_cleanup, "SymCleanup");
138 GET_DBGHELP_IMPORT(sym_set_options, "SymSetOptions");
139 GET_DBGHELP_IMPORT(sym_function_table_access64,
140 "SymFunctionTableAccess64");
141 GET_DBGHELP_IMPORT(sym_get_module_base64, "SymGetModuleBase64");
142 GET_DBGHELP_IMPORT(sym_from_addr, "SymFromAddrW");
143 GET_DBGHELP_IMPORT(sym_get_module_info64, "SymGetModuleInfo64");
144 GET_DBGHELP_IMPORT(sym_refresh_module_list, "SymRefreshModuleList");
145 GET_DBGHELP_IMPORT(stack_walk64, "StackWalk64");
146 GET_DBGHELP_IMPORT(enumerate_loaded_modules64,
147 "EnumerateLoadedModulesW64");
148 GET_DBGHELP_IMPORT(minidump_write_dump, "MiniDumpWriteDump");
149
150 return true;
151 }
152
init_instruction_data(struct stack_trace * trace)153 static inline void init_instruction_data(struct stack_trace *trace)
154 {
155 #ifdef _WIN64
156 trace->instruction_ptr = trace->context.Rip;
157 trace->frame.AddrPC.Offset = trace->instruction_ptr;
158 trace->frame.AddrFrame.Offset = trace->context.Rbp;
159 trace->frame.AddrStack.Offset = trace->context.Rsp;
160 trace->image_type = IMAGE_FILE_MACHINE_AMD64;
161 #else
162 trace->instruction_ptr = trace->context.Eip;
163 trace->frame.AddrPC.Offset = trace->instruction_ptr;
164 trace->frame.AddrFrame.Offset = trace->context.Ebp;
165 trace->frame.AddrStack.Offset = trace->context.Esp;
166 trace->image_type = IMAGE_FILE_MACHINE_I386;
167 #endif
168
169 trace->frame.AddrFrame.Mode = AddrModeFlat;
170 trace->frame.AddrPC.Mode = AddrModeFlat;
171 trace->frame.AddrStack.Mode = AddrModeFlat;
172 }
173
174 extern bool sym_initialize_called;
175
init_sym_info(struct exception_handler_data * data)176 static inline void init_sym_info(struct exception_handler_data *data)
177 {
178 data->sym_set_options(SYMOPT_UNDNAME | SYMOPT_FAIL_CRITICAL_ERRORS |
179 SYMOPT_LOAD_ANYTHING);
180
181 if (!sym_initialize_called)
182 data->sym_initialize(data->process, NULL, true);
183 else
184 data->sym_refresh_module_list(data->process);
185
186 data->sym_info = LocalAlloc(LPTR, sizeof(*data->sym_info) + 256);
187 data->sym_info->SizeOfStruct = sizeof(SYMBOL_INFO);
188 data->sym_info->MaxNameLen = 256;
189 }
190
init_version_info(struct exception_handler_data * data)191 static inline void init_version_info(struct exception_handler_data *data)
192 {
193 get_win_ver(&data->win_version);
194 }
195
196 #define PROCESSOR_REG_KEY L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0"
197 #define CPU_ERROR "<unable to query>"
198
init_cpu_info(struct exception_handler_data * data)199 static inline void init_cpu_info(struct exception_handler_data *data)
200 {
201 HKEY key;
202 LSTATUS status;
203
204 status = RegOpenKeyW(HKEY_LOCAL_MACHINE, PROCESSOR_REG_KEY, &key);
205 if (status == ERROR_SUCCESS) {
206 wchar_t str[1024];
207 DWORD size = 1024;
208
209 status = RegQueryValueExW(key, L"ProcessorNameString", NULL,
210 NULL, (LPBYTE)str, &size);
211 if (status == ERROR_SUCCESS)
212 dstr_from_wcs(&data->cpu_info, str);
213 else
214 dstr_copy(&data->cpu_info, CPU_ERROR);
215 } else {
216 dstr_copy(&data->cpu_info, CPU_ERROR);
217 }
218 }
219
enum_all_modules(PCTSTR module_name,DWORD64 module_base,ULONG module_size,struct exception_handler_data * data)220 static BOOL CALLBACK enum_all_modules(PCTSTR module_name, DWORD64 module_base,
221 ULONG module_size,
222 struct exception_handler_data *data)
223 {
224 char name_utf8[MAX_PATH];
225 os_wcs_to_utf8(module_name, 0, name_utf8, MAX_PATH);
226
227 if (data->main_trace.instruction_ptr >= module_base &&
228 data->main_trace.instruction_ptr < module_base + module_size) {
229
230 dstr_copy(&data->module_name, name_utf8);
231 strlwr(data->module_name.array);
232 }
233
234 #ifdef _WIN64
235 dstr_catf(&data->module_list, "%016" PRIX64 "-%016" PRIX64 " %s\r\n",
236 module_base, module_base + module_size, name_utf8);
237 #else
238 dstr_catf(&data->module_list, "%08" PRIX64 "-%08" PRIX64 " %s\r\n",
239 module_base, module_base + module_size, name_utf8);
240 #endif
241 return true;
242 }
243
init_module_info(struct exception_handler_data * data)244 static inline void init_module_info(struct exception_handler_data *data)
245 {
246 data->enumerate_loaded_modules64(
247 data->process, (PENUMLOADED_MODULES_CALLBACK64)enum_all_modules,
248 data);
249 }
250
251 extern const char *get_win_release_id();
252
write_header(struct exception_handler_data * data)253 static inline void write_header(struct exception_handler_data *data)
254 {
255 char date_time[80];
256 time_t now = time(0);
257 struct tm ts;
258 ts = *localtime(&now);
259 strftime(date_time, sizeof(date_time), "%Y-%m-%d, %X", &ts);
260
261 const char *obs_bitness;
262 if (sizeof(void *) == 8)
263 obs_bitness = "64";
264 else
265 obs_bitness = "32";
266
267 const char *release_id = get_win_release_id();
268
269 dstr_catf(&data->str,
270 "Unhandled exception: %x\r\n"
271 "Date/Time: %s\r\n"
272 "Fault address: %" PRIX64 " (%s)\r\n"
273 "libobs version: " OBS_VERSION " (%s-bit)\r\n"
274 "Windows version: %d.%d build %d (release: %s; revision: %d; "
275 "%s-bit)\r\n"
276 "CPU: %s\r\n\r\n",
277 data->exception->ExceptionRecord->ExceptionCode, date_time,
278 data->main_trace.instruction_ptr, data->module_name.array,
279 obs_bitness, data->win_version.major, data->win_version.minor,
280 data->win_version.build, release_id, data->win_version.revis,
281 is_64_bit_windows() ? "64" : "32", data->cpu_info.array);
282 }
283
284 struct module_info {
285 DWORD64 addr;
286 char name_utf8[MAX_PATH];
287 };
288
enum_module(PCTSTR module_name,DWORD64 module_base,ULONG module_size,struct module_info * info)289 static BOOL CALLBACK enum_module(PCTSTR module_name, DWORD64 module_base,
290 ULONG module_size, struct module_info *info)
291 {
292 if (info->addr >= module_base &&
293 info->addr < module_base + module_size) {
294
295 os_wcs_to_utf8(module_name, 0, info->name_utf8, MAX_PATH);
296 strlwr(info->name_utf8);
297 return false;
298 }
299
300 return true;
301 }
302
get_module_name(struct exception_handler_data * data,struct module_info * info)303 static inline void get_module_name(struct exception_handler_data *data,
304 struct module_info *info)
305 {
306 data->enumerate_loaded_modules64(
307 data->process, (PENUMLOADED_MODULES_CALLBACK64)enum_module,
308 info);
309 }
310
walk_stack(struct exception_handler_data * data,HANDLE thread,struct stack_trace * trace)311 static inline bool walk_stack(struct exception_handler_data *data,
312 HANDLE thread, struct stack_trace *trace)
313 {
314 struct module_info module_info = {0};
315 DWORD64 func_offset;
316 char sym_name[256];
317 char *p;
318
319 bool success = data->stack_walk64(trace->image_type, data->process,
320 thread, &trace->frame,
321 &trace->context, NULL,
322 data->sym_function_table_access64,
323 data->sym_get_module_base64, NULL);
324 if (!success)
325 return false;
326
327 module_info.addr = trace->frame.AddrPC.Offset;
328 get_module_name(data, &module_info);
329
330 if (!!module_info.name_utf8[0]) {
331 p = strrchr(module_info.name_utf8, '\\');
332 p = p ? (p + 1) : module_info.name_utf8;
333 } else {
334 strcpy(module_info.name_utf8, "<unknown>");
335 p = module_info.name_utf8;
336 }
337
338 success = !!data->sym_from_addr(data->process,
339 trace->frame.AddrPC.Offset,
340 &func_offset, data->sym_info);
341
342 if (success)
343 os_wcs_to_utf8(data->sym_info->Name, 0, sym_name, 256);
344
345 #ifdef _WIN64
346 #define SUCCESS_FORMAT \
347 "%016I64X %016I64X %016I64X %016I64X " \
348 "%016I64X %016I64X %s!%s+0x%I64x\r\n"
349 #define FAIL_FORMAT \
350 "%016I64X %016I64X %016I64X %016I64X " \
351 "%016I64X %016I64X %s!0x%I64x\r\n"
352 #else
353 #define SUCCESS_FORMAT \
354 "%08.8I64X %08.8I64X %08.8I64X %08.8I64X " \
355 "%08.8I64X %08.8I64X %s!%s+0x%I64x\r\n"
356 #define FAIL_FORMAT \
357 "%08.8I64X %08.8I64X %08.8I64X %08.8I64X " \
358 "%08.8I64X %08.8I64X %s!0x%I64x\r\n"
359
360 trace->frame.AddrStack.Offset &= 0xFFFFFFFFF;
361 trace->frame.AddrPC.Offset &= 0xFFFFFFFFF;
362 trace->frame.Params[0] &= 0xFFFFFFFF;
363 trace->frame.Params[1] &= 0xFFFFFFFF;
364 trace->frame.Params[2] &= 0xFFFFFFFF;
365 trace->frame.Params[3] &= 0xFFFFFFFF;
366 #endif
367
368 if (success && (data->sym_info->Flags & SYMFLAG_EXPORT) == 0) {
369 dstr_catf(&data->str, SUCCESS_FORMAT,
370 trace->frame.AddrStack.Offset,
371 trace->frame.AddrPC.Offset, trace->frame.Params[0],
372 trace->frame.Params[1], trace->frame.Params[2],
373 trace->frame.Params[3], p, sym_name, func_offset);
374 } else {
375 dstr_catf(&data->str, FAIL_FORMAT,
376 trace->frame.AddrStack.Offset,
377 trace->frame.AddrPC.Offset, trace->frame.Params[0],
378 trace->frame.Params[1], trace->frame.Params[2],
379 trace->frame.Params[3], p,
380 trace->frame.AddrPC.Offset);
381 }
382
383 return true;
384 }
385
386 #ifdef _WIN64
387 #define TRACE_TOP \
388 "Stack EIP Arg0 " \
389 "Arg1 Arg2 Arg3 Address\r\n"
390 #else
391 #define TRACE_TOP \
392 "Stack EIP Arg0 " \
393 "Arg1 Arg2 Arg3 Address\r\n"
394 #endif
395
get_thread_name(HANDLE thread)396 static inline char *get_thread_name(HANDLE thread)
397 {
398 static GETTHREADDESCRIPTION get_thread_desc = NULL;
399 static bool failed = false;
400
401 if (!get_thread_desc) {
402 if (failed) {
403 return NULL;
404 }
405
406 HMODULE k32 = LoadLibraryW(L"kernel32.dll");
407 get_thread_desc = (GETTHREADDESCRIPTION)GetProcAddress(
408 k32, "GetThreadDescription");
409 if (!get_thread_desc) {
410 failed = true;
411 return NULL;
412 }
413 }
414
415 wchar_t *w_name;
416 HRESULT hr = get_thread_desc(thread, &w_name);
417 if (FAILED(hr) || !w_name) {
418 return NULL;
419 }
420
421 struct dstr name = {0};
422 dstr_from_wcs(&name, w_name);
423 if (name.len)
424 dstr_insert_ch(&name, 0, ' ');
425 LocalFree(w_name);
426
427 return name.array;
428 }
429
write_thread_trace(struct exception_handler_data * data,THREADENTRY32 * entry,bool first_thread)430 static inline void write_thread_trace(struct exception_handler_data *data,
431 THREADENTRY32 *entry, bool first_thread)
432 {
433 bool crash_thread = entry->th32ThreadID == GetCurrentThreadId();
434 struct stack_trace trace = {0};
435 struct stack_trace *ptrace;
436 HANDLE thread;
437 char *thread_name;
438
439 if (first_thread != crash_thread)
440 return;
441
442 if (entry->th32OwnerProcessID != GetCurrentProcessId())
443 return;
444
445 thread = OpenThread(THREAD_ALL_ACCESS, false, entry->th32ThreadID);
446 if (!thread)
447 return;
448
449 trace.context.ContextFlags = CONTEXT_ALL;
450 GetThreadContext(thread, &trace.context);
451 init_instruction_data(&trace);
452
453 thread_name = get_thread_name(thread);
454
455 dstr_catf(&data->str, "\r\nThread %lX:%s%s\r\n" TRACE_TOP,
456 entry->th32ThreadID, thread_name ? thread_name : "",
457 crash_thread ? " (Crashed)" : "");
458
459 bfree(thread_name);
460
461 ptrace = crash_thread ? &data->main_trace : &trace;
462
463 while (walk_stack(data, thread, ptrace))
464 ;
465
466 CloseHandle(thread);
467 }
468
write_thread_traces(struct exception_handler_data * data)469 static inline void write_thread_traces(struct exception_handler_data *data)
470 {
471 THREADENTRY32 entry = {0};
472 HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD,
473 GetCurrentProcessId());
474 bool success;
475
476 if (snapshot == INVALID_HANDLE_VALUE)
477 return;
478
479 entry.dwSize = sizeof(entry);
480
481 success = !!Thread32First(snapshot, &entry);
482 while (success) {
483 write_thread_trace(data, &entry, true);
484 success = !!Thread32Next(snapshot, &entry);
485 }
486
487 success = !!Thread32First(snapshot, &entry);
488 while (success) {
489 write_thread_trace(data, &entry, false);
490 success = !!Thread32Next(snapshot, &entry);
491 }
492
493 CloseHandle(snapshot);
494 }
495
write_module_list(struct exception_handler_data * data)496 static inline void write_module_list(struct exception_handler_data *data)
497 {
498 dstr_cat(&data->str, "\r\nLoaded modules:\r\n");
499 #ifdef _WIN64
500 dstr_cat(&data->str, "Base Address Module\r\n");
501 #else
502 dstr_cat(&data->str, "Base Address Module\r\n");
503 #endif
504 dstr_cat_dstr(&data->str, &data->module_list);
505 }
506
507 /* ------------------------------------------------------------------------- */
508
handle_exception(struct exception_handler_data * data,PEXCEPTION_POINTERS exception)509 static inline void handle_exception(struct exception_handler_data *data,
510 PEXCEPTION_POINTERS exception)
511 {
512 if (!get_dbghelp_imports(data))
513 return;
514
515 data->exception = exception;
516 data->process = GetCurrentProcess();
517 data->main_trace.context = *exception->ContextRecord;
518 GetSystemTime(&data->time_info);
519
520 init_sym_info(data);
521 init_version_info(data);
522 init_cpu_info(data);
523 init_instruction_data(&data->main_trace);
524 init_module_info(data);
525
526 write_header(data);
527 write_thread_traces(data);
528 write_module_list(data);
529 }
530
exception_handler(PEXCEPTION_POINTERS exception)531 static LONG CALLBACK exception_handler(PEXCEPTION_POINTERS exception)
532 {
533 struct exception_handler_data data = {0};
534 static bool inside_handler = false;
535
536 /* don't use if a debugger is present */
537 if (IsDebuggerPresent())
538 return EXCEPTION_CONTINUE_SEARCH;
539
540 if (inside_handler)
541 return EXCEPTION_CONTINUE_SEARCH;
542
543 inside_handler = true;
544
545 handle_exception(&data, exception);
546 bcrash(data.str.array);
547 exception_handler_data_free(&data);
548
549 inside_handler = false;
550
551 return EXCEPTION_CONTINUE_SEARCH;
552 }
553
initialize_crash_handler(void)554 void initialize_crash_handler(void)
555 {
556 static bool initialized = false;
557
558 if (!initialized) {
559 SetUnhandledExceptionFilter(exception_handler);
560 initialized = true;
561 }
562 }
563