Log the guest's ExitProcess line after the exit guard, and bring the comments on gfx_window_closed's return up to date.

The review of the exit sequence found that svc.c case 0x07 logged "guest ExitProcess at ...; exiting" before
rt_exit_begin. When a close had already begun, the guest thread that the guard then parks still claimed to exit, and
past the log cap the line fell outside the end's reserve, which rt_exit_begin opens. It also found that host.h and
gfx_wsys.h still said gfx_window_closed does not return, though it returns for its own thread coming back, and that
rt_exit_begin's comment spoke of the window thread handling a message inside the sequence, which since the close
runs on a thread of its own happens only in the fallback.

svc.c logs the line after rt_exit_begin returns 1. The two header comments say gfx_window_closed returns only for its
own thread coming back (gfx_present.c rt_exit_begin), and rt_exit_begin's comment says the window thread runs the
sequence itself only when gfx_window_win.c exit_start could make no thread.

tests/exit_order_check.py checks statically that 0x07's rt_log comes after rt_exit_begin; it fails on the code
before this change and passes after it. exit_order_check and the compile check of every runtime file (a header
changed) pass, with no new -Wall warnings in svc.c and gfx_present.c.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
chrg6
2026-11-13 18:32:04 -05:00
parent 66c607414b
commit cd3f015732
5 changed files with 19 additions and 8 deletions

View File

@@ -115,8 +115,9 @@ void gfx_window_focus_changed(int in) {
// Once per process, whichever comes first. The window's close and the console's (main.c console_closed) can come
// together, or the guest's ExitProcess beside either: each ran its own sequence, so two pipeline saves and two
// frame-time summaries were written while both raced. 1 for the first caller; a caller on another thread waits here
// for good while the first ends the process; 0 for the first caller's own thread coming back (a message the window
// thread handles inside the sequence), which goes on with the sequence it is in.
// for good while the first ends the process; 0 for the first caller's own thread coming back, which goes on with the
// sequence it is in. The window's close runs on a thread of its own (gfx_window_win.c exit_start); the window thread
// runs the sequence itself, and may handle a message inside it, only when that thread could not be made.
static volatile uint32_t exit_tid; // the thread that runs the orderly end, 0 before one started
int rt_exit_begin(void) {