forked from lix-project/lix
* Automatically recover the database in case of a crash.
This commit is contained in:
parent
1d61e473c8
commit
c190f051ac
187
src/db.cc
187
src/db.cc
|
@ -1,8 +1,13 @@
|
||||||
#include "db.hh"
|
#include <sys/types.h>
|
||||||
#include "util.hh"
|
#include <sys/stat.h>
|
||||||
|
#include <fcntl.h>
|
||||||
|
|
||||||
#include <memory>
|
#include <memory>
|
||||||
|
|
||||||
|
#include "db.hh"
|
||||||
|
#include "util.hh"
|
||||||
|
#include "pathlocks.hh"
|
||||||
|
|
||||||
|
|
||||||
/* Wrapper class to ensure proper destruction. */
|
/* Wrapper class to ensure proper destruction. */
|
||||||
class DestroyDbc
|
class DestroyDbc
|
||||||
|
@ -89,51 +94,179 @@ Database::Database()
|
||||||
|
|
||||||
Database::~Database()
|
Database::~Database()
|
||||||
{
|
{
|
||||||
if (env) {
|
close();
|
||||||
debug(format("closing database environment"));
|
}
|
||||||
|
|
||||||
try {
|
|
||||||
|
|
||||||
for (map<TableId, Db *>::iterator i = tables.begin();
|
int getAccessorCount(int fd)
|
||||||
i != tables.end(); i++)
|
{
|
||||||
{
|
if (lseek(fd, 0, SEEK_SET) == -1)
|
||||||
debug(format("closing table %1%") % i->first);
|
throw SysError("seeking accessor count");
|
||||||
Db * db = i->second;
|
char buf[128];
|
||||||
db->close(0);
|
int len;
|
||||||
delete db;
|
if ((len = read(fd, buf, sizeof(buf) - 1)) == -1)
|
||||||
}
|
throw SysError("reading accessor count");
|
||||||
|
buf[len] = 0;
|
||||||
env->txn_checkpoint(0, 0, 0);
|
int count;
|
||||||
env->close(0);
|
if (sscanf(buf, "%d", &count) != 1) {
|
||||||
|
debug(format("accessor count is invalid: `%1%'") % buf);
|
||||||
} catch (DbException e) { rethrow(e); }
|
return -1;
|
||||||
|
|
||||||
delete env;
|
|
||||||
}
|
}
|
||||||
|
return count;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void setAccessorCount(int fd, int n)
|
||||||
|
{
|
||||||
|
if (lseek(fd, 0, SEEK_SET) == -1)
|
||||||
|
throw SysError("seeking accessor count");
|
||||||
|
string s = (format("%1%") % n).str();
|
||||||
|
const char * s2 = s.c_str();
|
||||||
|
if (write(fd, s2, strlen(s2)) != (ssize_t) strlen(s2) ||
|
||||||
|
ftruncate(fd, strlen(s2)) != 0)
|
||||||
|
throw SysError("writing accessor count");
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void openEnv(DbEnv * env, const string & path, u_int32_t flags)
|
||||||
|
{
|
||||||
|
env->open(path.c_str(),
|
||||||
|
DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN |
|
||||||
|
DB_CREATE | flags,
|
||||||
|
0666);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
void Database::open(const string & path)
|
void Database::open(const string & path)
|
||||||
{
|
{
|
||||||
try {
|
if (env) throw Error(format("environment already open"));
|
||||||
|
|
||||||
if (env) throw Error(format("environment already open"));
|
|
||||||
|
|
||||||
|
try {
|
||||||
|
|
||||||
|
debug(format("opening database environment"));
|
||||||
|
|
||||||
|
|
||||||
|
/* Create the database environment object. */
|
||||||
env = new DbEnv(0);
|
env = new DbEnv(0);
|
||||||
|
|
||||||
env->set_lg_bsize(32 * 1024); /* default */
|
env->set_lg_bsize(32 * 1024); /* default */
|
||||||
env->set_lg_max(256 * 1024); /* must be > 4 * lg_bsize */
|
env->set_lg_max(256 * 1024); /* must be > 4 * lg_bsize */
|
||||||
env->set_lk_detect(DB_LOCK_DEFAULT);
|
env->set_lk_detect(DB_LOCK_DEFAULT);
|
||||||
|
|
||||||
env->open(path.c_str(),
|
|
||||||
DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN |
|
/* The following code provides automatic recovery of the
|
||||||
DB_CREATE,
|
database environment. Recovery is necessary when a process
|
||||||
0666);
|
dies while it has the database open. To detect this,
|
||||||
|
processes atomically increment a counter when the open the
|
||||||
|
database, and decrement it when they close it. If we see
|
||||||
|
that counter is > 0 but no processes are accessing the
|
||||||
|
database---determined by attempting to obtain a write lock
|
||||||
|
on a lock file on which all accessors have a read lock---we
|
||||||
|
must run recovery. Note that this also ensures that we
|
||||||
|
only run recovery when there are no other accessors (which
|
||||||
|
could cause database corruption). */
|
||||||
|
|
||||||
|
/* !!! close fdAccessors / fdLock on exception */
|
||||||
|
|
||||||
|
/* Open the accessor count file. */
|
||||||
|
string accessorsPath = path + "/accessor_count";
|
||||||
|
fdAccessors = ::open(accessorsPath.c_str(), O_RDWR | O_CREAT, 0666);
|
||||||
|
if (fdAccessors == -1)
|
||||||
|
throw SysError(format("opening file `%1%'") % accessorsPath);
|
||||||
|
|
||||||
|
/* Open the lock file. */
|
||||||
|
string lockPath = path + "/access_lock";
|
||||||
|
fdLock = ::open(lockPath.c_str(), O_RDWR | O_CREAT, 0666);
|
||||||
|
if (fdLock == -1)
|
||||||
|
throw SysError(format("opening lock file `%1%'") % lockPath);
|
||||||
|
|
||||||
|
/* Try to acquire a write lock. */
|
||||||
|
debug(format("attempting write lock on `%1%'") % lockPath);
|
||||||
|
if (lockFile(fdLock, ltWrite, false)) { /* don't wait */
|
||||||
|
|
||||||
|
debug(format("write lock granted"));
|
||||||
|
|
||||||
|
/* We have a write lock, which means that there are no
|
||||||
|
other readers or writers. */
|
||||||
|
|
||||||
|
int n = getAccessorCount(fdAccessors);
|
||||||
|
setAccessorCount(fdAccessors, 1);
|
||||||
|
|
||||||
|
if (n != 0) {
|
||||||
|
msg(lvlTalkative, format("accessor count is %1%, running recovery") % n);
|
||||||
|
|
||||||
|
/* Open the environment after running recovery. */
|
||||||
|
openEnv(env, path, DB_RECOVER);
|
||||||
|
}
|
||||||
|
|
||||||
|
else
|
||||||
|
/* Open the environment normally. */
|
||||||
|
openEnv(env, path, 0);
|
||||||
|
|
||||||
|
/* Downgrade to a read lock. */
|
||||||
|
debug(format("downgrading to read lock on `%1%'") % lockPath);
|
||||||
|
lockFile(fdLock, ltRead, true);
|
||||||
|
|
||||||
|
} else {
|
||||||
|
/* There are other accessors. */
|
||||||
|
debug(format("write lock refused"));
|
||||||
|
|
||||||
|
/* Acquire a read lock. */
|
||||||
|
debug(format("acquiring read lock on `%1%'") % lockPath);
|
||||||
|
lockFile(fdLock, ltRead, true); /* wait indefinitely */
|
||||||
|
|
||||||
|
/* Increment the accessor count. */
|
||||||
|
lockFile(fdAccessors, ltWrite, true);
|
||||||
|
int n = getAccessorCount(fdAccessors) + 1;
|
||||||
|
setAccessorCount(fdAccessors, n);
|
||||||
|
debug(format("incremented accessor count to %1%") % n);
|
||||||
|
lockFile(fdAccessors, ltNone, true);
|
||||||
|
|
||||||
|
/* Open the environment normally. */
|
||||||
|
openEnv(env, path, 0);
|
||||||
|
}
|
||||||
|
|
||||||
} catch (DbException e) { rethrow(e); }
|
} catch (DbException e) { rethrow(e); }
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void Database::close()
|
||||||
|
{
|
||||||
|
if (!env) return;
|
||||||
|
|
||||||
|
/* Close the database environment. */
|
||||||
|
debug(format("closing database environment"));
|
||||||
|
|
||||||
|
try {
|
||||||
|
|
||||||
|
for (map<TableId, Db *>::iterator i = tables.begin();
|
||||||
|
i != tables.end(); i++)
|
||||||
|
{
|
||||||
|
debug(format("closing table %1%") % i->first);
|
||||||
|
Db * db = i->second;
|
||||||
|
db->close(0);
|
||||||
|
delete db;
|
||||||
|
}
|
||||||
|
|
||||||
|
env->txn_checkpoint(0, 0, 0);
|
||||||
|
env->close(0);
|
||||||
|
|
||||||
|
} catch (DbException e) { rethrow(e); }
|
||||||
|
|
||||||
|
delete env;
|
||||||
|
|
||||||
|
/* Decrement the accessor count. */
|
||||||
|
lockFile(fdAccessors, ltWrite, true);
|
||||||
|
int n = getAccessorCount(fdAccessors) - 1;
|
||||||
|
setAccessorCount(fdAccessors, n);
|
||||||
|
debug(format("decremented accessor count to %1%") % n);
|
||||||
|
lockFile(fdAccessors, ltNone, true);
|
||||||
|
|
||||||
|
::close(fdAccessors);
|
||||||
|
::close(fdLock);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
TableId Database::openTable(const string & tableName)
|
TableId Database::openTable(const string & tableName)
|
||||||
{
|
{
|
||||||
requireEnv();
|
requireEnv();
|
||||||
|
|
|
@ -45,6 +45,9 @@ class Database
|
||||||
private:
|
private:
|
||||||
DbEnv * env;
|
DbEnv * env;
|
||||||
|
|
||||||
|
int fdLock;
|
||||||
|
int fdAccessors;
|
||||||
|
|
||||||
TableId nextId;
|
TableId nextId;
|
||||||
map<TableId, Db *> tables;
|
map<TableId, Db *> tables;
|
||||||
|
|
||||||
|
@ -57,6 +60,7 @@ public:
|
||||||
~Database();
|
~Database();
|
||||||
|
|
||||||
void open(const string & path);
|
void open(const string & path);
|
||||||
|
void close();
|
||||||
|
|
||||||
TableId openTable(const string & table);
|
TableId openTable(const string & table);
|
||||||
|
|
||||||
|
|
|
@ -438,8 +438,6 @@ static void printNixExpr(EvalState & state, Expr e)
|
||||||
|
|
||||||
void run(Strings args)
|
void run(Strings args)
|
||||||
{
|
{
|
||||||
openDB();
|
|
||||||
|
|
||||||
EvalState state;
|
EvalState state;
|
||||||
Strings files;
|
Strings files;
|
||||||
bool readStdin = false;
|
bool readStdin = false;
|
||||||
|
@ -467,6 +465,8 @@ void run(Strings args)
|
||||||
files.push_back(arg);
|
files.push_back(arg);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
openDB();
|
||||||
|
|
||||||
if (readStdin) {
|
if (readStdin) {
|
||||||
Expr e = evalStdin(state);
|
Expr e = evalStdin(state);
|
||||||
printNixExpr(state, e);
|
printNixExpr(state, e);
|
||||||
|
|
|
@ -267,8 +267,6 @@ static void opVerify(Strings opFlags, Strings opArgs)
|
||||||
list. */
|
list. */
|
||||||
void run(Strings args)
|
void run(Strings args)
|
||||||
{
|
{
|
||||||
openDB();
|
|
||||||
|
|
||||||
Strings opFlags, opArgs;
|
Strings opFlags, opArgs;
|
||||||
Operation op = 0;
|
Operation op = 0;
|
||||||
|
|
||||||
|
@ -315,6 +313,8 @@ void run(Strings args)
|
||||||
|
|
||||||
if (!op) throw UsageError("no operation specified");
|
if (!op) throw UsageError("no operation specified");
|
||||||
|
|
||||||
|
openDB();
|
||||||
|
|
||||||
op(opFlags, opArgs);
|
op(opFlags, opArgs);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -1,10 +1,39 @@
|
||||||
#include <cerrno>
|
#include <cerrno>
|
||||||
|
|
||||||
|
#include <sys/types.h>
|
||||||
|
#include <sys/stat.h>
|
||||||
#include <fcntl.h>
|
#include <fcntl.h>
|
||||||
|
|
||||||
#include "pathlocks.hh"
|
#include "pathlocks.hh"
|
||||||
|
|
||||||
|
|
||||||
|
bool lockFile(int fd, LockType lockType, bool wait)
|
||||||
|
{
|
||||||
|
struct flock lock;
|
||||||
|
if (lockType == ltRead) lock.l_type = F_RDLCK;
|
||||||
|
else if (lockType == ltWrite) lock.l_type = F_WRLCK;
|
||||||
|
else if (lockType == ltNone) lock.l_type = F_UNLCK;
|
||||||
|
else abort();
|
||||||
|
lock.l_whence = SEEK_SET;
|
||||||
|
lock.l_start = 0;
|
||||||
|
lock.l_len = 0; /* entire file */
|
||||||
|
|
||||||
|
if (wait) {
|
||||||
|
while (fcntl(fd, F_SETLKW, &lock) != 0)
|
||||||
|
if (errno != EINTR)
|
||||||
|
throw SysError(format("acquiring/releasing lock"));
|
||||||
|
} else {
|
||||||
|
while (fcntl(fd, F_SETLK, &lock) != 0) {
|
||||||
|
if (errno == EACCES || errno == EAGAIN) return false;
|
||||||
|
if (errno != EINTR)
|
||||||
|
throw SysError(format("acquiring/releasing lock"));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
/* This enables us to check whether are not already holding a lock on
|
/* This enables us to check whether are not already holding a lock on
|
||||||
a file ourselves. POSIX locks (fcntl) suck in this respect: if we
|
a file ourselves. POSIX locks (fcntl) suck in this respect: if we
|
||||||
close a descriptor, the previous lock will be closed as well. And
|
close a descriptor, the previous lock will be closed as well. And
|
||||||
|
@ -43,16 +72,8 @@ PathLocks::PathLocks(const PathSet & _paths)
|
||||||
fds.push_back(fd);
|
fds.push_back(fd);
|
||||||
this->paths.push_back(lockPath);
|
this->paths.push_back(lockPath);
|
||||||
|
|
||||||
/* Lock it. */
|
/* Acquire an exclusive lock. */
|
||||||
struct flock lock;
|
lockFile(fd, ltWrite, true);
|
||||||
lock.l_type = F_WRLCK; /* exclusive lock */
|
|
||||||
lock.l_whence = SEEK_SET;
|
|
||||||
lock.l_start = 0;
|
|
||||||
lock.l_len = 0; /* entire file */
|
|
||||||
|
|
||||||
while (fcntl(fd, F_SETLKW, &lock) == -1)
|
|
||||||
if (errno != EINTR)
|
|
||||||
throw SysError(format("acquiring lock on `%1%'") % lockPath);
|
|
||||||
|
|
||||||
lockedPaths.insert(lockPath);
|
lockedPaths.insert(lockPath);
|
||||||
}
|
}
|
||||||
|
|
|
@ -4,6 +4,11 @@
|
||||||
#include "util.hh"
|
#include "util.hh"
|
||||||
|
|
||||||
|
|
||||||
|
typedef enum LockType { ltRead, ltWrite, ltNone };
|
||||||
|
|
||||||
|
bool lockFile(int fd, LockType lockType, bool wait);
|
||||||
|
|
||||||
|
|
||||||
class PathLocks
|
class PathLocks
|
||||||
{
|
{
|
||||||
private:
|
private:
|
||||||
|
|
Loading…
Reference in a new issue