tdb2: get rid of TDB1 mark and nonblock functions.
authorRusty Russell <rusty@rustcorp.com.au>
Wed, 31 Aug 2011 05:44:16 +0000 (15:14 +0930)
committerRusty Russell <rusty@rustcorp.com.au>
Wed, 31 Aug 2011 05:44:16 +0000 (15:14 +0930)
We do this using hooks in tdb2.

ccan/tdb2/tdb1_lock.c
ccan/tdb2/tdb1_open.c
ccan/tdb2/tdb1_private.h
ccan/tdb2/tdb1_tdb.c
ccan/tdb2/tdb1_transaction.c

index ee6aaf745e20b76a85fa1a0f876177e83539242a..a33c851c1721e0c92b10b834b33756bed2c602bc 100644 (file)
@@ -138,10 +138,6 @@ int tdb1_brlock(struct tdb1_context *tdb,
                return 0;
        }
 
-       if (flags & TDB1_LOCK_MARK_ONLY) {
-               return 0;
-       }
-
        if ((rw_type == F_WRLCK) && (tdb->read_only || tdb->traverse_read)) {
                tdb->ecode = TDB1_ERR_RDONLY;
                return -1;
@@ -344,7 +340,7 @@ static int tdb1_lock_list(struct tdb1_context *tdb, int list, int ltype,
                ret = tdb1_nest_lock(tdb, lock_offset(list), ltype, waitflag);
 
                if (ret == 0 && check && tdb1_needs_recovery(tdb)) {
-                       tdb1_nest_unlock(tdb, lock_offset(list), ltype, false);
+                       tdb1_nest_unlock(tdb, lock_offset(list), ltype);
 
                        if (tdb1_lock_and_recover(tdb) == -1) {
                                return -1;
@@ -368,8 +364,7 @@ int tdb1_lock(struct tdb1_context *tdb, int list, int ltype)
        return ret;
 }
 
-int tdb1_nest_unlock(struct tdb1_context *tdb, uint32_t offset, int ltype,
-                   bool mark_lock)
+int tdb1_nest_unlock(struct tdb1_context *tdb, uint32_t offset, int ltype)
 {
        int ret = -1;
        struct tdb1_lock_type *lck;
@@ -401,11 +396,7 @@ int tdb1_nest_unlock(struct tdb1_context *tdb, uint32_t offset, int ltype,
         * anyway.
         */
 
-       if (mark_lock) {
-               ret = 0;
-       } else {
-               ret = tdb1_brunlock(tdb, ltype, offset, 1);
-       }
+       ret = tdb1_brunlock(tdb, ltype, offset, 1);
 
        /*
         * Shrink the array by overwriting the element just unlocked with the
@@ -440,7 +431,7 @@ int tdb1_unlock(struct tdb1_context *tdb, int list, int ltype)
                return -1;
        }
 
-       return tdb1_nest_unlock(tdb, lock_offset(list), ltype, false);
+       return tdb1_nest_unlock(tdb, lock_offset(list), ltype);
 }
 
 /*
@@ -457,7 +448,7 @@ int tdb1_transaction_lock(struct tdb1_context *tdb, int ltype,
  */
 int tdb1_transaction_unlock(struct tdb1_context *tdb, int ltype)
 {
-       return tdb1_nest_unlock(tdb, TDB1_TRANSACTION_LOCK, ltype, false);
+       return tdb1_nest_unlock(tdb, TDB1_TRANSACTION_LOCK, ltype);
 }
 
 /* Returns 0 if all done, -1 if error, 1 if ok. */
@@ -569,14 +560,7 @@ int tdb1_allrecord_lock(struct tdb1_context *tdb, int ltype,
        tdb->allrecord_lock.off = upgradable;
 
        if (tdb1_needs_recovery(tdb)) {
-               bool mark = flags & TDB1_LOCK_MARK_ONLY;
-               tdb1_allrecord_unlock(tdb, ltype, mark);
-               if (mark) {
-                       tdb->ecode = TDB1_ERR_LOCK;
-                       TDB1_LOG((tdb, TDB1_DEBUG_ERROR,
-                                "tdb1_lockall_mark cannot do recovery\n"));
-                       return -1;
-               }
+               tdb1_allrecord_unlock(tdb, ltype);
                if (tdb1_lock_and_recover(tdb) == -1) {
                        return -1;
                }
@@ -589,7 +573,7 @@ int tdb1_allrecord_lock(struct tdb1_context *tdb, int ltype,
 
 
 /* unlock entire db */
-int tdb1_allrecord_unlock(struct tdb1_context *tdb, int ltype, bool mark_lock)
+int tdb1_allrecord_unlock(struct tdb1_context *tdb, int ltype)
 {
        /* There are no locks on read-only dbs */
        if (tdb->read_only || tdb->traverse_read) {
@@ -614,7 +598,7 @@ int tdb1_allrecord_unlock(struct tdb1_context *tdb, int ltype, bool mark_lock)
                return 0;
        }
 
-       if (!mark_lock && tdb1_brunlock(tdb, ltype, TDB1_FREELIST_TOP, 0)) {
+       if (tdb1_brunlock(tdb, ltype, TDB1_FREELIST_TOP, 0)) {
                TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_unlockall failed (%s)\n", strerror(errno)));
                return -1;
        }
@@ -634,7 +618,7 @@ int tdb1_lockall(struct tdb1_context *tdb)
 /* unlock entire database with write lock */
 int tdb1_unlockall(struct tdb1_context *tdb)
 {
-       return tdb1_allrecord_unlock(tdb, F_WRLCK, false);
+       return tdb1_allrecord_unlock(tdb, F_WRLCK);
 }
 
 /* lock entire database with read lock */
@@ -646,7 +630,7 @@ int tdb1_lockall_read(struct tdb1_context *tdb)
 /* unlock entire database with read lock */
 int tdb1_unlockall_read(struct tdb1_context *tdb)
 {
-       return tdb1_allrecord_unlock(tdb, F_RDLCK, false);
+       return tdb1_allrecord_unlock(tdb, F_RDLCK);
 }
 
 /* lock/unlock one hash chain. This is meant to be used to reduce
index 7c5100e3d1e17c45aed7edc51f76f537e2018106..65bc2dba14635e5833d6ab18368095de12cb02bf 100644 (file)
@@ -387,7 +387,7 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
        tdb->inode = st.st_ino;
        tdb1_mmap(tdb);
        if (locked) {
-               if (tdb1_nest_unlock(tdb, TDB1_ACTIVE_LOCK, F_WRLCK, false) == -1) {
+               if (tdb1_nest_unlock(tdb, TDB1_ACTIVE_LOCK, F_WRLCK) == -1) {
                        TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_open_ex: "
                                 "failed to release ACTIVE_LOCK on %s: %s\n",
                                 name, strerror(errno)));
@@ -416,7 +416,7 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
        /* Internal (memory-only) databases skip all the code above to
         * do with disk files, and resume here by releasing their
         * open lock and hooking into the active list. */
-       if (tdb1_nest_unlock(tdb, TDB1_OPEN_LOCK, F_WRLCK, false) == -1) {
+       if (tdb1_nest_unlock(tdb, TDB1_OPEN_LOCK, F_WRLCK) == -1) {
                goto fail;
        }
        tdb->next = tdb1s;
index ae2888c0a719eecbac59bb0c0b57c22fcdb8088f..809f13555552ac85811946f1d8dd212cc92f0200 100644 (file)
@@ -180,8 +180,6 @@ enum tdb1_lock_flags {
        TDB1_LOCK_WAIT = 1,
        /* If set, don't log an error on failure. */
        TDB1_LOCK_PROBE = 2,
-       /* If set, don't actually lock at all. */
-       TDB1_LOCK_MARK_ONLY = 4,
 };
 
 struct tdb1_context;
@@ -229,8 +227,7 @@ void tdb1_mmap(struct tdb1_context *tdb);
 int tdb1_lock(struct tdb1_context *tdb, int list, int ltype);
 int tdb1_nest_lock(struct tdb1_context *tdb, uint32_t offset, int ltype,
                  enum tdb1_lock_flags flags);
-int tdb1_nest_unlock(struct tdb1_context *tdb, uint32_t offset, int ltype,
-                   bool mark_lock);
+int tdb1_nest_unlock(struct tdb1_context *tdb, uint32_t offset, int ltype);
 int tdb1_unlock(struct tdb1_context *tdb, int list, int ltype);
 int tdb1_brlock(struct tdb1_context *tdb,
               int rw_type, tdb1_off_t offset, size_t len,
@@ -248,7 +245,7 @@ int tdb1_recovery_area(struct tdb1_context *tdb,
                      struct tdb1_record *rec);
 int tdb1_allrecord_lock(struct tdb1_context *tdb, int ltype,
                       enum tdb1_lock_flags flags, bool upgradable);
-int tdb1_allrecord_unlock(struct tdb1_context *tdb, int ltype, bool mark_lock);
+int tdb1_allrecord_unlock(struct tdb1_context *tdb, int ltype);
 int tdb1_allrecord_upgrade(struct tdb1_context *tdb);
 int tdb1_write_lock_record(struct tdb1_context *tdb, tdb1_off_t off);
 int tdb1_write_unlock_record(struct tdb1_context *tdb, tdb1_off_t off);
index cc7e580f2c3f1e8fc596da4a53c3039b94ad36de..113ebc0b6d122d42521a6ea84102651e7d6d448f 100644 (file)
@@ -66,7 +66,7 @@ static void tdb1_increment_seqnum(struct tdb1_context *tdb)
 
        tdb1_increment_seqnum_nonblock(tdb);
 
-       tdb1_nest_unlock(tdb, TDB1_SEQNUM_OFS, F_WRLCK, false);
+       tdb1_nest_unlock(tdb, TDB1_SEQNUM_OFS, F_WRLCK);
 }
 
 static int tdb1_key_compare(TDB1_DATA key, TDB1_DATA data, void *private_data)
index 43e99024ce091b70492f0929207849cd9fb36ce2..b09a2b3c10c157c5afbba0fb2c3d2a0f4b22abba 100644 (file)
@@ -421,8 +421,7 @@ static const struct tdb1_methods transaction1_methods = {
   start a tdb transaction. No token is returned, as only a single
   transaction is allowed to be pending per tdb1_context
 */
-static int _tdb1_transaction_start(struct tdb1_context *tdb,
-                                 enum tdb1_lock_flags lockflags)
+static int _tdb1_transaction_start(struct tdb1_context *tdb)
 {
        /* some sanity checks */
        if (tdb->read_only || (tdb->flags & TDB1_INTERNAL) || tdb->traverse_read) {
@@ -474,12 +473,9 @@ static int _tdb1_transaction_start(struct tdb1_context *tdb,
        /* get the transaction write lock. This is a blocking lock. As
           discussed with Volker, there are a number of ways we could
           make this async, which we will probably do in the future */
-       if (tdb1_transaction_lock(tdb, F_WRLCK, lockflags) == -1) {
+       if (tdb1_transaction_lock(tdb, F_WRLCK, TDB1_LOCK_WAIT) == -1) {
                SAFE_FREE(tdb->transaction->blocks);
                SAFE_FREE(tdb->transaction);
-               if ((lockflags & TDB1_LOCK_WAIT) == 0) {
-                       tdb->ecode = TDB1_ERR_NOLOCK;
-               }
                return -1;
        }
 
@@ -518,7 +514,7 @@ static int _tdb1_transaction_start(struct tdb1_context *tdb,
        return 0;
 
 fail:
-       tdb1_allrecord_unlock(tdb, F_RDLCK, false);
+       tdb1_allrecord_unlock(tdb, F_RDLCK);
 fail_allrecord_lock:
        tdb1_transaction_unlock(tdb, F_WRLCK);
        SAFE_FREE(tdb->transaction->blocks);
@@ -529,7 +525,7 @@ fail_allrecord_lock:
 
 int tdb1_transaction_start(struct tdb1_context *tdb)
 {
-       return _tdb1_transaction_start(tdb, TDB1_LOCK_WAIT);
+       return _tdb1_transaction_start(tdb);
 }
 
 /*