X-Git-Url: https://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Ftdb2%2Ftdb1_open.c;h=5176f57f77666dd264a6c2d2dfb693693978fb9f;hp=e1f16053666537eb91ba8501ab7c151fe8d35994;hb=22d0e0dc59fc9d7e0046fec6971ef478c2d604fd;hpb=919937354a331bb964564a11b5a5b80403ff8db9 diff --git a/ccan/tdb2/tdb1_open.c b/ccan/tdb2/tdb1_open.c index e1f16053..5176f57f 100644 --- a/ccan/tdb2/tdb1_open.c +++ b/ccan/tdb2/tdb1_open.c @@ -34,11 +34,11 @@ static struct tdb1_context *tdb1s = NULL; void tdb1_header_hash(struct tdb1_context *tdb, uint32_t *magic1_hash, uint32_t *magic2_hash) { - TDB1_DATA hash_key; + TDB_DATA hash_key; uint32_t tdb1_magic = TDB1_MAGIC; - hash_key.dptr = (unsigned char *)TDB1_MAGIC_FOOD; - hash_key.dsize = sizeof(TDB1_MAGIC_FOOD); + 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); @@ -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)); @@ -93,7 +93,7 @@ static int tdb1_new_database(struct tdb1_context *tdb, int hash_size) TDB1_CONV(*newdb); memcpy(&tdb->header, newdb, sizeof(tdb->header)); /* Don't endian-convert the magic food! */ - memcpy(newdb->magic_food, TDB1_MAGIC_FOOD, strlen(TDB1_MAGIC_FOOD)+1); + 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; @@ -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; @@ -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!"); @@ -293,51 +274,33 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag 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, TDB1_LOCK_WAIT) == -1) { + 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 */ } - /* 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, TDB1_LOCK_NOWAIT|TDB1_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, TDB1_MAGIC_FOOD) != 0) { + || 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; } - 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, TDB1_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);