tdb: cleanup: always grab allrecord lock to infinity.

[ccan] / ccan / tdb / lock.c

diff --git a/ccan/tdb/lock.c b/ccan/tdb/lock.c
index 920ba95fe0515a7773ddefd61098510974c18f23..b1153b2e6f72b20f81e65f135d1d56f051036727 100644 (file)
--- a/ccan/tdb/lock.c
+++ b/ccan/tdb/lock.c
@@ -277,12 +277,10 @@ int tdb_nest_lock(struct tdb_context *tdb, uint32_t offset, int ltype,
                return -1;
        }
 
-       tdb->num_locks++;
-
        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;
+       tdb->num_lockrecs++;
 
        return 0;
 }
@@ -368,17 +366,12 @@ int tdb_nest_unlock(struct tdb_context *tdb, uint32_t offset, int ltype,
        } else {
                ret = tdb->methods->brunlock(tdb, ltype, offset, 1);
        }
-       tdb->num_locks--;
 
        /*
         * Shrink the array by overwriting the element just unlocked with the
         * last array element.
         */
-
-       if (tdb->num_lockrecs > 1) {
-               *lck = tdb->lockrecs[tdb->num_lockrecs-1];
-       }
-       tdb->num_lockrecs -= 1;
+       *lck = tdb->lockrecs[--tdb->num_lockrecs];
 
        /*
         * We don't bother with realloc when the array shrinks, but if we have
@@ -415,18 +408,7 @@ int tdb_unlock(struct tdb_context *tdb, int list, int ltype)
  */
 int tdb_transaction_lock(struct tdb_context *tdb, int ltype)
 {
-       if (tdb->transaction_lock_count > 0) {
-               tdb->transaction_lock_count++;
-               return 0;
-       }
-
-       if (tdb->methods->brlock(tdb, ltype, TRANSACTION_LOCK, 1, TDB_LOCK_WAIT) == -1) {
-               TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_lock: failed to get transaction lock\n"));
-               tdb->ecode = TDB_ERR_LOCK;
-               return -1;
-       }
-       tdb->transaction_lock_count++;
-       return 0;
+       return tdb_nest_lock(tdb, TRANSACTION_LOCK, ltype, TDB_LOCK_WAIT);
 }
 
 /*
@@ -434,16 +416,7 @@ int tdb_transaction_lock(struct tdb_context *tdb, int ltype)
  */
 int tdb_transaction_unlock(struct tdb_context *tdb, int ltype)
 {
-       int ret;
-       if (tdb->transaction_lock_count > 1) {
-               tdb->transaction_lock_count--;
-               return 0;
-       }
-       ret = tdb->methods->brunlock(tdb, ltype, TRANSACTION_LOCK, 1);
-       if (ret == 0) {
-               tdb->transaction_lock_count = 0;
-       }
-       return ret;
+       return tdb_nest_unlock(tdb, TRANSACTION_LOCK, ltype, false);
 }
 
 
@@ -476,9 +449,7 @@ static int _tdb_lockall(struct tdb_context *tdb, int ltype,
                return -1;
        }
 
-       if (tdb->methods->brlock(tdb, ltype,
-                                FREELIST_TOP, 4*tdb->header.hash_size,
-                                flags)) {
+       if (tdb->methods->brlock(tdb, ltype, FREELIST_TOP, 0, flags)) {
                if (flags & TDB_LOCK_WAIT) {
                        TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_lockall failed (%s)\n", strerror(errno)));
                }
@@ -513,8 +484,7 @@ static int _tdb_unlockall(struct tdb_context *tdb, int ltype, bool mark_lock)
        }
 
        if (!mark_lock &&
-           tdb->methods->brunlock(tdb, ltype,
-                                  FREELIST_TOP, 4*tdb->header.hash_size)) {
+           tdb->methods->brunlock(tdb, ltype, FREELIST_TOP, 0)) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_unlockall failed (%s)\n", strerror(errno)));
                return -1;
        }
@@ -689,31 +659,50 @@ int tdb_unlock_record(struct tdb_context *tdb, tdb_off_t off)
 
 bool tdb_have_extra_locks(struct tdb_context *tdb)
 {
+       unsigned int extra = tdb->num_lockrecs;
+
        if (tdb->allrecord_lock.count) {
                return true;
        }
-       if (tdb->num_lockrecs) {
-               return true;
+
+       /* We always hold the active lock if CLEAR_IF_FIRST. */
+       if (find_nestlock(tdb, ACTIVE_LOCK)) {
+               extra--;
+       }
+
+       /* In a transaction, we expect to hold the transaction lock */
+       if (tdb->transaction && find_nestlock(tdb, TRANSACTION_LOCK)) {
+               extra--;
        }
-       return false;
+
+       return extra;
 }
 
-/* The transaction code uses this to remove all locks. */
+/* The transaction code uses this to remove all locks.  Note that this
+   may include OPEN_LOCK. */
 void tdb_release_extra_locks(struct tdb_context *tdb)
 {
-       unsigned int i;
+       unsigned int i, extra = 0;
 
        if (tdb->allrecord_lock.count != 0) {
-               tdb_brunlock(tdb, tdb->allrecord_lock.ltype,
-                            FREELIST_TOP, 4*tdb->header.hash_size);
+               tdb_brunlock(tdb, tdb->allrecord_lock.ltype, FREELIST_TOP, 0);
                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);
+               struct tdb_lock_type *lck = &tdb->lockrecs[i];
+
+               /* Don't release transaction or active locks! */
+               if (tdb->transaction && lck->off == TRANSACTION_LOCK) {
+                       tdb->lockrecs[extra++] = *lck;
+               } else if (lck->off == ACTIVE_LOCK) {
+                       tdb->lockrecs[extra++] = *lck;
+               } else {
+                       tdb_brunlock(tdb, lck->ltype, lck->off, 1);
+               }
+       }
+       tdb->num_lockrecs = extra;
+       if (tdb->num_lockrecs == 0) {
+               SAFE_FREE(tdb->lockrecs);
        }
-       tdb->num_locks = 0;
-       tdb->num_lockrecs = 0;
-       SAFE_FREE(tdb->lockrecs);
 }