X-Git-Url: http://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Ftdb2%2Ftdb1_traverse.c;h=d9d3649fd96c9e8de53c4eb207119e8c33c46f2d;hp=515beb1f0d2f69f7776d1d34213e3a0105080598;hb=56023cca5f66a40646a1e807c3d10af6e5913623;hpb=19e6c1a250ade1e7204ada17163294855585e825

diff --git a/ccan/tdb2/tdb1_traverse.c b/ccan/tdb2/tdb1_traverse.c
index 515beb1f..d9d3649f 100644
--- a/ccan/tdb2/tdb1_traverse.c
+++ b/ccan/tdb2/tdb1_traverse.c
@@ -29,15 +29,17 @@
 
 #define TDB1_NEXT_LOCK_ERR ((tdb1_off_t)-1)
 
+static TDB_DATA tdb1_null;
+
 /* Uses traverse lock: 0 = finish, TDB1_NEXT_LOCK_ERR = error,
    other = record offset */
-static tdb1_off_t tdb1_next_lock(struct tdb1_context *tdb, struct tdb1_traverse_lock *tlock,
+static tdb1_off_t tdb1_next_lock(struct tdb_context *tdb, struct tdb1_traverse_lock *tlock,
 			 struct tdb1_record *rec)
 {
 	int want_next = (tlock->off != 0);
 
 	/* Lock each chain from the start one. */
-	for (; tlock->hash < tdb->header.hash_size; tlock->hash++) {
+	for (; tlock->hash < tdb->tdb1.header.hash_size; tlock->hash++) {
 		if (!tlock->off && tlock->hash != 0) {
 			/* this is an optimisation for the common case where
 			   the hash chain is empty, which is particularly
@@ -67,8 +69,8 @@ static tdb1_off_t tdb1_next_lock(struct tdb1_context *tdb, struct tdb1_traverse_
 			   factor of around 80 in speed on a linux 2.6.x
 			   system (testing using ldbtest).
 			*/
-			tdb->methods->next_hash_chain(tdb, &tlock->hash);
-			if (tlock->hash == tdb->header.hash_size) {
+			tdb->tdb1.io->next_hash_chain(tdb, &tlock->hash);
+			if (tlock->hash == tdb->tdb1.header.hash_size) {
 				continue;
 			}
 		}
@@ -102,8 +104,10 @@ static tdb1_off_t tdb1_next_lock(struct tdb1_context *tdb, struct tdb1_traverse_
 
 			/* Detect infinite loops. From "Shlomi Yaakobovich" <Shlomi@exanet.com>. */
 			if (tlock->off == rec->next) {
-				tdb->ecode = TDB1_ERR_CORRUPT;
-				TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_next_lock: loop detected.\n"));
+				tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT,
+							TDB_LOG_ERROR,
+							"tdb1_next_lock:"
+							" loop detected.");
 				goto fail;
 			}
 
@@ -117,7 +121,7 @@ static tdb1_off_t tdb1_next_lock(struct tdb1_context *tdb, struct tdb1_traverse_
 			/* Try to clean dead ones from old traverses */
 			current = tlock->off;
 			tlock->off = rec->next;
-			if (!(tdb->read_only || tdb->traverse_read) &&
+			if (!((tdb->flags & TDB_RDONLY) || tdb->tdb1.traverse_read) &&
 			    tdb1_do_delete(tdb, current, rec) != 0)
 				goto fail;
 		}
@@ -125,13 +129,14 @@ static tdb1_off_t tdb1_next_lock(struct tdb1_context *tdb, struct tdb1_traverse_
 		want_next = 0;
 	}
 	/* We finished iteration without finding anything */
-	tdb->ecode = TDB1_SUCCESS;
+	tdb->last_error = TDB_SUCCESS;
 	return 0;
 
  fail:
 	tlock->off = 0;
 	if (tdb1_unlock(tdb, tlock->hash, tlock->lock_rw) != 0)
-		TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_next_lock: On error unlock failed!\n"));
+		tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+			   "tdb1_next_lock: On error unlock failed!");
 	return TDB1_NEXT_LOCK_ERR;
 }
 
@@ -140,11 +145,13 @@ static tdb1_off_t tdb1_next_lock(struct tdb1_context *tdb, struct tdb1_traverse_
    if fn is NULL then it is not called
    a non-zero return value from fn() indicates that the traversal should stop
   */
-static int tdb1_traverse_internal(struct tdb1_context *tdb,
-				 tdb1_traverse_func fn, void *private_data,
-				 struct tdb1_traverse_lock *tl)
+static int tdb1_traverse_internal(struct tdb_context *tdb,
+				  int (*fn)(struct tdb_context *,
+					    TDB_DATA, TDB_DATA, void *),
+				  void *private_data,
+				  struct tdb1_traverse_lock *tl)
 {
-	TDB1_DATA key, dbuf;
+	TDB_DATA key, dbuf;
 	struct tdb1_record rec;
 	int ret = 0, count = 0;
 	tdb1_off_t off;
@@ -152,10 +159,10 @@ static int tdb1_traverse_internal(struct tdb1_context *tdb,
 	/* This was in the initializaton, above, but the IRIX compiler
 	 * did not like it.  crh
 	 */
-	tl->next = tdb->travlocks.next;
+	tl->next = tdb->tdb1.travlocks.next;
 
 	/* fcntl locks don't stack: beware traverse inside traverse */
-	tdb->travlocks.next = tl;
+	tdb->tdb1.travlocks.next = tl;
 
 	/* tdb1_next_lock places locks on the record returned, and its chain */
 	while ((off = tdb1_next_lock(tdb, tl, &rec)) != 0) {
@@ -172,7 +179,9 @@ static int tdb1_traverse_internal(struct tdb1_context *tdb,
 			if (tdb1_unlock(tdb, tl->hash, tl->lock_rw) != 0)
 				goto out;
 			if (tdb1_unlock_record(tdb, tl->off) != 0)
-				TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_traverse: key.dptr == NULL and unlock_record failed!\n"));
+				tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+					   "tdb1_traverse: key.dptr == NULL and"
+					   " unlock_record failed!");
 			goto out;
 		}
 		key.dsize = rec.key_len;
@@ -188,7 +197,9 @@ static int tdb1_traverse_internal(struct tdb1_context *tdb,
 		if (fn && fn(tdb, key, dbuf, private_data)) {
 			/* They want us to terminate traversal */
 			if (tdb1_unlock_record(tdb, tl->off) != 0) {
-				TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_traverse: unlock_record failed!\n"));;
+				tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+					   "tdb1_traverse:"
+					   " unlock_record failed!");
 				ret = -1;
 			}
 			SAFE_FREE(key.dptr);
@@ -197,7 +208,7 @@ static int tdb1_traverse_internal(struct tdb1_context *tdb,
 		SAFE_FREE(key.dptr);
 	}
 out:
-	tdb->travlocks.next = tl->next;
+	tdb->tdb1.travlocks.next = tl->next;
 	if (ret < 0)
 		return -1;
 	else
@@ -206,23 +217,25 @@ out:
 
 
 /*
-  a write style traverse - temporarily marks the db read only
+  a read style traverse - only if db read only
 */
-_PUBLIC_ int tdb1_traverse_read(struct tdb1_context *tdb,
-		      tdb1_traverse_func fn, void *private_data)
+static int tdb1_traverse_read(struct tdb_context *tdb,
+			      int (*fn)(struct tdb_context *,
+					TDB_DATA, TDB_DATA, void *),
+			      void *private_data)
 {
 	struct tdb1_traverse_lock tl = { NULL, 0, 0, F_RDLCK };
 	int ret;
 
 	/* we need to get a read lock on the transaction lock here to
 	   cope with the lock ordering semantics of solaris10 */
-	if (tdb1_transaction_lock(tdb, F_RDLCK, TDB1_LOCK_WAIT)) {
+	if (tdb1_transaction_lock(tdb, F_RDLCK, TDB_LOCK_WAIT)) {
 		return -1;
 	}
 
-	tdb->traverse_read++;
+	tdb->tdb1.traverse_read++;
 	ret = tdb1_traverse_internal(tdb, fn, private_data, &tl);
-	tdb->traverse_read--;
+	tdb->tdb1.traverse_read--;
 
 	tdb1_transaction_unlock(tdb, F_RDLCK);
 
@@ -236,23 +249,25 @@ _PUBLIC_ int tdb1_traverse_read(struct tdb1_context *tdb,
   WARNING: The data buffer given to the callback fn does NOT meet the
   alignment restrictions malloc gives you.
 */
-_PUBLIC_ int tdb1_traverse(struct tdb1_context *tdb,
-		 tdb1_traverse_func fn, void *private_data)
+int tdb1_traverse(struct tdb_context *tdb,
+		  int (*fn)(struct tdb_context *, TDB_DATA, TDB_DATA, void *),
+		  void *private_data)
 {
 	struct tdb1_traverse_lock tl = { NULL, 0, 0, F_WRLCK };
 	int ret;
 
-	if (tdb->read_only || tdb->traverse_read) {
+	/* If we're read-only, we don't have to write-lock whole db. */
+	if (tdb->flags & TDB_RDONLY) {
 		return tdb1_traverse_read(tdb, fn, private_data);
 	}
 
-	if (tdb1_transaction_lock(tdb, F_WRLCK, TDB1_LOCK_WAIT)) {
+	if (tdb1_transaction_lock(tdb, F_WRLCK, TDB_LOCK_WAIT)) {
 		return -1;
 	}
 
-	tdb->traverse_write++;
+	tdb->tdb1.traverse_write++;
 	ret = tdb1_traverse_internal(tdb, fn, private_data, &tl);
-	tdb->traverse_write--;
+	tdb->tdb1.traverse_write--;
 
 	tdb1_transaction_unlock(tdb, F_WRLCK);
 
@@ -261,92 +276,98 @@ _PUBLIC_ int tdb1_traverse(struct tdb1_context *tdb,
 
 
 /* find the first entry in the database and return its key */
-_PUBLIC_ TDB1_DATA tdb1_firstkey(struct tdb1_context *tdb)
+TDB_DATA tdb1_firstkey(struct tdb_context *tdb)
 {
-	TDB1_DATA key;
+	TDB_DATA key;
 	struct tdb1_record rec;
 	tdb1_off_t off;
 
 	/* release any old lock */
-	if (tdb1_unlock_record(tdb, tdb->travlocks.off) != 0)
+	if (tdb1_unlock_record(tdb, tdb->tdb1.travlocks.off) != 0)
 		return tdb1_null;
-	tdb->travlocks.off = tdb->travlocks.hash = 0;
-	tdb->travlocks.lock_rw = F_RDLCK;
+	tdb->tdb1.travlocks.off = tdb->tdb1.travlocks.hash = 0;
+	tdb->tdb1.travlocks.lock_rw = F_RDLCK;
 
 	/* Grab first record: locks chain and returned record. */
-	off = tdb1_next_lock(tdb, &tdb->travlocks, &rec);
+	off = tdb1_next_lock(tdb, &tdb->tdb1.travlocks, &rec);
 	if (off == 0 || off == TDB1_NEXT_LOCK_ERR) {
 		return tdb1_null;
 	}
 	/* now read the key */
 	key.dsize = rec.key_len;
-	key.dptr =tdb1_alloc_read(tdb,tdb->travlocks.off+sizeof(rec),key.dsize);
+	key.dptr =tdb1_alloc_read(tdb,tdb->tdb1.travlocks.off+sizeof(rec),key.dsize);
 
 	/* Unlock the hash chain of the record we just read. */
-	if (tdb1_unlock(tdb, tdb->travlocks.hash, tdb->travlocks.lock_rw) != 0)
-		TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_firstkey: error occurred while tdb1_unlocking!\n"));
+	if (tdb1_unlock(tdb, tdb->tdb1.travlocks.hash, tdb->tdb1.travlocks.lock_rw) != 0)
+		tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+			   "tdb1_firstkey:"
+			   " error occurred while tdb1_unlocking!");
 	return key;
 }
 
 /* find the next entry in the database, returning its key */
-_PUBLIC_ TDB1_DATA tdb1_nextkey(struct tdb1_context *tdb, TDB1_DATA oldkey)
+TDB_DATA tdb1_nextkey(struct tdb_context *tdb, TDB_DATA oldkey)
 {
 	uint32_t oldhash;
-	TDB1_DATA key = tdb1_null;
+	TDB_DATA key = tdb1_null;
 	struct tdb1_record rec;
 	unsigned char *k = NULL;
 	tdb1_off_t off;
 
 	/* Is locked key the old key?  If so, traverse will be reliable. */
-	if (tdb->travlocks.off) {
-		if (tdb1_lock(tdb,tdb->travlocks.hash,tdb->travlocks.lock_rw))
+	if (tdb->tdb1.travlocks.off) {
+		if (tdb1_lock(tdb,tdb->tdb1.travlocks.hash,tdb->tdb1.travlocks.lock_rw))
 			return tdb1_null;
-		if (tdb1_rec_read(tdb, tdb->travlocks.off, &rec) == -1
-		    || !(k = tdb1_alloc_read(tdb,tdb->travlocks.off+sizeof(rec),
+		if (tdb1_rec_read(tdb, tdb->tdb1.travlocks.off, &rec) == -1
+		    || !(k = tdb1_alloc_read(tdb,tdb->tdb1.travlocks.off+sizeof(rec),
 					    rec.key_len))
 		    || memcmp(k, oldkey.dptr, oldkey.dsize) != 0) {
 			/* No, it wasn't: unlock it and start from scratch */
-			if (tdb1_unlock_record(tdb, tdb->travlocks.off) != 0) {
+			if (tdb1_unlock_record(tdb, tdb->tdb1.travlocks.off) != 0) {
 				SAFE_FREE(k);
 				return tdb1_null;
 			}
-			if (tdb1_unlock(tdb, tdb->travlocks.hash, tdb->travlocks.lock_rw) != 0) {
+			if (tdb1_unlock(tdb, tdb->tdb1.travlocks.hash, tdb->tdb1.travlocks.lock_rw) != 0) {
 				SAFE_FREE(k);
 				return tdb1_null;
 			}
-			tdb->travlocks.off = 0;
+			tdb->tdb1.travlocks.off = 0;
 		}
 
 		SAFE_FREE(k);
 	}
 
-	if (!tdb->travlocks.off) {
+	if (!tdb->tdb1.travlocks.off) {
 		/* No previous element: do normal find, and lock record */
-		tdb->travlocks.off = tdb1_find_lock_hash(tdb, oldkey, tdb->hash_fn(&oldkey), tdb->travlocks.lock_rw, &rec);
-		if (!tdb->travlocks.off) {
+		tdb->tdb1.travlocks.off = tdb1_find_lock_hash(tdb, oldkey, tdb_hash(tdb, oldkey.dptr, oldkey.dsize), tdb->tdb1.travlocks.lock_rw, &rec);
+		if (!tdb->tdb1.travlocks.off) {
 			return tdb1_null;
 		}
-		tdb->travlocks.hash = TDB1_BUCKET(rec.full_hash);
-		if (tdb1_lock_record(tdb, tdb->travlocks.off) != 0) {
-			TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_nextkey: lock_record failed (%s)!\n", strerror(errno)));
+		tdb->tdb1.travlocks.hash = TDB1_BUCKET(rec.full_hash);
+		if (tdb1_lock_record(tdb, tdb->tdb1.travlocks.off) != 0) {
+			tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+				   "tdb1_nextkey: lock_record failed (%s)!",
+				   strerror(errno));
 			return tdb1_null;
 		}
 	}
-	oldhash = tdb->travlocks.hash;
+	oldhash = tdb->tdb1.travlocks.hash;
 
 	/* Grab next record: locks chain and returned record,
 	   unlocks old record */
-	off = tdb1_next_lock(tdb, &tdb->travlocks, &rec);
+	off = tdb1_next_lock(tdb, &tdb->tdb1.travlocks, &rec);
 	if (off != TDB1_NEXT_LOCK_ERR && off != 0) {
 		key.dsize = rec.key_len;
-		key.dptr = tdb1_alloc_read(tdb, tdb->travlocks.off+sizeof(rec),
+		key.dptr = tdb1_alloc_read(tdb, tdb->tdb1.travlocks.off+sizeof(rec),
 					  key.dsize);
 		/* Unlock the chain of this new record */
-		if (tdb1_unlock(tdb, tdb->travlocks.hash, tdb->travlocks.lock_rw) != 0)
-			TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_nextkey: WARNING tdb1_unlock failed!\n"));
+		if (tdb1_unlock(tdb, tdb->tdb1.travlocks.hash, tdb->tdb1.travlocks.lock_rw) != 0)
+			tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+				   "tdb1_nextkey: WARNING tdb1_unlock failed!");
 	}
 	/* Unlock the chain of old record */
-	if (tdb1_unlock(tdb, TDB1_BUCKET(oldhash), tdb->travlocks.lock_rw) != 0)
-		TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_nextkey: WARNING tdb1_unlock failed!\n"));
+	if (tdb1_unlock(tdb, TDB1_BUCKET(oldhash), tdb->tdb1.travlocks.lock_rw) != 0)
+		tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+			   "tdb1_nextkey: WARNING tdb1_unlock failed!");
 	return key;
 }