#include <ccan/build_assert/build_assert.h>
/* If we were threaded, we could wait for unlock, but we're not, so fail. */
-static enum TDB_ERROR owner_conflict(struct tdb_context *tdb, const char *call)
+enum TDB_ERROR owner_conflict(struct tdb_context *tdb, const char *call)
{
return tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_USE_ERROR,
"%s: lock owned by another tdb in this process.",
}
/* If we fork, we no longer really own locks. */
-static bool check_lock_pid(struct tdb_context *tdb,
- const char *call, bool log)
+bool check_lock_pid(struct tdb_context *tdb, const char *call, bool log)
{
/* No locks? No problem! */
if (tdb->file->allrecord_lock.count == 0
return tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
"tdb_unlock_hashes RO allrecord!");
}
+ if (tdb->file->allrecord_lock.owner != tdb) {
+ return tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_USE_ERROR,
+ "tdb_unlock_hashes:"
+ " not locked by us!");
+ }
return TDB_SUCCESS;
}
if (!check_lock_pid(tdb, "tdb_lock_free_bucket", true))
return TDB_ERR_LOCK;
+ if (tdb->file->allrecord_lock.owner != tdb) {
+ return owner_conflict(tdb, "tdb_lock_free_bucket");
+ }
+
if (tdb->file->allrecord_lock.ltype == F_WRLCK)
return 0;
return tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
bool check = false;
/* a allrecord lock allows us to avoid per chain locks */
- if (tdb->file->allrecord_lock.count &&
- (ltype == tdb->file->allrecord_lock.ltype || ltype == F_RDLCK)) {
- return 0;
+ if (tdb->file->allrecord_lock.count) {
+ if (!check_lock_pid(tdb, "tdb1_lock_list", true)) {
+ tdb->last_error = TDB_ERR_LOCK;
+ return -1;
+ }
+ if (tdb->file->allrecord_lock.owner != tdb) {
+ tdb->last_error = owner_conflict(tdb, "tdb1_lock_list");
+ return -1;
+ }
+ if (ltype == tdb->file->allrecord_lock.ltype
+ || ltype == F_RDLCK) {
+ return 0;
+ }
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK,
+ TDB_LOG_USE_ERROR,
+ "tdb1_lock_list:"
+ " already have read lock");
+ return -1;
}
- if (tdb->file->allrecord_lock.count) {
- tdb->last_error = TDB_ERR_LOCK;
- ret = -1;
- } else {
- /* Only check when we grab first data lock. */
- check = !have_data_locks(tdb);
- ret = tdb1_nest_lock(tdb, lock_offset(list), ltype, waitflag);
+ /* Only check when we grab first data lock. */
+ check = !have_data_locks(tdb);
+ ret = tdb1_nest_lock(tdb, lock_offset(list), ltype, waitflag);
+
+ if (ret == 0 && check) {
+ tdb_bool_err berr = tdb1_needs_recovery(tdb);
- if (ret == 0 && check) {
- tdb_bool_err berr = tdb1_needs_recovery(tdb);
+ if (berr < 0) {
+ return -1;
+ }
+ if (berr == true) {
+ tdb1_nest_unlock(tdb, lock_offset(list), ltype);
- if (berr < 0) {
+ if (tdb1_lock_and_recover(tdb) == -1) {
return -1;
}
- if (berr == true) {
- tdb1_nest_unlock(tdb, lock_offset(list), ltype);
-
- if (tdb1_lock_and_recover(tdb) == -1) {
- return -1;
- }
- return tdb1_lock_list(tdb, list, ltype,
- waitflag);
- }
+ return tdb1_lock_list(tdb, list, ltype, waitflag);
}
}
return ret;
/* a global lock allows us to avoid per chain locks */
if (tdb->file->allrecord_lock.count &&
(ltype == tdb->file->allrecord_lock.ltype || ltype == F_RDLCK)) {
+ if (tdb->file->allrecord_lock.owner != tdb) {
+ tdb->last_error = owner_conflict(tdb, "tdb1_unlock");
+ return -1;
+ }
return 0;
}
return -1;
}
- /* FIXME: Temporary cast. */
- tdb->file->allrecord_lock.owner = (void *)(struct tdb_context *)tdb;
+ tdb->file->allrecord_lock.owner = tdb;
tdb->file->allrecord_lock.count = 1;
+ tdb->file->locker = getpid();
/* If it's upgradable, it's actually exclusive so we can treat
* it as a write lock. */
tdb->file->allrecord_lock.ltype = upgradable ? F_WRLCK : ltype;
}
if (tdb->file->allrecord_lock.count > 1) {
+ if (tdb->file->allrecord_lock.owner != tdb) {
+ tdb->last_error
+ = owner_conflict(tdb, "tdb1_allrecord_unlock");
+ return -1;
+ }
tdb->file->allrecord_lock.count--;
return 0;
}
int tdb1_lock_record(struct tdb_context *tdb, tdb1_off_t off)
{
if (tdb->file->allrecord_lock.count) {
+ if (!check_lock_pid(tdb, "tdb1_lock_record", true)) {
+ tdb->last_error = TDB_ERR_LOCK;
+ return -1;
+ }
+ if (tdb->file->allrecord_lock.owner != tdb) {
+ tdb->last_error = owner_conflict(tdb,
+ "tdb1_lock_record");
+ return -1;
+ }
return 0;
}
return off ? tdb1_brlock(tdb, F_RDLCK, off, 1, TDB_LOCK_WAIT) : 0;
if (i->off == off)
return -1;
if (tdb->file->allrecord_lock.count) {
+ if (!check_lock_pid(tdb, "tdb1_write_lock_record", true)) {
+ tdb->last_error = TDB_ERR_LOCK;
+ return -1;
+ }
+ if (tdb->file->allrecord_lock.owner != tdb) {
+ tdb->last_error
+ = owner_conflict(tdb, "tdb1_write_lock_record");
+ return -1;
+ }
if (tdb->file->allrecord_lock.ltype == F_WRLCK) {
return 0;
}
int tdb1_write_unlock_record(struct tdb_context *tdb, tdb1_off_t off)
{
if (tdb->file->allrecord_lock.count) {
+ if (tdb->file->allrecord_lock.owner != tdb) {
+ tdb->last_error
+ = owner_conflict(tdb,
+ "tdb1_write_unlock_record");
+ return -1;
+ }
return 0;
}
return tdb1_brunlock(tdb, F_WRLCK, off, 1);
uint32_t count = 0;
if (tdb->file->allrecord_lock.count) {
+ if (tdb->file->allrecord_lock.owner != tdb) {
+ tdb->last_error = owner_conflict(tdb,
+ "tdb1_unlock_record");
+ return -1;
+ }
return 0;
}