tdb2: remove tdb_get()
[ccan] / ccan / tdb2 / hash.c
index 71ede4dbffda9e6a31786a9224d1e5ec16dc042a..f8d6b5812ebfb5307e35f3203dbe0ded9abdbde5 100644 (file)
@@ -42,17 +42,19 @@ uint64_t tdb_hash(struct tdb_context *tdb, const void *ptr, size_t len)
 
 uint64_t hash_record(struct tdb_context *tdb, tdb_off_t off)
 {
-       struct tdb_used_record pad, *r;
+       const struct tdb_used_record *r;
        const void *key;
        uint64_t klen, hash;
 
-       r = tdb_get(tdb, off, &pad, sizeof(pad));
+       r = tdb_access_read(tdb, off, sizeof(*r), true);
        if (!r)
                /* FIXME */
                return 0;
 
        klen = rec_key_length(r);
-       key = tdb_access_read(tdb, off + sizeof(pad), klen, false);
+       tdb_access_release(tdb, r);
+
+       key = tdb_access_read(tdb, off + sizeof(*r), klen, false);
        if (!key)
                return 0;
 
@@ -129,16 +131,24 @@ bool is_subhash(tdb_off_t val)
        return val >> (64-TDB_OFF_UPPER_STEAL) == (1<<TDB_OFF_UPPER_STEAL) - 1;
 }
 
