mirror of
https://github.com/valentderah/totk-pc-recomp.git
synced 2026-11-21 04:55:56 +00:00
Delete read-only folders and cloud placeholders of an old save working copy, retry for 2 s, and name the failing path in the fatal
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
6c2595275d
commit
d3f403ecf6
4 files changed
+80
-13
No files matched your search
+48
-5
@@ -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);
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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);
|
||||
|
||||
Reference in new issue
Block a user