Claude
061e836fa4
- Recovery works when another named buffer is current. On that path
OpenFile's NotifyFilenameChanged deleted the journal (old path ==
new path) that was about to be replayed; the swap was lost and the
file opened without the edits (pre-existing).
- After recovering from a journal with a torn final record, the torn
bytes are truncated before the session appends to it (ReplayFile now
reports the valid prefix length). A journal that recovers nothing is
removed instead of appended to.
- Reload restarts the journal; recovery used to replay the edits the
reload discarded.
- Opening a file that is already open switches to its buffer (in
OpenFile and before the recovery check). Two buffers for one file
interleaved records in one journal, and closing either unlinked it.
- Swap file names escape '!' and '%', so distinct paths no longer
share a journal ('/x/a!b' vs '/x/a/b'). Swap files for paths that
contain those characters get new names.
- The gap flag is cleared when the journal restarts, and a gap that
cannot be closed (buffer too large to checkpoint) is reported once.
- crc32's table is initialised thread-safely; writer-thread error
reports identify the buffer by journal path instead of racing on
Buffer::Filename(); Close() no longer retries on EINTR (the fd is
already released and may have been reused).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015rcVQiiWyTzoNrsvLSaAfB
89 lines
1.3 KiB
C++
89 lines
1.3 KiB
C++
#include "SyscallWrappers.h"
|
|
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <sys/stat.h>
|
|
#include <cerrno>
|
|
#include <cstdlib>
|
|
|
|
namespace kte {
|
|
namespace syscall {
|
|
int
|
|
Open(const char *path, int flags, mode_t mode)
|
|
{
|
|
int fd;
|
|
do {
|
|
fd = ::open(path, flags, mode);
|
|
} while (fd == -1 && errno == EINTR);
|
|
return fd;
|
|
}
|
|
|
|
|
|
int
|
|
Close(int fd)
|
|
{
|
|
// Do not retry on EINTR: on Linux (and most systems) the descriptor is
|
|
// released even when close() is interrupted, so a retry could close an
|
|
// fd that another thread (e.g. the swap writer) has just opened.
|
|
const int ret = ::close(fd);
|
|
if (ret == -1 && errno == EINTR)
|
|
return 0;
|
|
return ret;
|
|
}
|
|
|
|
|
|
int
|
|
Fsync(int fd)
|
|
{
|
|
int ret;
|
|
do {
|
|
ret = ::fsync(fd);
|
|
} while (ret == -1 && errno == EINTR);
|
|
return ret;
|
|
}
|
|
|
|
|
|
int
|
|
Fstat(int fd, struct stat *buf)
|
|
{
|
|
int ret;
|
|
do {
|
|
ret = ::fstat(fd, buf);
|
|
} while (ret == -1 && errno == EINTR);
|
|
return ret;
|
|
}
|
|
|
|
|
|
int
|
|
Ftruncate(int fd, off_t length)
|
|
{
|
|
int ret;
|
|
do {
|
|
ret = ::ftruncate(fd, length);
|
|
} while (ret == -1 && errno == EINTR);
|
|
return ret;
|
|
}
|
|
|
|
|
|
int
|
|
Fchmod(int fd, mode_t mode)
|
|
{
|
|
int ret;
|
|
do {
|
|
ret = ::fchmod(fd, mode);
|
|
} while (ret == -1 && errno == EINTR);
|
|
return ret;
|
|
}
|
|
|
|
|
|
int
|
|
Mkstemp(char *template_str)
|
|
{
|
|
int fd;
|
|
do {
|
|
fd = ::mkstemp(template_str);
|
|
} while (fd == -1 && errno == EINTR);
|
|
return fd;
|
|
}
|
|
} // namespace syscall
|
|
} // namespace kte
|