mirror of
https://git.triforceproject.com/triforce/source
synced 2026-11-19 16:20:01 -04:00
What was merged from NX2navi (DLSS frame generation, AMD FSR 4 in Setup builds, texture detail by video memory, sprint, volume, frame caps, safer saves, the above-60 fixes), the ultrawide HUD at the screen edges, camera speed, movies without the AV1 Video Extension, the 5120x2880 + RenoDX HDR start fix, the renderer work of 11-14 and the first float changes of the lift.
402 lines
19 KiB
C
402 lines
19 KiB
C
/* (triforce) The save as a transaction, with backups. Included by nn_fs.c after its file helpers (its CreateFileA and the rest
|
|
are the long-path ones there); tests/test_save_tx.py compiles it alone.
|
|
|
|
On the console the game writes its save files and then calls nn::fs::Commit: until then the old save is what a power cut
|
|
leaves. Here the "save:" mount was the save folder itself and Commit did nothing, so a crash, a kill or a power cut in the
|
|
middle of a save left a half-written one, and nothing kept an older save. NX2navi commits its save as a transaction and
|
|
keeps backups (its runtime/fs_host.c, "save transactions": public domain); this is that design for Triforce's folders:
|
|
|
|
<user>/save/<uid>/ the committed save: where it always was (Setup's Convert saves, the lab's save copies)
|
|
<user>/save-tx/<uid>/work/ the working copy, the save mount's root; made from the committed save at each first mount
|
|
<user>/save-tx/<uid>/new/ Commit's staging copy of the working copy
|
|
<user>/save-tx/<uid>/ready-<n>/ a finished commit not swapped in yet: the newest save
|
|
<user>/save-tx/<uid>/old/ the committed save a Commit replaced, on its way to the backups
|
|
<user>/save-backup/<uid>/<UTC date-time>/ the saves Commits replaced: the newest SAVE_TX_BACKUPS of them
|
|
|
|
Commit: (1) copy work to new, every file written out to the disk (FlushFileBuffers); (2) rename new to ready-<n>, the commit
|
|
point, and delete the ready-<n> it supersedes; (3) rename save/<uid> to old; (4) rename ready-<n> to save/<uid>; (5) old
|
|
becomes a backup when the run has made none yet or the last one is SAVE_TX_BACKUP_GAP_S old, else it is deleted. Windows
|
|
refuses (3) while another program holds a file of the save open (a virus scanner, a sync tool): ready-<n> then stays the
|
|
newest save, and the next Commit and the next start try (3) to (5) again. A step that fails before the commit point falls
|
|
back to what was done before: the working copy's files copied over the save's.
|
|
|
|
The first mount of a run (save_tx_mount) puts the disk right after a run that died: new (an unfinished copy) is deleted; the
|
|
highest ready-<n> is swapped in; a save folder that is gone with old still there gets old back; then the working copy is
|
|
made again from the committed save, so changes no Commit took are gone, as on the console.
|
|
|
|
HOS_SAVE_TX=0: the save folder itself is the mount again and Commit does nothing, as before. */
|
|
#pragma once
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
|
|
#define SAVE_TX_BACKUPS 5
|
|
#define SAVE_TX_BACKUP_GAP_S 300
|
|
#define SAVE_TX_MOVE_TRIES 10 /* (20 ms apart: 0.2 s at most on the game's thread) */
|
|
|
|
typedef struct {
|
|
char save[HOS_FS_PATH], tx[HOS_FS_PATH], work[HOS_FS_PATH], staging[HOS_FS_PATH], old[HOS_FS_PATH], backups[HOS_FS_PATH];
|
|
} SaveTxPaths;
|
|
|
|
/* (tests: a Commit or a recovery stops before its save_tx_crash_at-th step, from 1, and leaves the disk as a process killed
|
|
there would; save_tx_test_now stands for the clock) */
|
|
static int save_tx_crash_at, save_tx_step, save_tx_dead;
|
|
static time_t save_tx_test_now;
|
|
static time_t save_tx_last_backup; /* (this run's last backup: 0 before the first) */
|
|
|
|
static int tx_crashed(void) {
|
|
if (save_tx_crash_at && ++save_tx_step == save_tx_crash_at) save_tx_dead = 1;
|
|
return save_tx_dead;
|
|
}
|
|
static time_t tx_now(void) { return save_tx_test_now ? save_tx_test_now : time(NULL); }
|
|
static int tx_exists(const char *p) { return GetFileAttributesA(p) != INVALID_FILE_ATTRIBUTES; }
|
|
static int tx_is_dir(const char *p) {
|
|
const DWORD a = GetFileAttributesA(p);
|
|
return a != INVALID_FILE_ATTRIBUTES && (a & FILE_ATTRIBUTE_DIRECTORY) && !(a & FILE_ATTRIBUTE_REPARSE_POINT);
|
|
}
|
|
|
|
static void tx_make_dirs(const char *path) { /* path and every parent of it */
|
|
char p[HOS_FS_PATH];
|
|
snprintf(p, sizeof p, "%s", path);
|
|
for (char *q = p + 1; *q; q++)
|
|
if ((*q == '\\' || *q == '/') && q[-1] != ':') {
|
|
const char keep = *q;
|
|
*q = 0;
|
|
CreateDirectoryA(p, NULL);
|
|
*q = keep;
|
|
}
|
|
CreateDirectoryA(p, NULL);
|
|
}
|
|
|
|
static void tx_delete_tree(const char *dir) {
|
|
char pat[HOS_FS_PATH];
|
|
WIN32_FIND_DATAA fd;
|
|
snprintf(pat, sizeof pat, "%s\\*", dir);
|
|
HANDLE f = FindFirstFileA(pat, &fd);
|
|
if (f != INVALID_HANDLE_VALUE) {
|
|
do {
|
|
if (!strcmp(fd.cFileName, ".") || !strcmp(fd.cFileName, "..")) continue;
|
|
char sub[HOS_FS_PATH];
|
|
snprintf(sub, sizeof sub, "%s\\%s", dir, fd.cFileName);
|
|
/* (a link goes itself: never what it points to) */
|
|
if (fd.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) { if (!DeleteFileA(sub)) RemoveDirectoryA(sub); }
|
|
else if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) tx_delete_tree(sub);
|
|
else DeleteFileA(sub);
|
|
} while (FindNextFileA(f, &fd));
|
|
FindClose(f);
|
|
}
|
|
RemoveDirectoryA(dir);
|
|
}
|
|
|
|
static int tx_empty(const char *dir) { /* 1: a folder with nothing in it */
|
|
char pat[HOS_FS_PATH];
|
|
WIN32_FIND_DATAA fd;
|
|
int any = 0;
|
|
snprintf(pat, sizeof pat, "%s\\*", dir);
|
|
HANDLE f = FindFirstFileA(pat, &fd);
|
|
if (f == INVALID_HANDLE_VALUE) return 1;
|
|
do {
|
|
if (strcmp(fd.cFileName, ".") && strcmp(fd.cFileName, "..")) any = 1;
|
|
} while (!any && FindNextFileA(f, &fd));
|
|
FindClose(f);
|
|
return !any;
|
|
}
|
|
|
|
/* One file; the source may be open for writing (a save file the game has not closed). 1: copied */
|
|
static int tx_copy_file(const char *src, const char *dst, int flush) {
|
|
HANDLE in = CreateFileA(src, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (in == INVALID_HANDLE_VALUE) return 0;
|
|
HANDLE out = CreateFileA(dst, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (out == INVALID_HANDLE_VALUE) {
|
|
CloseHandle(in);
|
|
return 0;
|
|
}
|
|
static const DWORD chunk = 1u << 16;
|
|
char *buf = (char *)malloc(chunk);
|
|
int ok = buf != NULL;
|
|
while (ok) {
|
|
DWORD got = 0, put = 0;
|
|
if (!ReadFile(in, buf, chunk, &got, NULL)) ok = 0;
|
|
else if (!got) break;
|
|
else if (!WriteFile(out, buf, got, &put, NULL) || put != got) ok = 0;
|
|
}
|
|
free(buf);
|
|
if (ok && flush && !FlushFileBuffers(out)) ok = 0;
|
|
CloseHandle(out);
|
|
CloseHandle(in);
|
|
return ok;
|
|
}
|
|
|
|
/* A folder with everything in it, links left out; dst is made. 1: every file copied */
|
|
static int tx_copy_tree(const char *src, const char *dst, int flush) {
|
|
tx_make_dirs(dst);
|
|
if (!tx_is_dir(dst)) return 0;
|
|
char pat[HOS_FS_PATH];
|
|
WIN32_FIND_DATAA fd;
|
|
snprintf(pat, sizeof pat, "%s\\*", src);
|
|
HANDLE f = FindFirstFileA(pat, &fd);
|
|
if (f == INVALID_HANDLE_VALUE) return tx_is_dir(src); /* (an empty folder has "." at least; a missing one is no copy) */
|
|
int ok = 1;
|
|
do {
|
|
if (!strcmp(fd.cFileName, ".") || !strcmp(fd.cFileName, "..")) continue;
|
|
if (fd.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) continue;
|
|
char a[HOS_FS_PATH], b[HOS_FS_PATH];
|
|
if (snprintf(a, sizeof a, "%s\\%s", src, fd.cFileName) >= (int)sizeof a ||
|
|
snprintf(b, sizeof b, "%s\\%s", dst, fd.cFileName) >= (int)sizeof b) { ok = 0; continue; }
|
|
if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ok &= tx_copy_tree(a, b, flush);
|
|
else ok &= tx_copy_file(a, b, flush);
|
|
} while (FindNextFileA(f, &fd));
|
|
FindClose(f);
|
|
return ok;
|
|
}
|
|
|
|
/* Rename a folder; tried again while another program holds a file in it. 1: moved */
|
|
static int tx_move(const char *from, const char *to, int tries) {
|
|
for (int i = 0; i < tries; i++) {
|
|
if (MoveFileExA(from, to, 0)) return 1;
|
|
if (i + 1 < tries) Sleep(20);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* The highest ready-<n> under tx (0: none), its path in out */
|
|
static unsigned tx_ready_highest(const SaveTxPaths *p, char *out, size_t cap) {
|
|
char pat[HOS_FS_PATH];
|
|
WIN32_FIND_DATAA fd;
|
|
unsigned best = 0;
|
|
snprintf(pat, sizeof pat, "%s\\ready-*", p->tx);
|
|
HANDLE f = FindFirstFileA(pat, &fd);
|
|
if (f == INVALID_HANDLE_VALUE) return 0;
|
|
do {
|
|
const char *digits = fd.cFileName + 6;
|
|
if (strncmp(fd.cFileName, "ready-", 6) || !*digits || strlen(digits) > 9 || strspn(digits, "0123456789") != strlen(digits)) continue;
|
|
if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) || (fd.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) continue;
|
|
const unsigned n = (unsigned)strtoul(digits, NULL, 10);
|
|
if (n > best) best = n;
|
|
} while (FindNextFileA(f, &fd));
|
|
FindClose(f);
|
|
if (best && out) snprintf(out, cap, "%s\\ready-%u", p->tx, best);
|
|
return best;
|
|
}
|
|
|
|
static void tx_ready_delete_below(const SaveTxPaths *p, unsigned n) {
|
|
char pat[HOS_FS_PATH];
|
|
WIN32_FIND_DATAA fd;
|
|
snprintf(pat, sizeof pat, "%s\\ready-*", p->tx);
|
|
HANDLE f = FindFirstFileA(pat, &fd);
|
|
if (f == INVALID_HANDLE_VALUE) return;
|
|
do {
|
|
const char *digits = fd.cFileName + 6;
|
|
if (strncmp(fd.cFileName, "ready-", 6) || !*digits || strlen(digits) > 9 || strspn(digits, "0123456789") != strlen(digits)) continue;
|
|
if ((unsigned)strtoul(digits, NULL, 10) >= n) continue;
|
|
char sub[HOS_FS_PATH];
|
|
snprintf(sub, sizeof sub, "%s\\%s", p->tx, fd.cFileName);
|
|
tx_delete_tree(sub);
|
|
} while (FindNextFileA(f, &fd));
|
|
FindClose(f);
|
|
}
|
|
|
|
static int tx_backup_name(const char *name) { /* YYYYMMDD-HHMMSS, or that with -<k> after it: the names made here */
|
|
if (strlen(name) < 15 || strspn(name, "0123456789") != 8 || name[8] != '-' || strspn(name + 9, "0123456789") != 6) return 0;
|
|
return !name[15] || (name[15] == '-' && name[16] && strspn(name + 16, "0123456789") == strlen(name + 16));
|
|
}
|
|
|
|
/* Deletes the oldest backups past SAVE_TX_BACKUPS; only folders with the names made here */
|
|
static void tx_backups_prune(const SaveTxPaths *p) {
|
|
for (;;) {
|
|
char pat[HOS_FS_PATH], oldest[64] = "";
|
|
WIN32_FIND_DATAA fd;
|
|
int count = 0;
|
|
snprintf(pat, sizeof pat, "%s\\*", p->backups);
|
|
HANDLE f = FindFirstFileA(pat, &fd);
|
|
if (f == INVALID_HANDLE_VALUE) return;
|
|
do {
|
|
if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) || (fd.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) continue;
|
|
if (!tx_backup_name(fd.cFileName) || strlen(fd.cFileName) >= sizeof oldest) continue;
|
|
count++;
|
|
/* (by the 15 characters of the time, then shorter first: "x" was made before "x-2") */
|
|
const int c = strncmp(fd.cFileName, oldest, 15);
|
|
if (!oldest[0] || c < 0 || (!c && (strlen(fd.cFileName) < strlen(oldest) ||
|
|
(strlen(fd.cFileName) == strlen(oldest) && strcmp(fd.cFileName, oldest) < 0))))
|
|
snprintf(oldest, sizeof oldest, "%s", fd.cFileName);
|
|
} while (FindNextFileA(f, &fd));
|
|
FindClose(f);
|
|
if (count <= SAVE_TX_BACKUPS) return;
|
|
char sub[HOS_FS_PATH];
|
|
snprintf(sub, sizeof sub, "%s\\%s", p->backups, oldest);
|
|
tx_delete_tree(sub);
|
|
if (tx_exists(sub)) return; /* (it cannot be deleted: no loop over it) */
|
|
}
|
|
}
|
|
|
|
/* old, the save a Commit replaced: a backup when wanted (always: a recovery's), else deleted. The name of the backup in made */
|
|
static void tx_old_away(const SaveTxPaths *p, int always, char *made, size_t cap) {
|
|
if (made && cap) made[0] = 0;
|
|
if (!tx_exists(p->old)) return;
|
|
const time_t now = tx_now();
|
|
if (tx_empty(p->old)) { /* (the folder a first mount made, before any save: nothing to keep) */
|
|
tx_delete_tree(p->old);
|
|
return;
|
|
}
|
|
if (always || !save_tx_last_backup || now - save_tx_last_backup >= SAVE_TX_BACKUP_GAP_S) {
|
|
struct tm t;
|
|
const time_t n = now;
|
|
#ifdef _WIN32
|
|
gmtime_s(&t, &n);
|
|
#else
|
|
gmtime_r(&n, &t);
|
|
#endif
|
|
char name[64], to[HOS_FS_PATH];
|
|
strftime(name, sizeof name, "%Y%m%d-%H%M%S", &t);
|
|
tx_make_dirs(p->backups);
|
|
snprintf(to, sizeof to, "%s\\%s", p->backups, name);
|
|
for (int k = 2; tx_exists(to) && k < 100; k++) snprintf(to, sizeof to, "%s\\%s-%d", p->backups, name, k);
|
|
if (tx_move(p->old, to, 3)) {
|
|
save_tx_last_backup = now;
|
|
if (made) snprintf(made, cap, "%s", to);
|
|
tx_backups_prune(p);
|
|
return;
|
|
}
|
|
}
|
|
tx_delete_tree(p->old);
|
|
}
|
|
|
|
/* Steps (3) and (4): the finished commit at ready becomes the committed save. 1: swapped in */
|
|
static int tx_swap(const SaveTxPaths *p, const char *ready) {
|
|
if (tx_exists(p->old)) tx_delete_tree(p->old); /* (left by a swap that died before its backup step: already replaced) */
|
|
if (tx_exists(p->save)) {
|
|
if (tx_crashed()) return 0;
|
|
if (!tx_move(p->save, p->old, SAVE_TX_MOVE_TRIES)) return 0; /* (held open elsewhere: ready stays the newest save) */
|
|
}
|
|
if (tx_crashed()) return 0;
|
|
if (!tx_move(ready, p->save, SAVE_TX_MOVE_TRIES)) {
|
|
if (!tx_exists(p->save)) tx_move(p->old, p->save, SAVE_TX_MOVE_TRIES); /* (the save back where it was) */
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static void save_tx_paths(SaveTxPaths *p, const char *user, const char *uid) {
|
|
snprintf(p->save, sizeof p->save, "%s\\save\\%s", user, uid);
|
|
snprintf(p->tx, sizeof p->tx, "%s\\save-tx\\%s", user, uid);
|
|
snprintf(p->work, sizeof p->work, "%s\\save-tx\\%s\\work", user, uid);
|
|
snprintf(p->staging, sizeof p->staging, "%s\\save-tx\\%s\\new", user, uid);
|
|
snprintf(p->old, sizeof p->old, "%s\\save-tx\\%s\\old", user, uid);
|
|
snprintf(p->backups, sizeof p->backups, "%s\\save-backup\\%s", user, uid);
|
|
}
|
|
|
|
static int save_tx_enabled(void) {
|
|
const char *e = getenv("HOS_SAVE_TX");
|
|
return !(e && e[0] == '0');
|
|
}
|
|
|
|
/* The first mount of the save in a run: the disk put right after a run that died, then the working copy made from the
|
|
committed save. 1: mount p->work; 0: the working copy could not be made, mount p->save as before. note (may be NULL) gets
|
|
a line for the log when the recovery found something to do */
|
|
static int save_tx_mount(const SaveTxPaths *p, char *note, size_t cap) {
|
|
if (note && cap) note[0] = 0;
|
|
tx_make_dirs(p->tx);
|
|
if (tx_exists(p->staging)) { /* (an unfinished copy: the commit never happened) */
|
|
tx_delete_tree(p->staging);
|
|
if (note) snprintf(note, cap, "an unfinished save was dropped (the run before ended in the middle of saving)");
|
|
}
|
|
char ready[HOS_FS_PATH];
|
|
const unsigned n = tx_ready_highest(p, ready, sizeof ready);
|
|
if (n) { /* (a finished commit: the newest save) */
|
|
const int in = tx_swap(p, ready);
|
|
if (save_tx_dead) return 0;
|
|
if (in) tx_ready_delete_below(p, n + 1);
|
|
if (note) snprintf(note, cap, in ? "a finished save that was not in place yet was put in place" :
|
|
"a finished save could not be put in place (another program holds the save folder): it is used from where it is");
|
|
} else if (!tx_exists(p->save) && tx_exists(p->old)) { /* (died between steps (3) and (4) of a swap whose ready is gone) */
|
|
tx_move(p->old, p->save, SAVE_TX_MOVE_TRIES);
|
|
if (note) snprintf(note, cap, "the save was put back in place");
|
|
}
|
|
if (tx_crashed()) return 0;
|
|
tx_old_away(p, 1, NULL, 0);
|
|
tx_delete_tree(p->work);
|
|
if (tx_exists(p->work)) return 0; /* (a file of it is held open: no second run of the game beside this one's files) */
|
|
/* (the newest save: a finished commit still waiting, else the committed one) */
|
|
const unsigned left = tx_ready_highest(p, ready, sizeof ready);
|
|
const char *from = left ? ready : p->save;
|
|
if (tx_is_dir(from)) {
|
|
if (!tx_copy_tree(from, p->work, 0)) {
|
|
tx_delete_tree(p->work);
|
|
return 0;
|
|
}
|
|
} else tx_make_dirs(p->work);
|
|
tx_make_dirs(p->save); /* (the save "exists" from its first mount on, as before: IsSaveDataExisting) */
|
|
return tx_is_dir(p->work);
|
|
}
|
|
|
|
/* Every file of a folder written out to the disk (FlushFileBuffers). 1: all of them */
|
|
static int tx_flush_tree(const char *dir) {
|
|
char pat[HOS_FS_PATH];
|
|
WIN32_FIND_DATAA fd;
|
|
snprintf(pat, sizeof pat, "%s\\*", dir);
|
|
HANDLE f = FindFirstFileA(pat, &fd);
|
|
if (f == INVALID_HANDLE_VALUE) return tx_is_dir(dir); /* (an empty folder, where the listing has no "." entry) */
|
|
int ok = 1;
|
|
do {
|
|
if (!strcmp(fd.cFileName, ".") || !strcmp(fd.cFileName, "..") || (fd.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) continue;
|
|
char sub[HOS_FS_PATH];
|
|
snprintf(sub, sizeof sub, "%s\\%s", dir, fd.cFileName);
|
|
if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { ok &= tx_flush_tree(sub); continue; }
|
|
HANDLE h = CreateFileA(sub, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (h == INVALID_HANDLE_VALUE) { ok = 0; continue; }
|
|
if (!FlushFileBuffers(h)) ok = 0;
|
|
CloseHandle(h);
|
|
} while (FindNextFileA(f, &fd));
|
|
FindClose(f);
|
|
return ok;
|
|
}
|
|
|
|
/* nn::fs::Commit of the save mount, in two parts so that the game's thread pays only the first (5 ms for a real save, against
|
|
30 with the second: nn_fs.c runs that one on a thread of its own).
|
|
|
|
save_tx_stage, on the game's thread: the working copy as it is at this moment, copied to the staging folder. What the game
|
|
writes after its Commit returned is not in it. 1: staged; 0: the staging copy could not be made and the working copy's files
|
|
were copied over the save's, as before this file (nothing left to finish); -1: that failed too */
|
|
static int save_tx_stage(const SaveTxPaths *p) {
|
|
if (tx_exists(p->staging)) tx_delete_tree(p->staging);
|
|
if (tx_crashed()) return -1;
|
|
if (!tx_exists(p->staging) && tx_copy_tree(p->work, p->staging, 0)) return 1;
|
|
tx_delete_tree(p->staging); /* (the disk is full, or something sits where the folder goes) */
|
|
return tx_copy_tree(p->work, p->save, 0) ? 0 : -1;
|
|
}
|
|
|
|
/* save_tx_finish, after a save_tx_stage that returned 1: the staged copy written out, made the newest save and put in place.
|
|
1: committed (swapped in, or waiting as ready-<n>); 0: a step before the commit point failed and the staged files were
|
|
copied over the save's; -1: that failed too. backup (may be NULL) gets the backup's folder when one was made */
|
|
static int save_tx_finish(const SaveTxPaths *p, char *backup, size_t cap) {
|
|
if (backup && cap) backup[0] = 0;
|
|
const int staged = tx_flush_tree(p->staging);
|
|
char ready[HOS_FS_PATH];
|
|
const unsigned n = tx_ready_highest(p, NULL, 0) + 1;
|
|
snprintf(ready, sizeof ready, "%s\\ready-%u", p->tx, n);
|
|
if (tx_crashed()) return -1;
|
|
if (!staged || !tx_move(p->staging, ready, 3)) { /* (a file could not be written out, or the folder cannot be renamed) */
|
|
const int copied = tx_copy_tree(p->staging, p->save, 0);
|
|
tx_delete_tree(p->staging);
|
|
return copied ? 0 : -1;
|
|
}
|
|
/* (committed: from here a death leaves ready-<n>, which the next start puts in place) */
|
|
if (tx_crashed()) return 1;
|
|
tx_ready_delete_below(p, n);
|
|
if (tx_swap(p, ready)) {
|
|
if (tx_crashed()) return 1;
|
|
tx_old_away(p, 0, backup, cap);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/* Both parts one after the other (the tests, and a build without threads) */
|
|
__attribute__((unused)) static int save_tx_commit(const SaveTxPaths *p, char *backup, size_t cap) {
|
|
if (backup && cap) backup[0] = 0;
|
|
const int staged = save_tx_stage(p);
|
|
if (staged != 1 || save_tx_dead) return save_tx_dead ? -1 : staged;
|
|
return save_tx_finish(p, backup, cap);
|
|
}
|