X-Git-Url: https://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Ftdb2%2Ftdb1_open.c;h=5d0097b2a79ac2de54875414cf8c0485d3d7357e;hp=f53a32b5befa977bc2a927dee37ec6da26f9bb81;hb=97224cbbe29e76522ec38d031c54b1cadce8ae03;hpb=3004f7e89a5978064b4fb29c1027e6d0d39e9418

diff --git a/ccan/tdb2/tdb1_open.c b/ccan/tdb2/tdb1_open.c
index f53a32b5..5d0097b2 100644
--- a/ccan/tdb2/tdb1_open.c
+++ b/ccan/tdb2/tdb1_open.c
@@ -27,23 +27,14 @@
 
 #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;
@@ -75,27 +66,28 @@ static int tdb1_new_database(struct tdb1_context *tdb, int hash_size)
 	if (tdb->hash_fn == tdb1_incompatible_hash)
 		newdb->rwlocks = TDB1_HASH_RWLOCK_MAGIC;
 
-	if (tdb->flags & TDB1_INTERNAL) {
-		tdb->map_size = size;
-		tdb->map_ptr = (char *)newdb;
-		memcpy(&tdb->header, newdb, sizeof(tdb->header));
+	if (tdb->flags & TDB_INTERNAL) {
+		tdb->file->fd = -1;
+		tdb->file->map_size = size;
+		tdb->file->map_ptr = (char *)newdb;
+		memcpy(&tdb->tdb1.header, newdb, sizeof(tdb->tdb1.header));
 		/* Convert the `ondisk' version if asked. */
 		TDB1_CONV(*newdb);
 		return 0;
 	}
-	if (lseek(tdb->fd, 0, SEEK_SET) == -1)
+	if (lseek(tdb->file->fd, 0, SEEK_SET) == -1)
 		goto fail;
 
-	if (ftruncate(tdb->fd, 0) == -1)
+	if (ftruncate(tdb->file->fd, 0) == -1)
 		goto fail;
 
 	/* 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 */
-	if (tdb1_write_all(tdb->fd, newdb, size))
+	if (tdb1_write_all(tdb->file->fd, newdb, size))
 		ret = 0;
 
   fail:
@@ -105,20 +97,6 @@ static int tdb1_new_database(struct tdb1_context *tdb, int hash_size)
 
 
 
-static int tdb1_already_open(dev_t device,
-			    ino_t ino)
-{
-	struct tdb1_context *i;
-
-	for (i = tdb1s; i; i = i->next) {
-		if (i->device == device && i->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
@@ -129,21 +107,21 @@ static int tdb1_already_open(dev_t device,
    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,
+struct tdb_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))
@@ -159,38 +137,44 @@ 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,
+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, locked = 0;
-	unsigned char *vp;
-	uint32_t vertest;
+	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;
 	}
+	tdb->file = calloc(1, sizeof *tdb->file);
+	if (!tdb->file) {
+		free(tdb);
+		errno = ENOMEM;
+		goto fail;
+	}
 	tdb1_io_init(tdb);
-	tdb->fd = -1;
+	tdb->file->fd = -1;
 	tdb->name = NULL;
-	tdb->map_ptr = NULL;
-	tdb->flags = tdb1_flags;
+	tdb->file->map_ptr = NULL;
+	tdb->flags = tdb1_flags|TDB_VERSION1;
 	tdb->open_flags = open_flags;
+	tdb->lock_fn = tdb_fcntl_lock;
+	tdb->unlock_fn = tdb_fcntl_unlock;
 	if (log_ctx) {
 		tdb->log_fn = log_ctx->log_fn;
 		tdb->log_data = log_ctx->log_private;
 	} else
 		tdb->log_fn = NULL;
 
-	if (name == NULL && (tdb1_flags & TDB1_INTERNAL)) {
+	if (name == NULL && (tdb1_flags & TDB_INTERNAL)) {
 		name = "__TDB1_INTERNAL__";
 	}
 
@@ -216,6 +200,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;
@@ -229,12 +214,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;
 	}
 
-	tdb->max_dead_records = (tdb1_flags & TDB1_VOLATILE) ? 5 : 0;
+	/* FIXME: Used to be 5 for TDB_VOLATILE. */
+	tdb->tdb1.max_dead_records = 0;
 
 	if ((open_flags & O_ACCMODE) == O_WRONLY) {
 		tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
@@ -247,33 +233,14 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 	if (hash_size == 0)
 		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;
+		tdb->flags |= TDB_RDONLY;
+		/* 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!");
@@ -282,7 +249,7 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 		goto internal;
 	}
 
-	if ((tdb->fd = open(name, open_flags, mode)) == -1) {
+	if ((tdb->file->fd = open(name, open_flags, mode)) == -1) {
 		tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
 			   "tdb1_open_ex: could not open file %s: %s",
 			   name, strerror(errno));
@@ -290,8 +257,8 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 	}
 
 	/* on exec, don't inherit the fd */
-	v = fcntl(tdb->fd, F_GETFD, 0);
-        fcntl(tdb->fd, F_SETFD, v | FD_CLOEXEC);
+	v = fcntl(tdb->file->fd, F_GETFD, 0);
+        fcntl(tdb->file->fd, F_SETFD, v | FD_CLOEXEC);
 
 	/* ensure there is only one process initialising at once */
 	if (tdb1_nest_lock(tdb, TDB1_OPEN_LOCK, F_WRLCK, TDB_LOCK_WAIT) == -1) {
@@ -301,57 +268,39 @@ 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) {
+	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 */
 			}
 			goto fail;
 		}
-		rev = (tdb->flags & TDB1_CONVERT);
-	} else if (tdb->header.version != TDB1_VERSION
-		   && !(rev = (tdb->header.version==TDB1_BYTEREV(TDB1_VERSION)))) {
+		rev = (tdb->flags & TDB_CONVERT);
+	} else if (tdb->tdb1.header.version != TDB1_VERSION
+		   && !(rev = (tdb->tdb1.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;
-		tdb1_convert(&tdb->header, sizeof(tdb->header));
+		tdb->flags |= TDB_CONVERT;
+		tdb1_convert(&tdb->tdb1.header, sizeof(tdb->tdb1.header));
 	}
-	if (fstat(tdb->fd, &st) == -1)
+	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)) {
@@ -361,51 +310,20 @@ 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->map_size = st.st_size;
-	tdb->device = st.st_dev;
-	tdb->inode = st.st_ino;
+	tdb->file->map_size = st.st_size;
+	tdb->file->device = st.st_dev;
+	tdb->file->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) {
@@ -419,8 +337,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:
@@ -429,17 +345,20 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
 	if (!tdb)
 		return NULL;
 
-	if (tdb->map_ptr) {
-		if (tdb->flags & TDB1_INTERNAL)
-			SAFE_FREE(tdb->map_ptr);
+	if (tdb->file->map_ptr) {
+		if (tdb->flags & TDB_INTERNAL)
+			SAFE_FREE(tdb->file->map_ptr);
 		else
 			tdb1_munmap(tdb);
 	}
-	if (tdb->fd != -1)
-		if (close(tdb->fd) != 0)
+	if (tdb->file->fd != -1)
+		if (close(tdb->file->fd) != 0)
 			tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
 				   "tdb1_open_ex: failed to close tdb->fd on error!");
-	SAFE_FREE(tdb->lockrecs);
+	if (tdb->file) {
+		SAFE_FREE(tdb->file->lockrecs);
+		SAFE_FREE(tdb->file);
+	}
 	SAFE_FREE(tdb->name);
 	SAFE_FREE(tdb);
 	errno = save_errno;
@@ -451,9 +370,9 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
  * 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;
 }
 
 /**
@@ -461,35 +380,27 @@ 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);
 	}
 
-	if (tdb->map_ptr) {
-		if (tdb->flags & TDB1_INTERNAL)
-			SAFE_FREE(tdb->map_ptr);
+	if (tdb->file->map_ptr) {
+		if (tdb->flags & TDB_INTERNAL)
+			SAFE_FREE(tdb->file->map_ptr);
 		else
 			tdb1_munmap(tdb);
 	}
 	SAFE_FREE(tdb->name);
-	if (tdb->fd != -1) {
-		ret = close(tdb->fd);
-		tdb->fd = -1;
-	}
-	SAFE_FREE(tdb->lockrecs);
-
-	/* Remove from contexts list */
-	for (i = &tdb1s; *i; i = &(*i)->next) {
-		if (*i == tdb) {
-			*i = tdb->next;
-			break;
-		}
+	if (tdb->file->fd != -1) {
+		ret = close(tdb->file->fd);
+		tdb->file->fd = -1;
 	}
+	SAFE_FREE(tdb->file->lockrecs);
+	SAFE_FREE(tdb->file);
 
 	memset(tdb, 0, sizeof(*tdb));
 	SAFE_FREE(tdb);