tdb2: fix tdb_summary reports

[ccan] / ccan / tdb2 / check.c

diff --git a/ccan/tdb2/check.c b/ccan/tdb2/check.c
index b602d80d64777030aeb08fab853b1df9561561d2..ab6621ea85b4596aa192c3b53a9dc1aab73de366 100644 (file)
--- a/ccan/tdb2/check.c
+++ b/ccan/tdb2/check.c
@@ -72,7 +72,8 @@ static enum TDB_ERROR check_header(struct tdb_context *tdb, tdb_off_t *recovery,
        *features = hdr.features_offered;
        *recovery = hdr.recovery;
        if (*recovery) {
-               if (*recovery < sizeof(hdr) || *recovery > tdb->map_size) {
+               if (*recovery < sizeof(hdr)
+                   || *recovery > tdb->file->map_size) {
                        return tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
                                          "tdb_check:"
                                          " invalid recovery offset %zu",
@@ -401,22 +402,26 @@ static enum TDB_ERROR check_hash_tree(struct tdb_context *tdb,
                check:
                        if (check) {
                                TDB_DATA key, data;
-                               key.dsize = rec_key_length(&rec);
-                               data.dsize = rec_data_length(&rec);
-                               key.dptr = (void *)tdb_access_read(tdb,
-                                                  off + sizeof(rec),
-                                                  key.dsize + data.dsize,
-                                                  false);
-                               if (TDB_PTR_IS_ERR(key.dptr)) {
-                                       ecode = TDB_PTR_ERR(key.dptr);
+                               const unsigned char *kptr;
+
+                               kptr = tdb_access_read(tdb,
+                                                      off + sizeof(rec),
+                                                      rec_key_length(&rec)
+                                                      + rec_data_length(&rec),
+                                                      false);
+                               if (TDB_PTR_IS_ERR(kptr)) {
+                                       ecode = TDB_PTR_ERR(kptr);
                                        goto fail;
                                }
-                               data.dptr = key.dptr + key.dsize;
+
+                               key = tdb_mkdata(kptr, rec_key_length(&rec));
+                               data = tdb_mkdata(kptr + key.dsize,
+                                                 rec_data_length(&rec));
                                ecode = check(key, data, private_data);
+                               tdb_access_release(tdb, kptr);
                                if (ecode != TDB_SUCCESS) {
                                        goto fail;
                                }
-                               tdb_access_release(tdb, key.dptr);
                        }
                }
        }
@@ -487,7 +492,7 @@ static enum TDB_ERROR check_free(struct tdb_context *tdb,
                                  (long long)off,
                                  bucket, size_to_bucket(frec_len(frec)));
        }
-       if (prev != frec_prev(frec)) {
+       if (prev && prev != frec_prev(frec)) {
                return tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
                                  "tdb_check: offset %llu bad prev"
                                  " (%llu vs %llu)",
@@ -523,11 +528,13 @@ static enum TDB_ERROR check_free_table(struct tdb_context *tdb,
        }
 
        for (i = 0; i < TDB_FREE_BUCKETS; i++) {
-               tdb_off_t off, prev = 0, *p;
+               tdb_off_t off, prev = 0, *p, first = 0;
                struct tdb_free_record f;
 
                h = bucket_off(ftable_off, i);
                for (off = tdb_read_off(tdb, h); off; off = f.next) {
+                       if (!first)
+                               first = off;
                        if (TDB_OFF_IS_ERR(off)) {
                                return off;
                        }
@@ -554,6 +561,18 @@ static enum TDB_ERROR check_free_table(struct tdb_context *tdb,
                        (*num_found)++;
                        prev = off;
                }
+
+               if (first) {
+                       /* Now we can check first back pointer. */
+                       ecode = tdb_read_convert(tdb, first, &f, sizeof(f));
+                       if (ecode != TDB_SUCCESS) {
+                               return ecode;
+                       }
+                       ecode = check_free(tdb, first, &f, prev, ftable_num, i);
+                       if (ecode != TDB_SUCCESS) {
+                               return ecode;
+                       }
+               }
        }
        return TDB_SUCCESS;
 }
@@ -564,7 +583,7 @@ tdb_off_t dead_space(struct tdb_context *tdb, tdb_off_t off)
        size_t len;
        enum TDB_ERROR ecode;
 
-       for (len = 0; off + len < tdb->map_size; len++) {
+       for (len = 0; off + len < tdb->file->map_size; len++) {
                char c;
                ecode = tdb->methods->tread(tdb, off, &c, 1);
                if (ecode != TDB_SUCCESS) {
@@ -586,7 +605,9 @@ static enum TDB_ERROR check_linear(struct tdb_context *tdb,
        enum TDB_ERROR ecode;
        bool found_recovery = false;
 
-       for (off = sizeof(struct tdb_header); off < tdb->map_size; off += len) {
+       for (off = sizeof(struct tdb_header);
+            off < tdb->file->map_size;
+            off += len) {
                union {
                        struct tdb_used_record u;
                        struct tdb_free_record f;
@@ -624,7 +645,7 @@ static enum TDB_ERROR check_linear(struct tdb_context *tdb,
                                tdb_logerr(tdb, TDB_SUCCESS, TDB_LOG_WARNING,
                                           "Dead space at %zu-%zu (of %zu)",
                                           (size_t)off, (size_t)(off + len),
-                                          (size_t)tdb->map_size);
+                                          (size_t)tdb->file->map_size);
                        }
                } else if (rec.r.magic == TDB_RECOVERY_MAGIC) {
                        ecode = tdb_read_convert(tdb, off, &rec, sizeof(rec.r));
@@ -646,7 +667,7 @@ static enum TDB_ERROR check_linear(struct tdb_context *tdb,
                                                  " length %zu",
                                                  (size_t)rec.r.len);
                        }
-                       if (rec.r.eof > tdb->map_size) {
+                       if (rec.r.eof > tdb->file->map_size) {
                                return tdb_logerr(tdb, TDB_ERR_CORRUPT,
                                                  TDB_LOG_ERROR,
                                                  "tdb_check: invalid old EOF"
@@ -656,7 +677,7 @@ static enum TDB_ERROR check_linear(struct tdb_context *tdb,
                        len = sizeof(rec.r) + rec.r.max_len;
                } else if (frec_magic(&rec.f) == TDB_FREE_MAGIC) {
                        len = sizeof(rec.u) + frec_len(&rec.f);
-                       if (off + len > tdb->map_size) {
+                       if (off + len > tdb->file->map_size) {
                                return tdb_logerr(tdb, TDB_ERR_CORRUPT,
                                                  TDB_LOG_ERROR,
                                                  "tdb_check: free overlength"
@@ -691,7 +712,7 @@ static enum TDB_ERROR check_linear(struct tdb_context *tdb,
                        extra = rec_extra_padding(&rec.u);
 
                        len = sizeof(rec.u) + klen + dlen + extra;
-                       if (off + len > tdb->map_size) {
+                       if (off + len > tdb->file->map_size) {
                                return tdb_logerr(tdb, TDB_ERR_CORRUPT,
                                                  TDB_LOG_ERROR,
                                                  "tdb_check: used overlength"
@@ -752,8 +773,8 @@ static enum TDB_ERROR check_linear(struct tdb_context *tdb,
 
 enum TDB_ERROR tdb_check_(struct tdb_context *tdb,
                          enum TDB_ERROR (*check)(TDB_DATA key, TDB_DATA data,
-                                                 void *private),
-                         void *private)
+                                                 void *private_data),
+                         void *private_data)
 {
        tdb_off_t *fr = NULL, *used = NULL, ft, recovery;
        size_t num_free = 0, num_used = 0, num_found = 0, num_ftables = 0;
@@ -762,13 +783,13 @@ enum TDB_ERROR tdb_check_(struct tdb_context *tdb,
 
        ecode = tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false);
        if (ecode != TDB_SUCCESS) {
-               return ecode;
+               return tdb->last_error = ecode;
        }
 
        ecode = tdb_lock_expand(tdb, F_RDLCK);
        if (ecode != TDB_SUCCESS) {
                tdb_allrecord_unlock(tdb, F_RDLCK);
-               return ecode;
+               return tdb->last_error = ecode;
        }
 
        ecode = check_header(tdb, &recovery, &features);
@@ -794,7 +815,8 @@ enum TDB_ERROR tdb_check_(struct tdb_context *tdb,
        }
 
        /* FIXME: Check key uniqueness? */
-       ecode = check_hash(tdb, used, num_used, num_ftables, check, private);
+       ecode = check_hash(tdb, used, num_used, num_ftables, check,
+                          private_data);
        if (ecode != TDB_SUCCESS)
                goto out;
 
@@ -809,5 +831,5 @@ out:
        tdb_unlock_expand(tdb, F_RDLCK);
        free(fr);
        free(used);
-       return ecode;
+       return tdb->last_error = ecode;
 }