X-Git-Url: http://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Ftdb2%2Ftdb1_open.c;h=d02a33eb85c506ba5aa375171588203d85cfb31f;hp=30c11956ac185b7daeb53de5b92e960a0cc18b6e;hb=2b50be90a23893a06e0f1436a31d18b97ad0e11d;hpb=8a47d50d72ea62e378dc92b150c92c1317c73fa3

diff --git a/ccan/tdb2/tdb1_open.c b/ccan/tdb2/tdb1_open.c
index 30c11956..d02a33eb 100644
--- a/ccan/tdb2/tdb1_open.c
+++ b/ccan/tdb2/tdb1_open.c
@@ -72,10 +72,10 @@ static int tdb1_new_database(struct tdb1_context *tdb, int hash_size)
 
 	/* Make sure older tdbs (which don't check the magic hash fields)
 	 * will refuse to open this TDB. */
-	if (tdb->flags & TDB1_INCOMPATIBLE_HASH)
+	if (tdb->hash_fn == tdb1_incompatible_hash)
 		newdb->rwlocks = TDB1_HASH_RWLOCK_MAGIC;
 
-	if (tdb->flags & TDB1_INTERNAL) {
+	if (tdb->flags & TDB_INTERNAL) {
 		tdb->map_size = size;
 		tdb->map_ptr = (char *)newdb;
 		memcpy(&tdb->header, newdb, sizeof(tdb->header));
@@ -135,25 +135,28 @@ struct tdb1_context *tdb1_open(const char *name, int hash_size, int tdb1_flags,
 	return tdb1_open_ex(name, hash_size, tdb1_flags, open_flags, mode, NULL, NULL);
 }
 
-static bool check_header_hash(struct tdb1_context *tdb,
-			      bool default_hash, uint32_t *m1, uint32_t *m2)
+static bool hash_correct(struct tdb1_context *tdb,
+			 uint32_t *m1, uint32_t *m2)
 {
 	tdb1_header_hash(tdb, m1, m2);
-	if (tdb->header.magic1_hash == *m1 &&
-	    tdb->header.magic2_hash == *m2) {
-		return true;
-	}
+	return (tdb->header.magic1_hash == *m1 &&
+		tdb->header.magic2_hash == *m2);
+}
 
-	/* If they explicitly set a hash, always respect it. */
-	if (!default_hash)
-		return false;
+static bool check_header_hash(struct tdb1_context *tdb,
+			      uint32_t *m1, uint32_t *m2)
+{
+	if (hash_correct(tdb, m1, m2))
+		return true;
 
-	/* Otherwise, try the other inbuilt hash. */
+	/* If they use one inbuilt, try the other inbuilt hash. */
 	if (tdb->hash_fn == tdb1_old_hash)
-		tdb->hash_fn = tdb1_jenkins_hash;
-	else
+		tdb->hash_fn = tdb1_incompatible_hash;
+	else if (tdb->hash_fn == tdb1_incompatible_hash)
 		tdb->hash_fn = tdb1_old_hash;
-	return check_header_hash(tdb, false, m1, m2);
+	else
+		return false;
+	return hash_correct(tdb, m1, m2);
 }
 
 struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flags,
@@ -163,9 +166,7 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 {
 	struct tdb1_context *tdb;
 	struct stat st;
-	int rev = 0, locked = 0;
-	unsigned char *vp;
-	uint32_t vertest;
+	int rev = 0;
 	unsigned v;
 	const char *hash_alg;
 	uint32_t magic1, magic2;
@@ -179,7 +180,7 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 	tdb->fd = -1;
 	tdb->name = NULL;
 	tdb->map_ptr = NULL;
-	tdb->flags = tdb1_flags;
+	tdb->flags = tdb1_flags|TDB_VERSION1;
 	tdb->open_flags = open_flags;
 	if (log_ctx) {
 		tdb->log_fn = log_ctx->log_fn;
@@ -187,7 +188,7 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 	} else
 		tdb->log_fn = NULL;
 
-	if (name == NULL && (tdb1_flags & TDB1_INTERNAL)) {
+	if (name == NULL && (tdb1_flags & TDB_INTERNAL)) {
 		name = "__TDB1_INTERNAL__";
 	}
 
@@ -216,15 +217,13 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 
 	if (hash_fn) {
 		tdb->hash_fn = hash_fn;
-		hash_alg = "the user defined";
+		if (hash_fn == tdb1_incompatible_hash)
+			hash_alg = "tdb1_incompatible_hash";
+		else
+			hash_alg = "the user defined";
 	} else {
-		/* This controls what we use when creating a tdb. */
-		if (tdb->flags & TDB1_INCOMPATIBLE_HASH) {
-			tdb->hash_fn = tdb1_jenkins_hash;
-		} else {
-			tdb->hash_fn = tdb1_old_hash;
-		}
-		hash_alg = "either default";
+		tdb->hash_fn = tdb1_old_hash;
+		hash_alg = "default";
 	}
 
 	/* cache the page size */
@@ -233,7 +232,8 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 		tdb->page_size = 0x2000;
 	}
 
-	tdb->max_dead_records = (tdb1_flags & TDB1_VOLATILE) ? 5 : 0;
+	/* FIXME: Used to be 5 for TDB_VOLATILE. */
+	tdb->max_dead_records = 0;
 
 	if ((open_flags & O_ACCMODE) == O_WRONLY) {
 		tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
@@ -247,32 +247,13 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 		hash_size = TDB1_DEFAULT_HASH_SIZE;
 	if ((open_flags & O_ACCMODE) == O_RDONLY) {
 		tdb->read_only = 1;
-		/* read only databases don't do locking or clear if first */
-		tdb->flags |= TDB1_NOLOCK;
-		tdb->flags &= ~TDB1_CLEAR_IF_FIRST;
-	}
-
-	if ((tdb->flags & TDB1_ALLOW_NESTING) &&
-	    (tdb->flags & TDB1_DISALLOW_NESTING)) {
-		tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
-			   "tdb1_open_ex: "
-			   "allow_nesting and disallow_nesting are not allowed together!");
-		errno = EINVAL;
-		goto fail;
-	}
-
-	/*
-	 * TDB1_ALLOW_NESTING is the default behavior.
-	 * Note: this may change in future versions!
-	 */
-	if (!(tdb->flags & TDB1_DISALLOW_NESTING)) {
-		tdb->flags |= TDB1_ALLOW_NESTING;
+		/* read only databases don't do locking */
+		tdb->flags |= TDB_NOLOCK;
 	}
 
 	/* internal databases don't mmap or lock, and start off cleared */
-	if (tdb->flags & TDB1_INTERNAL) {
-		tdb->flags |= (TDB1_NOLOCK | TDB1_NOMMAP);
-		tdb->flags &= ~TDB1_CLEAR_IF_FIRST;
+	if (tdb->flags & TDB_INTERNAL) {
+		tdb->flags |= (TDB_NOLOCK | TDB_NOMMAP);
 		if (tdb1_new_database(tdb, hash_size) != 0) {
 			tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
 				   "tdb1_open_ex: tdb1_new_database failed!");
@@ -300,20 +281,6 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 		goto fail;	/* errno set by tdb1_brlock */
 	}
 
-	/* we need to zero database if we are the only one with it open */
-	if ((tdb1_flags & TDB1_CLEAR_IF_FIRST) &&
-	    (!tdb->read_only) &&
-	    (locked = (tdb1_nest_lock(tdb, TDB1_ACTIVE_LOCK, F_WRLCK, TDB_LOCK_NOWAIT|TDB_LOCK_PROBE) == 0))) {
-		open_flags |= O_CREAT;
-		if (ftruncate(tdb->fd, 0) == -1) {
-			tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
-				   "tdb1_open_ex: "
-				   "failed to truncate %s: %s",
-				   name, strerror(errno));
-			goto fail; /* errno set by ftruncate */
-		}
-	}
-
 	errno = 0;
 	if (read(tdb->fd, &tdb->header, sizeof(tdb->header)) != sizeof(tdb->header)
 	    || strcmp(tdb->header.magic_food, TDB_MAGIC_FOOD) != 0) {
@@ -323,21 +290,17 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 			}
 			goto fail;
 		}
-		rev = (tdb->flags & TDB1_CONVERT);
+		rev = (tdb->flags & TDB_CONVERT);
 	} else if (tdb->header.version != TDB1_VERSION
 		   && !(rev = (tdb->header.version==TDB1_BYTEREV(TDB1_VERSION)))) {
 		/* wrong version */
 		errno = EIO;
 		goto fail;
 	}
-	vp = (unsigned char *)&tdb->header.version;
-	vertest = (((uint32_t)vp[0]) << 24) | (((uint32_t)vp[1]) << 16) |
-		  (((uint32_t)vp[2]) << 8) | (uint32_t)vp[3];
-	tdb->flags |= (vertest==TDB1_VERSION) ? TDB1_BIGENDIAN : 0;
 	if (!rev)
-		tdb->flags &= ~TDB1_CONVERT;
+		tdb->flags &= ~TDB_CONVERT;
 	else {
-		tdb->flags |= TDB1_CONVERT;
+		tdb->flags |= TDB_CONVERT;
 		tdb1_convert(&tdb->header, sizeof(tdb->header));
 	}
 	if (fstat(tdb->fd, &st) == -1)
@@ -353,7 +316,7 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 	if ((tdb->header.magic1_hash == 0) && (tdb->header.magic2_hash == 0)) {
 		/* older TDB without magic hash references */
 		tdb->hash_fn = tdb1_old_hash;
-	} else if (!check_header_hash(tdb, !hash_fn, &magic1, &magic2)) {
+	} else if (!check_header_hash(tdb, &magic1, &magic2)) {
 		tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_USE_ERROR,
 			   "tdb1_open_ex: "
 			   "%s was not created with %s hash function we are using\n"
@@ -384,27 +347,6 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 	tdb->device = st.st_dev;
 	tdb->inode = st.st_ino;
 	tdb1_mmap(tdb);
-	if (locked) {
-		if (tdb1_nest_unlock(tdb, TDB1_ACTIVE_LOCK, F_WRLCK) == -1) {
-			tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
-				   "tdb1_open_ex: "
-				   "failed to release ACTIVE_LOCK on %s: %s",
-				   name, strerror(errno));
-			goto fail;
-		}
-
-	}
-
-	/* We always need to do this if the CLEAR_IF_FIRST flag is set, even if
-	   we didn't get the initial exclusive lock as we need to let all other
-	   users know we're using it. */
-
-	if (tdb1_flags & TDB1_CLEAR_IF_FIRST) {
-		/* leave this lock in place to indicate it's in use */
-		if (tdb1_nest_lock(tdb, TDB1_ACTIVE_LOCK, F_RDLCK, TDB_LOCK_WAIT) == -1) {
-			goto fail;
-		}
-	}
 
 	/* if needed, run recovery */
 	if (tdb1_transaction_recover(tdb) == -1) {
@@ -429,7 +371,7 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 		return NULL;
 
 	if (tdb->map_ptr) {
-		if (tdb->flags & TDB1_INTERNAL)
+		if (tdb->flags & TDB_INTERNAL)
 			SAFE_FREE(tdb->map_ptr);
 		else
 			tdb1_munmap(tdb);
@@ -470,7 +412,7 @@ int tdb1_close(struct tdb1_context *tdb)
 	}
 
 	if (tdb->map_ptr) {
-		if (tdb->flags & TDB1_INTERNAL)
+		if (tdb->flags & TDB_INTERNAL)
 			SAFE_FREE(tdb->map_ptr);
 		else
 			tdb1_munmap(tdb);