tdb2: rework some io.c functions to return enum TDB_ERROR.

[ccan] / ccan / tdb2 / check.c

diff --git a/ccan/tdb2/check.c b/ccan/tdb2/check.c
index 41acae4e9de3aa13616fadfdd6e6696c1030849f..2b7576e6a27b65d07da9cad0a64e199c165a92a6 100644 (file)
--- a/ccan/tdb2/check.c
+++ b/ccan/tdb2/check.c
@@ -34,9 +34,13 @@ static bool check_header(struct tdb_context *tdb, tdb_off_t *recovery)
 {
        uint64_t hash_test;
        struct tdb_header hdr;
+       enum TDB_ERROR ecode;
 
-       if (tdb_read_convert(tdb, 0, &hdr, sizeof(hdr)) == -1)
+       ecode = tdb_read_convert(tdb, 0, &hdr, sizeof(hdr));
+       if (ecode != TDB_SUCCESS) {
+               tdb->ecode = ecode;
                return false;
+       }
        /* magic food should not be converted, so convert back. */
        tdb_convert(tdb, hdr.magic_food, sizeof(hdr.magic_food));
 
@@ -91,9 +95,13 @@ static bool check_hash_chain(struct tdb_context *tdb,
                             void *private_data)
 {
        struct tdb_used_record rec;
+       enum TDB_ERROR ecode;
 
-       if (tdb_read_convert(tdb, off, &rec, sizeof(rec)) == -1)
+       ecode = tdb_read_convert(tdb, off, &rec, sizeof(rec));
+       if (ecode != TDB_SUCCESS) {
+               tdb->ecode = ecode;
                return false;
+       }
 
        if (rec_magic(&rec) != TDB_CHAIN_MAGIC) {
                tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
@@ -148,13 +156,17 @@ static bool check_hash_record(struct tdb_context *tdb,
                              void *private_data)
 {
        struct tdb_used_record rec;
+       enum TDB_ERROR ecode;
 
        if (hprefix_bits >= 64)
                return check_hash_chain(tdb, off, hprefix, used, num_used,
                                        num_found, check, private_data);
 
-       if (tdb_read_convert(tdb, off, &rec, sizeof(rec)) == -1)
+       ecode = tdb_read_convert(tdb, off, &rec, sizeof(rec));
+       if (ecode != TDB_SUCCESS) {
+               tdb->ecode = ecode;
                return false;
+       }
 
        if (rec_magic(&rec) != TDB_HTABLE_MAGIC) {
                tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
@@ -219,6 +231,7 @@ static bool check_hash_tree(struct tdb_context *tdb,
        unsigned int g, b;
        const tdb_off_t *hash;
        struct tdb_used_record rec;
+       enum TDB_ERROR ecode;
 
        hash = tdb_access_read(tdb, off,
                               sizeof(tdb_off_t)
@@ -269,9 +282,12 @@ static bool check_hash_tree(struct tdb_context *tdb,
                                                   (long long)hprefix);
                                        goto fail;
                                }
-                               if (tdb_read_convert(tdb, off, &rec,
-                                                    sizeof(rec)))
+                               ecode = tdb_read_convert(tdb, off, &rec,
+                                                        sizeof(rec));
+                               if (ecode != TDB_SUCCESS) {
+                                       tdb->ecode = ecode;
                                        goto fail;
+                               }
                                goto check;
                        }
 
@@ -346,8 +362,11 @@ static bool check_hash_tree(struct tdb_context *tdb,
                                }
                        }
 
-                       if (tdb_read_convert(tdb, off, &rec, sizeof(rec)))
+                       ecode = tdb_read_convert(tdb, off, &rec, sizeof(rec));
+                       if (ecode != TDB_SUCCESS) {
+                               tdb->ecode = ecode;
                                goto fail;
+                       }
 
                        /* Bottom bits must match header. */
                        if ((h & ((1 << 11)-1)) != rec_hash(&rec)) {
@@ -416,6 +435,8 @@ static bool check_free(struct tdb_context *tdb,
                       tdb_off_t prev, unsigned int ftable,
                       unsigned int bucket)
 {
+       enum TDB_ERROR ecode;
+
        if (frec_magic(frec) != TDB_FREE_MAGIC) {
                tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
                           "tdb_check: offset %llu bad magic 0x%llx",
@@ -429,10 +450,14 @@ static bool check_free(struct tdb_context *tdb,
                return false;
        }
 
-       if (tdb->methods->oob(tdb, off
-                             + frec_len(frec) + sizeof(struct tdb_used_record),
-                             false))
+       ecode = tdb->methods->oob(tdb, off
+                                 + frec_len(frec)
+                                 + sizeof(struct tdb_used_record),
+                                 false);
+       if (ecode != TDB_SUCCESS) {
+               tdb->ecode = ecode;
                return false;
+       }
        if (size_to_bucket(frec_len(frec)) != bucket) {
                tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
                           "tdb_check: offset %llu in wrong bucket %u vs %u",
@@ -460,9 +485,13 @@ static bool check_free_table(struct tdb_context *tdb,
        struct tdb_freetable ft;
        tdb_off_t h;
        unsigned int i;
+       enum TDB_ERROR ecode;
 
-       if (tdb_read_convert(tdb, ftable_off, &ft, sizeof(ft)) == -1)
+       ecode = tdb_read_convert(tdb, ftable_off, &ft, sizeof(ft));
+       if (ecode != TDB_SUCCESS) {
+               tdb->ecode = ecode;
                return false;
+       }
 
        if (rec_magic(&ft.hdr) != TDB_FTABLE_MAGIC
            || rec_key_length(&ft.hdr) != 0
@@ -481,8 +510,11 @@ static bool check_free_table(struct tdb_context *tdb,
                for (off = tdb_read_off(tdb, h); off; off = f.next) {
                        if (off == TDB_OFF_ERR)
                                return false;
-                       if (tdb_read_convert(tdb, off, &f, sizeof(f)))
+                       ecode = tdb_read_convert(tdb, off, &f, sizeof(f));
+                       if (ecode != TDB_SUCCESS) {
+                               tdb->ecode = ecode;
                                return false;
+                       }
                        if (!check_free(tdb, off, &f, prev, ftable_num, i))
                                return false;
 
@@ -509,11 +541,15 @@ static bool check_free_table(struct tdb_context *tdb,
 size_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++) {
                char c;
-               if (tdb->methods->tread(tdb, off, &c, 1))
+               ecode = tdb->methods->tread(tdb, off, &c, 1);
+               if (ecode != TDB_SUCCESS) {
+                       tdb->ecode = ecode;
                        return 0;
+               }
                if (c != 0 && c != 0x43)
                        break;
        }
@@ -527,6 +563,7 @@ static bool check_linear(struct tdb_context *tdb,
 {
        tdb_off_t off;
        tdb_len_t len;
+       enum TDB_ERROR ecode;
        bool found_recovery = false;
 
        for (off = sizeof(struct tdb_header); off < tdb->map_size; off += len) {
@@ -536,15 +573,20 @@ static bool check_linear(struct tdb_context *tdb,
                        struct tdb_recovery_record r;
                } rec;
                /* r is larger: only get that if we need to. */
-               if (tdb_read_convert(tdb, off, &rec, sizeof(rec.f)) == -1)
+               ecode = tdb_read_convert(tdb, off, &rec, sizeof(rec.f));
+               if (ecode != TDB_SUCCESS) {
+                       tdb->ecode = ecode;
                        return false;
+               }
 
                /* If we crash after ftruncate, we can get zeroes or fill. */
                if (rec.r.magic == TDB_RECOVERY_INVALID_MAGIC
                    || rec.r.magic ==  0x4343434343434343ULL) {
-                       if (tdb_read_convert(tdb, off, &rec, sizeof(rec.r)))
+                       ecode = tdb_read_convert(tdb, off, &rec, sizeof(rec.r));
+                       if (ecode != TDB_SUCCESS) {
+                               tdb->ecode = ecode;
                                return false;
-
+                       }
                        if (recovery == off) {
                                found_recovery = true;
                                len = sizeof(rec.r) + rec.r.max_len;
@@ -565,8 +607,11 @@ static bool check_linear(struct tdb_context *tdb,
                                           (size_t)tdb->map_size);
                        }
                } else if (rec.r.magic == TDB_RECOVERY_MAGIC) {
-                       if (tdb_read_convert(tdb, off, &rec, sizeof(rec.r)))
+                       ecode = tdb_read_convert(tdb, off, &rec, sizeof(rec.r));
+                       if (ecode != TDB_SUCCESS) {
+                               tdb->ecode = ecode;
                                return false;
+                       }
                        if (recovery != off) {
                                tdb_logerr(tdb, TDB_ERR_CORRUPT,
                                           TDB_LOG_ERROR,
@@ -673,11 +718,17 @@ int tdb_check(struct tdb_context *tdb,
 {
        tdb_off_t *fr = NULL, *used = NULL, ft, recovery;
        size_t num_free = 0, num_used = 0, num_found = 0, num_ftables = 0;
+       enum TDB_ERROR ecode;
 
-       if (tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false) != 0)
+       ecode = tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false);
+       if (ecpde != TDB_SUCCESS) {
+               tdb->ecode = ecode;
                return -1;
+       }
 
-       if (tdb_lock_expand(tdb, F_RDLCK) != 0) {
+       ecode = tdb_lock_expand(tdb, F_RDLCK);
+       if (ecode != TDB_SUCCESS) {
+               tdb->ecode = ecode;
                tdb_allrecord_unlock(tdb, F_RDLCK);
                return -1;
        }