X-Git-Url: http://git.ozlabs.org/?a=blobdiff_plain;ds=sidebyside;f=ccan%2Ftdb2%2Ftdb1_open.c;h=e1f16053666537eb91ba8501ab7c151fe8d35994;hb=919937354a331bb964564a11b5a5b80403ff8db9;hp=e7dbddd9ddbc4b67ed785e6d27bebdaae1270bff;hpb=19e6c1a250ade1e7204ada17163294855585e825;p=ccan

diff --git a/ccan/tdb2/tdb1_open.c b/ccan/tdb2/tdb1_open.c
index e7dbddd9..e1f16053 100644
--- a/ccan/tdb2/tdb1_open.c
+++ b/ccan/tdb2/tdb1_open.c
@@ -60,7 +60,7 @@ static int tdb1_new_database(struct tdb1_context *tdb, int hash_size)
 	/* We make it up in memory, then write it out if not internal */
 	size = sizeof(struct tdb1_header) + (hash_size+1)*sizeof(tdb1_off_t);
 	if (!(newdb = (struct tdb1_header *)calloc(size, 1))) {
-		tdb->ecode = TDB1_ERR_OOM;
+		tdb->last_error = TDB_ERR_OOM;
 		return -1;
 	}
 
@@ -129,18 +129,12 @@ 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. */
-_PUBLIC_ struct tdb1_context *tdb1_open(const char *name, int hash_size, int tdb1_flags,
+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);
 }
 
-/* a default logging function */
-static void null_log_fn(struct tdb1_context *tdb, enum tdb1_debug_level level, const char *fmt, ...) PRINTF_ATTRIBUTE(3, 4);
-static void null_log_fn(struct tdb1_context *tdb, enum tdb1_debug_level level, const char *fmt, ...)
-{
-}
-
 static bool check_header_hash(struct tdb1_context *tdb,
 			      bool default_hash, uint32_t *m1, uint32_t *m2)
 {
@@ -162,7 +156,7 @@ static bool check_header_hash(struct tdb1_context *tdb,
 	return check_header_hash(tdb, false, m1, m2);
 }
 
-_PUBLIC_ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flags,
+struct tdb1_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)
@@ -188,11 +182,10 @@ _PUBLIC_ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int
 	tdb->flags = tdb1_flags;
 	tdb->open_flags = open_flags;
 	if (log_ctx) {
-		tdb->log = *log_ctx;
-	} else {
-		tdb->log.log_fn = null_log_fn;
-		tdb->log.log_private = NULL;
-	}
+		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)) {
 		name = "__TDB1_INTERNAL__";
@@ -200,7 +193,8 @@ _PUBLIC_ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int
 
 	if (name == NULL) {
 		tdb->name = (char *)"__NULL__";
-		TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_open_ex: called with name == NULL\n"));
+		tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
+			   "tdb1_open_ex: called with name == NULL");
 		tdb->name = NULL;
 		errno = EINVAL;
 		goto fail;
@@ -213,8 +207,8 @@ _PUBLIC_ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int
 		 * work in case of an error.
 		 */
 		tdb->name = (char *)name;
-		TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_open_ex: can't strdup(%s)\n",
-			 name));
+		tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR,
+			   "tdb1_open_ex: can't strdup(%s)", name);
 		tdb->name = NULL;
 		errno = ENOMEM;
 		goto fail;
@@ -242,8 +236,9 @@ _PUBLIC_ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int
 	tdb->max_dead_records = (tdb1_flags & TDB1_VOLATILE) ? 5 : 0;
 
 	if ((open_flags & O_ACCMODE) == O_WRONLY) {
-		TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_open_ex: can't open tdb %s write-only\n",
-			 name));
+		tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
+			   "tdb1_open_ex: can't open tdb %s write-only",
+			   name);
 		errno = EINVAL;
 		goto fail;
 	}
@@ -259,17 +254,13 @@ _PUBLIC_ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int
 
 	if ((tdb->flags & TDB1_ALLOW_NESTING) &&
 	    (tdb->flags & TDB1_DISALLOW_NESTING)) {
-		tdb->ecode = TDB1_ERR_NESTING;
-		TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_open_ex: "
-			"allow_nesting and disallow_nesting are not allowed together!"));
+		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;
 	}
 
