diff --git a/runtime/main.c b/runtime/main.c index e6ced76e..e0a82263 100644 --- a/runtime/main.c +++ b/runtime/main.c @@ -218,16 +218,21 @@ static void crash_handler(const PlatCrash *x) { if (plat_xchg32(&busy, 1)) plat_exit(71); char d[160]; uintptr_t rip = x->rip; - rt_logf("FATAL: %s (%#x) at host %p (totk+%#llx)", x->what, x->code, (void *)rip, (unsigned long long)x->offset); + rt_logf("FATAL: %s (%#x) at host %p (", x->what, x->code, (void *)rip); + if (x->module && !*x->module) rt_logf("outside every module)"); + else rt_logf("%s+%#llx)", x->module ? x->module : "totk", (unsigned long long)x->offset); if (x->access >= 0) rt_logf(", %s address %#llx", x->access == 1 ? "writing" : x->access == 8 ? "executing" : "reading", (unsigned long long)x->addr); rt_log_raw("\n", 1); - uint64_t f = lifted_function(rip); + uint64_t f = x->module ? 0 : lifted_function(rip); if (f) rt_logf(" in lifted function f_%llx = %s\n", (unsigned long long)f, ldr_describe(f, d, sizeof d)); - for (int i = 0; i < x->nframes; i++) { // abort and invalid parameter: where the host code called it + // abort and invalid parameter: where the host code called it; a fault in another module: the host calls that led + // into it + uintptr_t exe = plat_exe_base(); + for (int i = 0; i < x->nframes; i++) { uint64_t g = lifted_function(x->frames[i]); - rt_logf(" host frame %2d: totk+%#llx", i, (unsigned long long)(x->frames[i] - (rip - x->offset))); + rt_logf(" host frame %2d: totk+%#llx", i, (unsigned long long)(x->frames[i] - exe)); if (g) rt_logf(" in lifted function f_%llx", (unsigned long long)g); rt_log_raw("\n", 1); } @@ -439,11 +444,27 @@ static int selftest(void) { return failures ? 1 : 0; } +// --probe-crash-call and --probe-crash-null crash on purpose, to check the report of a fault outside this executable. +// call: strlen in the C runtime library (ucrtbase.dll, libc.so.6) reads address 8, the way a driver faults inside a +// call the host made; the report names the library and the host frames that called it. null: a call through a null +// function pointer, which leaves rip at 0, outside every module. Both end with exit code 71 and a FATAL line in the +// log. +static size_t (*volatile probe_strlen)(const char *) = strlen; +static void (*volatile probe_null)(void); + +static int probe_crash(int null) { + if (null) probe_null(); + else printf("%zu\n", probe_strlen((const char *)(uintptr_t)8)); + printf("probe-crash: still running, the crash did not happen\n"); + return 1; +} + static int usage(const char *argv0) { fprintf(stderr, "usage: %s [--exefs DIR] [--romfs DIR] [--profile DIR] [--selftest | --probe-loader | " "--probe-cfg | --probe-dpi | --probe-mods | --probe-kernel | --probe-ipc | --probe-services | --probe-fs | --probe-gfx-abi | " "--probe-nvn | --probe-nvn-tex | --probe-window | --probe-shader | --probe-vkmem | " - "--probe-vkexec | --probe-astc | --probe-movie | --prepare-shaders | --warm-shaders | --boot |--seconds S [--shot PNG]]\n", argv0); + "--probe-vkexec | --probe-astc | --probe-movie | --probe-crash-call | --probe-crash-null | " + "--prepare-shaders | --warm-shaders | --boot |--seconds S [--shot PNG]]\n", argv0); return 2; } @@ -531,6 +552,8 @@ int main(int argc, char **argv) { } if (!strcmp(mode, "--selftest")) return selftest(); if (!strcmp(mode, "--probe-loader")) return probe_loader(); + if (!strcmp(mode, "--probe-crash-call")) return probe_crash(0); + if (!strcmp(mode, "--probe-crash-null")) return probe_crash(1); if (!strcmp(mode, "--probe-cfg")) return probe_cfg(); #ifdef _WIN32 if (!strcmp(mode, "--probe-dpi")) return probe_dpi(); // the Win32 DPI awareness of totk.manifest diff --git a/runtime/platform/linux.c b/runtime/platform/linux.c index 629dc0fe..194bc9d8 100644 --- a/runtime/platform/linux.c +++ b/runtime/platform/linux.c @@ -916,8 +916,9 @@ uint64_t plat_mem_written(uint64_t addr, uint64_t n, uint64_t *pages, uint64_t m } // One handler for the synchronous faults. A SIGSEGV whose page-fault error code has the write bit set goes to the -// write-fault hook first (memory.c thaws a frozen region); a fault in this executable's code then goes to the crash -// hook (main.c); anything else gets the default action. Runs on the thread's signal stack. +// write-fault hook first (memory.c thaws a frozen region); any other fault, in this executable or in a library (Mesa, +// SDL), then goes to the crash hook (main.c), which reports it and ends the process. Without a crash hook the fault +// gets the default action. Runs on the thread's signal stack. static int (*fault_hook)(uint64_t addr); static void (*crash_fn)(const PlatCrash *c); @@ -927,10 +928,17 @@ static void fault_handler(int sig, siginfo_t *si, void *uc) { if (sig == SIGSEGV && fault_hook && (err & 2) && fault_hook((uint64_t)(uintptr_t)si->si_addr)) return; uintptr_t rip = (uintptr_t)u->uc_mcontext.gregs[REG_RIP]; Dl_info at, self; - if (crash_fn && dladdr((void *)rip, &at) && dladdr((void *)plat_crash_hook, &self) && at.dli_fbase == self.dli_fbase) { + if (crash_fn) { + int found = dladdr((void *)rip, &at) && at.dli_fname; PlatCrash c = {sig == SIGSEGV ? "access violation" : sig == SIGBUS ? "bus error" : sig == SIGILL ? "illegal instruction" : "arithmetic exception", - (uint32_t)sig, rip, rip - (uintptr_t)self.dli_fbase, -1, 0}; + (uint32_t)sig, rip, found ? rip - (uintptr_t)at.dli_fbase : rip, -1, 0}; + if (!found) { + c.module = ""; + } else if (!dladdr((void *)plat_crash_hook, &self) || at.dli_fbase != self.dli_fbase) { + const char *n = strrchr(at.dli_fname, '/'); + c.module = n ? n + 1 : at.dli_fname; + } if (sig == SIGSEGV || sig == SIGBUS) c.access = (err & 16) ? 8 : (err & 2) ? 1 : 0, c.addr = (uint64_t)(uintptr_t)si->si_addr; crash_fn(&c); diff --git a/runtime/platform/platform.h b/runtime/platform/platform.h index f5104a1f..ec7050aa 100644 --- a/runtime/platform/platform.h +++ b/runtime/platform/platform.h @@ -218,19 +218,25 @@ void plat_mem_fault_hook(int (*fn)(uint64_t addr)); // replaces this process with it (Linux). Environment changes made before the call are passed on. _Noreturn void plat_reexec(void); -// A crash in this executable's own code (an access violation, an illegal instruction, a division by zero, a stack -// overflow) goes to fn, which reports it and must end the process. Faults in other modules (drivers) are left to the -// OS. The write-fault hook above runs first. On Windows abort() (a failed assert, std::terminate) and an invalid -// parameter to a C runtime function go there too, with the host frames in this executable: the C runtime ends the -// process for both with 0xc0000409 and no exception. +// A crash goes to fn, which reports it and must end the process. The write-fault hook above runs first. +// - A fault in this executable's own code (an access violation, an illegal instruction, a division by zero, a stack +// overflow) is reported as it happens. +// - A fault in another module (a GPU driver, a system library) is reported only when nothing handles it: on Windows +// from the unhandled-exception filter, with the return addresses in this executable on the faulting thread's stack, +// so the report shows which host call ran into the driver; on Linux from the signal handler, without frames. Drivers +// that raise and catch their own exceptions never reach fn. +// - On Windows abort() (a failed assert, std::terminate) and an invalid parameter to a C runtime function go there +// too, with the host frames in this executable: the C runtime ends the process for both with 0xc0000409 and no +// exception. typedef struct { const char *what; // "access violation", "illegal instruction", ... uint32_t code; // the Windows exception code or the signal number - uintptr_t rip, offset; // the faulting instruction, and its offset in the executable + uintptr_t rip, offset; // the faulting instruction, and its offset in its module int access; // the data access that faulted: 0 read, 1 write, 8 execute; -1 when not an access uint64_t addr; // its address when access >= 0 - int nframes; // abort and invalid parameter: return addresses in this executable, innermost first - uintptr_t frames[16]; // (rip is frames[0]); 0 for a fault, whose rip is exact + int nframes; // return addresses in this executable, innermost first: for abort and invalid parameter + uintptr_t frames[16]; // (rip is frames[0]) and for a fault in another module; 0 for a fault in this one + const char *module; // the module holding rip: NULL for this executable, "" for none (a jump to address 0) } PlatCrash; void plat_crash_hook(void (*fn)(const PlatCrash *c)); int plat_mem_read(uint64_t addr, void *out, size_t n); // copies n bytes, 0 instead of faulting on unmapped memory diff --git a/runtime/platform/win32.c b/runtime/platform/win32.c index 1d70c18d..1dc456b1 100644 --- a/runtime/platform/win32.c +++ b/runtime/platform/win32.c @@ -665,6 +665,76 @@ __attribute__((noinline)) static void crash_from_runtime(const char *what, uint3 crash_fn(&c); } +// The name a DLL records for itself in its export directory ("amdvlk64.dll"). Read from its mapped headers, not through +// the loader, whose lock another thread may hold when the process crashes. +static const char *image_name(const char *base) { + const IMAGE_NT_HEADERS64 *nt = (const void *)(base + ((const IMAGE_DOS_HEADER *)base)->e_lfanew); + const IMAGE_DATA_DIRECTORY *d = &nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT]; + if (!d->VirtualAddress || !d->Size) return "unnamed module"; + return base + ((const IMAGE_EXPORT_DIRECTORY *)(base + d->VirtualAddress))->Name; +} + +// The return addresses in [lo, lo + size) on the crashed thread's stack, innermost first: unwinds the faulting context +// with the x64 unwind tables; a function without a table entry (a leaf, or address 0 after a call through a null +// pointer) has its return address on top of the stack. The walk stops at return address 0 (the thread's first frame) +// and when the stack pointer leaves the thread's stack, so a damaged stack ends it instead of faulting. +static int frames_in(const CONTEXT *at, uintptr_t lo, uintptr_t size, uintptr_t *out, int max) { + CONTEXT c = *at; + ULONG_PTR low, high; + GetCurrentThreadStackLimits(&low, &high); + int n = 0; + for (int i = 0; i < 256 && n < max && (c.Rip || !i) && c.Rsp >= low && c.Rsp + 8 <= high; i++) { + DWORD64 img; + RUNTIME_FUNCTION *fe = RtlLookupFunctionEntry(c.Rip, &img, NULL); + if (fe) { + void *data; + DWORD64 frame; + RtlVirtualUnwind(UNW_FLAG_NHANDLER, img, c.Rip, fe, &c, &data, &frame, NULL); + } else { + c.Rip = *(const DWORD64 *)c.Rsp; + c.Rsp += 8; + } + if (c.Rip - lo < size) out[n++] = (uintptr_t)c.Rip; + } + return n; +} + +// The last-chance filter: an exception no handler took, in any module. crash_veh reports faults in this executable as +// they happen; this one catches the rest, which used to end the process with no line in the log: a fault in a GPU +// driver's own thread or in a driver call (vkQueueSubmit, vkAllocateMemory), a C++ exception a library let escape, a +// call through a null pointer (rip 0, outside every module). Windows calls it only after every handler declined, so +// the exceptions drivers raise and catch themselves never get here; it costs nothing until a crash. +static LONG WINAPI crash_filter(EXCEPTION_POINTERS *ep) { + const EXCEPTION_RECORD *er = ep->ExceptionRecord; + DWORD code = er->ExceptionCode; + uintptr_t rip = (uintptr_t)ep->ContextRecord->Rip; + PlatCrash c = {code == EXCEPTION_ACCESS_VIOLATION ? "access violation" + : code == EXCEPTION_ILLEGAL_INSTRUCTION ? "illegal instruction" + : code == EXCEPTION_INT_DIVIDE_BY_ZERO ? "integer division by zero" + : code == EXCEPTION_PRIV_INSTRUCTION ? "privileged instruction" + : code == EXCEPTION_STACK_OVERFLOW ? "stack overflow" + : code == EXCEPTION_IN_PAGE_ERROR ? "in-page error" + : code == EXCEPTION_BREAKPOINT ? "breakpoint" + : code == 0xe06d7363u ? "C++ exception" + : code == 0xc0000374u ? "heap corruption" // STATUS_HEAP_CORRUPTION + : "unhandled exception", + (uint32_t)code, rip, 0, -1, 0}; + if (code == EXCEPTION_ACCESS_VIOLATION && er->NumberParameters >= 2) + c.access = (int)er->ExceptionInformation[0], c.addr = er->ExceptionInformation[1]; + void *base = NULL; + RtlPcToFileHeader((void *)rip, &base); + MODULEINFO mi; + uintptr_t exe = (uintptr_t)GetModuleHandleW(NULL); + c.offset = rip - (uintptr_t)base; + if (!base) c.module = ""; + else if ((uintptr_t)base != exe) c.module = image_name(base); + if (c.module && GetModuleInformation(GetCurrentProcess(), (HMODULE)exe, &mi, sizeof mi)) + c.nframes = frames_in(ep->ContextRecord, exe, mi.SizeOfImage, c.frames, + (int)(sizeof c.frames / sizeof *c.frames)); + crash_fn(&c); + return EXCEPTION_CONTINUE_SEARCH; +} + static void abort_signal(int sig) { crash_from_runtime("abort", (uint32_t)sig); } static void invalid_parameter(const wchar_t *expr, const wchar_t *func, const wchar_t *file, unsigned line, @@ -676,6 +746,7 @@ static void invalid_parameter(const wchar_t *expr, const wchar_t *func, const wc void plat_crash_hook(void (*fn)(const PlatCrash *c)) { crash_fn = fn; AddVectoredExceptionHandler(0, crash_veh); + SetUnhandledExceptionFilter(crash_filter); // replaces the C runtime's filter; crash_fn never returns signal(SIGABRT, abort_signal); _set_invalid_parameter_handler(invalid_parameter); }