case TDB_ATTRIBUTE_HASH:
case TDB_ATTRIBUTE_SEED:
case TDB_ATTRIBUTE_OPENHOOK:
+ case TDB_ATTRIBUTE_TDB1_HASHSIZE:
return tdb->last_error
= tdb_logerr(tdb, TDB_ERR_EINVAL,
TDB_LOG_USE_ERROR,
? "TDB_ATTRIBUTE_HASH"
: attr->base.attr == TDB_ATTRIBUTE_SEED
? "TDB_ATTRIBUTE_SEED"
- : "TDB_ATTRIBUTE_OPENHOOK");
+ : attr->base.attr == TDB_ATTRIBUTE_OPENHOOK
+ ? "TDB_ATTRIBUTE_OPENHOOK"
+ : "TDB_ATTRIBUTE_TDB1_HASHSIZE");
case TDB_ATTRIBUTE_STATS:
return tdb->last_error
= tdb_logerr(tdb, TDB_ERR_EINVAL,
attr->flock.unlock = tdb->unlock_fn;
attr->flock.data = tdb->lock_data;
break;
+ case TDB_ATTRIBUTE_TDB1_HASHSIZE:
+ if (!(tdb->flags & TDB_VERSION1))
+ return tdb->last_error
+ = tdb_logerr(tdb, TDB_ERR_EINVAL,
+ TDB_LOG_USE_ERROR,
+ "tdb_get_attribute:"
+ " cannot get TDB_ATTRIBUTE_TDB1_HASHSIZE"
+ " on TDB2 tdb.");
+ attr->tdb1_hashsize.hsize = tdb->tdb1.header.hash_size;
+ break;
default:
return tdb->last_error
= tdb_logerr(tdb, TDB_ERR_EINVAL,
break;
case TDB_ATTRIBUTE_HASH:
case TDB_ATTRIBUTE_SEED:
+ case TDB_ATTRIBUTE_TDB1_HASHSIZE:
tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
"tdb_unset_attribute: cannot unset %s after opening",
type == TDB_ATTRIBUTE_HASH
? "TDB_ATTRIBUTE_HASH"
- : "TDB_ATTRIBUTE_SEED");
+ : type == TDB_ATTRIBUTE_SEED
+ ? "TDB_ATTRIBUTE_SEED"
+ : "TDB_ATTRIBUTE_TDB1_HASHSIZE");
break;
case TDB_ATTRIBUTE_STATS:
tdb_logerr(tdb, TDB_ERR_EINVAL,
ssize_t rlen;
struct tdb_header hdr;
struct tdb_attribute_seed *seed = NULL;
+ struct tdb_attribute_tdb1_hashsize *hsize_attr = NULL;
tdb_bool_err berr;
enum TDB_ERROR ecode;
int openlock;
tdb->openhook = attr->openhook.fn;
tdb->openhook_data = attr->openhook.data;
break;
+ case TDB_ATTRIBUTE_TDB1_HASHSIZE:
+ hsize_attr = &attr->tdb1_hashsize;
+ break;
default:
/* These are set as normal. */
ecode = tdb_set_attribute(tdb, attr);
goto fail;
}
+ if (hsize_attr) {
+ if (!(tdb_flags & TDB_VERSION1) ||
+ (!(tdb_flags & TDB_INTERNAL) && !(open_flags & O_CREAT))) {
+ ecode = tdb_logerr(tdb, TDB_ERR_EINVAL,
+ TDB_LOG_USE_ERROR,
+ "tdb_open: can only use"
+ " TDB_ATTRIBUTE_TDB1_HASHSIZE when"
+ " creating a TDB_VERSION1 tdb");
+ goto fail;
+ }
+ }
+
if ((open_flags & O_ACCMODE) == O_WRONLY) {
ecode = tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
"tdb_open: can't open tdb %s write-only",
typedef int (*tdb1_traverse_func)(struct tdb_context *, TDB_DATA, TDB_DATA, void *);
-struct tdb_context *tdb1_open(const char *name, int hash_size, int tdb1_flags,
+struct tdb_context *tdb1_open(const char *name, int tdb1_flags,
int open_flags, mode_t mode,
union tdb_attribute *attributes);
int tdb1_get_seqnum(struct tdb_context *tdb);
-int tdb1_hash_size(struct tdb_context *tdb);
-
void tdb1_increment_seqnum_nonblock(struct tdb_context *tdb);
uint64_t tdb1_incompatible_hash(const void *key, size_t len, uint64_t seed, void *);
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"
/* We use two hashes to double-check they're using the right hash function. */
goto fail;
}
- if (hash_size == 0)
- hash_size = TDB1_DEFAULT_HASH_SIZE;
if ((open_flags & O_ACCMODE) == O_RDONLY) {
tdb->flags |= TDB_RDONLY;
/* read only databases don't do locking */
}
/* Temporart wrapper for transition. */
-struct tdb_context *tdb1_open(const char *name, int hash_size, int tdb1_flags,
+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) {
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;
}
- return tdb1_open_ex(name, hash_size, tdb1_flags, open_flags, mode,
+ 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);
}
return seqnum;
}
-int tdb1_hash_size(struct tdb_context *tdb)
-{
- return tdb->tdb1.header.hash_size;
-}
-
/*
add a region of the file to the freelist. Length is the size of the region in bytes,
{
struct tdb_context *tmp_db;
struct traverse_state state;
+ union tdb_attribute hsize;
+
+ hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
+ hsize.base.next = NULL;
+ hsize.tdb1_hashsize.hsize = tdb->tdb1.header.hash_size;
if (tdb1_transaction_start(tdb) != 0) {
tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
return -1;
}
- tmp_db = tdb1_open("tmpdb", tdb1_hash_size(tdb), TDB_INTERNAL, O_RDWR|O_CREAT, 0, NULL);
+ tmp_db = tdb1_open("tmpdb", TDB_INTERNAL, O_RDWR|O_CREAT, 0, &hsize);
if (tmp_db == NULL) {
tdb->last_error = tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR,
__location__ " Failed to create tmp_db");
TDB_ATTRIBUTE_SEED = 2,
TDB_ATTRIBUTE_STATS = 3,
TDB_ATTRIBUTE_OPENHOOK = 4,
- TDB_ATTRIBUTE_FLOCK = 5
+ TDB_ATTRIBUTE_FLOCK = 5,
+ TDB_ATTRIBUTE_TDB1_HASHSIZE = 128,
};
/**
* of the same type. It returns TDB_ERR_EINVAL if the attribute is
* unknown or invalid.
*
- * Note that TDB_ATTRIBUTE_HASH, TDB_ATTRIBUTE_SEED and
- * TDB_ATTRIBUTE_OPENHOOK cannot currently be set after tdb_open.
+ * Note that TDB_ATTRIBUTE_HASH, TDB_ATTRIBUTE_SEED,
+ * TDB_ATTRIBUTE_OPENHOOK and TDB_ATTRIBUTE_TDB1_HASHSIZE cannot
+ * currently be set after tdb_open.
*/
enum TDB_ERROR tdb_set_attribute(struct tdb_context *tdb,
const union tdb_attribute *attr);
void *data;
};
+/**
+ * struct tdb_attribute_tdb1_hashsize - tdb1 hashsize
+ *
+ * This attribute allows setting the TDB1 hashsize; it only makes sense with
+ * O_CREAT and TDB_VERSION1.
+ *
+ * Hashsize should generally be a prime, such as 10007.
+ */
+struct tdb_attribute_tdb1_hashsize {
+ struct tdb_attribute_base base; /* .attr = TDB_ATTRIBUTE_TDB1_HASHSIZE */
+ unsigned int hsize;
+};
+
/**
* union tdb_attribute - tdb attributes.
*
struct tdb_attribute_stats stats;
struct tdb_attribute_openhook openhook;
struct tdb_attribute_flock flock;
+ struct tdb_attribute_tdb1_hashsize tdb1_hashsize;
};
#ifdef __cplusplus
#include <stdbool.h>
/* FIXME: Check these! */
-#define INITIAL_TDB_MALLOC "open.c", 343, FAILTEST_MALLOC
+#define INITIAL_TDB_MALLOC "open.c", 360, FAILTEST_MALLOC
#define URANDOM_OPEN "open.c", 61, FAILTEST_OPEN
#define URANDOM_READ "open.c", 41, FAILTEST_READ
uint32_t hash;
tdb1_off_t rec_ptr;
struct tdb1_record rec;
+ union tdb_attribute hsize;
+
+ hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
+ hsize.base.next = &tap_log_attr;
+ hsize.tdb1_hashsize.hsize = 1024;
plan_tests(24);
- tdb = tdb1_open("run-36-file.tdb", 1024, TDB_DEFAULT,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &tap_log_attr);
+ tdb = tdb1_open("run-36-file.tdb", TDB_DEFAULT,
+ O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
ok1(tdb);
tdb->tdb1.io = &large_io_methods;
struct tdb_context *tdb;
struct tdb1_header hdr;
int fd;
+ union tdb_attribute hsize;
+
+ hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
+ hsize.base.next = &tap_log_attr;
+ hsize.tdb1_hashsize.hsize = 1024;
plan_tests(11);
/* Can open fine if complete crap, as long as O_CREAT. */
ok1(fd >= 0);
ok1(write(fd, "hello world", 11) == 11);
close(fd);
- tdb = tdb1_open("run-bad-tdb-header.tdb", 1024, 0, O_RDWR, 0,
- &tap_log_attr);
+ tdb = tdb1_open("run-bad-tdb-header.tdb", 0, O_RDWR, 0, &tap_log_attr);
ok1(!tdb);
- tdb = tdb1_open("run-bad-tdb-header.tdb", 1024, 0, O_CREAT|O_RDWR,
- 0600, &tap_log_attr);
+ tdb = tdb1_open("run-bad-tdb-header.tdb", 0, O_CREAT|O_RDWR,
+ 0600, &hsize);
ok1(tdb);
tdb1_close(tdb);
ok1(write(fd, &hdr, sizeof(hdr)) == sizeof(hdr));
close(fd);
- tdb = tdb1_open("run-bad-tdb-header.tdb", 1024, 0, O_RDWR|O_CREAT,
- 0600, &tap_log_attr);
+ tdb = tdb1_open("run-bad-tdb-header.tdb", 0, O_RDWR|O_CREAT,
+ 0600, &hsize);
ok1(errno == EIO);
ok1(!tdb);
/* With truncate, will be fine. */
- tdb = tdb1_open("run-bad-tdb-header.tdb", 1024, 0,
- O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr);
+ tdb = tdb1_open("run-bad-tdb-header.tdb", 0,
+ O_RDWR|O_CREAT|O_TRUNC, 0600, &hsize);
ok1(tdb);
tdb1_close(tdb);
{
struct tdb_context *tdb;
TDB_DATA key, data;
+ union tdb_attribute hsize;
+
+ hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
+ hsize.base.next = &tap_log_attr;
+ hsize.tdb1_hashsize.hsize = 1;
plan_tests(13);
- tdb = tdb1_open("run-check.tdb", 1, TDB_DEFAULT,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &tap_log_attr);
+ tdb = tdb1_open("run-check.tdb", TDB_DEFAULT,
+ O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
ok1(tdb);
ok1(tdb1_check(tdb, NULL, NULL) == 0);
ok1(tdb1_check(tdb, NULL, NULL) == 0);
tdb1_close(tdb);
- tdb = tdb1_open("run-check.tdb", 1024, 0, O_RDWR, 0,
+ tdb = tdb1_open("run-check.tdb", 0, O_RDWR, 0,
&tap_log_attr);
ok1(tdb);
ok1(tdb1_check(tdb, NULL, NULL) == 0);
tdb1_close(tdb);
- tdb = tdb1_open("test/tdb1.corrupt", 1024, 0, O_RDWR, 0,
+ tdb = tdb1_open("test/tdb1.corrupt", 0, O_RDWR, 0,
&tap_log_attr);
ok1(tdb);
ok1(tdb1_check(tdb, NULL, NULL) == -1);
tdb1_close(tdb);
/* Big and little endian should work! */
- tdb = tdb1_open("test/old-nohash-le.tdb1", 1024, 0, O_RDWR, 0,
+ tdb = tdb1_open("test/old-nohash-le.tdb1", 0, O_RDWR, 0,
&tap_log_attr);
ok1(tdb);
ok1(tdb1_check(tdb, NULL, NULL) == 0);
tdb1_close(tdb);
- tdb = tdb1_open("test/old-nohash-be.tdb1", 1024, 0, O_RDWR, 0,
+ tdb = tdb1_open("test/old-nohash-be.tdb1", 0, O_RDWR, 0,
&tap_log_attr);
ok1(tdb);
ok1(tdb1_check(tdb, NULL, NULL) == 0);
int main(int argc, char *argv[])
{
struct tdb_context *tdb;
+ union tdb_attribute hsize;
+
+ hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
+ hsize.base.next = &tap_log_attr;
+ hsize.tdb1_hashsize.hsize = 2;
plan_tests(4);
/* This should use mmap. */
- tdb = tdb1_open("run-corrupt.tdb", 2, TDB_DEFAULT,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &tap_log_attr);
+ tdb = tdb1_open("run-corrupt.tdb", TDB_DEFAULT,
+ O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
if (!tdb)
abort();
tdb1_close(tdb);
/* This should not. */
- tdb = tdb1_open("run-corrupt.tdb", 2, TDB_NOMMAP,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &tap_log_attr);
+ tdb = tdb1_open("run-corrupt.tdb", TDB_NOMMAP,
+ O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
if (!tdb)
abort();
TDB_DATA key;
enum agent_return ret;
int needed_recovery = 0;
+ union tdb_attribute hsize;
+
+ hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
+ hsize.base.next = &tap_log_attr;
+ hsize.tdb1_hashsize.hsize = 1024;
current = target = 0;
reset:
unlink(TEST_DBNAME);
- tdb = tdb1_open(TEST_DBNAME, 1024, TDB_NOMMAP,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &tap_log_attr);
+ tdb = tdb1_open(TEST_DBNAME, TDB_NOMMAP,
+ O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
if (setjmp(jmpbuf) != 0) {
/* We're partway through. Simulate our death. */
{
struct tdb_context *tdb;
TDB_DATA key, data;
+ union tdb_attribute hsize;
+
+ hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
+ hsize.base.next = &tap_log_attr;
+ hsize.tdb1_hashsize.hsize = 1024;
plan_tests(13);
- tdb = tdb1_open("run-endian.tdb", 1024,
+ tdb = tdb1_open("run-endian.tdb",
TDB_CONVERT,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &tap_log_attr);
+ O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
ok1(tdb);
key.dsize = strlen("hi");
tdb1_close(tdb);
/* Reopen: should read it */
- tdb = tdb1_open("run-endian.tdb", 1024, 0, O_RDWR, 0,
- &tap_log_attr);
+ tdb = tdb1_open("run-endian.tdb", 0, O_RDWR, 0, NULL);
ok1(tdb);
key.dsize = strlen("hi");
--- /dev/null
+#include "tdb2-source.h"
+#include <ccan/tap/tap.h>
+#include <stdlib.h>
+#include <err.h>
+#include "logging.h"
+
+int main(int argc, char *argv[])
+{
+ struct tdb_context *tdb;
+ union tdb_attribute hsize, h2;
+
+ hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
+ hsize.base.next = &tap_log_attr;
+ hsize.tdb1_hashsize.hsize = 1024;
+
+ plan_tests(14);
+ tdb = tdb1_open("run-tdb1-hashsize.tdb1", TDB_DEFAULT,
+ O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
+ ok1(tdb);
+ h2.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
+ ok1(tdb_get_attribute(tdb, &h2) == TDB_SUCCESS);
+ ok1(h2.tdb1_hashsize.hsize == hsize.tdb1_hashsize.hsize);
+ tdb_close(tdb);
+
+ /* Can't specify TDB_ATTRIBUTE_TDB1_HASHSIZE without O_CREAT */
+ tdb = tdb1_open("run-tdb1-hashsize.tdb1", TDB_DEFAULT,
+ O_RDWR, 0600, &hsize);
+ ok1(!tdb);
+ ok1(tap_log_messages == 1);
+
+ /* Can't specify TDB_ATTRIBUTE_TDB1_HASHSIZE for version2. */
+ tdb = tdb_open("run-tdb1-hashsize.tdb", TDB_DEFAULT,
+ O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
+ ok1(!tdb);
+ ok1(tap_log_messages == 2);
+
+ /* We can get attribute even if we didn't set it though. */
+ tdb = tdb1_open("run-tdb1-hashsize.tdb1", TDB_DEFAULT,
+ O_RDWR, 0600, &tap_log_attr);
+
+ ok1(tdb);
+ memset(&h2, 0, sizeof(h2));
+ h2.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
+ ok1(tdb_get_attribute(tdb, &h2) == TDB_SUCCESS);
+ ok1(h2.tdb1_hashsize.hsize == hsize.tdb1_hashsize.hsize);
+ tdb_close(tdb);
+
+ /* Check for default hash size. */
+ tdb = tdb1_open("run-tdb1-hashsize.tdb1", TDB_DEFAULT,
+ O_CREAT|O_TRUNC|O_RDWR, 0600, &tap_log_attr);
+
+ ok1(tdb);
+ memset(&h2, 0, sizeof(h2));
+ h2.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
+ ok1(tdb_get_attribute(tdb, &h2) == TDB_SUCCESS);
+ ok1(h2.tdb1_hashsize.hsize == TDB1_DEFAULT_HASH_SIZE);
+ tdb_close(tdb);
+ ok1(tap_log_messages == 2);
+
+ return exit_status();
+}
/* Create an old-style hash. */
log_count = 0;
- tdb = tdb1_open("run-incompatible.tdb", 0, flags,
+ tdb = tdb1_open("run-incompatible.tdb", flags,
O_CREAT|O_RDWR|O_TRUNC, 0600, &log_attr);
ok1(tdb);
ok1(log_count == 0);
/* We can still open any old-style with incompat hash. */
log_count = 0;
- tdb = tdb1_open("run-incompatible.tdb", 0,
+ tdb = tdb1_open("run-incompatible.tdb",
TDB_DEFAULT,
O_RDWR, 0600, &incompat_hash_attr);
ok1(tdb);
tdb1_close(tdb);
log_count = 0;
- tdb = tdb1_open("test/jenkins-le-hash.tdb1", 0, 0, O_RDONLY,
+ tdb = tdb1_open("test/jenkins-le-hash.tdb1", 0, O_RDONLY,
0, &jhash_attr);
ok1(tdb);
ok1(log_count == 0);
tdb1_close(tdb);
log_count = 0;
- tdb = tdb1_open("test/jenkins-be-hash.tdb1", 0, 0, O_RDONLY,
+ tdb = tdb1_open("test/jenkins-be-hash.tdb1", 0, O_RDONLY,
0, &jhash_attr);
ok1(tdb);
ok1(log_count == 0);
/* OK, now create with incompatible hash. */
log_count = 0;
- tdb = tdb1_open("run-incompatible.tdb", 0,
+ tdb = tdb1_open("run-incompatible.tdb",
flags,
O_CREAT|O_RDWR|O_TRUNC, 0600,
&incompat_hash_attr);
/* Cannot open with old hash. */
log_count = 0;
- tdb = tdb1_open("run-incompatible.tdb", 0, 0,
+ tdb = tdb1_open("run-incompatible.tdb", 0,
O_RDWR, 0600, &ohash_attr);
ok1(!tdb);
ok1(log_count == 1);
/* Can open with jenkins hash. */
log_count = 0;
- tdb = tdb1_open("run-incompatible.tdb", 0, 0,
+ tdb = tdb1_open("run-incompatible.tdb", 0,
O_RDWR, 0600, &jhash_attr);
ok1(tdb);
ok1(log_count == 0);
/* Can open by letting it figure it out itself. */
log_count = 0;
- tdb = tdb1_open("run-incompatible.tdb", 0, 0,
+ tdb = tdb1_open("run-incompatible.tdb", 0,
O_RDWR, 0600, &log_attr);
ok1(tdb);
ok1(log_count == 0);
/* FIXME: Not possible with TDB2 :( */
/* We can also use incompatible hash with other hashes. */
log_count = 0;
- tdb = tdb1_open("run-incompatible.tdb", 0,
+ tdb = tdb1_open("run-incompatible.tdb",
flags,
O_CREAT|O_RDWR|O_TRUNC, 0600, &dumbhash_attr);
ok1(tdb);
/* It should not open if we don't specify. */
log_count = 0;
- tdb = tdb1_open("run-incompatible.tdb", 0, 0, O_RDWR, 0,
+ tdb = tdb1_open("run-incompatible.tdb", 0, O_RDWR, 0,
&log_attr);
ok1(!tdb);
ok1(log_count == 1);
/* Should reopen with correct hash. */
log_count = 0;
- tdb = tdb1_open("run-incompatible.tdb", 0, 0, O_RDWR, 0,
+ tdb = tdb1_open("run-incompatible.tdb", 0, O_RDWR, 0,
&dumbhash_attr);
ok1(tdb);
ok1(log_count == 0);
{
struct tdb_context *tdb;
TDB_DATA key, data;
+ union tdb_attribute hsize;
+
+ hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
+ hsize.base.next = &tap_log_attr;
+ hsize.tdb1_hashsize.hsize = 1024;
plan_tests(27);
key.dsize = strlen("hi");
key.dptr = (void *)"hi";
tdb = tdb1_open("run-nested-transactions.tdb",
- 1024, TDB_DEFAULT,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &tap_log_attr);
+ TDB_DEFAULT,
+ O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
ok1(tdb);
/* No nesting by default. */
tdb1_close(tdb);
tdb = tdb1_open("run-nested-transactions.tdb",
- 1024, TDB_ALLOW_NESTING, O_RDWR, 0, &tap_log_attr);
+ TDB_ALLOW_NESTING, O_RDWR, 0, &tap_log_attr);
ok1(tdb);
ok1(tdb1_transaction_start(tdb) == 0);
{
struct tdb_context *tdb;
TDB_DATA key, data;
+ union tdb_attribute hsize;
+
+ hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
+ hsize.base.next = &tap_log_attr;
+ hsize.tdb1_hashsize.hsize = 1024;
plan_tests(17);
agent = prepare_external_agent1();
if (!agent)
err(1, "preparing agent");
- tdb = tdb1_open("run-nested-traverse.tdb", 1024, TDB_DEFAULT,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &tap_log_attr);
+ tdb = tdb1_open("run-nested-traverse.tdb", TDB_DEFAULT,
+ O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
ok1(tdb);
ok1(external_agent_operation1(agent, OPEN, tdb->name) == SUCCESS);
{
struct tdb_context *tdb;
int errors = 0;
+ union tdb_attribute hsize;
+
+ hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
+ hsize.base.next = &tap_log_attr;
+ hsize.tdb1_hashsize.hsize = 1024;
plan_tests(41);
tdb = tdb1_open("run-no-lock-during-traverse.tdb",
- 1024, TDB_DEFAULT, O_CREAT|O_TRUNC|O_RDWR,
- 0600, &tap_log_attr);
+ TDB_DEFAULT, O_CREAT|O_TRUNC|O_RDWR,
+ 0600, &hsize);
ok1(tdb);
ok1(prepare_entries(tdb));
/* Old format (with zeroes in the hash magic fields) should
* open with any hash (since we don't know what hash they used). */
- tdb = tdb1_open("test/old-nohash-le.tdb1", 0, 0, O_RDWR, 0,
+ tdb = tdb1_open("test/old-nohash-le.tdb1", 0, O_RDWR, 0,
&tap_log_attr);
ok1(tdb);
ok1(tdb1_check(tdb, NULL, NULL) == 0);
tdb1_close(tdb);
- tdb = tdb1_open("test/old-nohash-be.tdb1", 0, 0, O_RDWR, 0,
+ tdb = tdb1_open("test/old-nohash-be.tdb1", 0, O_RDWR, 0,
&tap_log_attr);
ok1(tdb);
ok1(tdb1_check(tdb, NULL, NULL) == 0);
tdb1_close(tdb);
- tdb = tdb1_open("test/old-nohash-le.tdb1", 0, 0, O_RDWR, 0,
+ tdb = tdb1_open("test/old-nohash-le.tdb1", 0, O_RDWR, 0,
&incompat_hash_attr);
ok1(tdb);
ok1(tdb1_check(tdb, NULL, NULL) == 0);
tdb1_close(tdb);
- tdb = tdb1_open("test/old-nohash-be.tdb1", 0, 0, O_RDWR, 0,
+ tdb = tdb1_open("test/old-nohash-be.tdb1", 0, O_RDWR, 0,
&incompat_hash_attr);
ok1(tdb);
ok1(tdb1_check(tdb, NULL, NULL) == 0);
int i;
struct tdb_context *tdb;
TDB_DATA key, data;
+ union tdb_attribute hsize;
+
+ hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
+ hsize.base.next = &tap_log_attr;
+ hsize.tdb1_hashsize.hsize = 1024;
plan_tests(10);
agent = prepare_external_agent1();
"DEFAULT",
(flags[i] & TDB_NOMMAP) ? "no mmap" : "mmap");
unlink(TEST_DBNAME);
- tdb = tdb1_open(TEST_DBNAME, 1024, flags[i],
+ tdb = tdb1_open(TEST_DBNAME, flags[i],
O_CREAT|O_TRUNC|O_RDWR, 0600,
- &tap_log_attr);
+ &hsize);
ok1(tdb);
opened = true;
{
struct tdb_context *tdb;
TDB_DATA key, data;
+ union tdb_attribute hsize;
+
+ hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
+ hsize.base.next = &tap_log_attr;
+ hsize.tdb1_hashsize.hsize = 1024;
plan_tests(11);
- tdb = tdb1_open("run-readonly-check.tdb", 1024,
+ tdb = tdb1_open("run-readonly-check.tdb",
TDB_DEFAULT,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &tap_log_attr);
+ O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
ok1(tdb);
key.dsize = strlen("hi");
ok1(tdb1_check(tdb, NULL, NULL) == 0);
ok1(tdb1_close(tdb) == 0);
- tdb = tdb1_open("run-readonly-check.tdb", 1024,
+ tdb = tdb1_open("run-readonly-check.tdb",
TDB_DEFAULT, O_RDONLY, 0, &tap_log_attr);
ok1(tdb);
/* We should fail to open rwlock-using tdbs of either endian. */
log_count = 0;
- tdb = tdb1_open("test/rwlock-le.tdb1", 0, 0, O_RDWR, 0,
+ tdb = tdb1_open("test/rwlock-le.tdb1", 0, O_RDWR, 0,
&log_attr);
ok1(!tdb);
ok1(log_count == 1);
log_count = 0;
- tdb = tdb1_open("test/rwlock-be.tdb1", 0, 0, O_RDWR, 0,
+ tdb = tdb1_open("test/rwlock-be.tdb1", 0, O_RDWR, 0,
&log_attr);
ok1(!tdb);
ok1(log_count == 1);
plan_tests(sizeof(flags) / sizeof(flags[0]) * 14);
for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
- tdb = tdb1_open("run-summary.tdb", 131, flags[i],
+ tdb = tdb1_open("run-summary.tdb", flags[i],
O_RDWR|O_CREAT|O_TRUNC, 0600, NULL);
ok1(tdb);
if (!tdb)
{
struct tdb_context *tdb;
TDB_DATA key, data;
+ union tdb_attribute hsize;
+
+ hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
+ hsize.base.next = &tap_log_attr;
+ hsize.tdb1_hashsize.hsize = 1024;
plan_tests(13);
agent = prepare_external_agent1();
err(1, "preparing agent");
tdb = tdb1_open("run-traverse-in-transaction.tdb",
- 1024, TDB_DEFAULT, O_CREAT|O_TRUNC|O_RDWR,
- 0600, &tap_log_attr);
+ TDB_DEFAULT, O_CREAT|O_TRUNC|O_RDWR,
+ 0600, &hsize);
ok1(tdb);
key.dsize = strlen("hi");
/* Create with default hash. */
log_count = 0;
- tdb = tdb1_open("run-wronghash-fail.tdb", 0, 0,
+ tdb = tdb1_open("run-wronghash-fail.tdb", 0,
O_CREAT|O_RDWR|O_TRUNC, 0600, &log_attr);
ok1(tdb);
ok1(log_count == 0);
tdb1_close(tdb);
/* Fail to open with different hash. */
- tdb = tdb1_open("run-wronghash-fail.tdb", 0, 0, O_RDWR, 0,
+ tdb = tdb1_open("run-wronghash-fail.tdb", 0, O_RDWR, 0,
&jhash_attr);
ok1(!tdb);
ok1(log_count == 1);
/* Create with different hash. */
log_count = 0;
- tdb = tdb1_open("run-wronghash-fail.tdb", 0, 0,
+ tdb = tdb1_open("run-wronghash-fail.tdb", 0,
O_CREAT|O_RDWR|O_TRUNC,
0600, &jhash_attr);
ok1(tdb);
/* Endian should be no problem. */
log_count = 0;
- tdb = tdb1_open("test/jenkins-le-hash.tdb1", 0, 0, O_RDWR, 0,
+ tdb = tdb1_open("test/jenkins-le-hash.tdb1", 0, O_RDWR, 0,
&ohash_attr);
ok1(!tdb);
ok1(log_count == 1);
log_count = 0;
- tdb = tdb1_open("test/jenkins-be-hash.tdb1", 0, 0, O_RDWR, 0,
+ tdb = tdb1_open("test/jenkins-be-hash.tdb1", 0, O_RDWR, 0,
&ohash_attr);
ok1(!tdb);
ok1(log_count == 1);
log_count = 0;
/* Fail to open with old default hash. */
- tdb = tdb1_open("run-wronghash-fail.tdb", 0, 0, O_RDWR, 0,
+ tdb = tdb1_open("run-wronghash-fail.tdb", 0, O_RDWR, 0,
&ohash_attr);
ok1(!tdb);
ok1(log_count == 1);
log_count = 0;
- tdb = tdb1_open("test/jenkins-le-hash.tdb1", 0, 0, O_RDONLY,
+ tdb = tdb1_open("test/jenkins-le-hash.tdb1", 0, O_RDONLY,
0, &incompat_hash_attr);
ok1(tdb);
ok1(log_count == 0);
tdb1_close(tdb);
log_count = 0;
- tdb = tdb1_open("test/jenkins-be-hash.tdb1", 0, 0, O_RDONLY,
+ tdb = tdb1_open("test/jenkins-be-hash.tdb1", 0, O_RDONLY,
0, &incompat_hash_attr);
ok1(tdb);
ok1(log_count == 0);
/* It should open with jenkins hash if we don't specify. */
log_count = 0;
- tdb = tdb1_open("test/jenkins-le-hash.tdb1", 0, 0, O_RDWR, 0,
+ tdb = tdb1_open("test/jenkins-le-hash.tdb1", 0, O_RDWR, 0,
&log_attr);
ok1(tdb);
ok1(log_count == 0);
tdb1_close(tdb);
log_count = 0;
- tdb = tdb1_open("test/jenkins-be-hash.tdb1", 0, 0, O_RDWR, 0,
+ tdb = tdb1_open("test/jenkins-be-hash.tdb1", 0, O_RDWR, 0,
&log_attr);
ok1(tdb);
ok1(log_count == 0);
tdb1_close(tdb);
log_count = 0;
- tdb = tdb1_open("run-wronghash-fail.tdb", 0, 0, O_RDONLY,
+ tdb = tdb1_open("run-wronghash-fail.tdb", 0, O_RDONLY,
0, &log_attr);
ok1(tdb);
ok1(log_count == 0);
{
struct tdb_context *tdb;
TDB_DATA key, data;
+ union tdb_attribute hsize;
+
+ hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
+ hsize.base.next = &tap_log_attr;
+ hsize.tdb1_hashsize.hsize = 1024;
plan_tests(4);
- tdb = tdb1_open(NULL, 1024, TDB_INTERNAL, O_CREAT|O_TRUNC|O_RDWR,
- 0600, &tap_log_attr);
+ tdb = tdb1_open(NULL, TDB_INTERNAL, O_CREAT|O_TRUNC|O_RDWR,
+ 0600, &hsize);
ok1(tdb);
/* Tickle bug on appending zero length buffer to zero length buffer. */
{
struct tdb_context *tdb;
TDB_DATA key, data;
+ union tdb_attribute hsize;
+
+ hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
+ hsize.base.next = &tap_log_attr;
+ hsize.tdb1_hashsize.hsize = 1024;
plan_tests(10);
- tdb = tdb1_open("run.tdb", 1024, TDB_DEFAULT,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &tap_log_attr);
+ tdb = tdb1_open("run.tdb", TDB_DEFAULT,
+ O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
ok1(tdb);
key.dsize = strlen("hi");
diag("Already have tdb %s open", tdb->name);
return OTHER_FAILURE;
}
- tdb = tdb1_open(name, 0, TDB_DEFAULT, O_RDWR, 0,
+ tdb = tdb1_open(name, TDB_DEFAULT, O_RDWR, 0,
&tap_log_attr);
if (!tdb) {
if (!locking_would_block1)