From 7c1cd42aa51cf4512ba259f56d92d1c160bd2c0a Mon Sep 17 00:00:00 2001 From: Valiantsin Dzerakh Date: Sun, 1 Nov 2026 22:20:36 +0300 Subject: [PATCH] Bind a system event again after the guest destroyed it The game destroys the nfp activate and deactivate events and attaches the same SystemEventType again before each detection. kern_bind_system_event kept the first writable handle per guest address and returned early, so the second Attach left the event destroyed and the game's next TryWaitSystemEvent aborted (issue #398, equipping the Amiibo power). A kept handle now counts only while the SDK's state byte of the event is nonzero; otherwise the event is created again and its entry takes the new handle, and a signal to a destroyed event is dropped. probe-services destroys and attaches both nfp events again and checks that they work. Co-Authored-By: Claude Opus 5.5 --- runtime/kernel.c | 26 +++++++++++++++++++++----- runtime/ov_probe.c | 15 ++++++++++++++- 2 files changed, 35 insertions(+), 6 deletions(-) diff --git a/runtime/kernel.c b/runtime/kernel.c index 3f5c6614..d438b052 100644 --- a/runtime/kernel.c +++ b/runtime/kernel.c @@ -2056,10 +2056,19 @@ void kern_event_signal(uint32_t hw) { // System events of host services: the SDK's own nn::os::CreateSystemEvent creates the kernel event (SVC 0x45) on a // guest thread; the writable handle is kept, so any thread (host audio tick included) can signal it later. +// The guest may destroy such an event and attach the same SystemEventType again: the game does that with the nfp +// activate and deactivate events before each detection. nn::os::DestroySystemEvent zeroes the state byte at +0x28 +// (0 not initialised, 1 event, 2 inter-process event; nn::os::TryWaitSystemEvent aborts on 0) and closes both +// handles, so a kept handle counts only while that byte is nonzero. +#define SE_STATE 0x28 static struct { uint64_t ev; uint32_t wh; } g_se[512]; static int g_nse; static PlatMutex g_se_lock = PLAT_MUTEX_INIT; +static int se_live(uint64_t ev) { + return __atomic_load_n((const uint8_t *)(uintptr_t)(ev + SE_STATE), __ATOMIC_RELAXED) != 0; +} + static uint32_t se_find(uint64_t ev) { plat_mutex_lock_shared(&g_se_lock); uint32_t wh = 0; @@ -2069,8 +2078,9 @@ static uint32_t se_find(uint64_t ev) { return wh; } +// A bound event the guest destroyed since is created again and its table entry takes the new writable handle. void kern_bind_system_event(Cpu *c, uint64_t ev, int autoclear) { - if (se_find(ev)) return; + if (se_find(ev) && se_live(ev)) return; if (!tcur || !c) rt_fatal("kern_bind_system_event(%#llx) on a host thread", (unsigned long long)ev); static uint64_t create, getw; if (!create) { @@ -2082,15 +2092,21 @@ void kern_bind_system_event(Cpu *c, uint64_t ev, int autoclear) { if (r) rt_fatal("kern_bind_system_event: CreateSystemEvent(%#llx) failed %#x", (unsigned long long)ev, r); uint32_t wh = (uint32_t)rt_call(c, getw, 1, ev); plat_mutex_lock(&g_se_lock); - if (g_nse == (int)(sizeof g_se / sizeof *g_se)) rt_fatal("kern_bind_system_event: table full"); - g_se[g_nse].ev = ev; - g_se[g_nse++].wh = wh; + int i = 0; + while (i < g_nse && g_se[i].ev != ev) i++; + if (i == g_nse) { + if (g_nse == (int)(sizeof g_se / sizeof *g_se)) rt_fatal("kern_bind_system_event: table full"); + g_se[g_nse++].ev = ev; + } + g_se[i].wh = wh; plat_mutex_unlock(&g_se_lock); } -// An event not bound yet is bound on the spot with manual clear, which needs a guest thread. +// An event not bound yet is bound on the spot with manual clear, which needs a guest thread. A bound event the guest +// destroyed is not signalled: its handles are closed and the kernel hands their numbers to new objects. void kern_signal_system_event(uint64_t ev) { uint32_t wh = se_find(ev); + if (wh && !se_live(ev)) return; if (!wh) { kern_bind_system_event(kern_cpu(), ev, 0); wh = se_find(ev); diff --git a/runtime/ov_probe.c b/runtime/ov_probe.c index 9a803004..42bbb52b 100644 --- a/runtime/ov_probe.c +++ b/runtime/ov_probe.c @@ -25,6 +25,7 @@ #define CHILD_ENV "TOTK_PROBE_SERVICES_CHILD" #define TRY_WAIT_SYSTEM_EVENT "_ZN2nn2os18TryWaitSystemEventEPNS0_15SystemEventTypeE" +#define DESTROY_SYSTEM_EVENT "_ZN2nn2os18DestroySystemEventEPNS0_15SystemEventTypeE" typedef struct { const char *key, *name; int fatal; uint64_t addr; int bound, calls; } Ov; static Ov ovs[] = { @@ -386,6 +387,17 @@ static void probe_applet(void) { CHECK(event_works(activate, 0), "the nfp activate event is set without an amiibo on the reader"); CHECK((uint32_t)CALL("nfp.StartDetection", U(handles)) == 0, "nfp StartDetection"); CHECK((uint32_t)CALL("nfp.StopDetection", U(handles)) == 0, "nfp StopDetection"); + // The game attaches again before each detection: DestroySystemEvent on the attached event, then Attach* on the + // same SystemEventType. Both events must work again afterwards. + static uint64_t destroy; + if (!destroy && !(destroy = ldr_symbol(DESTROY_SYSTEM_EVENT))) rt_fatal("probe-services: no %s", DESTROY_SYSTEM_EVENT); + rt_call(gc, destroy, 1, activate); + rt_call(gc, destroy, 1, deactivate); + CHECK(CALL("nfp.AttachActivateEvent", activate, U(handles)) == 0, "nfp AttachActivateEvent again"); + CHECK(CALL("nfp.AttachDeactivateEvent", deactivate, U(handles)) == 0, "nfp AttachDeactivateEvent again"); + int reattached = event_works(activate, 0) && event_works(deactivate, 0); + CHECK(reattached, "the nfp events do not work after DestroySystemEvent and a second Attach"); + CHECK((uint32_t)CALL("nfp.StartDetection", U(handles)) == 0, "nfp StartDetection again"); CHECK(CALL("nfp.Finalize", 0) == 0 && (uint32_t)CALL("nfp.GetState", 0) == 0, "nfp finalize"); CALL("err.ShowError", 0x2a8); CALL("nndiagStartup", 0); @@ -395,7 +407,8 @@ static void probe_applet(void) { CALL("pctl.Initialize", 0); CALL("diag.InitializeApplicationAbortObserver", 0); printf("applet/prepo/nfp/err: launch parameter none, volume balance, play reports local, an NFC reader without " - "an amiibo, availability event (bound through the SDK's CreateSystemEvent) %s\n", nfp_event ? "ok" : "FAILED"); + "an amiibo, availability event (bound through the SDK's CreateSystemEvent) %s, activate and deactivate events " + "destroyed and attached again %s\n", nfp_event ? "ok" : "FAILED", reattached ? "ok" : "FAILED"); } static void probe_account(void) {