tdb2: more fixes and tests for enlarging hash.
authorRusty Russell <rusty@rustcorp.com.au>
Thu, 26 Aug 2010 14:38:34 +0000 (00:08 +0930)
committerRusty Russell <rusty@rustcorp.com.au>
Thu, 26 Aug 2010 14:38:34 +0000 (00:08 +0930)
- Neaten I/O function
- Don't use fill in zero_out: it's only for low-level ops.
- Don't mangle arg in tdb_write_convert: it broke write_header.
- More use of tdb_access_read, make it optionally converting.
- Rename unlock_range to unlock_lists.
- Lots of fixes to enlarge_hash now it's being tested.
- More expansion cases tested.

ccan/tdb2/check.c
ccan/tdb2/free.c
ccan/tdb2/io.c
ccan/tdb2/private.h
ccan/tdb2/tdb.c
ccan/tdb2/test/run-enlarge_hash.c [new file with mode: 0644]
ccan/tdb2/test/run-expand.c

index ca5479b56d06fbf9650982a6c7b34325b11dc62e..f8abfc1fad4e30f20829e96cb6e557e0630efc45 100644 (file)
@@ -71,8 +71,8 @@ static bool check_header(struct tdb_context *tdb)
            < tdb->map_size) {
                tdb->log(tdb, TDB_DEBUG_ERROR, tdb->log_priv,
                         "check: %llu zones size %llu don't cover %llu\n",
-                        (long long)(1ULL << tdb->header.v.zone_bits),
                         (long long)tdb->header.v.num_zones,
+                        (long long)(1ULL << tdb->header.v.zone_bits),
                         (long long)tdb->map_size);
                return false;
        }
