X-Git-Url: http://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Ftdb2%2Ftdb1_open.c;h=c1729b577f78a857e117d84d0bcab8de69df2247;hp=1fe981ac76b2a7f688ad6c4c70f534235f4e3001;hb=49475d68deecd0b31597ed6094229171d2699b11;hpb=fbad02b680b6cbc33ae305ae1cbcdead4eedc7b1

diff --git a/ccan/tdb2/tdb1_open.c b/ccan/tdb2/tdb1_open.c
index 1fe981ac..c1729b57 100644
--- a/ccan/tdb2/tdb1_open.c
+++ b/ccan/tdb2/tdb1_open.c
@@ -24,26 +24,17 @@
    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */
-
+#include <assert.h>
 #include "tdb1_private.h"
 
-/* all contexts, to ensure no double-opens (fcntl locks don't nest!) */
-static struct tdb1_context *tdb1s = NULL;
-
 /* We use two hashes to double-check they're using the right hash function. */
-void tdb1_header_hash(struct tdb1_context *tdb,
+void tdb1_header_hash(struct tdb_context *tdb,
 		     uint32_t *magic1_hash, uint32_t *magic2_hash)
 {
-	TDB_DATA hash_key;
 	uint32_t tdb1_magic = TDB1_MAGIC;
 
-	hash_key.dptr = (unsigned char *)TDB_MAGIC_FOOD;
-	hash_key.dsize = sizeof(TDB_MAGIC_FOOD);
-	*magic1_hash = tdb->hash_fn(&hash_key);
-
-	hash_key.dptr = (unsigned char *)TDB1_CONV(tdb1_magic);
-	hash_key.dsize = sizeof(tdb1_magic);
-	*magic2_hash = tdb->hash_fn(&hash_key);
+	*magic1_hash = tdb_hash(tdb, TDB_MAGIC_FOOD, sizeof(TDB_MAGIC_FOOD));
+	*magic2_hash = tdb_hash(tdb, TDB1_CONV(tdb1_magic), sizeof(tdb1_magic));
 
 	/* Make sure at least one hash is non-zero! */
 	if (*magic1_hash == 0 && *magic2_hash == 0)
@@ -51,7 +42,7 @@ void tdb1_header_hash(struct tdb1_context *tdb,
 }
 
 /* initialise a new database with a specified hash size */
-static int tdb1_new_database(struct tdb1_context *tdb, int hash_size)
+static int tdb1_new_database(struct tdb_context *tdb, int hash_size)
 {
 	struct tdb1_header *newdb;
 	size_t size;
@@ -79,7 +70,7 @@ static int tdb1_new_database(struct tdb1_context *tdb, int hash_size)
 		tdb->file->fd = -1;
 		tdb->file->map_size = size;
 		tdb->file->map_ptr = (char *)newdb;
-		memcpy(&tdb->header, newdb, sizeof(tdb->header));
+		memcpy(&tdb->tdb1.header, newdb, sizeof(tdb->tdb1.header));
 		/* Convert the `ondisk' version if asked. */
 		TDB1_CONV(*newdb);
 		return 0;
@@ -92,7 +83,7 @@ static int tdb1_new_database(struct tdb1_context *tdb, int hash_size)
 
 	/* This creates an endian-converted header, as if read from disk */
 	TDB1_CONV(*newdb);
-	memcpy(&tdb->header, newdb, sizeof(tdb->header));
+	memcpy(&tdb->tdb1.header, newdb, sizeof(tdb->tdb1.header));
 	/* Don't endian-convert the magic food! */
 	memcpy(newdb->magic_food, TDB_MAGIC_FOOD, strlen(TDB_MAGIC_FOOD)+1);
 	/* we still have "ret == -1" here */
@@ -104,47 +95,25 @@ static int tdb1_new_database(struct tdb1_context *tdb, int hash_size)
 	return ret;
 }
 
+typedef void (*tdb1_log_func)(struct tdb_context *, enum tdb_log_level, enum TDB_ERROR,
+			      const char *, void *);
+typedef uint64_t (*tdb1_hash_func)(const void *key, size_t len, uint64_t seed,
+				   void *data);
 
+struct tdb1_logging_context {
+        tdb1_log_func log_fn;
+        void *log_private;
+};
 
-static int tdb1_already_open(dev_t device,
-			    ino_t ino)
-{
-	struct tdb1_context *i;
-
-	for (i = tdb1s; i; i = i->next) {
-		if (i->file->device == device && i->file->inode == ino) {
-			return 1;
-		}
-	}
-
-	return 0;
-}
-
-/* open the database, creating it if necessary
-
-   The open_flags and mode are passed straight to the open call on the
-   database file. A flags value of O_WRONLY is invalid. The hash size
-   is advisory, use zero for a default value.
-
-   Return is NULL on error, in which case errno is also set.  Don't
-   try to call tdb1_error or tdb1_errname, just do strerror(errno).
-
-   @param name may be NULL for internal databases. */
-struct tdb1_context *tdb1_open(const char *name, int hash_size, int tdb1_flags,
-		      int open_flags, mode_t mode)
-{
-	return tdb1_open_ex(name, hash_size, tdb1_flags, open_flags, mode, NULL, NULL);
-}
-
-static bool hash_correct(struct tdb1_context *tdb,
+static bool hash_correct(struct tdb_context *tdb,
 			 uint32_t *m1, uint32_t *m2)
 {
 	tdb1_header_hash(tdb, m1, m2);
-	return (tdb->header.magic1_hash == *m1 &&
-		tdb->header.magic2_hash == *m2);
+	return (tdb->tdb1.header.magic1_hash == *m1 &&
+		tdb->tdb1.header.magic2_hash == *m2);
 }
 
-static bool check_header_hash(struct tdb1_context *tdb,
+static bool check_header_hash(struct tdb_context *tdb,
 			      uint32_t *m1, uint32_t *m2)
 {
 	if (hash_correct(tdb, m1, m2))
@@ -160,19 +129,19 @@ static bool check_header_hash(struct tdb1_context *tdb,
 	return hash_correct(tdb, m1, m2);
 }
 
-struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flags,
+static struct tdb_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flags,
 				int open_flags, mode_t mode,
 				const struct tdb1_logging_context *log_ctx,
 				tdb1_hash_func hash_fn)
 {
-	struct tdb1_context *tdb;
+	struct tdb_context *tdb;
 	struct stat st;
 	int rev = 0;
 	unsigned v;
 	const char *hash_alg;
 	uint32_t magic1, magic2;
 
-	if (!(tdb = (struct tdb1_context *)calloc(1, sizeof *tdb))) {
+	if (!(tdb = (struct tdb_context *)calloc(1, sizeof *tdb))) {
 		/* Can't log this */
 		errno = ENOMEM;
 		goto fail;
@@ -223,6 +192,7 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 		errno = ENOMEM;
 		goto fail;
 	}
+	tdb->hash_seed = 0;
 
 	if (hash_fn) {
 		tdb->hash_fn = hash_fn;
@@ -236,13 +206,13 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 	}
 
 	/* cache the page size */
-	tdb->page_size = getpagesize();
-	if (tdb->page_size <= 0) {
-		tdb->page_size = 0x2000;
+	tdb->tdb1.page_size = getpagesize();
+	if (tdb->tdb1.page_size <= 0) {
+		tdb->tdb1.page_size = 0x2000;
 	}
 
 	/* FIXME: Used to be 5 for TDB_VOLATILE. */
-	tdb->max_dead_records = 0;
+	tdb->tdb1.max_dead_records = 0;
 
 	if ((open_flags & O_ACCMODE) == O_WRONLY) {
 		tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
@@ -252,10 +222,8 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 		goto fail;
 	}
 
-	if (hash_size == 0)
-		hash_size = TDB1_DEFAULT_HASH_SIZE;
 	if ((open_flags & O_ACCMODE) == O_RDONLY) {
-		tdb->read_only = 1;
+		tdb->flags |= TDB_RDONLY;
 		/* read only databases don't do locking */
 		tdb->flags |= TDB_NOLOCK;
 	}
@@ -291,8 +259,8 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 	}
 
 	errno = 0;
-	if (read(tdb->file->fd, &tdb->header, sizeof(tdb->header)) != sizeof(tdb->header)
-	    || strcmp(tdb->header.magic_food, TDB_MAGIC_FOOD) != 0) {
+	if (read(tdb->file->fd, &tdb->tdb1.header, sizeof(tdb->tdb1.header)) != sizeof(tdb->tdb1.header)
+	    || strcmp(tdb->tdb1.header.magic_food, TDB_MAGIC_FOOD) != 0) {
 		if (!(open_flags & O_CREAT) || tdb1_new_database(tdb, hash_size) == -1) {
 			if (errno == 0) {
 				errno = EIO; /* ie bad format or something */
@@ -300,8 +268,8 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 			goto fail;
 		}
 		rev = (tdb->flags & TDB_CONVERT);
-	} else if (tdb->header.version != TDB1_VERSION
-		   && !(rev = (tdb->header.version==TDB1_BYTEREV(TDB1_VERSION)))) {
+	} else if (tdb->tdb1.header.version != TDB1_VERSION
+		   && !(rev = (tdb->tdb1.header.version==TDB1_BYTEREV(TDB1_VERSION)))) {
 		/* wrong version */
 		errno = EIO;
 		goto fail;
@@ -310,19 +278,19 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 		tdb->flags &= ~TDB_CONVERT;
 	else {
 		tdb->flags |= TDB_CONVERT;
-		tdb1_convert(&tdb->header, sizeof(tdb->header));
+		tdb1_convert(&tdb->tdb1.header, sizeof(tdb->tdb1.header));
 	}
 	if (fstat(tdb->file->fd, &st) == -1)
 		goto fail;
 
-	if (tdb->header.rwlocks != 0 &&
-	    tdb->header.rwlocks != TDB1_HASH_RWLOCK_MAGIC) {
+	if (tdb->tdb1.header.rwlocks != 0 &&
+	    tdb->tdb1.header.rwlocks != TDB1_HASH_RWLOCK_MAGIC) {
 		tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
 			   "tdb1_open_ex: spinlocks no longer supported");
 		goto fail;
 	}
 
-	if ((tdb->header.magic1_hash == 0) && (tdb->header.magic2_hash == 0)) {
+	if ((tdb->tdb1.header.magic1_hash == 0) && (tdb->tdb1.header.magic2_hash == 0)) {
 		/* older TDB without magic hash references */
 		tdb->hash_fn = tdb1_old_hash;
 	} else if (!check_header_hash(tdb, &magic1, &magic2)) {
@@ -332,26 +300,16 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 			   "magic1_hash[0x%08X %s 0x%08X] "
 			   "magic2_hash[0x%08X %s 0x%08X]",
 			   name, hash_alg,
-			   tdb->header.magic1_hash,
-			   (tdb->header.magic1_hash == magic1) ? "==" : "!=",
+			   tdb->tdb1.header.magic1_hash,
+			   (tdb->tdb1.header.magic1_hash == magic1) ? "==" : "!=",
 			   magic1,
-			   tdb->header.magic2_hash,
-			   (tdb->header.magic2_hash == magic2) ? "==" : "!=",
+			   tdb->tdb1.header.magic2_hash,
+			   (tdb->tdb1.header.magic2_hash == magic2) ? "==" : "!=",
 			   magic2);
 		errno = EINVAL;
 		goto fail;
 	}
 
-	/* Is it already in the open list?  If so, fail. */
-	if (tdb1_already_open(st.st_dev, st.st_ino)) {
-		tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_USE_ERROR,
-			   "tdb1_open_ex: "
-			   "%s (%d,%d) is already open in this process",
-			   name, (int)st.st_dev, (int)st.st_ino);
-		errno = EBUSY;
-		goto fail;
-	}
-
 	tdb->file->map_size = st.st_size;
 	tdb->file->device = st.st_dev;
 	tdb->file->inode = st.st_ino;
@@ -369,8 +327,6 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 	if (tdb1_nest_unlock(tdb, TDB1_OPEN_LOCK, F_WRLCK) == -1) {
 		goto fail;
 	}
-	tdb->next = tdb1s;
-	tdb1s = tdb;
 	return tdb;
 
  fail:
@@ -400,13 +356,60 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 	}
 }
 
+/* Temporart wrapper for transition. */
+struct tdb_context *tdb1_open(const char *name, int tdb1_flags,
+			      int open_flags, mode_t mode,
+			      union tdb_attribute *attr)
+{
+	struct tdb1_logging_context *log_ctx = NULL, log;
+	tdb1_hash_func hash_fn = NULL;
+	struct tdb_attribute_tdb1_hashsize *hsize = NULL;
+
+	while (attr) {
+		switch (attr->base.attr) {
+		case TDB_ATTRIBUTE_HASH:
+			hash_fn = attr->hash.fn;
+			break;
+		case TDB_ATTRIBUTE_LOG:
+			log.log_fn = attr->log.fn;
+			log.log_private = attr->log.data;
+			log_ctx = &log;
+			break;
+		case TDB_ATTRIBUTE_TDB1_HASHSIZE:
+			hsize = &attr->tdb1_hashsize;
+			break;
+			break;
+		default:
+			abort();
+		}
+		attr = attr->base.next;
+	}
+
+	if (hsize && !(open_flags & O_CREAT)) {
+		if (log_ctx) {
+			log_ctx->log_fn(NULL,
+					TDB_ERR_EINVAL,
+					TDB_LOG_USE_ERROR,
+					"tdb_open: can only use"
+					" TDB_ATTRIBUTE_TDB1_HASHSIZE when"
+					" creating a tdb",
+					log_ctx->log_private);
+		}
+		errno = EINVAL;
+		return NULL;
+	}
+	return tdb1_open_ex(name, hsize ? hsize->hsize : TDB1_DEFAULT_HASH_SIZE,
+			    tdb1_flags, open_flags, mode,
+			    log_ctx, hash_fn);
+}
+
 /*
  * Set the maximum number of dead records per hash chain
  */
 
-void tdb1_set_max_dead(struct tdb1_context *tdb, int max_dead)
+void tdb1_set_max_dead(struct tdb_context *tdb, int max_dead)
 {
-	tdb->max_dead_records = max_dead;
+	tdb->tdb1.max_dead_records = max_dead;
 }
 
 /**
@@ -414,12 +417,11 @@ void tdb1_set_max_dead(struct tdb1_context *tdb, int max_dead)
  *
  * @returns -1 for error; 0 for success.
  **/
-int tdb1_close(struct tdb1_context *tdb)
+int tdb1_close(struct tdb_context *tdb)
 {
-	struct tdb1_context **i;
 	int ret = 0;
 
-	if (tdb->transaction) {
+	if (tdb->tdb1.transaction) {
 		tdb1_transaction_cancel(tdb);
 	}
 
@@ -437,14 +439,6 @@ int tdb1_close(struct tdb1_context *tdb)
 	SAFE_FREE(tdb->file->lockrecs);
 	SAFE_FREE(tdb->file);
 
-	/* Remove from contexts list */
-	for (i = &tdb1s; *i; i = &(*i)->next) {
-		if (*i == tdb) {
-			*i = tdb->next;
-			break;
-		}
-	}
-
 	memset(tdb, 0, sizeof(*tdb));
 	SAFE_FREE(tdb);