+/* FIXME: Guess the depth, don't over-lock! */
+static tdb_off_t hlock_range(tdb_off_t group, tdb_off_t *size)
+{
+       *size = 1ULL << (64 - (TDB_TOPLEVEL_HASH_BITS - TDB_HASH_GROUP_BITS));
+       return group << (64 - (TDB_TOPLEVEL_HASH_BITS - TDB_HASH_GROUP_BITS));
+}
+
 /* This is the core routine which searches the hashtable for an entry.
  * On error, no locks are held and TDB_OFF_ERR is returned.
- * Otherwise, hinfo is filled in.
+ * Otherwise, hinfo is filled in (and the optional tinfo).
  * If not found, the return value is 0.
  * If found, the return value is the offset, and *rec is the record. */
 tdb_off_t find_and_lock(struct tdb_context *tdb,
                        struct tdb_data key,
                        int ltype,
                        struct hash_info *h,
-                       struct tdb_used_record *rec)
+                       struct tdb_used_record *rec,
+                       struct traverse_info *tinfo)
 {
        uint32_t i, group;
        tdb_off_t hashtable;
@@ -148,16 +158,20 @@ tdb_off_t find_and_lock(struct tdb_context *tdb,
        group = use_bits(h, TDB_TOPLEVEL_HASH_BITS - TDB_HASH_GROUP_BITS);
        h->home_bucket = use_bits(h, TDB_HASH_GROUP_BITS);
 
-       /* FIXME: Guess the depth, don't over-lock! */
-       h->hlock_start = (tdb_off_t)group
-               << (64 - (TDB_TOPLEVEL_HASH_BITS - TDB_HASH_GROUP_BITS));
-       h->hlock_range = 1ULL << (64 - (TDB_TOPLEVEL_HASH_BITS
-                                       - TDB_HASH_GROUP_BITS));
+       h->hlock_start = hlock_range(group, &h->hlock_range);
        if (tdb_lock_hashes(tdb, h->hlock_start, h->hlock_range, ltype,
                            TDB_LOCK_WAIT))
                return TDB_OFF_ERR;
 
        hashtable = offsetof(struct tdb_header, hashtable);
+       if (tinfo) {
+               tinfo->toplevel_group = group;
+               tinfo->num_levels = 1;
+               tinfo->levels[0].entry = 0;
+               tinfo->levels[0].hashtable = hashtable 
+                       + (group << TDB_HASH_GROUP_BITS) * sizeof(tdb_off_t);
+               tinfo->levels[0].total_buckets = 1 << TDB_HASH_GROUP_BITS;
+       }
 
        while (likely(h->hash_used < 64)) {
                /* Read in the hash group. */
@@ -172,9 +186,23 @@ tdb_off_t find_and_lock(struct tdb_context *tdb,
                if (is_subhash(h->group[h->home_bucket])) {
                        hashtable = (h->group[h->home_bucket] & TDB_OFF_MASK)
                                + sizeof(struct tdb_used_record);
+                       if (tinfo) {
+                               /* When we come back, use *next* bucket */
+                               tinfo->levels[tinfo->num_levels-1].entry
+                                       += h->home_bucket + 1;
+                       }
                        group = use_bits(h, TDB_SUBLEVEL_HASH_BITS
                                         - TDB_HASH_GROUP_BITS);
                        h->home_bucket = use_bits(h, TDB_HASH_GROUP_BITS);
+                       if (tinfo) {
+                               tinfo->levels[tinfo->num_levels].hashtable
+                                       = hashtable;
+                               tinfo->levels[tinfo->num_levels].total_buckets
+                                       = 1 << TDB_SUBLEVEL_HASH_BITS;
+                               tinfo->levels[tinfo->num_levels].entry
+                                       = group << TDB_HASH_GROUP_BITS;
+                               tinfo->num_levels++;
+                       }
                        continue;
                }
 
@@ -189,8 +217,14 @@ tdb_off_t find_and_lock(struct tdb_context *tdb,
                        if (!h->group[h->found_bucket])
                                break;
 
-                       if (match(tdb, h, &key, h->group[h->found_bucket], rec))
+                       if (match(tdb, h, &key, h->group[h->found_bucket],
+                                 rec)) {
+                               if (tinfo) {
+                                       tinfo->levels[tinfo->num_levels-1].entry
+                                               += h->found_bucket;
+                               }
                                return h->group[h->found_bucket] & TDB_OFF_MASK;
+                       }
                }
                /* Didn't find it: h indicates where it would go. */
                return 0;
@@ -326,6 +360,7 @@ static int expand_group(struct tdb_context *tdb, struct hash_info *h)
        if (subhash == TDB_OFF_ERR)
                return -1;
 
+       add_stat(tdb, alloc_subhash, 1);
        if (zero_out(tdb, subhash + sizeof(struct tdb_used_record),
                     sizeof(tdb_off_t) << TDB_SUBLEVEL_HASH_BITS) == -1)
                return -1;
@@ -470,17 +505,18 @@ again:
                if (unlikely(val == TDB_OFF_ERR))
                        return TDB_OFF_ERR;
 
+               off = val & TDB_OFF_MASK;
+
                /* This makes the delete-all-in-traverse case work
                 * (and simplifies our logic a little). */
-               if (val == tinfo->prev)
+               if (off == tinfo->prev)
                        continue;
 
                tlevel->entry = i;
-               off = val & TDB_OFF_MASK;
 
                if (!is_subhash(val)) {
                        /* Found one. */
-                       tinfo->prev = val;
+                       tinfo->prev = off;
                        return off;
                }
 
@@ -507,7 +543,7 @@ again:
 /* Return 1 if we find something, 0 if not, -1 on error. */
 int next_in_hash(struct tdb_context *tdb, int ltype,
                 struct traverse_info *tinfo,
-                TDB_DATA *kbuf, unsigned int *dlen)
+                TDB_DATA *kbuf, size_t *dlen)
 {
        const unsigned group_bits = TDB_TOPLEVEL_HASH_BITS-TDB_HASH_GROUP_BITS;
        tdb_off_t hlock_start, hlock_range, off;
@@ -530,6 +566,14 @@ int next_in_hash(struct tdb_context *tdb, int ltype,
                                                  ltype);
                                return -1;
                        }
+                       if (rec_magic(&rec) != TDB_MAGIC) {
+                               tdb->log(tdb, TDB_DEBUG_FATAL, tdb->log_priv,
+                                        "next_in_hash:"
+                                        " corrupt record at %llu\n",
+                                        (long long)off);
+                               return -1;
+                       }
+
                        kbuf->dsize = rec_key_length(&rec);
 
                        /* They want data as well? */
@@ -561,7 +605,7 @@ int next_in_hash(struct tdb_context *tdb, int ltype,
 /* Return 1 if we find something, 0 if not, -1 on error. */
 int first_in_hash(struct tdb_context *tdb, int ltype,
                  struct traverse_info *tinfo,
-                 TDB_DATA *kbuf, unsigned int *dlen)
+                 TDB_DATA *kbuf, size_t *dlen)
 {
        tinfo->prev = 0;
        tinfo->toplevel_group = 0;
@@ -572,3 +616,46 @@ int first_in_hash(struct tdb_context *tdb, int ltype,
 
        return next_in_hash(tdb, ltype, tinfo, kbuf, dlen);
 }
+
+/* Even if the entry isn't in this hash bucket, you'd have to lock this
+ * bucket to find it. */
+static int chainlock(struct tdb_context *tdb, const TDB_DATA *key,
+                    int ltype, enum tdb_lock_flags waitflag,
+                    const char *func)
+{
+       int ret;
+       uint64_t h = tdb_hash(tdb, key->dptr, key->dsize);
+       tdb_off_t lockstart, locksize;
+       unsigned int group, gbits;
+
+       gbits = TDB_TOPLEVEL_HASH_BITS - TDB_HASH_GROUP_BITS;
+       group = bits(h, 64 - gbits, gbits);
+
+       lockstart = hlock_range(group, &locksize);
+
+       ret = tdb_lock_hashes(tdb, lockstart, locksize, ltype, waitflag);
+       tdb_trace_1rec(tdb, func, *key);
+       return ret;
+}
+
+/* lock/unlock one hash chain. This is meant to be used to reduce
+   contention - it cannot guarantee how many records will be locked */
+int tdb_chainlock(struct tdb_context *tdb, TDB_DATA key)
+{
+       return chainlock(tdb, &key, F_WRLCK, TDB_LOCK_WAIT, "tdb_chainlock");
+}
+
+int tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key)
+{
+       uint64_t h = tdb_hash(tdb, key.dptr, key.dsize);
+       tdb_off_t lockstart, locksize;
+       unsigned int group, gbits;
+
+       gbits = TDB_TOPLEVEL_HASH_BITS - TDB_HASH_GROUP_BITS;
+       group = bits(h, 64 - gbits, gbits);
+
+       lockstart = hlock_range(group, &locksize);
+
+       tdb_trace_1rec(tdb, "tdb_chainunlock", key);
+       return tdb_unlock_hashes(tdb, lockstart, locksize, F_WRLCK);
+}