-	if (getenv("TDB_NO_FSYNC")) {
-		tdb->flags |= TDB1_NOSYNC;
-	}
-
 	/*
 	 * TDB1_ALLOW_NESTING is the default behavior.
 	 * Note: this may change in future versions!
@@ -283,15 +274,17 @@ _PUBLIC_ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int
 		tdb->flags |= (TDB1_NOLOCK | TDB1_NOMMAP);
 		tdb->flags &= ~TDB1_CLEAR_IF_FIRST;
 		if (tdb1_new_database(tdb, hash_size) != 0) {
-			TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_open_ex: tdb1_new_database failed!"));
+			tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+				   "tdb1_open_ex: tdb1_new_database failed!");
 			goto fail;
 		}
 		goto internal;
 	}
 
 	if ((tdb->fd = open(name, open_flags, mode)) == -1) {
-		TDB1_LOG((tdb, TDB1_DEBUG_WARNING, "tdb1_open_ex: could not open file %s: %s\n",
-			 name, strerror(errno)));
+		tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+			   "tdb1_open_ex: could not open file %s: %s",
+			   name, strerror(errno));
 		goto fail;	/* errno set by open(2) */
 	}
 
@@ -301,8 +294,9 @@ _PUBLIC_ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int
 
 	/* ensure there is only one process initialising at once */
 	if (tdb1_nest_lock(tdb, TDB1_OPEN_LOCK, F_WRLCK, TDB1_LOCK_WAIT) == -1) {
-		TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_open_ex: failed to get open lock on %s: %s\n",
-			 name, strerror(errno)));
+		tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+			   "tdb1_open_ex: failed to get open lock on %s: %s",
+			   name, strerror(errno));
 		goto fail;	/* errno set by tdb1_brlock */
 	}
 
@@ -312,9 +306,10 @@ _PUBLIC_ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int
 	    (locked = (tdb1_nest_lock(tdb, TDB1_ACTIVE_LOCK, F_WRLCK, TDB1_LOCK_NOWAIT|TDB1_LOCK_PROBE) == 0))) {
 		open_flags |= O_CREAT;
 		if (ftruncate(tdb->fd, 0) == -1) {
-			TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_open_ex: "
-				 "failed to truncate %s: %s\n",
-				 name, strerror(errno)));
+			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 */
 		}
 	}
@@ -350,7 +345,8 @@ _PUBLIC_ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int
 
 	if (tdb->header.rwlocks != 0 &&
 	    tdb->header.rwlocks != TDB1_HASH_RWLOCK_MAGIC) {
-		TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_open_ex: spinlocks no longer supported\n"));
+		tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+			   "tdb1_open_ex: spinlocks no longer supported");
 		goto fail;
 	}
 
@@ -358,26 +354,28 @@ _PUBLIC_ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int
 		/* older TDB without magic hash references */
 		tdb->hash_fn = tdb1_old_hash;
 	} else if (!check_header_hash(tdb, !hash_fn, &magic1, &magic2)) {
-		TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_open_ex: "
-			 "%s was not created with %s hash function we are using\n"
-			 "magic1_hash[0x%08X %s 0x%08X] "
-			 "magic2_hash[0x%08X %s 0x%08X]\n",
-			 name, hash_alg,
-			 tdb->header.magic1_hash,
-			 (tdb->header.magic1_hash == magic1) ? "==" : "!=",
-			 magic1,
-			 tdb->header.magic2_hash,
-			 (tdb->header.magic2_hash == magic2) ? "==" : "!=",
-			 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"
+			   "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) ? "==" : "!=",
+			   magic1,
+			   tdb->header.magic2_hash,
+			   (tdb->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)) {
-		TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_open_ex: "
-			 "%s (%d,%d) is already open in this process\n",
-			 name, (int)st.st_dev, (int)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;
 	}
@@ -387,10 +385,11 @@ _PUBLIC_ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int
 	tdb->inode = st.st_ino;
 	tdb1_mmap(tdb);
 	if (locked) {
-		if (tdb1_nest_unlock(tdb, TDB1_ACTIVE_LOCK, F_WRLCK, false) == -1) {
-			TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_open_ex: "
-				 "failed to release ACTIVE_LOCK on %s: %s\n",
-				 name, strerror(errno)));
+		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;
 		}
 
@@ -416,7 +415,7 @@ _PUBLIC_ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int
 	/* 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;
@@ -437,7 +436,8 @@ _PUBLIC_ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int
 	}
 	if (tdb->fd != -1)
 		if (close(tdb->fd) != 0)
-			TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_open_ex: failed to close tdb->fd on error!\n"));
+			tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+				   "tdb1_open_ex: failed to close tdb->fd on error!");
 	SAFE_FREE(tdb->lockrecs);
 	SAFE_FREE(tdb->name);
 	SAFE_FREE(tdb);
@@ -450,7 +450,7 @@ _PUBLIC_ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int
  * Set the maximum number of dead records per hash chain
  */
 
-_PUBLIC_ void tdb1_set_max_dead(struct tdb1_context *tdb, int max_dead)
+void tdb1_set_max_dead(struct tdb1_context *tdb, int max_dead)
 {
 	tdb->max_dead_records = max_dead;
 }
