X-Git-Url: http://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Ftdb2%2Ftdb1_open.c;h=e668616a045f7bc174eea539951526074752b28a;hp=5176f57f77666dd264a6c2d2dfb693693978fb9f;hb=56023cca5f66a40646a1e807c3d10af6e5913623;hpb=22d0e0dc59fc9d7e0046fec6971ef478c2d604fd
diff --git a/ccan/tdb2/tdb1_open.c b/ccan/tdb2/tdb1_open.c
index 5176f57f..e668616a 100644
--- a/ccan/tdb2/tdb1_open.c
+++ b/ccan/tdb2/tdb1_open.c
@@ -24,44 +24,72 @@
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, see .
*/
-
+#include
#include "tdb1_private.h"
-
-/* all contexts, to ensure no double-opens (fcntl locks don't nest!) */
-static struct tdb1_context *tdb1s = NULL;
+#include
/* 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)
*magic1_hash = 1;
}
-/* initialise a new database with a specified hash size */
-static int tdb1_new_database(struct tdb1_context *tdb, int hash_size)
+static void tdb_context_init(struct tdb_context *tdb,
+ struct tdb_attribute_tdb1_max_dead *max_dead)
+{
+ assert(tdb->flags & TDB_VERSION1);
+
+ tdb1_io_init(tdb);
+
+ tdb->tdb1.traverse_read = tdb->tdb1.traverse_write = 0;
+ memset(&tdb->tdb1.travlocks, 0, sizeof(tdb->tdb1.travlocks));
+ tdb->tdb1.transaction = NULL;
+
+ /* cache the page size */
+ tdb->tdb1.page_size = getpagesize();
+ if (tdb->tdb1.page_size <= 0) {
+ tdb->tdb1.page_size = 0x2000;
+ }
+
+ if (max_dead) {
+ tdb->tdb1.max_dead_records = max_dead->max_dead;
+ } else {
+ tdb->tdb1.max_dead_records = 0;
+ }
+}
+
+/* initialise a new database */
+enum TDB_ERROR tdb1_new_database(struct tdb_context *tdb,
+ struct tdb_attribute_tdb1_hashsize *hashsize,
+ struct tdb_attribute_tdb1_max_dead *max_dead)
{
struct tdb1_header *newdb;
size_t size;
- int ret = -1;
+ int hash_size = TDB1_DEFAULT_HASH_SIZE;
+ enum TDB_ERROR ret;
+
+ tdb_context_init(tdb, max_dead);
+
+ /* Default TDB2 hash becomes default TDB1 hash. */
+ if (tdb->hash_fn == tdb_jenkins_hash)
+ tdb->hash_fn = tdb1_old_hash;
+
+ if (hashsize)
+ hash_size = hashsize->hsize;
/* 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->last_error = TDB_ERR_OOM;
- return -1;
+ return tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR,
+ "Could not allocate new database header");
}
/* Fill in the header */
@@ -75,75 +103,66 @@ 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;
+ memcpy(&tdb->tdb1.header, newdb, sizeof(tdb->tdb1.header));
+ /* This creates an endian-converted db. */
+ TDB1_CONV(*newdb);
+ /* Don't endian-convert the magic food! */
+ memcpy(newdb->magic_food, TDB_MAGIC_FOOD, strlen(TDB_MAGIC_FOOD)+1);
+
if (tdb->flags & TDB_INTERNAL) {
- tdb->map_size = size;
- tdb->map_ptr = (char *)newdb;
- memcpy(&tdb->header, newdb, sizeof(tdb->header));
- /* Convert the `ondisk' version if asked. */
- TDB1_CONV(*newdb);
- return 0;
+ tdb->file->map_size = size;
+ tdb->file->map_ptr = (char *)newdb;
+ return TDB_SUCCESS;
}
- if (lseek(tdb->fd, 0, SEEK_SET) == -1)
+ if (lseek(tdb->file->fd, 0, SEEK_SET) == -1) {
+ ret = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb1_new_database: lseek failed");
goto fail;
+ }
- if (ftruncate(tdb->fd, 0) == -1)
+ if (ftruncate(tdb->file->fd, 0) == -1) {
+ ret = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb1_new_database: ftruncate failed");
goto fail;
+ }
- /* This creates an endian-converted header, as if read from disk */
- TDB1_CONV(*newdb);
- memcpy(&tdb->header, newdb, sizeof(tdb->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))
- ret = 0;
+ if (!tdb1_write_all(tdb->file->fd, newdb, size)) {
+ ret = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb1_new_database: write failed");
+ goto fail;
+ }
+ ret = TDB_SUCCESS;
fail:
SAFE_FREE(newdb);
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)
+static bool hash_correct(struct tdb_context *tdb,
+ uint32_t *m1, uint32_t *m2)
{
- struct tdb1_context *i;
-
- for (i = tdb1s; i; i = i->next) {
- if (i->device == device && i->inode == ino) {
- return 1;
- }
+ /* older TDB without magic hash references */
+ if (tdb->tdb1.header.magic1_hash == 0
+ && tdb->tdb1.header.magic2_hash == 0) {
+ return true;
}
- 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,
- 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,281 +178,57 @@ 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,
- int open_flags, mode_t mode,
- const struct tdb1_logging_context *log_ctx,
- tdb1_hash_func hash_fn)
+/* We are hold the TDB open lock on tdb->fd. */
+enum TDB_ERROR tdb1_open(struct tdb_context *tdb,
+ struct tdb_attribute_tdb1_max_dead *max_dead)
{
- struct tdb1_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))) {
- /* Can't log this */
- errno = ENOMEM;
- goto fail;
- }
- tdb1_io_init(tdb);
- tdb->fd = -1;
- tdb->name = NULL;
- tdb->map_ptr = NULL;
- tdb->flags = tdb1_flags;
- tdb->open_flags = open_flags;
- 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 & TDB_INTERNAL)) {
- name = "__TDB1_INTERNAL__";
- }
-
- if (name == NULL) {
- tdb->name = (char *)"__NULL__";
- tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
- "tdb1_open_ex: called with name == NULL");
- tdb->name = NULL;
- errno = EINVAL;
- goto fail;
- }
+ tdb->flags |= TDB_VERSION1;
- /* now make a copy of the name, as the caller memory might went away */
- if (!(tdb->name = (char *)strdup(name))) {
- /*
- * set the name as the given string, so that tdb1_name() will
- * work in case of an error.
- */
- tdb->name = (char *)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;
- }
+ tdb_context_init(tdb, max_dead);
- if (hash_fn) {
- tdb->hash_fn = hash_fn;
- if (hash_fn == tdb1_incompatible_hash)
- hash_alg = "tdb1_incompatible_hash";
- else
- hash_alg = "the user defined";
- } else {
+ /* Default TDB2 hash becomes default TDB1 hash. */
+ if (tdb->hash_fn == tdb_jenkins_hash) {
tdb->hash_fn = tdb1_old_hash;
hash_alg = "default";
- }
-
- /* cache the page size */
- tdb->page_size = getpagesize();
- if (tdb->page_size <= 0) {
- tdb->page_size = 0x2000;
- }
-
- /* 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,
- "tdb1_open_ex: can't open tdb %s write-only",
- name);
- errno = EINVAL;
- goto fail;
- }
-
- 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 */
- tdb->flags |= TDB_NOLOCK;
- }
-
- /* internal databases don't mmap or lock, and start off cleared */
- 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!");
- goto fail;
- }
- goto internal;
- }
-
- if ((tdb->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));
- goto fail; /* errno set by open(2) */
- }
-
- /* on exec, don't inherit the fd */
- v = fcntl(tdb->fd, F_GETFD, 0);
- fcntl(tdb->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) {
- 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 */
- }
-
- errno = 0;
- if (read(tdb->fd, &tdb->header, sizeof(tdb->header)) != sizeof(tdb->header)
- || strcmp(tdb->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;
+ } else if (tdb->hash_fn == tdb1_incompatible_hash)
+ hash_alg = "tdb1_incompatible_hash";
+ else
+ hash_alg = "the user defined";
+
+ if (tdb->tdb1.header.version != TDB1_BYTEREV(TDB1_VERSION)) {
+ if (tdb->flags & TDB_CONVERT) {
+ return tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb1_open:"
+ " %s does not need TDB_CONVERT",
+ tdb->name);
}
- 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;
- }
- if (!rev)
- tdb->flags &= ~TDB_CONVERT;
- else {
+ } else {
tdb->flags |= TDB_CONVERT;
- tdb1_convert(&tdb->header, sizeof(tdb->header));
+ tdb1_convert(&tdb->tdb1.header, sizeof(tdb->tdb1.header));
}
- if (fstat(tdb->fd, &st) == -1)
- goto fail;
- if (tdb->header.rwlocks != 0 &&
- tdb->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->tdb1.header.rwlocks != 0 &&
+ tdb->tdb1.header.rwlocks != TDB1_HASH_RWLOCK_MAGIC) {
+ return tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "tdb1_open: spinlocks no longer supported");
}
- 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, &magic1, &magic2)) {
- tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_USE_ERROR,
- "tdb1_open_ex: "
+ if (!check_header_hash(tdb, &magic1, &magic2)) {
+ return tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_USE_ERROR,
+ "tdb1_open: "
"%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) ? "==" : "!=",
+ tdb->name, hash_alg,
+ 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;
- tdb1_mmap(tdb);
-
- /* if needed, run recovery */
- if (tdb1_transaction_recover(tdb) == -1) {
- goto fail;
- }
-
- internal:
- /* 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) == -1) {
- goto fail;
- }
- tdb->next = tdb1s;
- tdb1s = tdb;
- return tdb;
-
- fail:
- { int save_errno = errno;
-
- if (!tdb)
- return NULL;
-
- if (tdb->map_ptr) {
- if (tdb->flags & TDB_INTERNAL)
- SAFE_FREE(tdb->map_ptr);
- else
- tdb1_munmap(tdb);
- }
- if (tdb->fd != -1)
- if (close(tdb->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);
- SAFE_FREE(tdb->name);
- SAFE_FREE(tdb);
- errno = save_errno;
- return NULL;
- }
-}
-
-/*
- * Set the maximum number of dead records per hash chain
- */
-
-void tdb1_set_max_dead(struct tdb1_context *tdb, int max_dead)
-{
- tdb->max_dead_records = max_dead;
-}
-
-/**
- * Close a database.
- *
- * @returns -1 for error; 0 for success.
- **/
-int tdb1_close(struct tdb1_context *tdb)
-{
- struct tdb1_context **i;
- int ret = 0;
-
- if (tdb->transaction) {
- tdb1_transaction_cancel(tdb);
- }
-
- if (tdb->map_ptr) {
- if (tdb->flags & TDB_INTERNAL)
- SAFE_FREE(tdb->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;
- }
- }
-
- memset(tdb, 0, sizeof(*tdb));
- SAFE_FREE(tdb);
-
- return ret;
+ return TDB_SUCCESS;
}