mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-20 18:59:58 -04:00
Destroy a movie decoder's system events and free their table entries when the decoder goes.
The review of the system-event change (Ev-1) found the table still filling. Entries in host memory now count as live for good in the full-table scan, but their objects are freed: ov_movie2.c ov_dtor freed the Video with in_ev and out_ev still bound, so each decoder left two dead entries that nothing reclaimed (AUDIT F-1-08 measured about two entries per reload of a save, which E-4's verifier tied to the decoder pair), and their four kernel handles stayed open. A long session would end with "kern_bind_system_event: table full" once no dead guest entry was left to take. kernel.c gains kern_unbind_system_event(c, ev). On a guest thread it calls the SDK's nn::os::DestroySystemEvent, which zeroes the state byte and closes both handles, and then removes the entry under g_se_lock (the last entry takes its place). The destroy comes first, so a signal still in flight finds the event destroyed or its handle no longer naming it and skips it, rather than finding no entry and binding again on a host thread. Off a guest thread, or when the SDK lacks the function (logged once), only the entry goes. ov_dtor calls it for each bound event after finalize has joined the decoder and convert threads, then frees the Video. net_offline.c frees its HostTask with a bound event in the same way; that file is outside this change and is handed to the coordinator. Not reproduced before the change in a game run. tests/system_event_check.c fills the table with live guest events and the movie's two host-memory events, unbinds one: it leaves the table, its handles are closed and its state byte is 0, the other keeps its entry, and a second unbind changes nothing; with the table full again and the last host entry unbound, a new guest bind succeeds where it would have ended with "table full". The check passes in both modes, movie_planes_check passes, and the compile check of every runtime file (host.h changed) passes, adding no warnings in kernel.c or ov_movie2.c with -Wall -Wextra. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -5,7 +5,9 @@
|
||||
// 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
|
||||
// thread then still signals; kern_system_event_live tells live guest events from destroyed ones;
|
||||
// kern_unbind_system_event destroys a host-memory event and frees its entry, so a full table takes a
|
||||
// new guest bind once the host entries are unbound
|
||||
// full every entry live: the next bind ends with "table full" (the script checks the exit code and text)
|
||||
#include "kernel.c"
|
||||
|
||||
@@ -32,8 +34,11 @@ int rt_knob(const char *name, const char *def) { (void)name; return strcmp(def,
|
||||
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; }
|
||||
// The SDK's functions the table calls: 1 CreateSystemEvent, 2 GetWritableHandleOfSystemEvent (kern_bind_system_event),
|
||||
// 3 DestroySystemEvent (kern_unbind_system_event).
|
||||
uint64_t ldr_symbol(const char *name) {
|
||||
return strstr(name, "CreateSystemEvent") ? 1 : strstr(name, "DestroySystemEvent") ? 3 : 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
|
||||
@@ -61,8 +66,10 @@ void rt_fatal(const char *fmt, ...) {
|
||||
}
|
||||
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); }
|
||||
static void destroy(void *p);
|
||||
// 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.
|
||||
// readable one at +4, and sets the state byte; GetWritableHandleOfSystemEvent(ev) reads +0; DestroySystemEvent(ev) as
|
||||
// destroy below.
|
||||
uint64_t rt_call(Cpu *c, uint64_t fn, int n, ...) {
|
||||
(void)c;
|
||||
va_list ap;
|
||||
@@ -77,6 +84,10 @@ uint64_t rt_call(Cpu *c, uint64_t fn, int n, ...) {
|
||||
__atomic_store_n(p + SE_STATE, 1, __ATOMIC_RELEASE);
|
||||
return 0;
|
||||
}
|
||||
if (fn == 3) {
|
||||
destroy(p);
|
||||
return 0;
|
||||
}
|
||||
uint32_t wh;
|
||||
memcpy(&wh, p, 4);
|
||||
return wh;
|
||||
@@ -210,6 +221,37 @@ static void full_table(int all_live) {
|
||||
"a host thread signals the movie's events with the table full");
|
||||
}
|
||||
|
||||
// ov_movie2.c ov_dtor with the table full of live guest events and the movie's two host-memory events: each unbound
|
||||
// event is destroyed (its handles closed) and leaves the table, the other keeps its entry, and once the last host
|
||||
// entry is gone a new guest bind finds room (the full-table scan keeps host entries, so it would end with "table full").
|
||||
static void unbind_host(void) {
|
||||
int n = (int)(sizeof g_se / sizeof *g_se);
|
||||
CHECK(g_nse == n, "the table is full before the unbinds (%d of %d)", g_nse, n);
|
||||
uint32_t in_w = wh_of(movie_in), in_r = rh_of(movie_in);
|
||||
kern_unbind_system_event(&cpu, ev_of(movie_in));
|
||||
CHECK(se_find(ev_of(movie_in), NULL) == 0, "an unbound event leaves the table");
|
||||
CHECK(g_nse == n - 1, "the table has one entry fewer (%d)", g_nse);
|
||||
CHECK(se_find(ev_of(movie_out), NULL) != 0, "the other host-memory event keeps its entry");
|
||||
CHECK(movie_in[SE_STATE] == 0 && signaled(in_w) == -1, "the unbound event is destroyed: state 0, handle %#x closed",
|
||||
in_w);
|
||||
lock();
|
||||
int r_open = h_peek(in_r, O_EVENT_R) != NULL;
|
||||
unlock();
|
||||
CHECK(!r_open, "its readable handle %#x is closed too", in_r);
|
||||
kern_unbind_system_event(&cpu, ev_of(movie_in)); // a second unbind finds nothing and leaves the table alone
|
||||
CHECK(g_nse == n - 1, "a second unbind changes nothing (%d)", g_nse);
|
||||
// Full again with live guest entries and one host entry; the host entry unbound, the next guest bind takes its room.
|
||||
int next = n + 2;
|
||||
bind(guest[next++]);
|
||||
CHECK(g_nse == n, "full again (%d)", g_nse);
|
||||
kern_unbind_system_event(&cpu, ev_of(movie_out));
|
||||
bind(guest[next]);
|
||||
CHECK(se_find(ev_of(guest[next]), NULL) != 0 && g_nse == n,
|
||||
"a guest bind succeeds once the host entry is unbound (%d entries)", g_nse);
|
||||
free(movie_in), free(movie_out);
|
||||
movie_in = movie_out = NULL;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
setvbuf(stdout, NULL, _IONBF, 0);
|
||||
me.cur = &cpu;
|
||||
@@ -219,6 +261,7 @@ int main(int argc, char **argv) {
|
||||
race();
|
||||
full_table(full);
|
||||
if (full) return 0;
|
||||
unbind_host();
|
||||
printf(fails ? "system_event_check: %d failed\n" : "system_event_check: ok\n", fails);
|
||||
return fails ? 1 : 0;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user