diff --git a/runtime/fs_host.c b/runtime/fs_host.c index 90eaa8dc..3af390a7 100644 --- a/runtime/fs_host.c +++ b/runtime/fs_host.c @@ -125,12 +125,30 @@ static void make_dirs(const char *p) { if (!make_dir(buf)) rt_fatal("fs: cannot create directory %s", buf); } -// Remove a directory tree; a link (reparse point, symbolic link) is removed as a link, never followed. 0 also when +// The first path remove_tree could not delete and the OS error code, for the message of a fatal. +static char remove_failed[1100]; +static int remove_error; +static void remove_note(const char *path) { + if (*remove_failed) return; + snprintf(remove_failed, sizeof remove_failed, "%s", path); + remove_error = plat_fs_os_error(); +} + +// Remove a directory tree; a link (symbolic link, junction) is removed as a link, never followed. 0 also when // nothing is there. static int remove_tree(const char *path) { int kind = plat_fs_kind(path); if (kind == PLAT_FS_MISSING) return 0; - if (kind == PLAT_FS_FILE) return plat_fs_unlink(path) ? -1 : 0; + if (kind == PLAT_FS_FILE) { + if (!plat_fs_unlink(path)) return 0; + remove_note(path); + return -1; + } + if (kind == PLAT_FS_LINK) { // a link to a file goes by unlink, a link to a directory by rmdir + if (!plat_fs_unlink(path) || !plat_fs_rmdir(path)) return 0; + remove_note(path); + return -1; + } int bad = 0; if (kind == PLAT_FS_DIR) { Listing l; @@ -142,7 +160,23 @@ static int remove_tree(const char *path) { } listing_free(l.e, l.n); } - return bad | (plat_fs_rmdir(path) ? -1 : 0); + if (plat_fs_rmdir(path)) { + remove_note(path); + bad |= -1; + } + return bad; +} + +// remove_tree, tried again every 50 ms for up to 2 s while another process (the previous run still exiting, a virus +// scanner, a sync client) holds a file in the tree. The failing path and its OS error stay in remove_failed. +#define MOVE_TRIES 40 // 2 s, also move_dir's +static int remove_tree_retry(const char *path) { + for (int i = 0;; i++) { + *remove_failed = 0; + if (!remove_tree(path)) return 0; + if (i == MOVE_TRIES) return -1; + plat_sleep_ms(50); + } } // ---- save transactions @@ -190,7 +224,6 @@ static int exists(const char *p) { return plat_fs_kind(p) != PLAT_FS_MISSING; } // Rename a directory, durably; retried every 50 ms, tries times in all, while another process (a virus scanner, the // indexer) holds a file in it. 0 on success. -#define MOVE_TRIES 40 // 2 s static int move_dir(const char *from, const char *to, int tries) { for (int i = 0; i < tries; i++) { int e = plat_fs_rename(from, to, 1); @@ -446,7 +479,8 @@ static void save_recover(void) { did = swap_in() ? "a finished commit still waits in save-tx; the game loads it from there" : "completed a finished commit"; if (exists(work_root)) { - if (remove_tree(work_root)) rt_fatal("fs: cannot delete the old save working copy"); + if (remove_tree_retry(work_root)) + rt_fatal("fs: cannot delete the old save working copy: %s (OS error %d)", remove_failed, remove_error); if (!strcmp(did, "nothing to recover")) did = "deleted the last run's working copy (changes after its last Commit)"; } @@ -1575,6 +1609,15 @@ static void probe_save_tx(const uint64_t *uid) { CALL(S_UNMOUNT, U("ro")); CHECK(RES(S_DELETE_FILE, U(a)) == 0 && RES(S_DELETE_FILE, U(b)) == 0 && tx_commit() == 0 && tx_read_committed("tx_a.sav") == -1, "Commit of deletions"); + // a run that left read-only folders and files in the working copy (attributes another emulator's save carried): + // the next start deletes them and names the failing path if it cannot + char *ro_dir = join(work_root, "ro_dir"), *ro_file = join(ro_dir, "ro.sav"); + CHECK(!plat_fs_mkdir(ro_dir) && plat_file_write(ro_file, "x", 1) && plat_file_set_readonly(ro_file, 1) && + plat_file_set_readonly(ro_dir, 1), "read-only leftovers in the working copy"); + probe_restart(uid); + CHECK(!exists(ro_dir), "the next start deleted a working copy with read-only folders"); + free(ro_dir); + free(ro_file); printf("save tx: uncommitted writes visible to the game and dropped by a restart and by Unmount, commits kept; a " "crash at each of %d commit steps recovers to the old save %d times, the new one %d times, mixed %d " "times; %d backups\n", steps, olds, news, mixed, backups); diff --git a/runtime/platform/linux.c b/runtime/platform/linux.c index 7d502925..629dc0fe 100644 --- a/runtime/platform/linux.c +++ b/runtime/platform/linux.c @@ -1038,6 +1038,8 @@ const void *plat_file_map(PlatFile *f) { return v == MAP_FAILED ? NULL : v; } +int plat_fs_os_error(void) { return errno; } + static int fs_err(int e) { switch (e) { case ENOENT: case ENOTDIR: return PLAT_FS_NOT_FOUND; diff --git a/runtime/platform/platform.h b/runtime/platform/platform.h index b8e0c74b..f5104a1f 100644 --- a/runtime/platform/platform.h +++ b/runtime/platform/platform.h @@ -316,8 +316,9 @@ enum { PLAT_FS_OK, PLAT_FS_NOT_FOUND, PLAT_FS_EXISTS, PLAT_FS_NOT_EMPTY, PLAT_FS enum { PLAT_FS_MISSING = -1, PLAT_FS_FILE, PLAT_FS_DIR, PLAT_FS_LINK }; // plat_fs_kind; LINK: a symbolic link or // reparse point, never followed int plat_fs_kind(const char *path); +int plat_fs_os_error(void); // the OS error code (GetLastError, errno) of this thread's last failed plat_fs_* call int plat_fs_mkdir(const char *path); // PLAT_FS_EXISTS when something is there -int plat_fs_rmdir(const char *path); // an empty directory, or a link to one +int plat_fs_rmdir(const char *path); // an empty directory (a read-only one too), or a link to one int plat_fs_unlink(const char *path); // a file or a link; a read-only one too // Renames a file or directory; never replaces (PLAT_FS_EXISTS). durable: the change is on the disk at return. int plat_fs_rename(const char *from, const char *to, int durable); diff --git a/runtime/platform/win32.c b/runtime/platform/win32.c index 6d83b6a3..3934f87f 100644 --- a/runtime/platform/win32.c +++ b/runtime/platform/win32.c @@ -866,7 +866,11 @@ const void *plat_file_map(PlatFile *f) { return v; } +static __thread DWORD fs_last_error; +int plat_fs_os_error(void) { return (int)fs_last_error; } + static int fs_err(DWORD e) { + fs_last_error = e; switch (e) { case ERROR_FILE_NOT_FOUND: case ERROR_PATH_NOT_FOUND: case ERROR_DIRECTORY: return PLAT_FS_NOT_FOUND; case ERROR_FILE_EXISTS: case ERROR_ALREADY_EXISTS: return PLAT_FS_EXISTS; @@ -876,12 +880,23 @@ static int fs_err(DWORD e) { } } +// A symbolic link or junction is a link: removed as a link, never followed. Any other reparse point (OneDrive's cloud +// placeholders, deduplicated files) is an ordinary file or directory whose content the file system fetches on access. +static int fs_kind_of(const WIN32_FIND_DATAW *fd) { + DWORD a = fd->dwFileAttributes; + if (a & FILE_ATTRIBUTE_REPARSE_POINT && (fd->dwReserved0 == IO_REPARSE_TAG_SYMLINK || fd->dwReserved0 == IO_REPARSE_TAG_MOUNT_POINT)) + return PLAT_FS_LINK; + return a & FILE_ATTRIBUTE_DIRECTORY ? PLAT_FS_DIR : PLAT_FS_FILE; +} + int plat_fs_kind(const char *path) { wchar_t w[WPATH]; if (!widen(path, w, WPATH)) return PLAT_FS_MISSING; - DWORD a = GetFileAttributesW(w); - if (a == INVALID_FILE_ATTRIBUTES) return PLAT_FS_MISSING; - return a & FILE_ATTRIBUTE_REPARSE_POINT ? PLAT_FS_LINK : a & FILE_ATTRIBUTE_DIRECTORY ? PLAT_FS_DIR : PLAT_FS_FILE; + WIN32_FIND_DATAW fd; + HANDLE h = FindFirstFileW(w, &fd); // the reparse tag comes with the find data only + if (h == INVALID_HANDLE_VALUE) return PLAT_FS_MISSING; + FindClose(h); + return fs_kind_of(&fd); } int plat_fs_mkdir(const char *path) { @@ -893,7 +908,15 @@ int plat_fs_mkdir(const char *path) { int plat_fs_rmdir(const char *path) { wchar_t w[WPATH]; if (!widen(path, w, WPATH)) return PLAT_FS_ERROR; - return RemoveDirectoryW(w) ? PLAT_FS_OK : fs_err(GetLastError()); + if (RemoveDirectoryW(w)) return PLAT_FS_OK; + DWORD e = GetLastError(), a = GetFileAttributesW(w); + if (e == ERROR_ACCESS_DENIED && a != INVALID_FILE_ATTRIBUTES && (a & FILE_ATTRIBUTE_READONLY)) { + // a read-only directory (copied over from another emulator's save folder) refuses RemoveDirectoryW + SetFileAttributesW(w, a & ~(DWORD)FILE_ATTRIBUTE_READONLY); + if (RemoveDirectoryW(w)) return PLAT_FS_OK; + e = GetLastError(); + } + return fs_err(e); } int plat_fs_unlink(const char *path) { @@ -1038,9 +1061,7 @@ int plat_fs_list(const char *dir, int (*cb)(const char *name, int kind, uint64_t if (!wcscmp(fd.cFileName, L".") || !wcscmp(fd.cFileName, L"..")) continue; char name[1024]; if (!WideCharToMultiByte(CP_UTF8, 0, fd.cFileName, -1, name, sizeof name, NULL, NULL)) continue; - DWORD a = fd.dwFileAttributes; - int kind = a & FILE_ATTRIBUTE_REPARSE_POINT ? PLAT_FS_LINK : a & FILE_ATTRIBUTE_DIRECTORY ? PLAT_FS_DIR - : PLAT_FS_FILE; + int kind = fs_kind_of(&fd); if (!cb(name, kind, (uint64_t)fd.nFileSizeHigh << 32 | fd.nFileSizeLow, ctx)) break; } while (FindNextFileW(h, &fd)); FindClose(h);