X-Git-Url: http://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Ftdb2%2Ftdb.c;h=bd5c268173dcda9b11e1889957b64274c03773d9;hp=e3b3c2303f282ae387eec8171a3327f4d8864a29;hb=afc3c1e723b4eca0b32f7c5b656f5b070eb1c9fb;hpb=a40b318e7a07a452ae7456053727bd11b2fa49b4 diff --git a/ccan/tdb2/tdb.c b/ccan/tdb2/tdb.c index e3b3c230..bd5c2681 100644 --- a/ccan/tdb2/tdb.c +++ b/ccan/tdb2/tdb.c @@ -80,17 +80,7 @@ static uint64_t random_number(struct tdb_context *tdb) struct new_database { struct tdb_header hdr; - /* 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! */ + struct tdb_freelist flist; }; /* initialise a new database */ @@ -100,10 +90,7 @@ static int tdb_new_database(struct tdb_context *tdb, { /* 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; @@ -116,30 +103,17 @@ static int tdb_new_database(struct tdb_context *tdb, sizeof(newdb.hdr.hash_test), newdb.hdr.hash_seed, tdb->hash_priv); + newdb.hdr.recovery = 0; memset(newdb.hdr.reserved, 0, sizeof(newdb.hdr.reserved)); /* Initial hashes are empty. */ memset(newdb.hdr.hashtable, 0, sizeof(newdb.hdr.hashtable)); - /* Free is mostly 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; + /* Free is empty. */ + newdb.hdr.free_list = offsetof(struct new_database, flist); + memset(&newdb.flist, 0, sizeof(newdb.flist)); + set_used_header(NULL, &newdb.flist.hdr, 0, + sizeof(newdb.flist) - sizeof(newdb.flist.hdr), + sizeof(newdb.flist) - sizeof(newdb.flist.hdr), 1); /* Magic food */ memset(newdb.hdr.magic_food, 0, sizeof(newdb.hdr.magic_food)); @@ -148,13 +122,12 @@ static int tdb_new_database(struct tdb_context *tdb, /* 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; @@ -169,7 +142,7 @@ static int tdb_new_database(struct tdb_context *tdb, 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; } @@ -204,8 +177,8 @@ struct tdb_context *tdb_open(const char *name, int tdb_flags, tdb->log = null_log_fn; tdb->log_priv = NULL; tdb->transaction = NULL; + tdb->stats = NULL; tdb_hash_init(tdb); - /* last_zone will be set below. */ tdb_io_init(tdb); tdb_lock_init(tdb); @@ -222,6 +195,12 @@ struct tdb_context *tdb_open(const char *name, int tdb_flags, case TDB_ATTRIBUTE_SEED: seed = &attr->seed; break; + case TDB_ATTRIBUTE_STATS: + tdb->stats = &attr->stats; + /* They have stats we don't know about? Tell them. */ + if (tdb->stats->size > sizeof(attr->stats)) + tdb->stats->size = sizeof(attr->stats); + break; default: tdb->log(tdb, TDB_DEBUG_ERROR, tdb->log_priv, "tdb_open: unknown attribute type %u\n", @@ -259,7 +238,7 @@ struct tdb_context *tdb_open(const char *name, int tdb_flags, } tdb_convert(tdb, &hdr.hash_seed, sizeof(hdr.hash_seed)); tdb->hash_seed = hdr.hash_seed; - tdb_zone_init(tdb); + tdb_flist_init(tdb); return tdb; } @@ -275,7 +254,7 @@ struct tdb_context *tdb_open(const char *name, int tdb_flags, fcntl(tdb->fd, F_SETFD, v | FD_CLOEXEC); /* ensure there is only one process initialising at once */ - if (tdb_lock_open(tdb) == -1) { + if (tdb_lock_open(tdb, TDB_LOCK_WAIT|TDB_LOCK_NOCHECK) == -1) { tdb->log(tdb, TDB_DEBUG_ERROR, tdb->log_priv, "tdb_open: failed to get open lock on %s: %s\n", name, strerror(errno)); @@ -343,8 +322,13 @@ struct tdb_context *tdb_open(const char *name, int tdb_flags, /* This make sure we have current map_size and mmap. */ tdb->methods->oob(tdb, tdb->map_size + 1, true); - /* Now we can pick a random free zone to start from. */ - if (tdb_zone_init(tdb) == -1) + /* Now it's fully formed, recover if necessary. */ + if (tdb_needs_recovery(tdb) && tdb_lock_and_recover(tdb) == -1) { + errno = EIO; + goto fail; + } + + if (tdb_flist_init(tdb) == -1) goto fail; tdb->next = tdbs; @@ -387,8 +371,7 @@ static int update_rec_hdr(struct tdb_context *tdb, { uint64_t dataroom = rec_data_length(rec) + rec_extra_padding(rec); - if (set_header(tdb, rec, keylen, datalen, keylen + dataroom, h, - rec_zone_bits(rec))) + if (set_used_header(tdb, rec, keylen, datalen, keylen + dataroom, h)) return -1; return tdb_write_convert(tdb, off, rec, sizeof(*rec)); @@ -399,7 +382,6 @@ static int replace_data(struct tdb_context *tdb, struct hash_info *h, struct tdb_data key, struct tdb_data dbuf, tdb_off_t old_off, tdb_len_t old_room, - unsigned old_zone, bool growing) { tdb_off_t new_off; @@ -411,7 +393,8 @@ static int replace_data(struct tdb_context *tdb, /* We didn't like the existing one: remove it. */ if (old_off) { - add_free_record(tdb, old_zone, old_off, + add_stat(tdb, frees, 1); + add_free_record(tdb, old_off, sizeof(struct tdb_used_record) + key.dsize + old_room); if (replace_in_hash(tdb, h, new_off) == -1) @@ -483,8 +466,7 @@ int tdb_store(struct tdb_context *tdb, } /* If we didn't use the old record, this implies we're growing. */ - ret = replace_data(tdb, &h, key, dbuf, off, old_room, - rec_zone_bits(&rec), off != 0); + ret = replace_data(tdb, &h, key, dbuf, off, old_room, off != 0); tdb_unlock_hashes(tdb, h.hlock_start, h.hlock_range, F_WRLCK); return ret; @@ -553,8 +535,7 @@ int tdb_append(struct tdb_context *tdb, } /* If they're using tdb_append(), it implies they're growing record. */ - ret = replace_data(tdb, &h, key, new_dbuf, off, - old_room, rec_zone_bits(&rec), true); + ret = replace_data(tdb, &h, key, new_dbuf, off, old_room, true); tdb_unlock_hashes(tdb, h.hlock_start, h.hlock_range, F_WRLCK); free(newdata); @@ -609,7 +590,8 @@ int tdb_delete(struct tdb_context *tdb, struct tdb_data key) goto unlock_err; /* Free the deleted entry. */ - if (add_free_record(tdb, rec_zone_bits(&rec), off, + add_stat(tdb, frees, 1); + if (add_free_record(tdb, off, sizeof(struct tdb_used_record) + rec_key_length(&rec) + rec_data_length(&rec) @@ -629,12 +611,11 @@ int tdb_close(struct tdb_context *tdb) struct tdb_context **i; int ret = 0; - /* FIXME: + tdb_trace(tdb, "tdb_close"); + if (tdb->transaction) { tdb_transaction_cancel(tdb); } - */ - tdb_trace(tdb, "tdb_close"); if (tdb->map_ptr) { if (tdb->flags & TDB_INTERNAL)