contention - it cannot guarantee how many records will be locked */
enum TDB_ERROR tdb_chainlock(struct tdb_context *tdb, TDB_DATA key)
{
+ if (tdb->flags & TDB_VERSION1) {
+ if (tdb1_chainlock(tdb, key) == -1)
+ return tdb->last_error;
+ return TDB_SUCCESS;
+ }
return tdb->last_error = chainlock(tdb, &key, F_WRLCK, TDB_LOCK_WAIT,
"tdb_chainlock");
}
tdb_off_t lockstart, locksize;
unsigned int group, gbits;
+ if (tdb->flags & TDB_VERSION1) {
+ tdb1_chainunlock(tdb, key);
+ return;
+ }
+
gbits = TDB_TOPLEVEL_HASH_BITS - TDB_HASH_GROUP_BITS;
group = bits_from(h, 64 - gbits, gbits);
enum TDB_ERROR tdb_chainlock_read(struct tdb_context *tdb, TDB_DATA key)
{
+ if (tdb->flags & TDB_VERSION1) {
+ if (tdb1_chainlock_read(tdb, key) == -1)
+ return tdb->last_error;
+ return TDB_SUCCESS;
+ }
return tdb->last_error = chainlock(tdb, &key, F_RDLCK, TDB_LOCK_WAIT,
"tdb_chainlock_read");
}
tdb_off_t lockstart, locksize;
unsigned int group, gbits;
+ if (tdb->flags & TDB_VERSION1) {
+ tdb1_chainunlock_read(tdb, key);
+ return;
+ }
gbits = TDB_TOPLEVEL_HASH_BITS - TDB_HASH_GROUP_BITS;
group = bits_from(h, 64 - gbits, gbits);
enum TDB_ERROR ecode;
tdb_bool_err berr;
+ if (tdb->flags & TDB_VERSION1) {
+ if (tdb1_allrecord_lock(tdb, ltype, flags, upgradable) == -1)
+ return tdb->last_error;
+ return TDB_SUCCESS;
+ }
+
if (tdb->flags & TDB_NOLOCK)
return TDB_SUCCESS;
/* unlock entire db */
void tdb_allrecord_unlock(struct tdb_context *tdb, int ltype)
{
+ if (tdb->flags & TDB_VERSION1) {
+ tdb1_allrecord_unlock(tdb, ltype);
+ return;
+ }
+
if (tdb->flags & TDB_NOLOCK)
return;
while (tdb->file->allrecord_lock.count
&& tdb->file->allrecord_lock.owner == tdb) {
- if (tdb->flags & TDB_VERSION1)
- tdb1_allrecord_unlock(tdb,
- tdb->file->allrecord_lock.ltype);
- else
- tdb_allrecord_unlock(tdb,
- tdb->file->allrecord_lock.ltype);
+ tdb_allrecord_unlock(tdb, tdb->file->allrecord_lock.ltype);
}
for (i=0; i<tdb->file->num_lockrecs; i++) {
enum TDB_ERROR tdb1_probe_length(struct tdb_context *tdb);
/* tdb1_lock.c: */
+int tdb1_allrecord_lock(struct tdb_context *tdb, int ltype,
+ enum tdb_lock_flags flags, bool upgradable);
int tdb1_allrecord_unlock(struct tdb_context *tdb, int ltype);
+int tdb1_chainlock(struct tdb_context *tdb, TDB_DATA key);
+int tdb1_chainunlock(struct tdb_context *tdb, TDB_DATA key);
+int tdb1_chainlock_read(struct tdb_context *tdb, TDB_DATA key);
+int tdb1_chainunlock_read(struct tdb_context *tdb, TDB_DATA key);
+
/* tdb1_transaction.c: */
int tdb1_transaction_recover(struct tdb_context *tdb);
int tdb1_transaction_cancel(struct tdb_context *tdb);
TDB_DATA tdb1_nextkey(struct tdb_context *tdb, TDB_DATA key);
-int tdb1_lockall(struct tdb_context *tdb);
-
-int tdb1_unlockall(struct tdb_context *tdb);
-
-int tdb1_lockall_read(struct tdb_context *tdb);
-
-int tdb1_unlockall_read(struct tdb_context *tdb);
-
int tdb1_transaction_start(struct tdb_context *tdb);
int tdb1_transaction_prepare_commit(struct tdb_context *tdb);
/* @} ******************************************************************/
-/* Low level locking functions: use with care */
-int tdb1_chainlock(struct tdb_context *tdb, TDB_DATA key);
-int tdb1_chainunlock(struct tdb_context *tdb, TDB_DATA key);
-int tdb1_chainlock_read(struct tdb_context *tdb, TDB_DATA key);
-int tdb1_chainunlock_read(struct tdb_context *tdb, TDB_DATA key);
-
-
/* wipe and repack */
int tdb1_wipe_all(struct tdb_context *tdb);
int tdb1_repack(struct tdb_context *tdb);
if (tdb->file->allrecord_lock.count != 0) {
locked = false;
} else {
- if (tdb1_lockall_read(tdb) == -1)
+ if (tdb_lockall_read(tdb) != TDB_SUCCESS)
return -1;
locked = true;
}
free(hashes);
if (locked) {
- tdb1_unlockall_read(tdb);
+ tdb_unlockall_read(tdb);
}
return 0;
free(hashes);
unlock:
if (locked) {
- tdb1_unlockall_read(tdb);
+ tdb_unlockall_read(tdb);
}
return -1;
}
}
/* FIXME: Temporary cast. */
- tdb->file->allrecord_lock.owner = (void *)(struct tdb1_context *)tdb;
+ tdb->file->allrecord_lock.owner = (void *)(struct tdb_context *)tdb;
tdb->file->allrecord_lock.count = 1;
/* If it's upgradable, it's actually exclusive so we can treat
* it as a write lock. */
return 0;
}
-/* lock entire database with write lock */
-int tdb1_lockall(struct tdb_context *tdb)
-{
- return tdb1_allrecord_lock(tdb, F_WRLCK, TDB_LOCK_WAIT, false);
-}
-
-/* unlock entire database with write lock */
-int tdb1_unlockall(struct tdb_context *tdb)
-{
- return tdb1_allrecord_unlock(tdb, F_WRLCK);
-}
-
-/* lock entire database with read lock */
-int tdb1_lockall_read(struct tdb_context *tdb)
-{
- return tdb1_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false);
-}
-
-/* unlock entire database with read lock */
-int tdb1_unlockall_read(struct tdb_context *tdb)
-{
- return tdb1_allrecord_unlock(tdb, F_RDLCK);
-}
-
/* lock/unlock one hash chain. This is meant to be used to reduce
contention - it cannot guarantee how many records will be locked */
int tdb1_chainlock(struct tdb_context *tdb, TDB_DATA key)
*magic1_hash = 1;
}
-static void tdb1_context_init(struct tdb_context *tdb)
+static void tdb_context_init(struct tdb_context *tdb)
{
assert(tdb->flags & TDB_VERSION1);
int hash_size = TDB1_DEFAULT_HASH_SIZE;
enum TDB_ERROR ret = TDB_ERR_IO;
- tdb1_context_init(tdb);
+ tdb_context_init(tdb);
/* Default TDB2 hash becomes default TDB1 hash. */
if (tdb->hash_fn == tdb_jenkins_hash)
tdb->flags |= TDB_VERSION1;
- tdb1_context_init(tdb);
+ tdb_context_init(tdb);
/* Default TDB2 hash becomes default TDB1 hash. */
if (tdb->hash_fn == tdb_jenkins_hash) {
const struct tdb1_methods *methods,
tdb1_off_t *recovery_offset,
struct tdb1_record *rec);
-int tdb1_allrecord_lock(struct tdb_context *tdb, int ltype,
- enum tdb_lock_flags flags, bool upgradable);
int tdb1_allrecord_upgrade(struct tdb_context *tdb);
int tdb1_write_lock_record(struct tdb_context *tdb, tdb1_off_t off);
int tdb1_write_unlock_record(struct tdb_context *tdb, tdb1_off_t off);
if (tdb->file->allrecord_lock.count != 0) {
locked = false;
} else {
- if (tdb1_lockall_read(tdb) == -1)
+ if (tdb_lockall_read(tdb) != TDB_SUCCESS)
return NULL;
locked = true;
}
unlock:
if (locked) {
- tdb1_unlockall_read(tdb);
+ tdb_unlockall_read(tdb);
}
return ret;
}
tdb1_off_t recovery_head;
tdb1_len_t recovery_size = 0;
- if (tdb1_lockall(tdb) != 0) {
+ if (tdb_lockall(tdb) != TDB_SUCCESS) {
return -1;
}
}
}
- if (tdb1_unlockall(tdb) != 0) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_wipe_all: failed to unlock");
- goto failed;
- }
-
+ tdb_unlockall(tdb);
return 0;
failed:
- tdb1_unlockall(tdb);
+ tdb_unlockall(tdb);
return -1;
}
hsize.base.next = &tap_log_attr;
hsize.tdb1_hashsize.hsize = 1024;
- plan_tests(43);
+ plan_tests(40);
tdb = tdb_open("run-no-lock-during-traverse.tdb1",
TDB_VERSION1, O_CREAT|O_TRUNC|O_RDWR,
0600, &hsize);
ok1(tdb);
ok1(prepare_entries(tdb));
ok1(locking_errors1 == 0);
- ok1(tdb1_lockall(tdb) == 0);
+ ok1(tdb_lockall(tdb) == 0);
ok1(locking_errors1 == 0);
ok1(tdb_traverse(tdb, delete_other, &errors) >= 0);
ok1(errors == 0);
ok1(locking_errors1 == 0);
- ok1(tdb1_unlockall(tdb) == 0);
+ tdb_unlockall(tdb);
ok1(prepare_entries(tdb));
ok1(locking_errors1 == 0);
- ok1(tdb1_lockall(tdb) == 0);
+ ok1(tdb_lockall(tdb) == 0);
ok1(locking_errors1 == 0);
ok1(tdb_traverse(tdb, delete_self, NULL) == NUM_ENTRIES);
ok1(locking_errors1 == 0);
- ok1(tdb1_unlockall(tdb) == 0);
+ tdb_unlockall(tdb);
ok1(prepare_entries(tdb));
ok1(locking_errors1 == 0);
- ok1(tdb1_lockall(tdb) == 0);
+ ok1(tdb_lockall(tdb) == 0);
ok1(locking_errors1 == 0);
delete_entries(tdb);
ok1(locking_errors1 == 0);
- ok1(tdb1_unlockall(tdb) == 0);
+ tdb_unlockall(tdb);
ok1(tdb_close(tdb) == 0);