From 7f846ae03da8d7327a3b09685ba659849414e8ba Mon Sep 17 00:00:00 2001 From: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com> Date: Fri, 13 Nov 2026 14:25:17 -0500 Subject: [PATCH] Launcher: the shared-folder cleanup never collides with an earlier cleanup; bounded retries StartCleanup moves %LOCALAPPDATA%\WrongGPU aside and lets a hidden cmd.exe delete it. The target name was .cleanup--; that clock moves in steps of about 16 ms, so a second cleanup of the same folder within one step (an install's restore followed by the last game's uninstall, or Remove data right after an uninstall) aimed at the first cleanup's folder, which is deleted only seconds later. The move failed with error 183 and the folder was left in place ("cleanup deferred"). - The target name adds a process-wide sequence number and is checked free first. - A sharing violation (32) or an access denied (5: how a folder rename fails while another program, such as a scanner, has a just-written file in it open) is tried again, at most 5 times with waits from 50 ms doubling, each wait logged with the error. Any other error is final; the deferred line now names the error. - Test seam SetCleanupMoveForTest (record.h). Tests (wg-core, every build): two cleanups of one folder back to back, 20 runs; error 5 for 3 tries then success; error 5 every time (5 tries, folder left, deferred line names the error); error 32 twice then success; error 183 once (deferred at once). Split out of #46 at review. Signed-off-by: phantoslayer21 <156617979+phantoslayer21@users.noreply.github.com> --- clean/installer/src/wg_core/record.cpp | 40 +++++++++++- clean/installer/src/wg_core/record.h | 10 +++ clean/installer/tests/wg_core_tests.cpp | 86 +++++++++++++++++++++++++ 3 files changed, 133 insertions(+), 3 deletions(-) diff --git a/clean/installer/src/wg_core/record.cpp b/clean/installer/src/wg_core/record.cpp index 30eff7d3..495c3846 100644 --- a/clean/installer/src/wg_core/record.cpp +++ b/clean/installer/src/wg_core/record.cpp @@ -4,6 +4,7 @@ #include "record.h" #include +#include #include "detect.h" #include "gamerules.h" @@ -350,14 +351,47 @@ size_t RemoveRuntimeFiles(const wstring& dir, const wstring& exeDir, const Recor // programs it starts share one invisible console, so nothing appears on screen. // state / self: the wronggpu-setup folder and the running uninstaller in it (empty: not this case); appData: // %LOCALAPPDATA%\WrongGPU, removed with everything in it (empty: other games still use it). +static std::atomic g_cleanupMove{nullptr}; // test seam (record.h SetCleanupMoveForTest) +void SetCleanupMoveForTest(CleanupMoveFn fn) { g_cleanupMove = fn; } + void StartCleanup(Context& ctx, const wstring& state, const wstring& self, const wstring& appData) { // Detach this generation now. Delayed cleanup must never recursively delete the shared pathname, // which a following install can already have recreated with its new model and runtime selection. wstring retired; if (!appData.empty() && IsDir(appData)) { - retired = appData + L".cleanup-" + std::to_wstring(GetCurrentProcessId()) + L"-" + std::to_wstring(GetTickCount64()); - if (!MoveFileExW(appData.c_str(), retired.c_str(), MOVEFILE_WRITE_THROUGH)) { - LogLine(ctx, L"Shared data cleanup deferred: cannot detach " + appData + L"; it was left in place."); + // The name the folder is moved to is free and unique. It was - alone; that clock moves in + // ~16 ms steps, so a second cleanup of the same folder within one step (an install's restore, then the last game's + // uninstall) aimed at the previous cleanup's folder, which its cmd.exe deletes only seconds later: the move failed + // with ERROR_ALREADY_EXISTS and the folder was left in place. + static std::atomic sequence{0}; + for (int k = 0; k < 64; ++k) { + retired = appData + L".cleanup-" + std::to_wstring(GetCurrentProcessId()) + L"-" + std::to_wstring(GetTickCount64()) + L"-" + + std::to_wstring(sequence++); + if (GetFileAttributesW(retired.c_str()) == INVALID_FILE_ATTRIBUTES) break; + } + // Nothing of WrongGPU's holds a file in the folder here (every write closes its handle, the log opens and closes + // per line). Another program can, briefly (a scanner reading a file just written): a sharing violation (32) or an + // access denied (5, how a folder rename fails while a file in it is open elsewhere) is tried again, at most + // kCleanupMoveTries times, 50-400 ms apart, each wait logged with the error. Any other error is final. + bool moved = false; + DWORD err = 0; + const CleanupMoveFn seam = g_cleanupMove.load(); + const CleanupMoveFn move = seam ? seam : &MoveFileExW; + for (int t = 0; t < kCleanupMoveTries; ++t) { + if (move(appData.c_str(), retired.c_str(), MOVEFILE_WRITE_THROUGH)) { moved = true; break; } + err = GetLastError(); + if ((err != ERROR_SHARING_VIOLATION && err != ERROR_ACCESS_DENIED) || t == kCleanupMoveTries - 1) break; + const DWORD wait = kCleanupMoveFirstWaitMs << t; + LogLine(ctx, L"Shared data cleanup: " + appData + L" is in use by another program (error " + std::to_wstring(err) + + (err == ERROR_SHARING_VIOLATION ? L", sharing violation" : L", access denied") + L"); trying again in " + + std::to_wstring(wait) + L" ms (try " + std::to_wstring(t + 2) + L" of " + std::to_wstring(kCleanupMoveTries) + L")"); + Sleep(wait); + } + if (!moved) { + wstring why = ErrText(err); + while (!why.empty() && (why.back() == L'\n' || why.back() == L'\r' || why.back() == L' ' || why.back() == L'.')) why.pop_back(); + LogLine(ctx, L"Shared data cleanup deferred: cannot detach " + appData + L" (error " + std::to_wstring(err) + L": " + why + + L"); it was left in place."); retired.clear(); } else if (StartsWithI(ctx.logFile, appData + L"\\")) { ctx.logFile = retired + ctx.logFile.substr(appData.size()); diff --git a/clean/installer/src/wg_core/record.h b/clean/installer/src/wg_core/record.h index 66b717b5..e96c75b4 100644 --- a/clean/installer/src/wg_core/record.h +++ b/clean/installer/src/wg_core/record.h @@ -134,6 +134,16 @@ bool PortableLauncherUsesSharedData(); void NotePortableLauncher(const wstring& exe); void UnregisterUninstall(const Record& m); size_t RemoveRuntimeFiles(const wstring& dir, const wstring& exeDir, const Record& m, bool settings); +// The shared folder (appData) is moved aside, to a free name made unique with a process-wide sequence number, and deleted by a +// hidden cmd.exe. The move: a sharing violation (32) or an access denied (5: a scanner holding a file in the folder) is tried +// again, at most kCleanupMoveTries times (waits from kCleanupMoveFirstWaitMs doubling: 50, 100, 200, 400 ms), each wait logged +// with the error; any other error, or the last try, leaves the folder in place ("Shared data cleanup deferred ... (error N: ...)"). +constexpr int kCleanupMoveTries = 5; +constexpr unsigned long kCleanupMoveFirstWaitMs = 50; +// Test seam: the call StartCleanup moves the folder with (MoveFileExW when unset). The tests put in one that fails with +// a chosen error for the first tries; nullptr puts MoveFileExW back. +using CleanupMoveFn = BOOL (WINAPI*)(LPCWSTR from, LPCWSTR to, DWORD flags); +void SetCleanupMoveForTest(CleanupMoveFn fn); void StartCleanup(Context& ctx, const wstring& state, const wstring& self, const wstring& appData); std::vector DoRestore(Context& ctx, const wstring& dir, Ui& ui, bool failedInstall, bool keepState); // rc6 L4: the player's things in the state folder that a failed install or update never removes when they were there before diff --git a/clean/installer/tests/wg_core_tests.cpp b/clean/installer/tests/wg_core_tests.cpp index 293edd1b..fbd0d2cf 100644 --- a/clean/installer/tests/wg_core_tests.cpp +++ b/clean/installer/tests/wg_core_tests.cpp @@ -2,6 +2,7 @@ // Unit tests of wg_core (the installer's / launcher's engine) that need no game, no payload and no GPU: strings and // paths, the install record, wronggpu.ini keys, the runtime options of a Model-M-only build, the Context's log file. // Written for this project. Run by ctest ("wg-core") in a WRONGGPU_TESTING build. +#include #include #include #include @@ -29,6 +30,19 @@ wstring TempFolder() { EnsureDir(dir); return dir; } +// StartCleanup's folder move for the retry cases (record.h SetCleanupMoveForTest): the first g_moveFailFirst calls fail +// with g_moveError, later ones really move. +std::atomic g_moveCalls{0}, g_moveFailFirst{0}; +std::atomic g_moveError{0}; +BOOL WINAPI FakeMove(LPCWSTR from, LPCWSTR to, DWORD flags) { + if (++g_moveCalls <= g_moveFailFirst) { SetLastError(g_moveError); return FALSE; } + return MoveFileExW(from, to, flags); +} +size_t CountIn(const string& s, const string& part) { + size_t n = 0; + for (size_t at = 0; (at = s.find(part, at)) != string::npos; ++at) ++n; + return n; +} } // namespace int main() { @@ -241,6 +255,78 @@ int main() { LogLine(ctx, L"second \u00e9"); string log; require(ReadAll(ctx.logFile, log) && log.find("] first\r\n") != string::npos && log.find("] second \xc3\xa9\r\n") != string::npos, "LogLine appends UTF-8 lines"); + + // StartCleanup: the shared folder moved aside to a name that is free, with bounded retries. Synthetic folder in the + // temp folder; the hidden cmd.exe it starts deletes each moved-aside folder a few seconds later. + { + const wstring cleanRoot = Join(dir, L"cleanup"), appData = Join(cleanRoot, L"WrongGPU"); + const wstring modelFile = Join(appData, L"model\\model.wgcm"); + auto makeShared = [&] { EnsureDir(Parent(modelFile)); const char d[] = "synthetic model data"; WriteFileAtomic(modelFile, d, sizeof d - 1); }; + auto contains = [](const string& s, const string& part) { return s.find(part) != string::npos; }; + // two cleanups of one folder back to back, 20 runs (CI has one runner: not more). Within one GetTickCount64 step + // (~16 ms) the second move used to aim at the first one's folder, which its cmd.exe deletes seconds later: error + // 183, the folder left in place. + { + Context sctx; + sctx.logFile = Join(cleanRoot, L"cleanup-stress.log"); // outside the folder that is moved + const int runs = 20; + int gone = 0; + for (int i = 0; i < runs; ++i) { + makeShared(); + StartCleanup(sctx, L"", L"", appData); + const bool first = !IsDir(appData); + makeShared(); + StartCleanup(sctx, L"", L"", appData); + if (first && !IsDir(appData)) ++gone; + } + string slog; + ReadAll(sctx.logFile, slog); + std::printf("wg-core: cleanup stress %d/%d (deferred %zu)\n", gone, runs, CountIn(slog, "cleanup deferred")); + require(gone == runs && !contains(slog, "cleanup deferred"), "two cleanups of one folder back to back: it goes both times, 20 of 20 runs"); + } + // the bounded retry (error 32 sharing violation, error 5 access denied: a scanner's open file), through the test + // seam: fails for the first N tries, then moves; or fails every time and ends deferred; any other error is final + { + Context rctx; + rctx.logFile = Join(cleanRoot, L"cleanup-retry.log"); + struct Case { DWORD error; int failFirst; bool gone; int calls; size_t retries; const char* what; }; + const Case cases[] = { + {ERROR_ACCESS_DENIED, 3, true, 4, 3, "error 5 for 3 tries, then the move: the folder goes after 3 logged retries"}, + {ERROR_ACCESS_DENIED, 1000, false, kCleanupMoveTries, kCleanupMoveTries - 1, + "error 5 every time: 5 tries (4 logged retries), then deferred with the error named, the folder left in place"}, + {ERROR_SHARING_VIOLATION, 2, true, 3, 2, "error 32 for 2 tries, then the move: the folder goes"}, + {ERROR_ALREADY_EXISTS, 1, false, 1, 0, "error 183 once: no retry, deferred at once"}}; + for (const Case& rc : cases) { + DeleteFileW(rctx.logFile.c_str()); + makeShared(); + g_moveCalls = 0; g_moveFailFirst = rc.failFirst; g_moveError = rc.error; + SetCleanupMoveForTest(&FakeMove); + const ULONGLONG t0 = GetTickCount64(); + StartCleanup(rctx, L"", L"", appData); + const ULONGLONG took = GetTickCount64() - t0; + SetCleanupMoveForTest(nullptr); + string rlog; + ReadAll(rctx.logFile, rlog); + const string code = "(error " + std::to_string(rc.error); + const size_t retries = CountIn(rlog, code + (rc.error == ERROR_SHARING_VIOLATION ? ", sharing violation); trying again" : ", access denied); trying again")); + const size_t deferred = CountIn(rlog, "cleanup deferred: cannot detach " + ToUtf8(appData) + " " + code + ":"); + std::printf("wg-core: cleanup retry, error %lu x %d: %d tries, %zu retries logged, deferred %zu, %llu ms\n", rc.error, rc.failFirst, + g_moveCalls.load(), retries, deferred, (unsigned long long)took); + require(IsDir(appData) == !rc.gone && g_moveCalls == rc.calls && retries == rc.retries && deferred == (rc.gone ? 0u : 1u) && took < 5000, rc.what); + } + if (IsDir(appData)) { // the deferred cases left it: the real move now + StartCleanup(rctx, L"", L"", appData); + require(!IsDir(appData), "after the retry cases: the folder goes"); + } + } + for (int i = 0; i < 600; ++i) { // the hidden cleanups delete the moved-aside folders (ping -n 3 first) + bool left = false; + for (auto& d : ListDirs(cleanRoot)) left = left || d.find(L".cleanup-") != wstring::npos; + if (!left) break; + Sleep(100); + } + } + RemoveTree(dir); require(!IsDir(dir), "RemoveTree"); } catch (const std::exception& ex) {