}
static int fcntl_lock(struct tdb_context *tdb,
- int rw, off_t off, off_t len, bool wait)
+ int rw, off_t off, off_t len, bool waitflag)
{
struct flock fl;
-
+
fl.l_type = rw;
fl.l_whence = SEEK_SET;
fl.l_start = off;
fl.l_len = len;
fl.l_pid = 0;
- if (wait)
+ if (waitflag)
return fcntl(tdb->fd, F_SETLKW, &fl);
else
return fcntl(tdb->fd, F_SETLK, &fl);
* EAGAIN is an expected return from non-blocking
* locks. */
if (!(flags & TDB_LOCK_PROBE) && errno != EAGAIN) {
- TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_brlock failed (fd=%d) at offset %d rw_type=%d flags=%d len=%d\n",
+ TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_brlock failed (fd=%d) at offset %d rw_type=%d flags=%d len=%d\n",
tdb->fd, offset, rw_type, flags, (int)len));
}
return -1;
} while (ret == -1 && errno == EINTR);
if (ret == -1) {
- TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_brunlock failed (fd=%d) at offset %d rw_type=%d len=%d\n",
+ TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_brunlock failed (fd=%d) at offset %d rw_type=%d len=%d\n",
tdb->fd, offset, rw_type, (int)len));
}
return ret;
return -1;
}
+/* list -1 is the alloc list, otherwise a hash chain. */
+static tdb_off_t lock_offset(int list)
+{
+ return FREELIST_TOP + 4*list;
+}
-/* lock a list in the database. list -1 is the alloc list */
-static int _tdb_lock(struct tdb_context *tdb, int list, int ltype,
- enum tdb_lock_flags flags)
+static struct tdb_lock_type *find_nestlock(struct tdb_context *tdb,
+ tdb_off_t offset)
{
- struct tdb_lock_type *new_lck;
- int i;
+ unsigned int i;
- /* a global lock allows us to avoid per chain locks */
- if (tdb->global_lock.count &&
- (ltype == tdb->global_lock.ltype || ltype == F_RDLCK)) {
- return 0;
+ for (i=0; i<tdb->num_lockrecs; i++) {
+ if (tdb->lockrecs[i].off == offset) {
+ return &tdb->lockrecs[i];
+ }
}
+ return NULL;
+}
- if (tdb->global_lock.count) {
- tdb->ecode = TDB_ERR_LOCK;
- return -1;
- }
+/* lock an offset in the database. */
+int tdb_nest_lock(struct tdb_context *tdb, uint32_t offset, int ltype,
+ enum tdb_lock_flags flags)
+{
+ struct tdb_lock_type *new_lck;
- if (list < -1 || list >= (int)tdb->header.hash_size) {
+ if (offset >= lock_offset(tdb->header.hash_size)) {
tdb->ecode = TDB_ERR_LOCK;
- TDB_LOG((tdb, TDB_DEBUG_ERROR,"tdb_lock: invalid list %d for ltype=%d\n",
- list, ltype));
+ TDB_LOG((tdb, TDB_DEBUG_ERROR,"tdb_lock: invalid offset %u for ltype=%d\n",
+ offset, ltype));
return -1;
}
if (tdb->flags & TDB_NOLOCK)
return 0;
- for (i=0; i<tdb->num_lockrecs; i++) {
- if (tdb->lockrecs[i].list == list) {
- if (tdb->lockrecs[i].count == 0) {
- /*
- * Can't happen, see tdb_unlock(). It should
- * be an assert.
- */
- TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_lock: "
- "lck->count == 0 for list %d", list));
- }
- /*
- * Just increment the in-memory struct, posix locks
- * don't stack.
- */
- tdb->lockrecs[i].count++;
- return 0;
- }
+ new_lck = find_nestlock(tdb, offset);
+ if (new_lck) {
+ /*
+ * Just increment the in-memory struct, posix locks
+ * don't stack.
+ */
+ new_lck->count++;
+ return 0;
}
new_lck = (struct tdb_lock_type *)realloc(
/* Since fcntl locks don't nest, we do a lock for the first one,
and simply bump the count for future ones */
- if (tdb->methods->brlock(tdb, ltype, FREELIST_TOP+4*list, 1, flags)) {
+ if (tdb->methods->brlock(tdb, ltype, offset, 1, flags)) {
return -1;
}
tdb->num_locks++;
- tdb->lockrecs[tdb->num_lockrecs].list = list;
+ tdb->lockrecs[tdb->num_lockrecs].off = offset;
tdb->lockrecs[tdb->num_lockrecs].count = 1;
tdb->lockrecs[tdb->num_lockrecs].ltype = ltype;
tdb->num_lockrecs += 1;
{
int ret;
- ret = _tdb_lock(tdb, list, ltype, TDB_LOCK_WAIT);
+ /* a allrecord lock allows us to avoid per chain locks */
+ if (tdb->allrecord_lock.count &&
+ (ltype == tdb->allrecord_lock.ltype || ltype == F_RDLCK)) {
+ return 0;
+ }
+
+ if (tdb->allrecord_lock.count) {
+ tdb->ecode = TDB_ERR_LOCK;
+ ret = -1;
+ } else {
+ ret = tdb_nest_lock(tdb, lock_offset(list), ltype,
+ TDB_LOCK_WAIT);
+ }
if (ret) {
TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_lock failed on list %d "
"ltype=%d (%s)\n", list, ltype, strerror(errno)));
/* lock a list in the database. list -1 is the alloc list. non-blocking lock */
int tdb_lock_nonblock(struct tdb_context *tdb, int list, int ltype)
{
- return _tdb_lock(tdb, list, ltype, TDB_LOCK_NOWAIT);
-}
-
-
-static int _tdb_unlock(struct tdb_context *tdb, int list, int ltype,
- bool mark_lock)
-{
- int ret = -1;
- int i;
- struct tdb_lock_type *lck = NULL;
-
- /* a global lock allows us to avoid per chain locks */
- if (tdb->global_lock.count &&
- (ltype == tdb->global_lock.ltype || ltype == F_RDLCK)) {
+ /* a allrecord lock allows us to avoid per chain locks */
+ if (tdb->allrecord_lock.count &&
+ (ltype == tdb->allrecord_lock.ltype || ltype == F_RDLCK)) {
return 0;
}
- if (tdb->global_lock.count) {
+ if (tdb->allrecord_lock.count) {
tdb->ecode = TDB_ERR_LOCK;
return -1;
}
+ return tdb_nest_lock(tdb, lock_offset(list), ltype, TDB_LOCK_NOWAIT);
+}
+
+
+int tdb_nest_unlock(struct tdb_context *tdb, uint32_t offset, int ltype,
+ bool mark_lock)
+{
+ int ret = -1;
+ struct tdb_lock_type *lck;
+
if (tdb->flags & TDB_NOLOCK)
return 0;
/* Sanity checks */
- if (list < -1 || list >= (int)tdb->header.hash_size) {
- TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_unlock: list %d invalid (%d)\n", list, tdb->header.hash_size));
+ if (offset >= lock_offset(tdb->header.hash_size)) {
+ TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_unlock: offset %u invalid (%d)\n", offset, tdb->header.hash_size));
return ret;
}
- for (i=0; i<tdb->num_lockrecs; i++) {
- if (tdb->lockrecs[i].list == list) {
- lck = &tdb->lockrecs[i];
- break;
- }
- }
-
+ lck = find_nestlock(tdb, offset);
if ((lck == NULL) || (lck->count == 0)) {
TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_unlock: count is 0\n"));
return -1;
if (mark_lock) {
ret = 0;
} else {
- ret = tdb->methods->brunlock(tdb, ltype,
- FREELIST_TOP+4*list, 1);
+ ret = tdb->methods->brunlock(tdb, ltype, offset, 1);
}
tdb->num_locks--;
int tdb_unlock(struct tdb_context *tdb, int list, int ltype)
{
- return _tdb_unlock(tdb, list, ltype, false);
+ /* a global lock allows us to avoid per chain locks */
+ if (tdb->allrecord_lock.count &&
+ (ltype == tdb->allrecord_lock.ltype || ltype == F_RDLCK)) {
+ return 0;
+ }
+
+ if (tdb->allrecord_lock.count) {
+ tdb->ecode = TDB_ERR_LOCK;
+ return -1;
+ }
+
+ return tdb_nest_unlock(tdb, lock_offset(list), ltype, false);
}
/*
*/
int tdb_transaction_lock(struct tdb_context *tdb, int ltype)
{
- if (tdb->global_lock.count) {
- return 0;
- }
if (tdb->transaction_lock_count > 0) {
tdb->transaction_lock_count++;
return 0;
int tdb_transaction_unlock(struct tdb_context *tdb, int ltype)
{
int ret;
- if (tdb->global_lock.count) {
- return 0;
- }
if (tdb->transaction_lock_count > 1) {
tdb->transaction_lock_count--;
return 0;
return -1;
}
- if (tdb->global_lock.count && tdb->global_lock.ltype == ltype) {
- tdb->global_lock.count++;
+ if (tdb->allrecord_lock.count && tdb->allrecord_lock.ltype == ltype) {
+ tdb->allrecord_lock.count++;
return 0;
}
- if (tdb->global_lock.count) {
+ if (tdb->allrecord_lock.count) {
/* a global lock of a different type exists */
tdb->ecode = TDB_ERR_LOCK;
return -1;
}
-
- if (tdb->num_locks != 0) {
+
+ if (tdb_have_extra_locks(tdb)) {
/* can't combine global and chain locks */
tdb->ecode = TDB_ERR_LOCK;
return -1;
return -1;
}
- tdb->global_lock.count = 1;
- tdb->global_lock.ltype = ltype;
+ tdb->allrecord_lock.count = 1;
+ tdb->allrecord_lock.ltype = ltype;
return 0;
}
return -1;
}
- if (tdb->global_lock.ltype != ltype || tdb->global_lock.count == 0) {
+ if (tdb->allrecord_lock.ltype != ltype || tdb->allrecord_lock.count == 0) {
tdb->ecode = TDB_ERR_LOCK;
return -1;
}
- if (tdb->global_lock.count > 1) {
- tdb->global_lock.count--;
+ if (tdb->allrecord_lock.count > 1) {
+ tdb->allrecord_lock.count--;
return 0;
}
return -1;
}
- tdb->global_lock.count = 0;
- tdb->global_lock.ltype = 0;
+ tdb->allrecord_lock.count = 0;
+ tdb->allrecord_lock.ltype = 0;
return 0;
}
/* mark a chain as locked without actually locking it. Warning! use with great caution! */
int tdb_chainlock_mark(struct tdb_context *tdb, TDB_DATA key)
{
- int ret = _tdb_lock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK,
- TDB_LOCK_MARK_ONLY);
+ int ret = tdb_nest_lock(tdb, lock_offset(BUCKET(tdb->hash_fn(&key))),
+ F_WRLCK, TDB_LOCK_MARK_ONLY);
tdb_trace_1rec(tdb, "tdb_chainlock_mark", key);
return ret;
}
int tdb_chainlock_unmark(struct tdb_context *tdb, TDB_DATA key)
{
tdb_trace_1rec(tdb, "tdb_chainlock_unmark", key);
- return _tdb_unlock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK, true);
+ return tdb_nest_unlock(tdb, lock_offset(BUCKET(tdb->hash_fn(&key))),
+ F_WRLCK, true);
}
int tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key)
return tdb_unlock(tdb, BUCKET(tdb->hash_fn(&key)), F_RDLCK);
}
+
+
/* record lock stops delete underneath */
int tdb_lock_record(struct tdb_context *tdb, tdb_off_t off)
{
- if (tdb->global_lock.count) {
+ if (tdb->allrecord_lock.count) {
return 0;
}
return off ? tdb->methods->brlock(tdb, F_RDLCK, off, 1, TDB_LOCK_WAIT) : 0;
struct tdb_traverse_lock *i;
uint32_t count = 0;
- if (tdb->global_lock.count) {
+ if (tdb->allrecord_lock.count) {
return 0;
}
count++;
return (count == 1 ? tdb->methods->brunlock(tdb, F_RDLCK, off, 1) : 0);
}
+
+bool tdb_have_extra_locks(struct tdb_context *tdb)
+{
+ if (tdb->allrecord_lock.count) {
+ return true;
+ }
+ if (tdb->num_lockrecs) {
+ return true;
+ }
+ return false;
+}
+
+/* The transaction code uses this to remove all locks. */
+void tdb_release_extra_locks(struct tdb_context *tdb)
+{
+ unsigned int i;
+
+ if (tdb->allrecord_lock.count != 0) {
+ tdb_brunlock(tdb, tdb->allrecord_lock.ltype,
+ FREELIST_TOP, 4*tdb->header.hash_size);
+ tdb->allrecord_lock.count = 0;
+ }
+
+ for (i=0;i<tdb->num_lockrecs;i++) {
+ tdb_brunlock(tdb, tdb->lockrecs[i].ltype,
+ tdb->lockrecs[i].off, 1);
+ }
+ tdb->num_locks = 0;
+ tdb->num_lockrecs = 0;
+ SAFE_FREE(tdb->lockrecs);
+}
projects / ccan / blobdiff