"""A save file's handle and a CloseFile on another thread (runtime/fs_host.c file_of, file_release, close_file): a call under way keeps its host file open, the close happens once when the last call is out, the guest's handle value is not handed out again before that, and a call after the close gets FS_R_INVALID_ARGUMENT. A call with no close pending takes no exclusive lock, so it ends while another thread holds the lock shared (a Commit's fsync loop). The host files here are stand-ins that hand a closed file's value to the next one opened, as Windows does with a HANDLE: a read that went on through a closed handle would read the other file. Builds fs_host.c's file functions into a test program. No game files. Usage: python tests/fs_file_use_check.py [path to clang]""" import os import re import shutil import subprocess import sys from pathlib import Path ROOT = Path(__file__).resolve().parents[1] MSYS_BIN = Path(r'C:\msys64\ucrt64\bin') source = (ROOT / 'runtime' / 'fs_host.c').read_text(encoding='utf-8') def compiler(): if len(sys.argv) > 1: return sys.argv[1] if os.environ.get('CC'): return os.environ['CC'] if os.name == 'nt' and (MSYS_BIN / 'clang.exe').exists(): return str(MSYS_BIN / 'clang.exe') return shutil.which('clang') or 'clang' def function(signature): start = source.index(signature) brace = source.index('{', start) depth, end = 1, brace + 1 while depth: depth += (source[end] == '{') - (source[end] == '}') end += 1 return source[start:end] HARNESS = r''' #include #include #include #include #include typedef SRWLOCK PlatMutex; #define PLAT_MUTEX_INIT SRWLOCK_INIT static volatile LONG exclusive_takes; // exclusive acquisitions of fs_host.c's lock static void plat_mutex_lock(PlatMutex *m) { InterlockedIncrement(&exclusive_takes); AcquireSRWLockExclusive(m); } static void plat_mutex_unlock(PlatMutex *m) { ReleaseSRWLockExclusive(m); } static void plat_mutex_lock_shared(PlatMutex *m) { AcquireSRWLockShared(m); } static void plat_mutex_unlock_shared(PlatMutex *m) { ReleaseSRWLockShared(m); } static void plat_inc32(volatile int32_t *v) { InterlockedIncrement((volatile LONG *)v); } static void plat_dec32(volatile int32_t *v) { InterlockedDecrement((volatile LONG *)v); } static void rt_log(const char *fmt, ...) { (void)fmt; } __attribute__((noreturn)) static void rt_fatal(const char *fmt, ...) { printf("FATAL: %s\n", fmt); fflush(stdout); ExitProcess(99); } enum { FS_OPEN_READ = 1, FS_OPEN_WRITE = 2, FS_OPEN_APPEND = 4 }; enum { FS_R_INVALID_ARGUMENT = 6001, FS_R_OPEN_MODE = 6002, FS_R_PATH_NOT_FOUND = 6003, FS_R_UNSUPPORTED_OPEN = 6004 }; enum { M_FREE, M_SAVE, M_TEMP, M_CACHE, M_SAVE_RO }; enum { PLAT_FS_FILE = 1 }; #define FILE_BASE 0x1000 #define NFILES 8 #define PATH_CAP 64 static int romfs_owns(const char *p) { (void)p; return 0; } static uint32_t romfs_open(uint64_t *o, const char *p, int m) { (void)o, (void)p, (void)m; return 1; } static int romfs_handle(uint64_t h) { (void)h; return 0; } static uint32_t romfs_read(uint64_t *o, uint64_t h, int64_t off, void *b, uint64_t n) { (void)o, (void)h, (void)off, (void)b, (void)n; return 1; } static void romfs_close(uint64_t h) { (void)h; } static void fs_trace(const char *w, const char *p) { (void)w, (void)p; } static uint32_t fs_result(int e) { return e ? 6099u : 0; } static void mem_thaw(uintptr_t a, uint64_t n) { (void)a, (void)n; } static uint32_t host_path_kind(const char *path, char *p, size_t n, int *kind) { snprintf(p, n, "%s", path); *kind = M_SAVE; return 0; } static int plat_fs_kind(const char *p) { (void)p; return PLAT_FS_FILE; } static volatile int32_t save_writers; static void save_touched(void) {} // The host's files: four kernel objects; a close frees one, and the next open takes the lowest free one, so a closed // handle's value comes back for another file at once. typedef struct PlatFile { volatile LONG open, closes; char content; } PlatFile; static PlatFile kfiles[4]; static SRWLOCK klock = SRWLOCK_INIT; static HANDLE hold_read, in_read; // hold_read set: a read waits for it (and says so through in_read) static PlatFile *plat_fs_open(const char *p, int write, int *err) { (void)write; AcquireSRWLockExclusive(&klock); for (int i = 0; i < 4; i++) if (!kfiles[i].open) { kfiles[i].open = 1, kfiles[i].content = p[0]; ReleaseSRWLockExclusive(&klock); return &kfiles[i]; } ReleaseSRWLockExclusive(&klock); *err = 1; return NULL; } static void plat_file_close(PlatFile *f) { AcquireSRWLockExclusive(&klock); if (!f->open) printf("FAIL: a host file closed twice\n"); f->open = 0, f->closes++; ReleaseSRWLockExclusive(&klock); } static int64_t plat_file_pread(PlatFile *f, void *buf, uint32_t n, uint64_t off) { (void)off; if (hold_read) { SetEvent(in_read); WaitForSingleObject(hold_read, INFINITE); } for (volatile int spin = 0; spin < 200; spin++) {} // the window in which another thread may close and open if (!f->open) return -1; memset(buf, f->content, n); return n; } ''' MAIN = r''' static uint64_t h_read; static char got; static uint32_t got_r; static DWORD WINAPI reader(void *arg) { (void)arg; uint64_t n = 0; char b[4] = {0}; got_r = read_file(&n, h_read, 0, b, 4); got = b[0]; return 0; } static volatile LONG stop, foreign, invalid, reads; static volatile uint64_t current; // the handle the looping reader reads: a file named "a" static DWORD WINAPI loop_reader(void *arg) { (void)arg; while (!stop) { uint64_t n = 0; char b[4] = {0}; uint32_t r = read_file(&n, current, 0, b, 4); if (!r && b[0] != 'a') InterlockedIncrement(&foreign); if (r == FS_R_INVALID_ARGUMENT) InterlockedIncrement(&invalid); InterlockedIncrement(&reads); } return 0; } int main(void) { int fails = 0; uint64_t ha, hb, hc; // 1. A read under way when CloseFile comes: it finishes in its own file; the close happens when it is out, once. if (open_file(&ha, "a", FS_OPEN_READ | FS_OPEN_WRITE)) return printf("FAIL: open\n"), 1; PlatFile *ka = files[ha - FILE_BASE].h; hold_read = CreateEventW(NULL, TRUE, FALSE, NULL), in_read = CreateEventW(NULL, FALSE, FALSE, NULL); h_read = ha; HANDLE t = CreateThread(NULL, 0, reader, NULL, 0, NULL); WaitForSingleObject(in_read, INFINITE); close_file(ha); int closed_early = ka->closes; uint64_t n = 0; char b[4]; HANDLE hr = hold_read; hold_read = NULL; // the calls below do not wait uint32_t after = read_file(&n, ha, 0, b, 4); open_file(&hb, "b", FS_OPEN_READ); int reused = hb == ha || files[hb - FILE_BASE].h == ka; SetEvent(hr); WaitForSingleObject(t, INFINITE); printf("close during a read: closed %s, a read after the close %s, the next open %s, the read got '%c' (%s), the " "file closed %ld time(s)\n", closed_early ? "AT ONCE (FAIL)" : "after the read", after == FS_R_INVALID_ARGUMENT ? "refused" : "ALLOWED (FAIL)", reused ? "TOOK ITS HANDLE (FAIL)" : "got another", got, got_r || got != 'a' ? "FAIL" : "ok", (long)ka->closes); if (closed_early || after != FS_R_INVALID_ARGUMENT || reused || got != 'a' || got_r || ka->closes != 1) fails++; open_file(&hc, "c", FS_OPEN_READ); if (hc != ha) printf("FAIL: the closed slot was not free again (%#llx)\n", (unsigned long long)hc), fails++; close_file(hb), close_file(hc); // 2. Calls with no close pending take no exclusive lock: 1000 reads add none, and a read ends while another thread // holds the lock shared (fs_host.c commit's fsync loop runs so). open_file(&ha, "a", FS_OPEN_READ); LONG before = exclusive_takes; int bad_reads = 0; for (int i = 0; i < 1000; i++) bad_reads += read_file(&n, ha, 0, b, 4) != 0 || b[0] != 'a'; LONG taken = exclusive_takes - before; AcquireSRWLockShared(&lock); h_read = ha, got = 0; t = CreateThread(NULL, 0, reader, NULL, 0, NULL); int ended = WaitForSingleObject(t, 2000) == WAIT_OBJECT_0; ReleaseSRWLockShared(&lock); WaitForSingleObject(t, INFINITE); printf("reads with no close pending: 1000 reads took the exclusive lock %ld time(s)%s, a read beside a shared holder " "%s\n", (long)taken, taken ? " (FAIL)" : "", ended ? "ended" : "WAITED FOR IT (FAIL)"); if (taken || bad_reads || !ended || got != 'a') fails++; close_file(ha); // 3. A reader loops over a file "a" while another thread closes it, opens "b" (which may take a closed handle's // value) and opens "a" again: no read returns b's bytes. open_file(&ha, "a", FS_OPEN_READ); current = ha; HANDLE r = CreateThread(NULL, 0, loop_reader, NULL, 0, NULL); for (int i = 0; i < 20000; i++) { close_file(current); open_file(&hb, "b", FS_OPEN_READ); open_file(&ha, "a", FS_OPEN_READ); current = ha; close_file(hb); } stop = 1; WaitForSingleObject(r, INFINITE); close_file(current); printf("a reader beside 20000 closes and opens: %ld reads, %ld refused after a close, %ld read another file's " "bytes\n", (long)reads, (long)invalid, (long)foreign); if (foreign) fails++; int open_left = 0; for (int i = 0; i < 4; i++) open_left += kfiles[i].open; for (int i = 0; i < NFILES; i++) open_left += files[i].h != NULL; if (open_left) printf("FAIL: %d files left open\n", open_left), fails++; printf("fs_file_use_check: %s\n", fails ? "FAILED" : "ok"); return fails ? 1 : 0; } ''' def main(): if os.name != 'nt': print('fs_file_use_check: Windows only') return 0 file_t = re.search(r'typedef struct \{ PlatFile \*h;[^\n]*\} File;', source).group(0) parts = [HARNESS, file_t, 'static File files[NFILES];', 'static PlatMutex lock = PLAT_MUTEX_INIT;'] for sig in ('static File *file_of(', 'static void file_closed(', 'static void file_clear(', 'static void file_release(', 'static int64_t host_read_at(', 'static uint32_t open_file(', 'static uint32_t read_file(', 'static void close_file('): parts.append(function(sig)) parts.append(MAIN) work = ROOT / 'build' / 'test' / 'fs_file_use' work.mkdir(parents=True, exist_ok=True) (work / 'fs_file_use_check.c').write_text('\n'.join(parts), encoding='utf-8') exe = work / 'fs_file_use_check.exe' env = dict(os.environ) if MSYS_BIN.exists(): env['PATH'] = str(MSYS_BIN) + os.pathsep + env.get('PATH', '') subprocess.check_call([compiler(), '-O1', '-g', '-Wall', '-Wno-unused-function', str(work / 'fs_file_use_check.c'), '-o', str(exe)], env=env) return subprocess.run([str(exe)], env=env, timeout=300).returncode if __name__ == '__main__': sys.exit(main())