Commit 850c5cfe authored by Rusty Russell's avatar Rusty Russell

tdb2: rework lock.c functions to return enum TDB_ERROR.

Make the other functions in lock.s return an error code, too.
parent 50b15fbd
...@@ -673,11 +673,17 @@ int tdb_check(struct tdb_context *tdb, ...@@ -673,11 +673,17 @@ int tdb_check(struct tdb_context *tdb,
{ {
tdb_off_t *fr = NULL, *used = NULL, ft, recovery; tdb_off_t *fr = NULL, *used = NULL, ft, recovery;
size_t num_free = 0, num_used = 0, num_found = 0, num_ftables = 0; size_t num_free = 0, num_used = 0, num_found = 0, num_ftables = 0;
enum TDB_ERROR ecode;
if (tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false) != 0) ecode = tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false);
if (ecpde != TDB_SUCCESS) {
tdb->ecode = ecode;
return -1; return -1;
}
if (tdb_lock_expand(tdb, F_RDLCK) != 0) { ecode = tdb_lock_expand(tdb, F_RDLCK);
if (ecode != TDB_SUCCESS) {
tdb->ecode = ecode;
tdb_allrecord_unlock(tdb, F_RDLCK); tdb_allrecord_unlock(tdb, F_RDLCK);
return -1; return -1;
} }
......
...@@ -204,14 +204,18 @@ int add_free_record(struct tdb_context *tdb, ...@@ -204,14 +204,18 @@ int add_free_record(struct tdb_context *tdb,
tdb_off_t b_off; tdb_off_t b_off;
tdb_len_t len; tdb_len_t len;
int ret; int ret;
enum TDB_ERROR ecode;
assert(len_with_header >= sizeof(struct tdb_free_record)); assert(len_with_header >= sizeof(struct tdb_free_record));
len = len_with_header - sizeof(struct tdb_used_record); len = len_with_header - sizeof(struct tdb_used_record);
b_off = bucket_off(tdb->ftable_off, size_to_bucket(len)); b_off = bucket_off(tdb->ftable_off, size_to_bucket(len));
if (tdb_lock_free_bucket(tdb, b_off, TDB_LOCK_WAIT) != 0) ecode = tdb_lock_free_bucket(tdb, b_off, TDB_LOCK_WAIT);
if (ecode != TDB_SUCCESS) {
tdb->ecode = ecode;
return -1; return -1;
}
ret = enqueue_in_free(tdb, b_off, off, len); ret = enqueue_in_free(tdb, b_off, off, len);
tdb_unlock_free_bucket(tdb, b_off); tdb_unlock_free_bucket(tdb, b_off);
...@@ -290,7 +294,8 @@ static int coalesce(struct tdb_context *tdb, ...@@ -290,7 +294,8 @@ static int coalesce(struct tdb_context *tdb,
tdb_access_release(tdb, r); tdb_access_release(tdb, r);
/* We may be violating lock order here, so best effort. */ /* We may be violating lock order here, so best effort. */
if (tdb_lock_free_bucket(tdb, nb_off, TDB_LOCK_NOWAIT) == -1) { if (tdb_lock_free_bucket(tdb, nb_off, TDB_LOCK_NOWAIT)
!= TDB_SUCCESS) {
add_stat(tdb, alloc_coalesce_lockfail, 1); add_stat(tdb, alloc_coalesce_lockfail, 1);
break; break;
} }
...@@ -377,6 +382,7 @@ static tdb_off_t lock_and_alloc(struct tdb_context *tdb, ...@@ -377,6 +382,7 @@ static tdb_off_t lock_and_alloc(struct tdb_context *tdb,
struct tdb_free_record best = { 0 }; struct tdb_free_record best = { 0 };
double multiplier; double multiplier;
size_t size = adjust_size(keylen, datalen); size_t size = adjust_size(keylen, datalen);
enum TDB_ERROR ecode;
add_stat(tdb, allocs, 1); add_stat(tdb, allocs, 1);
again: again:
...@@ -384,7 +390,9 @@ again: ...@@ -384,7 +390,9 @@ again:
/* FIXME: Try non-blocking wait first, to measure contention. */ /* FIXME: Try non-blocking wait first, to measure contention. */
/* Lock this bucket. */ /* Lock this bucket. */
if (tdb_lock_free_bucket(tdb, b_off, TDB_LOCK_WAIT) == -1) { ecode = tdb_lock_free_bucket(tdb, b_off, TDB_LOCK_WAIT);
if (ecode != TDB_SUCCESS) {
tdb->ecode = ecode;
return TDB_OFF_ERR; return TDB_OFF_ERR;
} }
...@@ -581,6 +589,7 @@ static int tdb_expand(struct tdb_context *tdb, tdb_len_t size) ...@@ -581,6 +589,7 @@ static int tdb_expand(struct tdb_context *tdb, tdb_len_t size)
{ {
uint64_t old_size; uint64_t old_size;
tdb_len_t wanted; tdb_len_t wanted;
enum TDB_ERROR ecode;
/* We need room for the record header too. */ /* We need room for the record header too. */
wanted = sizeof(struct tdb_used_record) + size; wanted = sizeof(struct tdb_used_record) + size;
...@@ -602,8 +611,11 @@ static int tdb_expand(struct tdb_context *tdb, tdb_len_t size) ...@@ -602,8 +611,11 @@ static int tdb_expand(struct tdb_context *tdb, tdb_len_t size)
wanted = adjust_size(0, wanted); wanted = adjust_size(0, wanted);
/* Only one person can expand file at a time. */ /* Only one person can expand file at a time. */
if (tdb_lock_expand(tdb, F_WRLCK) != 0) ecode = tdb_lock_expand(tdb, F_WRLCK);
if (ecode != TDB_SUCCESS) {
tdb->ecode = ecode;
return -1; return -1;
}
/* Someone else may have expanded the file, so retry. */ /* Someone else may have expanded the file, so retry. */
old_size = tdb->map_size; old_size = tdb->map_size;
......
...@@ -229,6 +229,7 @@ tdb_off_t find_and_lock(struct tdb_context *tdb, ...@@ -229,6 +229,7 @@ tdb_off_t find_and_lock(struct tdb_context *tdb,
{ {
uint32_t i, group; uint32_t i, group;
tdb_off_t hashtable; tdb_off_t hashtable;
enum TDB_ERROR ecode;
h->h = tdb_hash(tdb, key.dptr, key.dsize); h->h = tdb_hash(tdb, key.dptr, key.dsize);
h->hash_used = 0; h->hash_used = 0;
...@@ -236,9 +237,12 @@ tdb_off_t find_and_lock(struct tdb_context *tdb, ...@@ -236,9 +237,12 @@ tdb_off_t find_and_lock(struct tdb_context *tdb,
h->home_bucket = use_bits(h, TDB_HASH_GROUP_BITS); h->home_bucket = use_bits(h, TDB_HASH_GROUP_BITS);
h->hlock_start = hlock_range(group, &h->hlock_range); h->hlock_start = hlock_range(group, &h->hlock_range);
if (tdb_lock_hashes(tdb, h->hlock_start, h->hlock_range, ltype, ecode = tdb_lock_hashes(tdb, h->hlock_start, h->hlock_range, ltype,
TDB_LOCK_WAIT)) TDB_LOCK_WAIT);
if (ecode != TDB_SUCCESS) {
tdb->ecode = ecode;
return TDB_OFF_ERR; return TDB_OFF_ERR;
}
hashtable = offsetof(struct tdb_header, hashtable); hashtable = offsetof(struct tdb_header, hashtable);
if (tinfo) { if (tinfo) {
...@@ -684,14 +688,18 @@ int next_in_hash(struct tdb_context *tdb, ...@@ -684,14 +688,18 @@ int next_in_hash(struct tdb_context *tdb,
{ {
const unsigned group_bits = TDB_TOPLEVEL_HASH_BITS-TDB_HASH_GROUP_BITS; const unsigned group_bits = TDB_TOPLEVEL_HASH_BITS-TDB_HASH_GROUP_BITS;
tdb_off_t hl_start, hl_range, off; tdb_off_t hl_start, hl_range, off;
enum TDB_ERROR ecode;
while (tinfo->toplevel_group < (1 << group_bits)) { while (tinfo->toplevel_group < (1 << group_bits)) {
hl_start = (tdb_off_t)tinfo->toplevel_group hl_start = (tdb_off_t)tinfo->toplevel_group
<< (64 - group_bits); << (64 - group_bits);
hl_range = 1ULL << group_bits; hl_range = 1ULL << group_bits;
if (tdb_lock_hashes(tdb, hl_start, hl_range, F_RDLCK, ecode = tdb_lock_hashes(tdb, hl_start, hl_range, F_RDLCK,
TDB_LOCK_WAIT) != 0) TDB_LOCK_WAIT);
if (ecode != TDB_SUCCESS) {
tdb->ecode = ecode;
return -1; return -1;
}
off = iterate_hash(tdb, tinfo); off = iterate_hash(tdb, tinfo);
if (off) { if (off) {
...@@ -760,7 +768,7 @@ static int chainlock(struct tdb_context *tdb, const TDB_DATA *key, ...@@ -760,7 +768,7 @@ static int chainlock(struct tdb_context *tdb, const TDB_DATA *key,
int ltype, enum tdb_lock_flags waitflag, int ltype, enum tdb_lock_flags waitflag,
const char *func) const char *func)
{ {
int ret; enum TDB_ERROR ecode;
uint64_t h = tdb_hash(tdb, key->dptr, key->dsize); uint64_t h = tdb_hash(tdb, key->dptr, key->dsize);
tdb_off_t lockstart, locksize; tdb_off_t lockstart, locksize;
unsigned int group, gbits; unsigned int group, gbits;
...@@ -770,9 +778,13 @@ static int chainlock(struct tdb_context *tdb, const TDB_DATA *key, ...@@ -770,9 +778,13 @@ static int chainlock(struct tdb_context *tdb, const TDB_DATA *key,
lockstart = hlock_range(group, &locksize); lockstart = hlock_range(group, &locksize);
ret = tdb_lock_hashes(tdb, lockstart, locksize, ltype, waitflag); ecode = tdb_lock_hashes(tdb, lockstart, locksize, ltype, waitflag);
tdb_trace_1rec(tdb, func, *key); tdb_trace_1rec(tdb, func, *key);
return ret; if (ecode != TDB_SUCCESS) {
tdb->ecode = ecode;
return -1;
}
return 0;
} }
/* lock/unlock one hash chain. This is meant to be used to reduce /* lock/unlock one hash chain. This is meant to be used to reduce
...@@ -787,6 +799,7 @@ int tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key) ...@@ -787,6 +799,7 @@ int tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key)
uint64_t h = tdb_hash(tdb, key.dptr, key.dsize); uint64_t h = tdb_hash(tdb, key.dptr, key.dsize);
tdb_off_t lockstart, locksize; tdb_off_t lockstart, locksize;
unsigned int group, gbits; unsigned int group, gbits;
enum TDB_ERROR ecode;
gbits = TDB_TOPLEVEL_HASH_BITS - TDB_HASH_GROUP_BITS; gbits = TDB_TOPLEVEL_HASH_BITS - TDB_HASH_GROUP_BITS;
group = bits_from(h, 64 - gbits, gbits); group = bits_from(h, 64 - gbits, gbits);
...@@ -794,5 +807,10 @@ int tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key) ...@@ -794,5 +807,10 @@ int tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key)
lockstart = hlock_range(group, &locksize); lockstart = hlock_range(group, &locksize);
tdb_trace_1rec(tdb, "tdb_chainunlock", key); tdb_trace_1rec(tdb, "tdb_chainunlock", key);
return tdb_unlock_hashes(tdb, lockstart, locksize, F_WRLCK); ecode = tdb_unlock_hashes(tdb, lockstart, locksize, F_WRLCK);
if (ecode != TDB_SUCCESS) {
tdb->ecode = ecode;
return -1;
}
return 0;
} }
...@@ -70,6 +70,7 @@ void tdb_mmap(struct tdb_context *tdb) ...@@ -70,6 +70,7 @@ void tdb_mmap(struct tdb_context *tdb)
static int tdb_oob(struct tdb_context *tdb, tdb_off_t len, bool probe) static int tdb_oob(struct tdb_context *tdb, tdb_off_t len, bool probe)
{ {
struct stat st; struct stat st;
enum TDB_ERROR ecode;
/* We can't hold pointers during this: we could unmap! */ /* We can't hold pointers during this: we could unmap! */
assert(!tdb->direct_access assert(!tdb->direct_access
...@@ -89,8 +90,11 @@ static int tdb_oob(struct tdb_context *tdb, tdb_off_t len, bool probe) ...@@ -89,8 +90,11 @@ static int tdb_oob(struct tdb_context *tdb, tdb_off_t len, bool probe)
return -1; return -1;
} }
if (tdb_lock_expand(tdb, F_RDLCK) != 0) ecode = tdb_lock_expand(tdb, F_RDLCK);
if (ecode != TDB_SUCCESS) {
tdb->ecode = ecode;
return -1; return -1;
}
if (fstat(tdb->fd, &st) != 0) { if (fstat(tdb->fd, &st) != 0) {
tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR, tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
......
This diff is collapsed.
...@@ -518,43 +518,44 @@ void add_stat_(struct tdb_context *tdb, uint64_t *stat, size_t val); ...@@ -518,43 +518,44 @@ void add_stat_(struct tdb_context *tdb, uint64_t *stat, size_t val);
void tdb_lock_init(struct tdb_context *tdb); void tdb_lock_init(struct tdb_context *tdb);
/* Lock/unlock a range of hashes. */ /* Lock/unlock a range of hashes. */
int tdb_lock_hashes(struct tdb_context *tdb, enum TDB_ERROR tdb_lock_hashes(struct tdb_context *tdb,
tdb_off_t hash_lock, tdb_len_t hash_range, tdb_off_t hash_lock, tdb_len_t hash_range,
int ltype, enum tdb_lock_flags waitflag); int ltype, enum tdb_lock_flags waitflag);
int tdb_unlock_hashes(struct tdb_context *tdb, enum TDB_ERROR tdb_unlock_hashes(struct tdb_context *tdb,
tdb_off_t hash_lock, tdb_off_t hash_lock,
tdb_len_t hash_range, int ltype); tdb_len_t hash_range, int ltype);
/* Lock/unlock a particular free bucket. */ /* Lock/unlock a particular free bucket. */
int tdb_lock_free_bucket(struct tdb_context *tdb, tdb_off_t b_off, enum TDB_ERROR tdb_lock_free_bucket(struct tdb_context *tdb, tdb_off_t b_off,
enum tdb_lock_flags waitflag); enum tdb_lock_flags waitflag);
void tdb_unlock_free_bucket(struct tdb_context *tdb, tdb_off_t b_off); void tdb_unlock_free_bucket(struct tdb_context *tdb, tdb_off_t b_off);
/* Serialize transaction start. */ /* Serialize transaction start. */
int tdb_transaction_lock(struct tdb_context *tdb, int ltype); enum TDB_ERROR tdb_transaction_lock(struct tdb_context *tdb, int ltype);
int tdb_transaction_unlock(struct tdb_context *tdb, int ltype); void tdb_transaction_unlock(struct tdb_context *tdb, int ltype);
/* Do we have any hash locks (ie. via tdb_chainlock) ? */ /* Do we have any hash locks (ie. via tdb_chainlock) ? */
bool tdb_has_hash_locks(struct tdb_context *tdb); bool tdb_has_hash_locks(struct tdb_context *tdb);
/* Lock entire database. */ /* Lock entire database. */
int tdb_allrecord_lock(struct tdb_context *tdb, int ltype, enum TDB_ERROR tdb_allrecord_lock(struct tdb_context *tdb, int ltype,
enum tdb_lock_flags flags, bool upgradable); enum tdb_lock_flags flags, bool upgradable);
int tdb_allrecord_unlock(struct tdb_context *tdb, int ltype); void tdb_allrecord_unlock(struct tdb_context *tdb, int ltype);
int tdb_allrecord_upgrade(struct tdb_context *tdb); enum TDB_ERROR tdb_allrecord_upgrade(struct tdb_context *tdb);
/* Serialize db open. */ /* Serialize db open. */
int tdb_lock_open(struct tdb_context *tdb, enum tdb_lock_flags flags); enum TDB_ERROR tdb_lock_open(struct tdb_context *tdb,
enum tdb_lock_flags flags);
void tdb_unlock_open(struct tdb_context *tdb); void tdb_unlock_open(struct tdb_context *tdb);
bool tdb_has_open_lock(struct tdb_context *tdb); bool tdb_has_open_lock(struct tdb_context *tdb);
/* Serialize db expand. */ /* Serialize db expand. */
int tdb_lock_expand(struct tdb_context *tdb, int ltype); enum TDB_ERROR tdb_lock_expand(struct tdb_context *tdb, int ltype);
void tdb_unlock_expand(struct tdb_context *tdb, int ltype); void tdb_unlock_expand(struct tdb_context *tdb, int ltype);
bool tdb_has_expansion_lock(struct tdb_context *tdb); bool tdb_has_expansion_lock(struct tdb_context *tdb);
/* If it needs recovery, grab all the locks and do it. */ /* If it needs recovery, grab all the locks and do it. */
int tdb_lock_and_recover(struct tdb_context *tdb); enum TDB_ERROR tdb_lock_and_recover(struct tdb_context *tdb);
/* transaction.c: */ /* transaction.c: */
int tdb_transaction_recover(struct tdb_context *tdb); int tdb_transaction_recover(struct tdb_context *tdb);
......
...@@ -152,13 +152,19 @@ char *tdb_summary(struct tdb_context *tdb, enum tdb_summary_flags flags) ...@@ -152,13 +152,19 @@ char *tdb_summary(struct tdb_context *tdb, enum tdb_summary_flags flags)
*buckets, *chains; *buckets, *chains;
char *hashesg, *freeg, *keysg, *datag, *extrag, *uncoalg, *bucketsg; char *hashesg, *freeg, *keysg, *datag, *extrag, *uncoalg, *bucketsg;
char *ret = NULL; char *ret = NULL;
enum TDB_ERROR ecode;
hashesg = freeg = keysg = datag = extrag = uncoalg = bucketsg = NULL; hashesg = freeg = keysg = datag = extrag = uncoalg = bucketsg = NULL;
if (tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false) != 0) ecode = tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false);
if (ecode != TDB_SUCCESS) {
tdb->ecode = ecode;
return NULL; return NULL;
}
if (tdb_lock_expand(tdb, F_RDLCK) != 0) { ecode = tdb_lock_expand(tdb, F_RDLCK);
if (ecode != TDB_SUCCESS) {
tdb->ecode = ecode;
tdb_allrecord_unlock(tdb, F_RDLCK); tdb_allrecord_unlock(tdb, F_RDLCK);
return NULL; return NULL;
} }
......
...@@ -173,6 +173,7 @@ struct tdb_context *tdb_open(const char *name, int tdb_flags, ...@@ -173,6 +173,7 @@ struct tdb_context *tdb_open(const char *name, int tdb_flags,
ssize_t rlen; ssize_t rlen;
struct tdb_header hdr; struct tdb_header hdr;
struct tdb_attribute_seed *seed = NULL; struct tdb_attribute_seed *seed = NULL;
enum TDB_ERROR ecode;
tdb = malloc(sizeof(*tdb)); tdb = malloc(sizeof(*tdb));
if (!tdb) { if (!tdb) {
...@@ -265,9 +266,8 @@ struct tdb_context *tdb_open(const char *name, int tdb_flags, ...@@ -265,9 +266,8 @@ struct tdb_context *tdb_open(const char *name, int tdb_flags,
fcntl(tdb->fd, F_SETFD, v | FD_CLOEXEC); fcntl(tdb->fd, F_SETFD, v | FD_CLOEXEC);
/* ensure there is only one process initialising at once */ /* ensure there is only one process initialising at once */
if (tdb_lock_open(tdb, TDB_LOCK_WAIT|TDB_LOCK_NOCHECK) == -1) { tdb->ecode = tdb_lock_open(tdb, TDB_LOCK_WAIT|TDB_LOCK_NOCHECK);
/* errno set by tdb_brlock */ if (tdb->ecode != TDB_SUCCESS) {
saved_errno = errno;
goto fail; goto fail;
} }
...@@ -346,8 +346,12 @@ struct tdb_context *tdb_open(const char *name, int tdb_flags, ...@@ -346,8 +346,12 @@ struct tdb_context *tdb_open(const char *name, int tdb_flags,
tdb->methods->oob(tdb, tdb->map_size + 1, true); tdb->methods->oob(tdb, tdb->map_size + 1, true);
/* Now it's fully formed, recover if necessary. */ /* Now it's fully formed, recover if necessary. */
if (tdb_needs_recovery(tdb) && tdb_lock_and_recover(tdb) == -1) { if (tdb_needs_recovery(tdb)) {
goto fail; ecode = tdb_lock_and_recover(tdb);
if (ecode != TDB_SUCCESS) {
tdb->ecode = ecode;
goto fail;
}
} }
if (tdb_ftable_init(tdb) == -1) if (tdb_ftable_init(tdb) == -1)
......
...@@ -11,7 +11,7 @@ ...@@ -11,7 +11,7 @@
#include "logging.h" #include "logging.h"
/* FIXME: Check these! */ /* FIXME: Check these! */
#define INITIAL_TDB_MALLOC "tdb.c", 177, FAILTEST_MALLOC #define INITIAL_TDB_MALLOC "tdb.c", 178, FAILTEST_MALLOC
#define LOGGING_MALLOC "tdb.c", 734, FAILTEST_MALLOC #define LOGGING_MALLOC "tdb.c", 734, FAILTEST_MALLOC
#define URANDOM_OPEN "tdb.c", 49, FAILTEST_OPEN #define URANDOM_OPEN "tdb.c", 49, FAILTEST_OPEN
#define URANDOM_READ "tdb.c", 29, FAILTEST_READ #define URANDOM_READ "tdb.c", 29, FAILTEST_READ
......
...@@ -499,6 +499,8 @@ static void _tdb_transaction_cancel(struct tdb_context *tdb) ...@@ -499,6 +499,8 @@ static void _tdb_transaction_cancel(struct tdb_context *tdb)
*/ */
int tdb_transaction_start(struct tdb_context *tdb) int tdb_transaction_start(struct tdb_context *tdb)
{ {
enum TDB_ERROR ecode;
/* some sanity checks */ /* some sanity checks */
if (tdb->read_only || (tdb->flags & TDB_INTERNAL)) { if (tdb->read_only || (tdb->flags & TDB_INTERNAL)) {
tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR, tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
...@@ -536,7 +538,9 @@ int tdb_transaction_start(struct tdb_context *tdb) ...@@ -536,7 +538,9 @@ int tdb_transaction_start(struct tdb_context *tdb)
/* get the transaction write lock. This is a blocking lock. As /* get the transaction write lock. This is a blocking lock. As
discussed with Volker, there are a number of ways we could discussed with Volker, there are a number of ways we could
make this async, which we will probably do in the future */ make this async, which we will probably do in the future */
if (tdb_transaction_lock(tdb, F_WRLCK) == -1) { ecode = tdb_transaction_lock(tdb, F_WRLCK);
if (ecode != TDB_SUCCESS) {
tdb->ecode = ecode;
SAFE_FREE(tdb->transaction->blocks); SAFE_FREE(tdb->transaction->blocks);
SAFE_FREE(tdb->transaction); SAFE_FREE(tdb->transaction);
return -1; return -1;
...@@ -544,7 +548,9 @@ int tdb_transaction_start(struct tdb_context *tdb) ...@@ -544,7 +548,9 @@ int tdb_transaction_start(struct tdb_context *tdb)
/* get a read lock over entire file. This is upgraded to a write /* get a read lock over entire file. This is upgraded to a write
lock during the commit */ lock during the commit */
if (tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, true) == -1) { ecode = tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, true);
if (ecode != TDB_SUCCESS) {
tdb->ecode = ecode;
goto fail_allrecord_lock; goto fail_allrecord_lock;
} }
...@@ -853,6 +859,7 @@ static int transaction_setup_recovery(struct tdb_context *tdb, ...@@ -853,6 +859,7 @@ static int transaction_setup_recovery(struct tdb_context *tdb,
static int _tdb_transaction_prepare_commit(struct tdb_context *tdb) static int _tdb_transaction_prepare_commit(struct tdb_context *tdb)
{ {
const struct tdb_methods *methods; const struct tdb_methods *methods;
enum TDB_ERROR ecode;
if (tdb->transaction == NULL) { if (tdb->transaction == NULL) {
tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR, tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
...@@ -890,8 +897,9 @@ static int _tdb_transaction_prepare_commit(struct tdb_context *tdb) ...@@ -890,8 +897,9 @@ static int _tdb_transaction_prepare_commit(struct tdb_context *tdb)
methods = tdb->transaction->io_methods; methods = tdb->transaction->io_methods;
/* upgrade the main transaction lock region to a write lock */ /* upgrade the main transaction lock region to a write lock */
if (tdb_allrecord_upgrade(tdb) == -1) { ecode = tdb_allrecord_upgrade(tdb);
tdb_logerr(tdb, tdb->ecode, TDB_LOG_ERROR, if (ecode != TDB_SUCCESS) {
tdb_logerr(tdb, ecode, TDB_LOG_ERROR,
"tdb_transaction_prepare_commit:" "tdb_transaction_prepare_commit:"
" failed to upgrade hash locks"); " failed to upgrade hash locks");
_tdb_transaction_cancel(tdb); _tdb_transaction_cancel(tdb);
...@@ -900,10 +908,11 @@ static int _tdb_transaction_prepare_commit(struct tdb_context *tdb) ...@@ -900,10 +908,11 @@ static int _tdb_transaction_prepare_commit(struct tdb_context *tdb)
/* get the open lock - this prevents new users attaching to the database /* get the open lock - this prevents new users attaching to the database
during the commit */ during the commit */
if (tdb_lock_open(tdb, TDB_LOCK_WAIT|TDB_LOCK_NOCHECK) == -1) { ecode = tdb_lock_open(tdb, TDB_LOCK_WAIT|TDB_LOCK_NOCHECK);
tdb_logerr(tdb, tdb->ecode, TDB_LOG_ERROR, if (ecode != TDB_SUCCESS) {
"tdb_transaction_prepare_commit:" tdb_logerr(tdb, ecode, TDB_LOG_ERROR,
" failed to get open lock"); "tdb_transaction_prepare_commit:"
" failed to get open lock");
_tdb_transaction_cancel(tdb); _tdb_transaction_cancel(tdb);
return -1; return -1;
} }
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment