Put the process's OS handle count on the sizes line and add a handle census by kind behind NX2NAVI_HANDLE_CENSUS.

A session of 2026-11-13 grew from 683 to 1095 OS handles in 11 minutes, rising at every area load and never falling,
while the guest's own handles stayed at 116-122 and the threads flat; the VMA block count fell back while the handle
count did not. The log could not show it: the 600-frame "mem: sizes" line had only the guest's handles, and nothing
told which kind of handle grows.

kernel.c kern_sizes now adds "process handles" (plat_handle_count, one system call every 600 frames under trace=perf)
beside the guest's "handles". platform.h gets plat_handle_census: on Windows the system's extended handle table
filtered by our process id, with the type names from NtQueryObject's ObjectTypesInformation; on Linux the
/proc/self/fd links grouped by kind. It never opens, duplicates or names a handle (a name query can block on a pipe).
With NX2NAVI_HANDLE_CENSUS=1 (default 0, read at start) and trace=perf, perf.c starts one long-lived thread that the
600-frame report wakes; when the count grew by 16 or more since its last census it logs "mem: handles frame N: T in
all (+D since the last census): Event a (+x), ...". The census reads a few MiB of the system's table in 2-5 ms, off
the drawing threads; one thread for the run keeps a new thread's own handle out of what it counts. New cfg rows:
HANDLE_CENSUS in known[], sections[] (diagnostics) and metas[] ("0", "0|1", restart), and an nx2navi.ini.example
entry.

New tests/handle_census_check.py builds the platform layer alone: 20 events and 5 sections show as Event +20 and
Section +5, the total stays within 2 of GetProcessHandleCount, the figures return once they are closed, and kinds
past the room given go into the last entry; docs/building.md describes it. Not reproduced before the change (the
growth needs a game run). handle_census_check, sync_wake_check and the cfg row check pass; every runtime file compiles
with the dev flags, and perf.c, kernel.c, win32.c and cfg.c add no -Wall -Wextra warnings.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
chrg6
2026-11-13 17:11:52 -05:00
parent baf83fda6a
commit 26b7cfd658
10 changed files with 360 additions and 2 deletions

View File

@@ -2188,6 +2188,106 @@ uint32_t plat_handle_count(void) {
return GetProcessHandleCount(GetCurrentProcess(), &n) ? (uint32_t)n : 0;
}
// plat_handle_census: the system's handle table (NtQuerySystemInformation, class 64, the extended handle information)
// filtered by this process's id, and the object types' names from NtQueryObject's ObjectTypesInformation, whose entries
// carry the type index the table uses (Windows 8.1 and later). The table holds every process's handles; a census took
// 1.5-4.7 ms over 3.6 MiB of it on the development PC.
typedef struct {
PVOID object;
ULONG_PTR pid, handle;
ULONG access;
USHORT backtrace, type;
ULONG attributes, reserved;
} HcEntry;
typedef struct {
ULONG_PTR n, reserved;
HcEntry e[1];
} HcTable;
typedef struct {
USHORT len, max;
PWSTR buf;
} HcName;
typedef struct { // one entry of ObjectTypesInformation; its name's characters follow it
HcName name;
ULONG totals[13]; // object and handle counts, pool use, their high-water marks, invalid attributes: not read
GENERIC_MAPPING mapping;
ULONG valid_access;
BOOLEAN security, maintain;
UCHAR index;
CHAR reserved;
ULONG pool, paged, nonpaged;
} HcType;
static void hc_type_names(char names[256][32]) {
typedef LONG(NTAPI * Qo)(HANDLE, ULONG, PVOID, ULONG, PULONG);
HMODULE nt = GetModuleHandleW(L"ntdll.dll");
Qo qo = nt ? (Qo)(void *)GetProcAddress(nt, "NtQueryObject") : NULL;
if (!qo) return;
size_t cap = 1u << 16;
uint8_t *buf = NULL;
LONG st = -1;
for (int tries = 0; tries < 6; tries++, cap *= 2) {
uint8_t *b = realloc(buf, cap);
if (!b) break;
buf = b;
ULONG need = 0;
st = qo(NULL, 3, buf, (ULONG)cap, &need); // ObjectTypesInformation
if (st != (LONG)0xC0000004L) break; // not STATUS_INFO_LENGTH_MISMATCH: done, or failed
}
if (st >= 0 && buf) {
ULONG count = *(ULONG *)buf;
const uint8_t *p = buf + sizeof(void *), *end = buf + cap; // the count, then entries at pointer alignment
for (ULONG i = 0; i < count && p + sizeof(HcType) <= end; i++) {
const HcType *t = (const HcType *)p;
WideCharToMultiByte(CP_UTF8, 0, t->name.buf, t->name.len / 2, names[t->index], 31, NULL, NULL);
p += sizeof(HcType) + ((t->name.max + sizeof(void *) - 1) & ~(sizeof(void *) - 1));
}
}
free(buf);
}
int plat_handle_census(PlatHandleKind *out, int max) {
typedef LONG(NTAPI * Qsi)(ULONG, PVOID, ULONG, PULONG);
static char names[256][32];
static int named;
static void *table;
static size_t cap;
HMODULE nt = GetModuleHandleW(L"ntdll.dll");
Qsi qsi = nt ? (Qsi)(void *)GetProcAddress(nt, "NtQuerySystemInformation") : NULL;
if (!qsi || max <= 0) return -1;
if (!named) hc_type_names(names), named = 1;
LONG st = -1;
for (int tries = 0; tries < 6; tries++) {
if (!table && !(table = malloc(cap = 4u << 20))) return -1;
ULONG need = 0;
st = qsi(64, table, (ULONG)cap, &need); // SystemExtendedHandleInformation
if (st != (LONG)0xC0000004L) break; // the table outgrew the buffer: a larger one
size_t want = need > cap ? need + (1u << 20) : cap * 2;
void *b = realloc(table, want);
if (!b) return -1;
table = b, cap = want;
}
if (st < 0) return -1;
uint32_t count[256] = {0};
const HcTable *t = table;
ULONG_PTR pid = GetCurrentProcessId();
for (ULONG_PTR i = 0; i < t->n && offsetof(HcTable, e) + (i + 1) * sizeof(HcEntry) <= cap; i++)
if (t->e[i].pid == pid) count[t->e[i].type & 255]++;
int n = 0;
for (int k = 0; k < 256; k++) {
if (!count[k]) continue;
if (n == max) { // no room: the last entry takes the rest
snprintf(out[max - 1].name, sizeof out[0].name, "%s", "(more kinds)");
out[max - 1].n += count[k];
continue;
}
if (names[k][0]) snprintf(out[n].name, sizeof out[0].name, "%s", names[k]);
else snprintf(out[n].name, sizeof out[0].name, "type %d", k);
out[n++].n = count[k];
}
return n;
}
// The UCRT's malloc takes its memory from the heap _get_heap_handle names (the process heap); HeapSummary sums it. The
// other heaps are only counted: one made with HEAP_NO_SERIALIZE has no lock to take.
void plat_heap_info(PlatHeapInfo *h) {