mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-16 09:39:58 -04:00
input_rumble_hd_stop ran only in the orderly ends, so a FATAL or a crash while a controller vibrated on HD rumble left it buzzing: nothing renews or stops the value after the process is gone (input.c says so). It also took hd_lock with a blocking lock while it only tried the other two. dispatch.c rt_rumble_stop_bounded runs input_rumble_hd_stop (weak in dispatch.c, as fs_save_crash_wait is, for builds without input.c) on a new "rumble stop" thread and waits at most 300 ms for it, never joining it: the stop goes through SDL, which takes its own joystick lock, and a crash on SDL's thread while it held that lock would otherwise keep the ending thread there and the process would never end. fatal_end and main.c crash_handler call it right after rtss_limit_restore. input.c tries hd_lock 50 times 1 ms apart, as it does `lock` and sdl_lock, and skips the stop when it is not taken. Not reproduced before the change. tests/fatal_exit_check.py (now linking dispatch.c as its own unit: the stop runs at a fatal error; a stop that hangs leaves the end at code 70 after 0.3 s; statically both failed ends call the bounded stop after the RTSS restore), tests/rumble_hd_check.py and the compile checks pass. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
132 lines
4.9 KiB
C
132 lines
4.9 KiB
C
// runtime/dispatch.c's end of a fatal error (fatal_end), with the platform layer linked and the rest of the runtime as
|
|
// stand-ins that write straight to stdout. Built and run by tests/fatal_exit_check.py, which reads what each mode
|
|
// printed and its exit code. The exe has a TLS callback that prints a line when the process's libraries get their
|
|
// detach call, which ExitProcess (and _Exit, which is ExitProcess in the C runtime) makes and TerminateProcess does not.
|
|
//
|
|
// fatal_exit_check fatal rt_fatal: exit code 70, the FATAL line, no detach line
|
|
// fatal_exit_check crash_crash two threads fault at once: one whole crash report, exit code 71
|
|
// fatal_exit_check fatal_crash a fault on another thread while rt_fatal reports: its FATAL line alone, exit code 70
|
|
// fatal_exit_check crash_fatal rt_fatal on another thread while a crash is reported: the whole report, exit code 71
|
|
// fatal_exit_check fatal_rumble rt_fatal while the HD rumble stop hangs (SDL's lock held): exit code 70 all the same
|
|
//
|
|
// The crash handler here is a stand-in for main.c crash_handler with its first line (the static check in
|
|
// tests/fatal_exit_check.py holds main.c to it): it writes three report lines 100 ms apart and ends with plat_exit(71).
|
|
#include <stdio.h>
|
|
#include <windows.h>
|
|
|
|
#include "host.h"
|
|
#include "platform/platform.h"
|
|
|
|
static void say(const char *s) {
|
|
DWORD w;
|
|
WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), s, (DWORD)strlen(s), &w, NULL);
|
|
}
|
|
|
|
static void NTAPI tls_cb(PVOID h, DWORD reason, PVOID reserved) {
|
|
(void)h, (void)reserved;
|
|
if (reason == DLL_PROCESS_DETACH) say("detach: the libraries' detach calls ran\n");
|
|
}
|
|
__attribute__((section(".CRT$XLB"), used)) PIMAGE_TLS_CALLBACK p_tls_cb = tls_cb;
|
|
__thread int tls_var; // with _tls_used below: the image gets its TLS directory, so the callback is called
|
|
extern const IMAGE_TLS_DIRECTORY _tls_used;
|
|
const void *volatile keep_tls = &_tls_used;
|
|
|
|
// ---- the runtime fatal_end reaches
|
|
void rt_log_sync(void) {}
|
|
void rt_log_raw(const char *p, size_t n) {
|
|
DWORD w;
|
|
WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), p, (DWORD)n, &w, NULL);
|
|
}
|
|
void rt_vlogf(const char *fmt, va_list ap) {
|
|
char b[1024];
|
|
int n = vsnprintf(b, sizeof b, fmt, ap);
|
|
if (n > 0) rt_log_raw(b, (size_t)n < sizeof b ? (size_t)n : sizeof b - 1);
|
|
}
|
|
void rt_logf(const char *fmt, ...) {
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
rt_vlogf(fmt, ap);
|
|
va_end(ap);
|
|
}
|
|
void rt_log(const char *fmt, ...) {
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
rt_vlogf(fmt, ap);
|
|
va_end(ap);
|
|
rt_log_raw("\n", 1);
|
|
}
|
|
void kern_free_cores_note(void) {}
|
|
void prof_sampler_write(void) {}
|
|
void rtss_limit_restore(void) {}
|
|
void kern_checkpoint(void) {}
|
|
|
|
// input.c's stop, which dispatch.c calls through a weak symbol: says it ran, or hangs as when SDL's lock is held
|
|
static int rumble_hangs;
|
|
void input_rumble_hd_stop(void) {
|
|
if (rumble_hangs) Sleep(INFINITE);
|
|
say("rumble: stopped\n");
|
|
}
|
|
|
|
// ---- the crash report and the threads that fail beside it
|
|
static void crash(const PlatCrash *x) {
|
|
if (!rt_ending_enter()) plat_exit(71); // main.c crash_handler's first line
|
|
char b[160];
|
|
for (int i = 1; i <= 3; i++) {
|
|
snprintf(b, sizeof b, "report line %d: %s on thread %lu\n", i, x->what, (unsigned long)GetCurrentThreadId());
|
|
say(b);
|
|
Sleep(100);
|
|
}
|
|
plat_exit(71);
|
|
}
|
|
|
|
static volatile LONG go;
|
|
static DWORD WINAPI fault(void *arg) {
|
|
Sleep((DWORD)(uintptr_t)arg);
|
|
while (!go) Sleep(0);
|
|
*(volatile int *)(uintptr_t)16 = 1;
|
|
return 0;
|
|
}
|
|
static DWORD WINAPI fatal_thread(void *arg) {
|
|
Sleep((DWORD)(uintptr_t)arg);
|
|
rt_fatal("the test's fatal error %d", 2);
|
|
}
|
|
static void slow_note(void) { // a fatal note that takes a while, as the card's and the memory settings' may
|
|
say("fatal note: start\n");
|
|
Sleep(300);
|
|
say("fatal note: end\n");
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
setvbuf(stdout, NULL, _IONBF, 0);
|
|
const char *mode = argc > 1 ? argv[1] : "";
|
|
tls_var = 1;
|
|
plat_crash_hook(crash);
|
|
if (!strcmp(mode, "fatal")) rt_fatal("the test's fatal error %d", 1);
|
|
if (!strcmp(mode, "fatal_rumble")) {
|
|
rumble_hangs = 1;
|
|
rt_fatal("the test's fatal error %d", 1);
|
|
}
|
|
if (!strcmp(mode, "crash_crash")) {
|
|
CloseHandle(CreateThread(NULL, 0, fault, (void *)0, 0, NULL));
|
|
CloseHandle(CreateThread(NULL, 0, fault, (void *)0, 0, NULL));
|
|
Sleep(50);
|
|
go = 1;
|
|
Sleep(10000);
|
|
return 3;
|
|
}
|
|
if (!strcmp(mode, "fatal_crash")) {
|
|
rt_fatal_note_add(slow_note);
|
|
go = 1;
|
|
CloseHandle(CreateThread(NULL, 0, fault, (void *)100, 0, NULL));
|
|
rt_fatal("the test's fatal error %d", 1);
|
|
}
|
|
if (!strcmp(mode, "crash_fatal")) {
|
|
CloseHandle(CreateThread(NULL, 0, fatal_thread, (void *)100, 0, NULL));
|
|
go = 1;
|
|
fault(0);
|
|
return 3;
|
|
}
|
|
printf("usage: fatal_exit_check fatal|crash_crash|fatal_crash|crash_fatal|fatal_rumble\n");
|
|
return 2;
|
|
}
|