tdb2: get rid of TDB1 mark and nonblock functions.

We do this using hooks in tdb2.

ccan/tdb2/tdb1_lock.c

@@ -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

ccan/tdb2/tdb1_open.c

@@ -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;

ccan/tdb2/tdb1_private.h

@@ -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);

ccan/tdb2/tdb1_tdb.c

@@ -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)

ccan/tdb2/tdb1_transaction.c

@@ -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);
 }
 
 /*