index 134c1ff025bd1263e4cabdfa3147cbf442f1e6dd..f9e81ca4a134e5f9df51a8b096f2dd0ea70f2aac 100644 (file)
@@ -404,20 +404,17 @@ static tdb_off_t huge_alloc(struct tdb_context *tdb, size_t size,
 {
        tdb_off_t i, off;
 
-       do {
-               for (i = 0; i < tdb->header.v.num_zones; i++) {
-                       /* Try getting one from list. */
-                       off = lock_and_alloc(tdb, tdb->header.v.free_buckets,
-                                            size, actual);
-                       if (off == TDB_OFF_ERR)
-                               return TDB_OFF_ERR;
-                       if (off != 0)
-                               return off;
-                       /* FIXME: Coalesce! */
-               }
-       } while (tdb_expand(tdb, 0, size, false) == 0);
-
-       return TDB_OFF_ERR;
+       for (i = 0; i < tdb->header.v.num_zones; i++) {
+               /* Try getting one from list. */
+               off = lock_and_alloc(tdb, tdb->header.v.free_buckets,
+                                    size, actual);
+               if (off == TDB_OFF_ERR)
+                       return TDB_OFF_ERR;
+               if (off != 0)
+                       return off;
+               /* FIXME: Coalesce! */
+       }
+       return 0;
 }
 
 static tdb_off_t get_free(struct tdb_context *tdb, size_t size,
@@ -634,14 +631,15 @@ int tdb_expand(struct tdb_context *tdb, tdb_len_t klen, tdb_len_t dlen,
                /* Increase the zone size. */
                new_num_zones = tdb->header.v.num_zones;
                new_zone_bits = tdb->header.v.zone_bits+1;
-               while ((new_num_zones << new_zone_bits) - tdb->map_size
-                      < needed) {
+               while ((new_num_zones << new_zone_bits)
+                      < tdb->map_size + needed) {
                        new_zone_bits++;
                }
 
-               /* We expand by enough zones to meet the need. */
-               add = (needed + (1ULL << new_zone_bits)-1)
-                       & ~((1ULL << new_zone_bits)-1);
+               /* We expand by enough full zones to meet the need. */
+               add = ((tdb->map_size + needed + (1ULL << new_zone_bits)-1)
+                      & ~((1ULL << new_zone_bits)-1))
+                       - tdb->map_size;
        }
 
        /* Updates tdb->map_size. */
@@ -667,15 +665,17 @@ int tdb_expand(struct tdb_context *tdb, tdb_len_t klen, tdb_len_t dlen,
        old_num_total = tdb->header.v.num_zones*(tdb->header.v.free_buckets+1);
        old_free_off = tdb->header.v.free_off;
        oldf = tdb_access_read(tdb, old_free_off,
-                              old_num_total * sizeof(tdb_off_t));
+                              old_num_total * sizeof(tdb_off_t), true);
        if (!oldf)
                goto fail;
 
        /* Switch to using our new zone. */
-       if (zero_out(tdb, off, new_num_zones * (new_num_buckets + 1)) == -1)
+       if (zero_out(tdb, off, freebucket_size) == -1)
                goto fail_release;
+
        tdb->header.v.free_off = off;
        tdb->header.v.num_zones = new_num_zones;
+       tdb->header.v.zone_bits = new_zone_bits;
        tdb->header.v.free_buckets = new_num_buckets;
 
        /* FIXME: If zone size hasn't changed, can simply copy pointers. */
@@ -704,7 +704,9 @@ int tdb_expand(struct tdb_context *tdb, tdb_len_t klen, tdb_len_t dlen,
        if (tdb_read_convert(tdb, old_free_off, &fhdr, sizeof(fhdr)) == -1)
                goto fail_release;
        if (add_free_record(tdb, old_free_off,
-                           rec_data_length(&fhdr)+rec_extra_padding(&fhdr)))
+                           sizeof(fhdr)
+                           + rec_data_length(&fhdr)
+                           + rec_extra_padding(&fhdr)))
                goto fail_release;
 
        /* Add the rest as a new free record. */
index cdee88aa1fd57321220d121a5bfe381332dc9269..f1cd7e90820d2b71f5baffaf597fad04f3b71244 100644 (file)
@@ -132,19 +132,13 @@ void *tdb_get(struct tdb_context *tdb, tdb_off_t off, void *pad, size_t len)
                if (ret)
                        return ret;
        }
-
-       if (unlikely(tdb_oob(tdb, off + len, false) == -1))
-               return NULL;
-
-       if (tdb->methods->read(tdb, off, pad, len) == -1)
-               return NULL;
-       return tdb_convert(tdb, pad, len);
+       return tdb_read_convert(tdb, off, pad, len) == -1 ? NULL : pad;
 }
 
 /* Endian conversion: we only ever deal with 8 byte quantities */
 void *tdb_convert(const struct tdb_context *tdb, void *buf, tdb_len_t size)
 {
-       if (unlikely((tdb->flags & TDB_CONVERT))) {
+       if (unlikely((tdb->flags & TDB_CONVERT)) && buf) {
                uint64_t i, *p = (uint64_t *)buf;
                for (i = 0; i < size / 8; i++)
                        p[i] = bswap_64(p[i]);
@@ -157,23 +151,19 @@ void *tdb_convert(const struct tdb_context *tdb, void *buf, tdb_len_t size)
 uint64_t tdb_find_nonzero_off(struct tdb_context *tdb, tdb_off_t off,
                              uint64_t num)
 {
-       uint64_t i, *val;
-       bool alloc = false;
-
-       val = tdb_direct(tdb, off, num * sizeof(tdb_off_t));
-       if (!unlikely(val)) {
-               val = tdb_alloc_read(tdb, off, num * sizeof(tdb_off_t));
-               if (!val)
-                       return num;
-               alloc = true;
-       }
+       uint64_t i;
+       const uint64_t *val;
+
+       /* Zero vs non-zero is the same unconverted: minor optimization. */
+       val = tdb_access_read(tdb, off, num * sizeof(tdb_off_t), false);
+       if (!val)
+               return num;
 
        for (i = 0; i < num; i++) {
                if (val[i])
                        break;
        }
-       if (unlikely(alloc))
-               free(val);
+       tdb_access_release(tdb, val);
        return i;
 }
 
@@ -181,55 +171,38 @@ uint64_t tdb_find_nonzero_off(struct tdb_context *tdb, tdb_off_t off,
 uint64_t tdb_find_zero_off(struct tdb_context *tdb, tdb_off_t off,
                           uint64_t num)
 {
-       uint64_t i, *val;
-       bool alloc = false;
-
-       val = tdb_direct(tdb, off, num * sizeof(tdb_off_t));
-       if (!unlikely(val)) {
-               val = tdb_alloc_read(tdb, off, num * sizeof(tdb_off_t));
-               if (!val)
-                       return num;
-               alloc = true;
-       }
+       uint64_t i;
+       const uint64_t *val;
+
+       /* Zero vs non-zero is the same unconverted: minor optimization. */
+       val = tdb_access_read(tdb, off, num * sizeof(tdb_off_t), false);
+       if (!val)
+               return num;
 
        for (i = 0; i < num; i++) {
                if (!val[i])
                        break;
        }
-       if (unlikely(alloc))
-               free(val);
+       tdb_access_release(tdb, val);
        return i;
 }
 
-static int fill(struct tdb_context *tdb,
-               const void *buf, size_t size,
-               tdb_off_t off, tdb_len_t len)
-{
-       while (len) {
-               size_t n = len > size ? size : len;
-
-               if (!tdb_pwrite_all(tdb->fd, buf, n, off)) {
-                       tdb->ecode = TDB_ERR_IO;
-                       tdb->log(tdb, TDB_DEBUG_FATAL, tdb->log_priv,
-                                "fill write failed: giving up!\n");
-                       return -1;
-               }
-               len -= n;
-               off += n;
-       }
-       return 0;
-}
-
 int zero_out(struct tdb_context *tdb, tdb_off_t off, tdb_len_t len)
 {
+       char buf[8192] = { 0 };
        void *p = tdb_direct(tdb, off, len);
        if (p) {
                memset(p, 0, len);
                return 0;
-       } else {
-               char buf[8192] = { 0 };
-               return fill(tdb, buf, sizeof(buf), off, len);
        }
+       while (len) {
+               unsigned todo = len < sizeof(buf) ? len : sizeof(buf);
+               if (tdb->methods->write(tdb, off, buf, todo) == -1)
+                       return -1;
+               len -= todo;
+               off += todo;
+       }
+       return 0;
 }
 
 tdb_off_t tdb_read_off(struct tdb_context *tdb, tdb_off_t off)
@@ -357,9 +330,26 @@ static int tdb_read(struct tdb_context *tdb, tdb_off_t off, void *buf,
 }
 
 int tdb_write_convert(struct tdb_context *tdb, tdb_off_t off,
-                     void *rec, size_t len)
+                     const void *rec, size_t len)
 {
-       return tdb->methods->write(tdb, off, tdb_convert(tdb, rec, len), len);
+       int ret;
+       if (unlikely((tdb->flags & TDB_CONVERT))) {
+               void *conv = malloc(len);
+               if (!conv) {
+                       tdb->ecode = TDB_ERR_OOM;
+                       tdb->log(tdb, TDB_DEBUG_FATAL, tdb->log_priv,
+                                "tdb_write: no memory converting %zu bytes\n",
+                                len);
+                       return -1;
+               }
+               memcpy(conv, rec, len);
+               ret = tdb->methods->write(tdb, off,
+                                         tdb_convert(tdb, conv, len), len);
+               free(conv);
+       } else
+               ret = tdb->methods->write(tdb, off, rec, len);
+
+       return ret;
 }
 
 int tdb_read_convert(struct tdb_context *tdb, tdb_off_t off,
@@ -397,7 +387,7 @@ void *tdb_alloc_read(struct tdb_context *tdb, tdb_off_t offset, tdb_len_t len)
 uint64_t hash_record(struct tdb_context *tdb, tdb_off_t off)
 {
        struct tdb_used_record pad, *r;
-       void *key;
+       const void *key;
        uint64_t klen, hash;
 
        r = tdb_get(tdb, off, &pad, sizeof(pad));
@@ -406,41 +396,32 @@ uint64_t hash_record(struct tdb_context *tdb, tdb_off_t off)
                return 0;
 
        klen = rec_key_length(r);
-       key = tdb_direct(tdb, off + sizeof(pad), klen);
-       if (likely(key))
-               return tdb_hash(tdb, key, klen);
-
-       key = tdb_alloc_read(tdb, off + sizeof(pad), klen);
-       if (unlikely(!key))
+       key = tdb_access_read(tdb, off + sizeof(pad), klen, false);
+       if (!key)
                return 0;
+
        hash = tdb_hash(tdb, key, klen);
-       free(key);
+       tdb_access_release(tdb, key);
        return hash;
 }
 
-/* Give a piece of tdb data to a parser */
-int tdb_parse_data(struct tdb_context *tdb, TDB_DATA key,
-                  tdb_off_t offset, tdb_len_t len,
-                  int (*parser)(TDB_DATA key, TDB_DATA data,
-                                void *private_data),
-                  void *private_data)
+static int fill(struct tdb_context *tdb,
+               const void *buf, size_t size,
+               tdb_off_t off, tdb_len_t len)
 {
-       TDB_DATA data;
-       int result;
-       bool allocated = false;
-
-       data.dsize = len;
-       data.dptr = tdb_direct(tdb, offset, len);
-       if (unlikely(!data.dptr)) {
-               if (!(data.dptr = tdb_alloc_read(tdb, offset, len))) {
+       while (len) {
+               size_t n = len > size ? size : len;
+
+               if (!tdb_pwrite_all(tdb->fd, buf, n, off)) {
+                       tdb->ecode = TDB_ERR_IO;
+                       tdb->log(tdb, TDB_DEBUG_FATAL, tdb->log_priv,
+                                "fill write failed: giving up!\n");
                        return -1;
                }
-               allocated = true;
+               len -= n;
+               off += n;
        }
-       result = parser(key, data, private_data);
-       if (unlikely(allocated))
-               free(data.dptr);
-       return result;
+       return 0;
 }
 
 /* expand a file.  we prefer to use ftruncate, as that is what posix
@@ -484,12 +465,18 @@ static int tdb_expand_file(struct tdb_context *tdb, tdb_len_t addition)
 }
 
 const void *tdb_access_read(struct tdb_context *tdb,
-                           tdb_off_t off, tdb_len_t len)
+                           tdb_off_t off, tdb_len_t len, bool convert)
 {
-       const void *ret = tdb_direct(tdb, off, len);
+       const void *ret = NULL;
 
-       if (!ret)
+       if (likely(!(tdb->flags & TDB_CONVERT)))
+               ret = tdb_direct(tdb, off, len);
+
+       if (!ret) {
                ret = tdb_alloc_read(tdb, off, len);
+               if (convert)
+                       tdb_convert(tdb, (void *)ret, len);
+       }
        return ret;
 }
 
index 86cfd7777bdd7dbcb6c0fdeafa627fe4c01e76e9..d7695cc41d8d06536b247a1d2290d3d51f79d467 100644 (file)
@@ -296,20 +296,13 @@ void *tdb_convert(const struct tdb_context *tdb, void *buf, tdb_len_t size);
 void tdb_munmap(struct tdb_context *tdb);
 void tdb_mmap(struct tdb_context *tdb);
 
-/* Hand data to a function, direct if possible */
-int tdb_parse_data(struct tdb_context *tdb, TDB_DATA key,
-                  tdb_off_t offset, tdb_len_t len,
-                  int (*parser)(TDB_DATA key, TDB_DATA data,
-                                void *private_data),
-                  void *private_data);
-
 /* Either make a copy into pad and return that, or return ptr into mmap.
  * Converts endian (ie. will use pad in that case). */
 void *tdb_get(struct tdb_context *tdb, tdb_off_t off, void *pad, size_t len);
 
 /* Either alloc a copy, or give direct access.  Release frees or noop. */
 const void *tdb_access_read(struct tdb_context *tdb,
-                           tdb_off_t off, tdb_len_t len);
+                           tdb_off_t off, tdb_len_t len, bool convert);
 void tdb_access_release(struct tdb_context *tdb, const void *p);
 
 /* Convenience routine to get an offset. */
@@ -337,9 +330,9 @@ bool tdb_read_all(int fd, void *buf, size_t len);
 /* Allocate and make a copy of some offset. */
 void *tdb_alloc_read(struct tdb_context *tdb, tdb_off_t offset, tdb_len_t len);
 
-/* Munges record and writes it */
+/* Writes a converted copy of a record. */
 int tdb_write_convert(struct tdb_context *tdb, tdb_off_t off,
-                     void *rec, size_t len);
+                     const void *rec, size_t len);
 
 /* Reads record and converts it */
 int tdb_read_convert(struct tdb_context *tdb, tdb_off_t off,
index 61791c9d5b5ca8af9ef22a1f88e07ce8f8bbafc7..7c8d3cd764fc4021f9cfa3d174e6f4d004116edc 100644 (file)
@@ -425,7 +425,7 @@ static tdb_off_t entry_matches(struct tdb_context *tdb,
        if (keylen != key->dsize)
                return TDB_OFF_ERR;
 
-       rkey = tdb_access_read(tdb, off + sizeof(*rec), keylen);
+       rkey = tdb_access_read(tdb, off + sizeof(*rec), keylen, false);
        if (!rkey)
                return TDB_OFF_ERR;
        if (memcmp(rkey, key->dptr, keylen) != 0)
@@ -435,7 +435,7 @@ static tdb_off_t entry_matches(struct tdb_context *tdb,
 }
 
 /* FIXME: Optimize? */
-static void unlock_range(struct tdb_context *tdb,
+static void unlock_lists(struct tdb_context *tdb,
                         tdb_off_t list, tdb_len_t num,
                         int ltype)
 {
@@ -446,7 +446,7 @@ static void unlock_range(struct tdb_context *tdb,
 }
 
 /* FIXME: Optimize? */
-static int lock_range(struct tdb_context *tdb,
+static int lock_lists(struct tdb_context *tdb,
                      tdb_off_t list, tdb_len_t num,
                      int ltype)
 {
@@ -454,7 +454,7 @@ static int lock_range(struct tdb_context *tdb,
 
        for (i = list; i < list + num; i++) {
                if (tdb_lock_list(tdb, i, ltype, TDB_LOCK_WAIT) != 0) {
-                       unlock_range(tdb, list, i - list, ltype);
+                       unlock_lists(tdb, list, i - list, ltype);
                        return -1;
                }
        }
@@ -480,7 +480,7 @@ again:
                if (tdb_lock_list(tdb, 0, ltype, TDB_LOCK_WAIT))
                        return TDB_OFF_ERR;
                len = tdb_find_zero_off(tdb, hash_off(tdb, 0), num);
-               if (lock_range(tdb, 1, len, ltype) == -1) {
+               if (lock_lists(tdb, 1, len, ltype) == -1) {
                        tdb_unlock_list(tdb, 0, ltype);
                        return TDB_OFF_ERR;
                }
@@ -491,9 +491,9 @@ again:
                start++;
                pre_locks = 0;
        }
-       if (unlikely(lock_range(tdb, start, len, ltype) == -1)) {
+       if (unlikely(lock_lists(tdb, start, len, ltype) == -1)) {
                if (pre_locks)
-                       unlock_range(tdb, 0, pre_locks, ltype);
+                       unlock_lists(tdb, 0, pre_locks, ltype);
                else
                        tdb_unlock_list(tdb, start, ltype);
                return TDB_OFF_ERR;
@@ -501,9 +501,9 @@ again:
 
        /* Now, did we lose the race, and it's not zero any more? */
        if (unlikely(tdb_read_off(tdb, hash_off(tdb, pre_locks + len)) != 0)) {
-               unlock_range(tdb, 0, pre_locks, ltype);
+               unlock_lists(tdb, 0, pre_locks, ltype);
                /* Leave the start locked, as expected. */
-               unlock_range(tdb, start + 1, len - 1, ltype);
+               unlock_lists(tdb, start + 1, len - 1, ltype);
                goto again;
        }
 
@@ -529,7 +529,8 @@ static int update_rec_hdr(struct tdb_context *tdb,
 /* If we fail, others will try after us. */
 static void enlarge_hash(struct tdb_context *tdb)
 {
-       tdb_off_t newoff, i;
+       tdb_off_t newoff, oldoff, i;
+       tdb_len_t hlen;
        uint64_t h, num = 1ULL << tdb->header.v.hash_bits;
        struct tdb_used_record pad, *r;
 
@@ -541,26 +542,32 @@ static void enlarge_hash(struct tdb_context *tdb)
        if ((1ULL << tdb->header.v.hash_bits) != num)
                goto unlock;
 
-       newoff = alloc(tdb, 0, num * 2, 0, false);
+       /* Allocate our new array. */
+       hlen = num * sizeof(tdb_off_t) * 2;
+       newoff = alloc(tdb, 0, hlen, 0, false);
        if (unlikely(newoff == TDB_OFF_ERR))
                goto unlock;
        if (unlikely(newoff == 0)) {
-               if (tdb_expand(tdb, 0, num * 2, false) == -1)
+               if (tdb_expand(tdb, 0, hlen, false) == -1)
                        goto unlock;
-               newoff = alloc(tdb, 0, num * 2, 0, false);
+               newoff = alloc(tdb, 0, hlen, 0, false);
                if (newoff == TDB_OFF_ERR || newoff == 0)
                        goto unlock;
        }
+       /* Step over record header! */
+       newoff += sizeof(struct tdb_used_record);
+
+       /* Starts all zero. */
+       if (zero_out(tdb, newoff, hlen) == -1)
+               goto unlock;
 
        /* FIXME: If the space before is empty, we know this is in its ideal
-        * location.  We can steal a bit from the pointer to avoid rehash. */
-       for (i = tdb_find_nonzero_off(tdb, tdb->header.v.hash_off, num);
+        * location.  Or steal a bit from the pointer to avoid rehash. */
+       for (i = tdb_find_nonzero_off(tdb, hash_off(tdb, 0), num);
             i < num;
-            i += tdb_find_nonzero_off(tdb, tdb->header.v.hash_off
-                                      + i*sizeof(tdb_off_t), num - i)) {
+            i += tdb_find_nonzero_off(tdb, hash_off(tdb, i), num - i)) {
                tdb_off_t off;
-               off = tdb_read_off(tdb, tdb->header.v.hash_off
-                                  + i*sizeof(tdb_off_t));
+               off = tdb_read_off(tdb, hash_off(tdb, i));
                if (unlikely(off == TDB_OFF_ERR))
                        goto unlock;
                if (unlikely(!off)) {
@@ -578,18 +585,17 @@ static void enlarge_hash(struct tdb_context *tdb)
        }
 
        /* Free up old hash. */
-       r = tdb_get(tdb, tdb->header.v.hash_off, &pad, sizeof(*r));
+       oldoff = tdb->header.v.hash_off - sizeof(*r);
+       r = tdb_get(tdb, oldoff, &pad, sizeof(*r));
        if (!r)
                goto unlock;
-       add_free_record(tdb, tdb->header.v.hash_off,
-                       rec_data_length(r) + rec_extra_padding(r));
+       add_free_record(tdb, oldoff,
+                       sizeof(*r)+rec_data_length(r)+rec_extra_padding(r));
 
        /* Now we write the modified header. */
-       tdb->header.v.generation++;
        tdb->header.v.hash_bits++;
        tdb->header.v.hash_off = newoff;
-       tdb_write_convert(tdb, offsetof(struct tdb_header, v),
-                         &tdb->header.v, sizeof(tdb->header.v));
+       write_header(tdb);
 unlock:
        tdb_allrecord_unlock(tdb, F_WRLCK);
 }
@@ -667,7 +673,7 @@ int tdb_store(struct tdb_context *tdb,
        /* Allocate a new record. */
        new_off = alloc(tdb, key.dsize, dbuf.dsize, h, growing);
        if (new_off == 0) {
-               unlock_range(tdb, start, num_locks, F_WRLCK);
+               unlock_lists(tdb, start, num_locks, F_WRLCK);
                /* Expand, then try again... */
                if (tdb_expand(tdb, key.dsize, dbuf.dsize, growing) == -1)
                        return -1;
@@ -695,7 +701,7 @@ write:
                goto fail;
 
        /* FIXME: tdb_increment_seqnum(tdb); */
-       unlock_range(tdb, start, num_locks, F_WRLCK);
+       unlock_lists(tdb, start, num_locks, F_WRLCK);
 
        /* FIXME: by simple simulation, this approximated 60% full.
         * Check in real case! */
@@ -705,7 +711,7 @@ write:
        return 0;
 
 fail:
-       unlock_range(tdb, start, num_locks, F_WRLCK);
+       unlock_lists(tdb, start, num_locks, F_WRLCK);
        return -1;
 }
 
@@ -745,7 +751,7 @@ struct tdb_data tdb_fetch(struct tdb_context *tdb, struct tdb_data key)
        }
 
        if (!off) {
-               unlock_range(tdb, start, num_locks, F_RDLCK);
+               unlock_lists(tdb, start, num_locks, F_RDLCK);
                tdb->ecode = TDB_ERR_NOEXIST;
                return tdb_null;
        }
@@ -753,7 +759,7 @@ struct tdb_data tdb_fetch(struct tdb_context *tdb, struct tdb_data key)
        ret.dsize = rec_data_length(&rec);
        ret.dptr = tdb_alloc_read(tdb, off + sizeof(rec) + key.dsize,
                                  ret.dsize);
-       unlock_range(tdb, start, num_locks, F_RDLCK);
+       unlock_lists(tdb, start, num_locks, F_RDLCK);
        return ret;
 }
 
@@ -831,7 +837,7 @@ int tdb_delete(struct tdb_context *tdb, struct tdb_data key)
        }
 
        if (!off) {
-               unlock_range(tdb, start, num_locks, F_WRLCK);
+               unlock_lists(tdb, start, num_locks, F_WRLCK);
                tdb->ecode = TDB_ERR_NOEXIST;
                return -1;
        }
@@ -875,11 +881,11 @@ delete:
                            + rec_extra_padding(&rec)) != 0)
                goto unlock_err;
 
-       unlock_range(tdb, start, num_locks, F_WRLCK);
+       unlock_lists(tdb, start, num_locks, F_WRLCK);
        return 0;
 
 unlock_err:
-       unlock_range(tdb, start, num_locks, F_WRLCK);
+       unlock_lists(tdb, start, num_locks, F_WRLCK);
        return -1;
 }
 
diff --git a/ccan/tdb2/test/run-enlarge_hash.c b/ccan/tdb2/test/run-enlarge_hash.c
new file mode 100644 (file)
index 0000000..10ded59
--- /dev/null
@@ -0,0 +1,30 @@
+#include <ccan/tdb2/tdb.c>
+#include <ccan/tdb2/free.c>
+#include <ccan/tdb2/lock.c>
+#include <ccan/tdb2/io.c>
+#include <ccan/tdb2/check.c>
+#include <ccan/tap/tap.h>
+#include "logging.h"
+
+int main(int argc, char *argv[])
+{
+       unsigned int i;
+       struct tdb_context *tdb;
+       int flags[] = { TDB_INTERNAL, TDB_DEFAULT,
+                       TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT };
+
+       plan_tests(sizeof(flags) / sizeof(flags[0]) * 2 + 1);
+       for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
+               tdb = tdb_open("/tmp/run-new_database.tdb", flags[i],
+                              O_RDWR|O_CREAT|O_TRUNC, 0600, NULL);
+               tdb->log = tap_log_fn;
+               ok1(tdb);
+               if (tdb) {
+                       enlarge_hash(tdb);
+                       ok1(tdb_check(tdb, NULL, NULL) == 0);
+                       tdb_close(tdb);
+               }
+       }
+       ok1(tap_log_messages == 0);
+       return exit_status();
+}
index 92dbf1808cf72999f9968f855b69fbdfa828f98a..ef2955cba9713593d0c13e87fe05a36430e544fe 100644 (file)
@@ -13,14 +13,24 @@ int main(int argc, char *argv[])
        int flags[] = { TDB_INTERNAL, TDB_DEFAULT,
                        TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT };
 
-       plan_tests(sizeof(flags) / sizeof(flags[0]) * 3 + 1);
+       plan_tests(sizeof(flags) / sizeof(flags[0]) * 10 + 1);
        for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
                tdb = tdb_open("/tmp/run-new_database.tdb", flags[i],
                               O_RDWR|O_CREAT|O_TRUNC, 0600, NULL);
                tdb->log = tap_log_fn;
                ok1(tdb);
                if (tdb) {
+                       /* First expand (expand file to fill zone). */
                        ok1(tdb_expand(tdb, 1, 1, false) == 0);
+                       ok1(tdb->header.v.num_zones == 1);
+                       ok1(tdb_check(tdb, NULL, NULL) == 0);
+                       /* Little expand (extra zone). */
+                       ok1(tdb_expand(tdb, 1, 1, false) == 0);
+                       ok1(tdb->header.v.num_zones == 2);
+                       ok1(tdb_check(tdb, NULL, NULL) == 0);
+                       /* Big expand (enlarge zones) */
+                       ok1(tdb_expand(tdb, 1, 4096, false) == 0);
+                       ok1(tdb->header.v.num_zones == 2);
                        ok1(tdb_check(tdb, NULL, NULL) == 0);
                        tdb_close(tdb);
                }