/* all contexts, to ensure no double-opens (fcntl locks don't nest!) */
static struct tdb_context *tdbs = NULL;
-PRINTF_ATTRIBUTE(4, 5) static void
+PRINTF_FMT(4, 5) static void
null_log_fn(struct tdb_context *tdb,
enum tdb_debug_level level, void *priv,
const char *fmt, ...)
/* Initial free zone. */
struct free_zone_header zhdr;
tdb_off_t free[BUCKETS_FOR_ZONE(INITIAL_ZONE_BITS) + 1];
- struct tdb_free_record frec;
- /* Rest up to 1 << INITIAL_ZONE_BITS is empty. */
- char space[(1 << INITIAL_ZONE_BITS)
- - sizeof(struct free_zone_header)
- - sizeof(tdb_off_t) * (BUCKETS_FOR_ZONE(INITIAL_ZONE_BITS)+1)
- - sizeof(struct tdb_free_record)];
- uint8_t tailer;
- /* Don't count final padding! */
};
/* initialise a new database */
-static int tdb_new_database(struct tdb_context *tdb, struct tdb_header *hdr)
+static int tdb_new_database(struct tdb_context *tdb,
+ struct tdb_attribute_seed *seed,
+ struct tdb_header *hdr)
{
/* We make it up in memory, then write it out if not internal */
struct new_database newdb;
- unsigned int bucket, magic_len, dbsize;
-
- /* Don't want any extra padding! */
- dbsize = offsetof(struct new_database, tailer) + sizeof(newdb.tailer);
+ unsigned int magic_len;
/* Fill in the header */
newdb.hdr.version = TDB_VERSION;
- newdb.hdr.hash_seed = random_number(tdb);
+ if (seed)
+ newdb.hdr.hash_seed = seed->seed;
+ else
+ newdb.hdr.hash_seed = random_number(tdb);
newdb.hdr.hash_test = TDB_HASH_MAGIC;
newdb.hdr.hash_test = tdb->khash(&newdb.hdr.hash_test,
sizeof(newdb.hdr.hash_test),
/* Initial hashes are empty. */
memset(newdb.hdr.hashtable, 0, sizeof(newdb.hdr.hashtable));
- /* Free is mostly empty... */
+ /* Free is empty. */
newdb.zhdr.zone_bits = INITIAL_ZONE_BITS;
memset(newdb.free, 0, sizeof(newdb.free));
- /* Create the single free entry. */
- newdb.frec.magic_and_meta = TDB_FREE_MAGIC | INITIAL_ZONE_BITS;
- newdb.frec.data_len = (sizeof(newdb.frec)
- - sizeof(struct tdb_used_record)
- + sizeof(newdb.space));
-
- /* Add it to the correct bucket. */
- bucket = size_to_bucket(INITIAL_ZONE_BITS, newdb.frec.data_len);
- newdb.free[bucket] = offsetof(struct new_database, frec);
- newdb.frec.next = newdb.frec.prev = 0;
-
- /* Clear free space to keep valgrind happy, and avoid leaking stack. */
- memset(newdb.space, 0, sizeof(newdb.space));
-
- /* Tailer contains maximum number of free_zone bits. */
- newdb.tailer = INITIAL_ZONE_BITS;
-
/* Magic food */
memset(newdb.hdr.magic_food, 0, sizeof(newdb.hdr.magic_food));
strcpy(newdb.hdr.magic_food, TDB_MAGIC_FOOD);
/* This creates an endian-converted database, as if read from disk */
magic_len = sizeof(newdb.hdr.magic_food);
tdb_convert(tdb,
- (char *)&newdb.hdr + magic_len,
- offsetof(struct new_database, space) - magic_len);
+ (char *)&newdb.hdr + magic_len, sizeof(newdb) - magic_len);
*hdr = newdb.hdr;
if (tdb->flags & TDB_INTERNAL) {
- tdb->map_size = dbsize;
+ tdb->map_size = sizeof(newdb);
tdb->map_ptr = malloc(tdb->map_size);
if (!tdb->map_ptr) {
tdb->ecode = TDB_ERR_OOM;
if (ftruncate(tdb->fd, 0) == -1)
return -1;
- if (!tdb_pwrite_all(tdb->fd, &newdb, dbsize, 0)) {
+ if (!tdb_pwrite_all(tdb->fd, &newdb, sizeof(newdb), 0)) {
tdb->ecode = TDB_ERR_IO;
return -1;
}
uint64_t hash_test;
unsigned v;
struct tdb_header hdr;
+ struct tdb_attribute_seed *seed = NULL;
tdb = malloc(sizeof(*tdb));
if (!tdb) {
tdb->khash = attr->hash.hash_fn;
tdb->hash_priv = attr->hash.hash_private;
break;
+ case TDB_ATTRIBUTE_SEED:
+ seed = &attr->seed;
+ break;
default:
tdb->log(tdb, TDB_DEBUG_ERROR, tdb->log_priv,
"tdb_open: unknown attribute type %u\n",
tdb->read_only = true;
/* read only databases don't do locking */
tdb->flags |= TDB_NOLOCK;
- } else
+ tdb->mmap_flags = PROT_READ;
+ } else {
tdb->read_only = false;
+ tdb->mmap_flags = PROT_READ | PROT_WRITE;
+ }
/* internal databases don't need any of the rest. */
if (tdb->flags & TDB_INTERNAL) {
tdb->flags |= (TDB_NOLOCK | TDB_NOMMAP);
- if (tdb_new_database(tdb, &hdr) != 0) {
+ if (tdb_new_database(tdb, seed, &hdr) != 0) {
tdb->log(tdb, TDB_DEBUG_ERROR, tdb->log_priv,
"tdb_open: tdb_new_database failed!");
goto fail;
if (!tdb_pread_all(tdb->fd, &hdr, sizeof(hdr), 0)
|| strcmp(hdr.magic_food, TDB_MAGIC_FOOD) != 0) {
- if (!(open_flags & O_CREAT) || tdb_new_database(tdb, &hdr) == -1) {
+ if (!(open_flags & O_CREAT)
+ || tdb_new_database(tdb, seed, &hdr) == -1) {
if (errno == 0) {
errno = EIO; /* ie bad format or something */
}
struct tdb_used_record rec;
int ret;
- off = find_and_lock(tdb, key, F_WRLCK, &h, &rec);
+ off = find_and_lock(tdb, key, F_WRLCK, &h, &rec, NULL);
if (unlikely(off == TDB_OFF_ERR))
return -1;
struct tdb_data new_dbuf;
int ret;
- off = find_and_lock(tdb, key, F_WRLCK, &h, &rec);
+ off = find_and_lock(tdb, key, F_WRLCK, &h, &rec, NULL);
if (unlikely(off == TDB_OFF_ERR))
return -1;
struct hash_info h;
struct tdb_data ret;
- off = find_and_lock(tdb, key, F_RDLCK, &h, &rec);
+ off = find_and_lock(tdb, key, F_RDLCK, &h, &rec, NULL);
if (unlikely(off == TDB_OFF_ERR))
return tdb_null;
struct tdb_used_record rec;
struct hash_info h;
- off = find_and_lock(tdb, key, F_WRLCK, &h, &rec);
+ off = find_and_lock(tdb, key, F_WRLCK, &h, &rec, NULL);
if (unlikely(off == TDB_OFF_ERR))
return -1;
{
return tdb->ecode;
}
+
+const char *tdb_errorstr(struct tdb_context *tdb)
+{
+ /* Gcc warns if you miss a case in the switch, so use that. */
+ switch (tdb->ecode) {
+ case TDB_SUCCESS: return "Success";
+ case TDB_ERR_CORRUPT: return "Corrupt database";
+ case TDB_ERR_IO: return "IO Error";
+ case TDB_ERR_LOCK: return "Locking error";
+ case TDB_ERR_OOM: return "Out of memory";
+ case TDB_ERR_EXISTS: return "Record exists";
+ case TDB_ERR_NESTING: return "Transaction already started";
+ case TDB_ERR_EINVAL: return "Invalid parameter";
+ case TDB_ERR_NOEXIST: return "Record does not exist";
+ case TDB_ERR_RDONLY: return "write not permitted";
+ }
+ return "Invalid error code";
+}
projects / ccan / blobdiff