Let the first failure report end the run whole when another thread crashes or hits a fatal error beside it.

The platform layer calls the crash handler on every thread that faults, without waiting for the others
(win32.c crash_veh, crash_filter), and main.c crash_handler ended any second entry with plat_exit(71) at once.
So a second fault during the first report cut it after its first lines, together with its wait for a save Commit
(fs_save_crash_wait) and RivaTuner's restore; the audit's probe showed it in 3 of 3 runs. fatal_end had no guard
at all and none shared with the crash report: a crash during a FATAL's end wrote a whole crash report whose
"FATAL: access violation" became the log's last FATAL line (the one the launcher shows) and replaced code 70 with
71, and a FATAL during a crash report cut it with code 70.

dispatch.c rt_ending_enter is the one guard for both ends: the first caller reports and ends the process; the
same thread again (a failure inside its own report) ends at once with its own code (crash_handler keeps
plat_exit(71), fatal_end plat_terminate(code)); another thread waits in 10 ms sleeps, logging nothing since it
may hold the log queue's lock, until the process ends, and after 30 s ends it with 71 should the first report
hang. fatal_end calls it first; crash_handler calls it in place of its own busy flag.

Reproduced before the change by tests/fatal_exit_check.py's new cases, which failed on the old guards: two
faults at once (report lines 2 and 3 missing), a fault during rt_fatal (a crash report after the FATAL) and
rt_fatal during a crash report (exit 70, the report cut). They pass now, with the earlier cases and the static
check that crash_handler starts with the shared guard; the compile checks pass.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
chrg6
2026-11-13 17:13:35 -05:00
parent 8f952d2841
commit 1352b14f64
5 changed files with 101 additions and 5 deletions

View File

@@ -59,9 +59,27 @@ void rt_fatal_notes(void) {
__attribute__((weak)) void fs_save_crash_wait(void) {} // fs_host.c; builds without it (the unit checks) have no saves
// One end for a failed run. The platform layer calls the crash handler on every thread that faults, without
// waiting for the others (platform/win32.c crash_veh, crash_filter), and a fatal error can come beside a crash from
// the same bad state (an allocation that failed here, a null pointer read there). The later end cut the first report
// where it was, together with its wait for a save Commit and RivaTuner's restore, and its own FATAL line and exit
// code replaced the first (the launcher shows the last FATAL). Another thread now waits until the first end is done;
// it logs nothing, since it may hold the log queue's lock, which the first report only tries. A first report that
// hangs still ends: after 30 s the waiting thread ends the process with the crash report's code.
static volatile uint32_t ending_tid; // the thread that reports, 0 before one does
int rt_ending_enter(void) {
uint32_t me = plat_thread_id(), was = 0;
if (__atomic_compare_exchange_n(&ending_tid, &was, me, 0, __ATOMIC_ACQ_REL, __ATOMIC_ACQUIRE)) return 1;
if (was == me) return 0;
for (int i = 0; i < 3000; i++) plat_sleep_ms(10);
plat_terminate(71);
}
// The fatal line, the report's notes and what has to be flushed, then the exit with `code`.
static void fatal_end(int code, const char *fmt, va_list ap) __attribute__((noreturn));
static void fatal_end(int code, const char *fmt, va_list ap) {
if (!rt_ending_enter()) plat_terminate(code); // a fatal error inside this thread's own report: no second one
rt_log_sync(); // main.c: the lines queued for the log thread, then these, written here
rt_log_raw("FATAL: ", 7);
rt_vlogf(fmt, ap);

View File

@@ -62,3 +62,7 @@ void rt_fatal_code(int code, const char *fmt, ...) __attribute__((noreturn, form
// needs none. At most four; adding one twice keeps one. rt_fatal_notes runs them, once per process.
void rt_fatal_note_add(void (*fn)(void));
void rt_fatal_notes(void);
// The one end of a failed run: the fatal error (rt_fatal) and the crash report (main.c crash_handler) call it first. 1
// for the first caller, which reports and ends the process; 0 for that thread again (a failure inside its own report),
// which ends at once with its code; any other thread waits, logging nothing, until the process ends (30 s at most).
int rt_ending_enter(void);

View File

@@ -315,8 +315,9 @@ static volatile int32_t mode_done;
static int mode_rc;
static void crash_handler(const PlatCrash *x) {
static volatile int32_t busy;
if (plat_xchg32(&busy, 1)) plat_exit(71);
// shared with the fatal error's end (dispatch.c rt_ending_enter): another thread's fault or fatal error waits there
// while this report is written; a fault inside this thread's own report ends the process at once
if (!rt_ending_enter()) plat_exit(71);
if (__atomic_load_n(&mode_done, __ATOMIC_ACQUIRE) && x->module) {
rt_log("exit: %s (%#x) in %s while the process was ending, after its work was done and saved%s: the run ends "
"with its own code %d", x->what, x->code, *x->module ? x->module : "code outside every module",