@@ -460,7 +460,7 @@ _PUBLIC_ void tdb1_set_max_dead(struct tdb1_context *tdb, int max_dead)
  *
  * @returns -1 for error; 0 for success.
  **/
-_PUBLIC_ int tdb1_close(struct tdb1_context *tdb)
+int tdb1_close(struct tdb1_context *tdb)
 {
 	struct tdb1_context **i;
 	int ret = 0;
@@ -495,115 +495,3 @@ _PUBLIC_ int tdb1_close(struct tdb1_context *tdb)
 
 	return ret;
 }
-
-/* register a loging function */
-_PUBLIC_ void tdb1_set_logging_function(struct tdb1_context *tdb,
-                                       const struct tdb1_logging_context *log_ctx)
-{
-        tdb->log = *log_ctx;
-}
-
-_PUBLIC_ void *tdb1_get_logging_private(struct tdb1_context *tdb)
-{
-	return tdb->log.log_private;
-}
-
-static int tdb1_reopen_internal(struct tdb1_context *tdb, bool active_lock)
-{
-#if !defined(LIBREPLACE_PREAD_NOT_REPLACED) || \
-	!defined(LIBREPLACE_PWRITE_NOT_REPLACED)
-	struct stat st;
-#endif
-
-	if (tdb->flags & TDB1_INTERNAL) {
-		return 0; /* Nothing to do. */
-	}
-
-	if (tdb1_have_extra_locks(tdb)) {
-		TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_reopen: reopen not allowed with locks held\n"));
-		goto fail;
-	}
-
-	if (tdb->transaction != 0) {
-		TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_reopen: reopen not allowed inside a transaction\n"));
-		goto fail;
-	}
-
-/* If we have real pread & pwrite, we can skip reopen. */
-#if !defined(LIBREPLACE_PREAD_NOT_REPLACED) || \
-	!defined(LIBREPLACE_PWRITE_NOT_REPLACED)
-	if (tdb1_munmap(tdb) != 0) {
-		TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_reopen: munmap failed (%s)\n", strerror(errno)));
-		goto fail;
-	}
-	if (close(tdb->fd) != 0)
-		TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_reopen: WARNING closing tdb->fd failed!\n"));
-	tdb->fd = open(tdb->name, tdb->open_flags & ~(O_CREAT|O_TRUNC), 0);
-	if (tdb->fd == -1) {
-		TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_reopen: open failed (%s)\n", strerror(errno)));
-		goto fail;
-	}
-	if (fstat(tdb->fd, &st) != 0) {
-		TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_reopen: fstat failed (%s)\n", strerror(errno)));
-		goto fail;
-	}
-	if (st.st_ino != tdb->inode || st.st_dev != tdb->device) {
-		TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_reopen: file dev/inode has changed!\n"));
-		goto fail;
-	}
-	tdb1_mmap(tdb);
-#endif /* fake pread or pwrite */
-
-	/* We may still think we hold the active lock. */
-	tdb->num_lockrecs = 0;
-	SAFE_FREE(tdb->lockrecs);
-
-	if (active_lock && tdb1_nest_lock(tdb, TDB1_ACTIVE_LOCK, F_RDLCK, TDB1_LOCK_WAIT) == -1) {
-		TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_reopen: failed to obtain active lock\n"));
-		goto fail;
-	}
-
-	return 0;
-
-fail:
-	tdb1_close(tdb);
-	return -1;
-}
-
-/* reopen a tdb - this can be used after a fork to ensure that we have an independent
-   seek pointer from our parent and to re-establish locks */
-_PUBLIC_ int tdb1_reopen(struct tdb1_context *tdb)
-{
-	return tdb1_reopen_internal(tdb, tdb->flags & TDB1_CLEAR_IF_FIRST);
-}
-
-/* reopen all tdb's */
-_PUBLIC_ int tdb1_reopen_all(int parent_longlived)
-{
-	struct tdb1_context *tdb;
-
-	for (tdb=tdb1s; tdb; tdb = tdb->next) {
-		bool active_lock = (tdb->flags & TDB1_CLEAR_IF_FIRST);
-
-		/*
-		 * If the parent is longlived (ie. a
-		 * parent daemon architecture), we know
-		 * it will keep it's active lock on a
-		 * tdb opened with CLEAR_IF_FIRST. Thus
-		 * for child processes we don't have to
-		 * add an active lock. This is essential
-		 * to improve performance on systems that
-		 * keep POSIX locks as a non-scalable data
-		 * structure in the kernel.
-		 */
-		if (parent_longlived) {
-			/* Ensure no clear-if-first. */
-			active_lock = false;
-		}
-
-		if (tdb1_reopen_internal(tdb, active_lock) != 0)
-			return -1;
-	}
-
-	return 0;
-}