Files
Triforce-Source/gpu/vk/vk_hangdump.cpp
ruckus7382sfgsgdf 6c7117635c Triforce v0.6.0 "Sage Of Power"
Faster frames (the replay's memory work, held submits, helper threads, collection and capture cuts), the game letting old areas go (QueryMemoryInfo), the 0.5.2 stutter fixed, AMD RX 5000/6000 and integrated-GPU fixes, the GPU device chosen by name, the in-game menus and launcher reworked, controller, Linux and benchmark fixes.
2026-11-20 17:06:21 -06:00

255 lines
12 KiB
C++

// (EvilOOT) A watchdog for freezes. When no frame has been presented for RX_VK_HANG_SEC seconds (default 20) after the
// first, every thread of the process is suspended in turn and its stack unwound with Windows' own unwinder (the modules'
// .pdata); the return addresses go to a file as module+offset, with the thread's name, once all threads run again.
// Triforce.map / triforce_vk.map turn the offsets into functions.
// (11-07: a freeze right after Load, every thread waiting, none spinning: which wait is it.)
// Nothing is allocated, locked or logged while a thread is suspended: it may hold the heap's or the log's lock.
//
// (Triforce, after NX2navi's hang watch) On in every run, not only with RX_VK_HANG_DUMP=<file>: a freeze left a log that
// just stopped, and the reports of a game that "stops with no error in the log" had nothing to go by. The file is
// triforce_hang.txt beside the game, and the top of every stack goes into the log as well, so that the log alone says
// where the threads were. Without a file named, a second counts only while the game's window is in front and not
// minimized (behind another window the game may show no frames), a stall is reported once (the next needs a frame
// first) and a run reports at most three (gpu/vk/hang_watch.h). The watch never ends the game: one that recovers goes
// on. RX_VK_HANG_DUMP=<file> writes there and judges every second, as before; RX_VK_HANG_DUMP=0 turns the watch off.
#ifdef _WIN32 // (hookshot: thread stacks through the Win32 debug API; the Linux build has none, see the end)
#define WIN32_LEAN_AND_MEAN
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <windows.h>
#include <tlhelp32.h>
#include <algorithm>
#include <atomic>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <thread>
#include "file_whole.h" // ((Triforce, handoff §8) the report whole, and the process's end: file_writers.h)
#include "hang_watch.h"
#include "vk_api.h"
#include "vk_paths.h"
namespace mkwvk {
extern int64_t presents_now;
void logf(const char* fmt, ...); // (vk_main.cpp)
extern const MkwVkHost* host; // (vk_main.cpp: its log_flush writes the queued log lines out)
namespace {
constexpr int kMaxThreads = 512;
constexpr int kMaxFrames = 40;
constexpr int kLogFrames = 8; // (the frames of each stack that go into the log; the file has them all)
struct ThreadStack {
DWORD id;
int frames;
DWORD64 pc[kMaxFrames];
char name[96];
};
ThreadStack stacks[kMaxThreads];
int unwind(HANDLE h, DWORD64* out) {
CONTEXT ctx{};
ctx.ContextFlags = CONTEXT_FULL;
if (!GetThreadContext(h, &ctx)) return 0;
int n = 0;
for (; n < kMaxFrames && ctx.Rip; n++) {
out[n] = ctx.Rip;
DWORD64 image = 0;
PRUNTIME_FUNCTION f = RtlLookupFunctionEntry(ctx.Rip, &image, nullptr);
if (!f) { // (a leaf: the return address on the top of the stack)
if (IsBadReadPtr((void*)ctx.Rsp, 8)) break;
ctx.Rip = *(DWORD64*)ctx.Rsp;
ctx.Rsp += 8;
} else {
void* handler_data = nullptr;
DWORD64 frame = 0;
RtlVirtualUnwind(UNW_FLAG_NHANDLER, image, ctx.Rip, f, &ctx, &handler_data, &frame, nullptr);
}
if (!ctx.Rsp) break;
}
return n;
}
/// An address as its module's file name and the offset in it ("?" and the address itself where no module holds it)
DWORD64 in_module(DWORD64 pc, char* mod, size_t size) {
HMODULE m = nullptr;
snprintf(mod, size, "?");
if (GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, (LPCSTR)pc, &m) && m) {
char full[MAX_PATH];
if (GetModuleFileNameA(m, full, sizeof full)) {
const char* b = full;
for (const char* q = full; *q; q++)
if (*q == '\\' || *q == '/') b = q + 1;
snprintf(mod, size, "%s", b);
}
}
return m ? pc - (DWORD64)m : pc;
}
/// Every other thread's stack into the file, and with to_log the top of each into the log. False when the file could
/// not be written (the log's lines are written all the same)
bool dump(const char* path, bool to_log) {
const DWORD self = GetCurrentThreadId(), pid = GetCurrentProcessId();
HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
if (snap == INVALID_HANDLE_VALUE) return false;
int count = 0;
THREADENTRY32 te{sizeof te};
for (BOOL ok = Thread32First(snap, &te); ok && count < kMaxThreads; ok = Thread32Next(snap, &te)) {
if (te.th32OwnerProcessID != pid || te.th32ThreadID == self) continue;
HANDLE h = OpenThread(THREAD_SUSPEND_RESUME | THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION, FALSE, te.th32ThreadID);
if (!h) continue;
ThreadStack& s = stacks[count];
s.id = te.th32ThreadID, s.frames = 0, s.name[0] = 0;
if (SuspendThread(h) != (DWORD)-1) {
s.frames = unwind(h, s.pc);
ResumeThread(h);
}
CloseHandle(h);
count++;
}
CloseHandle(snap);
// (all running again: now the names, the modules, the file and the log)
using GetDesc = HRESULT(WINAPI*)(HANDLE, PWSTR*);
const GetDesc get_desc = (GetDesc)(void*)GetProcAddress(GetModuleHandleA("kernel32.dll"), "GetThreadDescription");
for (int i = 0; i < count && get_desc; i++) {
ThreadStack& s = stacks[i];
if (HANDLE h = OpenThread(THREAD_QUERY_LIMITED_INFORMATION, FALSE, s.id)) {
PWSTR w = nullptr;
if (SUCCEEDED(get_desc(h, &w)) && w) {
WideCharToMultiByte(CP_UTF8, 0, w, -1, s.name, sizeof s.name, nullptr, nullptr);
s.name[sizeof s.name - 1] = 0;
LocalFree(w);
}
CloseHandle(h);
}
}
// ((Triforce, handoff §8) written beside it and put in its place: a report cut by the game's end (or by its close from
// outside, a hang's usual end) left half of one over the last; the exit waits for one under way, file_writers.h)
const file_writers::Writing writing;
const std::string part = std::string(path) + ".part";
FILE* f = writing ? fopen(part.c_str(), "w") : nullptr;
if (f) {
fprintf(f, "# hang dump: %d threads, %lld presents\n", count, (long long)presents_now);
for (int i = 0; i < count; i++) {
const ThreadStack& s = stacks[i];
fprintf(f, "\nthread %lu \"%s\" (%d frames)\n", (unsigned long)s.id, s.name, s.frames);
for (int k = 0; k < s.frames; k++) {
char mod[MAX_PATH];
const DWORD64 off = in_module(s.pc[k], mod, sizeof mod);
fprintf(f, " %2d %s+%#llx (%#llx)\n", k, mod, (unsigned long long)off, (unsigned long long)s.pc[k]);
}
}
const bool whole = !ferror(f);
if (fclose(f) != 0 || !whole || !file_writers::replace_file(part, path)) {
remove(part.c_str());
f = nullptr;
}
}
for (int i = 0; i < count && to_log; i++) {
const ThreadStack& s = stacks[i];
if (!s.frames) continue;
char line[900];
int n = snprintf(line, sizeof line, "vk: hang: thread %lu \"%s\":", (unsigned long)s.id, s.name);
for (int k = 0; k < s.frames && k < kLogFrames && n < (int)sizeof line - 80; k++) {
char mod[64];
const DWORD64 off = in_module(s.pc[k], mod, sizeof mod);
n += snprintf(line + n, sizeof line - (size_t)n, " %s+%#llx", mod, (unsigned long long)off);
}
logf("%s", line);
}
return f != nullptr;
}
/// ((Triforce) The ask's file taken away (hang_watch.h): DeleteFileW on the path as game_path_there reads it, so a game folder
/// past MAX_PATH is no different. False when it is still there: the ask is not served, or one file would ask every second
bool ask_take(const std::string& path) {
const int n = MultiByteToWideChar(CP_UTF8, 0, path.data(), (int)path.size(), nullptr, 0);
if (n <= 0) return false;
std::wstring w((size_t)n, L'\0');
MultiByteToWideChar(CP_UTF8, 0, path.data(), (int)path.size(), w.data(), n);
for (wchar_t& c : w)
if (c == L'/') c = L'\\';
const bool already = w.size() > 2 && w[0] == L'\\' && w[1] == L'\\' && (w[2] == L'?' || w[2] == L'.');
const bool unc = !already && w.size() > 2 && w[0] == L'\\' && w[1] == L'\\';
const bool drive = w.size() > 2 && w[1] == L':' && w[2] == L'\\';
if (!already && (unc || drive)) w = unc ? L"\\\\?\\UNC" + w.substr(1) : L"\\\\?\\" + w;
return DeleteFileW(w.c_str()) != 0;
}
/// The game's own window is the one in front, and not minimized
bool window_in_front() {
const HWND w = GetForegroundWindow();
DWORD pid = 0;
if (!w) return false;
GetWindowThreadProcessId(w, &pid);
return pid == GetCurrentProcessId() && !IsIconic(w);
}
/// triforce_hang.txt in the game folder (game_module_path's rule, as the caches beside the exe)
std::string default_path() {
char exe[MAX_PATH];
const DWORD n = game_module_path(exe, MAX_PATH);
const std::string dir(exe, n);
return dir.substr(0, dir.find_last_of("\\/") + 1) + "triforce_hang.txt";
}
} // namespace
/// (vk_replay.cpp, at the first present) starts the watchdog, unless RX_VK_HANG_DUMP=0
void hang_watch_start() {
static std::atomic<bool> started{false};
const char* named = getenv("RX_VK_HANG_DUMP");
if ((named && !strcmp(named, "0")) || started.exchange(true)) return;
const bool by_name = named && *named; // (asked for by name: every second is judged, whatever window is in front)
const std::string path = by_name ? std::string(named) : default_path();
const int sec = getenv("RX_VK_HANG_SEC") ? std::max(5, atoi(getenv("RX_VK_HANG_SEC"))) : 20;
std::thread([path, sec, by_name] {
SetThreadDescription(GetCurrentThread(), L"mkw_vk hang watch");
hangwatch::Watch watch;
int asked = 0;
bool ask_stuck = false; // (the ask's file could not be taken away: said once, not looked for again)
for (;;) {
Sleep(1000);
if (file_writers::stopping()) return; // ((Triforce) the game is ending: no report begins)
// ((Triforce) the stacks asked for from outside, hang_watch.h: the file taken away first, so that one ask is one report)
const std::string ask_path = path + hangwatch::kAskSuffix;
if (!ask_stuck && game_path_there(ask_path)) {
if (!ask_take(ask_path)) {
ask_stuck = true;
logf("vk: hang: %s is there but could not be taken away (read-only, or in use): no stacks are written for it",
ask_path.c_str());
} else if (hangwatch::ask(asked)) {
logf("vk: STACKS asked for (%s was there; present %lld): where every thread is follows, and their whole stacks "
"go to %s. Report %d of at most %d", ask_path.c_str(), (long long)presents_now, path.c_str(), asked,
hangwatch::kAsked);
if (!dump(path.c_str(), true)) logf("vk: hang: %s could not be written", path.c_str());
if (host && host->log_flush) host->log_flush();
}
}
const int64_t presents = presents_now;
if (!hangwatch::step(watch, presents, by_name || window_in_front(), sec)) continue;
logf("vk: HANG: no frame was shown for %d s%s (after present %lld). The game goes on if it can; where every "
"thread was follows, and their whole stacks go to %s: send that file with this log. Report %d of at "
"most %d", sec, by_name ? "" : " with the game's window in front", (long long)presents, path.c_str(),
watch.reports, hangwatch::kReports);
if (!dump(path.c_str(), true)) logf("vk: hang: %s could not be written", path.c_str());
// (the queued lines written out now: a game that never moves again is closed from outside, and the queue
// would go with it)
if (host && host->log_flush) host->log_flush();
}
}).detach();
}
} // namespace mkwvk
#else
namespace mkwvk {
void hang_watch_start() {} // (linux: no hang dump)
} // namespace mkwvk
#endif