* Automatically recover the database in case of a crash.

This commit is contained in:
Eelco Dolstra 2003-10-14 15:33:00 +00:00
parent 1d61e473c8
commit c190f051ac
6 changed files with 204 additions and 41 deletions

183
src/db.cc
View file

@ -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)
{ {
if (env) throw Error(format("environment already open"));
try { try {
if (env) throw Error(format("environment already open")); 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();

View file

@ -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);

View file

@ -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);

View file

@ -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);
} }

View file

@ -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);
} }

View file

@ -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: