mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-16 11:49:59 -04:00
gfx_vsync_bind kept every SystemEventType address the game ever passed to GetDisplayVsyncEvent, never dropped one, and called rt_fatal on the 17th distinct address. A destroyed event also stayed on the list the vsync thread signals 60 times a second. kernel.c now exports kern_system_event_live (mapped guest memory with a nonzero state byte), and with the list full gfx_vsync_bind gives the first slot whose event is no longer live to the new one, which also takes the destroyed event off the vsync thread's list; it stays fatal only when all 16 are live. Each new listing logs "gfx: vsync event ... bound in slot N, M listed", so a long session's log shows how often new addresses come. Not reproduced before the change: the fresh 0.10.0 session's system event count stayed at 9-10 across its area loads, and no log here covers returns to the title. tests/vsync_bind_check.py cuts gfx_vsync_bind from gfx_present.c with a stub liveness check: a 17th event takes the first destroyed slot, an 18th the next, and with 16 live events the 17th still ends with the fatal. system_event_check now also checks kern_system_event_live. The compile check of every runtime file passes. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
225 lines
9.9 KiB
C
225 lines
9.9 KiB
C
// runtime/kernel.c: the system-event table (kern_bind_system_event, kern_signal_system_event, kern_clear_system_event)
|
|
// with the platform layer linked and the rest of the runtime stubbed. Built and run by tests/system_event_check.py;
|
|
// prints each failed check and exits 1 on any.
|
|
// (no argument) a kept handle the guest closed (DestroySystemEvent) is neither signalled nor cleared, also when its
|
|
// number went to an unrelated event or the state byte reads nonzero again; a host thread signalling
|
|
// while a guest thread destroys and binds the event again never ends the process; with the table full,
|
|
// a new bind takes a destroyed guest-memory entry and keeps the entries in host memory, which a host
|
|
// thread then still signals; kern_system_event_live tells live guest events from destroyed ones
|
|
// full every entry live: the next bind ends with "table full" (the script checks the exit code and text)
|
|
#include "kernel.c"
|
|
|
|
#include <stdarg.h>
|
|
|
|
static int fails;
|
|
#define CHECK(c, ...) do { if (!(c)) { fails++; printf("FAIL line %d: ", __LINE__); printf(__VA_ARGS__); printf("\n"); } } while (0)
|
|
|
|
// ---- the runtime kernel.c reaches
|
|
unsigned rt_trace;
|
|
uint64_t rt_guest_start_ns;
|
|
volatile uint32_t prof_replay_tid, prof_main_tid;
|
|
// Guest memory is this block; anything else (the "host-memory" events below) is not, as memory.c answers.
|
|
static uint8_t guest[600][0x40] __attribute__((aligned(16)));
|
|
int mem_readable(uint64_t a, uint64_t n) {
|
|
uint64_t lo = (uint64_t)(uintptr_t)guest, hi = lo + sizeof guest;
|
|
return a >= lo && a + n <= hi;
|
|
}
|
|
const char *cfg_get(const char *name) { (void)name; return NULL; }
|
|
const char *cfg_value(const char *name) { (void)name; return "0"; }
|
|
int cfg_bool(const char *name) { (void)name; return 0; }
|
|
int rt_ab(void) { return 0; }
|
|
int rt_knob(const char *name, const char *def) { (void)name; return strcmp(def, "0") != 0; }
|
|
int64_t frame_step_world_us(void) { return -1; }
|
|
void ipc_handle_closed(int kind, void *obj) { (void)kind, (void)obj; }
|
|
const char *ldr_describe(uint64_t a, char *buf, int n) { snprintf(buf, (size_t)n, "%#llx", (unsigned long long)a); return buf; }
|
|
// The SDK's two functions kern_bind_system_event calls: 1 CreateSystemEvent, 2 GetWritableHandleOfSystemEvent.
|
|
uint64_t ldr_symbol(const char *name) { return strstr(name, "CreateSystemEvent") ? 1 : 2; }
|
|
void perf_main_thread(void) {}
|
|
void perf_size(PerfSizes *s, const char *name, uint64_t count, uint64_t limit, uint64_t bytes) {
|
|
(void)s, (void)name, (void)count, (void)limit, (void)bytes; // kern_sizes is not called here
|
|
}
|
|
int rt_linked_modules(RtModule *out, int max) { (void)out, (void)max; return 0; }
|
|
const RtGuestLayout *mem_layout(void) { return NULL; }
|
|
void *mem_kernel_alloc(uint64_t size, uint64_t align) {
|
|
void *p = plat_aligned_alloc(size, align < 64 ? 64 : align);
|
|
if (!p) rt_fatal("out of memory");
|
|
memset(p, 0, size);
|
|
return p;
|
|
}
|
|
void mem_kernel_free(void *p, uint64_t size) { (void)size; plat_aligned_free(p); }
|
|
void rt_log(const char *fmt, ...) { (void)fmt; }
|
|
void rt_logf(const char *fmt, ...) { (void)fmt; }
|
|
void rt_fatal(const char *fmt, ...) {
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
printf("FATAL: ");
|
|
vprintf(fmt, ap);
|
|
printf("\n");
|
|
va_end(ap);
|
|
fflush(stdout);
|
|
_Exit(3);
|
|
}
|
|
void rt_dispatch(Cpu *c) { (void)c; rt_fatal("rt_dispatch in the test"); }
|
|
void rt_svc(Cpu *c, uint32_t imm, uint64_t pc) { (void)pc; kern_svc(c, imm); }
|
|
// CreateSystemEvent(ev, mode, ipc) makes a kernel event, keeps its writable handle at +0 of the SystemEventType and its
|
|
// readable one at +4, and sets the state byte; GetWritableHandleOfSystemEvent(ev) reads +0.
|
|
uint64_t rt_call(Cpu *c, uint64_t fn, int n, ...) {
|
|
(void)c;
|
|
va_list ap;
|
|
va_start(ap, n);
|
|
uint64_t ev = va_arg(ap, uint64_t);
|
|
va_end(ap);
|
|
uint8_t *p = (uint8_t *)(uintptr_t)ev;
|
|
if (fn == 1) {
|
|
uint32_t wh = kern_event_new(), rh = kern_event_readable(wh);
|
|
memcpy(p, &wh, 4);
|
|
memcpy(p + 4, &rh, 4);
|
|
__atomic_store_n(p + SE_STATE, 1, __ATOMIC_RELEASE);
|
|
return 0;
|
|
}
|
|
uint32_t wh;
|
|
memcpy(&wh, p, 4);
|
|
return wh;
|
|
}
|
|
|
|
// ---- helpers
|
|
static RtThread me; // the main thread plays a guest thread for the binds
|
|
static Cpu cpu;
|
|
static uint64_t ev_of(void *p) { return (uint64_t)(uintptr_t)p; }
|
|
static uint32_t wh_of(const void *p) { uint32_t h; memcpy(&h, p, 4); return h; }
|
|
static uint32_t rh_of(const void *p) { uint32_t h; memcpy(&h, (const uint8_t *)p + 4, 4); return h; }
|
|
static void bind(void *p) { kern_bind_system_event(&cpu, ev_of(p), 0); }
|
|
// nn::os::DestroySystemEvent: the state byte first, then both handles (SVC 0x16).
|
|
static void destroy(void *p) {
|
|
__atomic_store_n((uint8_t *)p + SE_STATE, 0, __ATOMIC_RELEASE);
|
|
kern_handle_close(rh_of(p));
|
|
kern_handle_close(wh_of(p));
|
|
}
|
|
static int signaled(uint32_t wh) {
|
|
lock();
|
|
Event *e = h_peek(wh, O_EVENT_W);
|
|
int s = e ? e->signaled : -1;
|
|
unlock();
|
|
return s;
|
|
}
|
|
|
|
static void stale_and_reuse(void) {
|
|
uint8_t *ev = guest[0];
|
|
bind(ev);
|
|
uint32_t wh = wh_of(ev);
|
|
kern_signal_system_event(ev_of(ev));
|
|
CHECK(signaled(wh) == 1, "a live bound event is signalled");
|
|
kern_clear_system_event(ev_of(ev));
|
|
CHECK(signaled(wh) == 0, "a live bound event is cleared");
|
|
CHECK(kern_system_event_live(ev_of(ev)), "kern_system_event_live: a bound event in guest memory is live");
|
|
destroy(ev);
|
|
CHECK(!kern_system_event_live(ev_of(ev)), "kern_system_event_live: a destroyed event is not");
|
|
kern_signal_system_event(ev_of(ev)); // state byte 0: skipped before the kernel lock
|
|
// The byte reads nonzero again with the handles closed (the memory reused, or the SDK made the event again
|
|
// without the binder): the signal must neither end the process nor reach anything.
|
|
ev[SE_STATE] = 1;
|
|
kern_signal_system_event(ev_of(ev));
|
|
kern_clear_system_event(ev_of(ev));
|
|
// The closed number goes to the next new event at once: the stale entry must not set or clear it.
|
|
uint32_t other = kern_event_new();
|
|
CHECK(other == wh, "the next event takes the closed number (%#x, closed %#x)", other, wh);
|
|
kern_signal_system_event(ev_of(ev));
|
|
CHECK(signaled(other) == 0, "an unrelated event that took the closed number is not signalled by the stale entry");
|
|
lock();
|
|
((Event *)h_peek(other, O_EVENT_W))->signaled = 1;
|
|
unlock();
|
|
kern_clear_system_event(ev_of(ev));
|
|
CHECK(signaled(other) == 1, "an unrelated event that took the closed number is not cleared by the stale entry");
|
|
kern_handle_close(other);
|
|
// Bound again after the destroy (state byte 0 first, as the guest leaves it): signals again.
|
|
ev[SE_STATE] = 0;
|
|
bind(ev);
|
|
kern_signal_system_event(ev_of(ev));
|
|
CHECK(signaled(wh_of(ev)) == 1, "the event bound again is signalled");
|
|
destroy(ev);
|
|
}
|
|
|
|
// A host thread signals in a loop while the guest thread destroys the event and binds it again (the override called
|
|
// again after a DestroySystemEvent), as gfx_present.c vsync_main does with a vsync event.
|
|
static volatile int stop;
|
|
static volatile long signals;
|
|
static uint8_t *race_ev;
|
|
static void signaller(void *arg) {
|
|
(void)arg;
|
|
while (!stop) {
|
|
kern_signal_system_event(ev_of(race_ev));
|
|
kern_clear_system_event(ev_of(race_ev));
|
|
__atomic_add_fetch(&signals, 1, __ATOMIC_RELAXED);
|
|
}
|
|
}
|
|
|
|
static void race(void) {
|
|
race_ev = guest[1];
|
|
bind(race_ev);
|
|
void *t = plat_thread_new(signaller, NULL, "signaller");
|
|
uint64_t t0 = plat_now_ns();
|
|
long rounds = 0;
|
|
while (plat_now_ns() - t0 < 2000000000ull || rounds < 1000) {
|
|
destroy(race_ev);
|
|
bind(race_ev);
|
|
rounds++;
|
|
}
|
|
stop = 1;
|
|
plat_thread_join(t);
|
|
printf("race: %ld destroy and bind rounds against %ld signals, no fatal\n", rounds, signals);
|
|
destroy(race_ev);
|
|
}
|
|
|
|
// ov_movie2.c update_events on a movie decoder thread (a host thread).
|
|
static uint8_t *movie_in, *movie_out;
|
|
static void decoder(void *arg) {
|
|
(void)arg;
|
|
kern_signal_system_event(ev_of(movie_in));
|
|
kern_signal_system_event(ev_of(movie_out));
|
|
}
|
|
|
|
static void full_table(int all_live) {
|
|
int n = (int)(sizeof g_se / sizeof *g_se);
|
|
// the guest entries 0 and 1 of the checks above are destroyed; fill the rest of the table with live ones and the
|
|
// movie's two events, which live in host memory
|
|
for (int i = 2; i < n - 2; i++) bind(guest[i]);
|
|
movie_in = calloc(1, 0x40), movie_out = calloc(1, 0x40);
|
|
bind(movie_in);
|
|
bind(movie_out);
|
|
CHECK(g_nse == n, "the table is full (%d of %d)", g_nse, n);
|
|
if (all_live) {
|
|
bind(guest[0]); // the two destroyed guest entries are made again: every entry is live
|
|
|
|
bind(guest[1]);
|
|
printf("full: binding one more with every entry live\n");
|
|
bind(guest[n]);
|
|
printf("full: no fatal\n");
|
|
return;
|
|
}
|
|
bind(guest[n]);
|
|
CHECK(se_find(ev_of(movie_in), NULL) && se_find(ev_of(movie_out), NULL),
|
|
"the movie's host-memory events keep their entries (in %s, out %s)",
|
|
se_find(ev_of(movie_in), NULL) ? "kept" : "taken", se_find(ev_of(movie_out), NULL) ? "kept" : "taken");
|
|
CHECK(se_find(ev_of(guest[n]), NULL) != 0, "the new event is bound");
|
|
CHECK(se_find(ev_of(guest[0]), NULL) == 0, "it took the first destroyed guest entry");
|
|
bind(guest[n + 1]);
|
|
CHECK(se_find(ev_of(guest[1]), NULL) == 0, "the next takes the second destroyed guest entry");
|
|
void *t = plat_thread_new(decoder, NULL, "decoder");
|
|
plat_thread_join(t);
|
|
CHECK(signaled(wh_of(movie_in)) == 1 && signaled(wh_of(movie_out)) == 1,
|
|
"a host thread signals the movie's events with the table full");
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
setvbuf(stdout, NULL, _IONBF, 0);
|
|
me.cur = &cpu;
|
|
tcur = &me;
|
|
int full = argc > 1 && !strcmp(argv[1], "full");
|
|
stale_and_reuse();
|
|
race();
|
|
full_table(full);
|
|
if (full) return 0;
|
|
printf(fails ? "system_event_check: %d failed\n" : "system_event_check: ok\n", fails);
|
|
return fails ? 1 : 0;
|
|
}
|