tdb2: rework free.c functions to return enum TDB_ERROR.
[ccan] / ccan / tdb2 / free.c
index 897d3cbe4627eaf69c9bf985a53608741b045fe5..97320b585d727d82796e725ef97d1f71e3461e30 100644 (file)
@@ -59,7 +59,7 @@ tdb_off_t next_ftable(struct tdb_context *tdb, tdb_off_t ftable)
        return tdb_read_off(tdb, ftable + offsetof(struct tdb_freetable,next));
 }
 
-int tdb_ftable_init(struct tdb_context *tdb)
+enum TDB_ERROR tdb_ftable_init(struct tdb_context *tdb)
 {
        /* Use reservoir sampling algorithm to select a free list at random. */
        unsigned int rnd, max = 0, count = 0;
@@ -70,8 +70,7 @@ int tdb_ftable_init(struct tdb_context *tdb)
 
        while (off) {
                if (TDB_OFF_IS_ERR(off)) {
-                       tdb->ecode = off;
-                       return -1;
+                       return off;
                }
 
                rnd = random();
@@ -84,7 +83,7 @@ int tdb_ftable_init(struct tdb_context *tdb)
                off = next_ftable(tdb, off);
                count++;
        }
-       return 0;
+       return TDB_SUCCESS;
 }
 
 /* Offset of a given bucket. */
@@ -105,9 +104,9 @@ static tdb_off_t find_free_head(struct tdb_context *tdb,
 }
 
 /* Remove from free bucket. */
-static int remove_from_list(struct tdb_context *tdb,
-                           tdb_off_t b_off, tdb_off_t r_off,
-                           const struct tdb_free_record *r)
+static enum TDB_ERROR remove_from_list(struct tdb_context *tdb,
+                                      tdb_off_t b_off, tdb_off_t r_off,
+                                      const struct tdb_free_record *r)
 {
        tdb_off_t off;
        enum TDB_ERROR ecode;
@@ -121,18 +120,17 @@ static int remove_from_list(struct tdb_context *tdb,
 
 #ifdef CCAN_TDB2_DEBUG
        if (tdb_read_off(tdb, off) != r_off) {
-               tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
-                        "remove_from_list: %llu bad prev in list %llu",
-                        (long long)r_off, (long long)b_off);
-               return -1;
+               return tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+                                 "remove_from_list:"
+                                 " %llu bad prev in list %llu",
+                                 (long long)r_off, (long long)b_off);
        }
 #endif
 
        /* r->prev->next = r->next */
        ecode = tdb_write_off(tdb, off, r->next);
        if (ecode != TDB_SUCCESS) {
-               tdb->ecode = ecode;
-               return -1;
+               return ecode;
        }
 
        if (r->next != 0) {
@@ -141,27 +139,26 @@ static int remove_from_list(struct tdb_context *tdb,
 
 #ifdef CCAN_TDB2_DEBUG
                if (tdb_read_off(tdb, off) & TDB_OFF_MASK != r_off) {
-                       tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
-                                  "remove_from_list: %llu bad list %llu",
-                                  (long long)r_off, (long long)b_off);
-                       return -1;
+                       return tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+                                         "remove_from_list:"
+                                         " %llu bad list %llu",
+                                         (long long)r_off, (long long)b_off);
                }
 #endif
 
                ecode = tdb_write_off(tdb, off, r->magic_and_prev);
                if (ecode != TDB_SUCCESS) {
-                       tdb->ecode = ecode;
-                       return -1;
+                       return ecode;
                }
        }
-       return 0;
+       return TDB_SUCCESS;
 }
 
 /* Enqueue in this free bucket. */
-static int enqueue_in_free(struct tdb_context *tdb,
-                          tdb_off_t b_off,
-                          tdb_off_t off,
-                          tdb_len_t len)
+static enum TDB_ERROR enqueue_in_free(struct tdb_context *tdb,
+                                     tdb_off_t b_off,
+                                     tdb_off_t off,
+                                     tdb_len_t len)
 {
        struct tdb_free_record new;
        enum TDB_ERROR ecode;
@@ -176,8 +173,7 @@ static int enqueue_in_free(struct tdb_context *tdb,
        /* new->next = head. */
        new.next = tdb_read_off(tdb, b_off);
        if (TDB_OFF_IS_ERR(new.next)) {
-               tdb->ecode = new.next;
-               return -1;
+               return new.next;
        }
 
        if (new.next) {
@@ -186,11 +182,11 @@ static int enqueue_in_free(struct tdb_context *tdb,
                                 new.next + offsetof(struct tdb_free_record,
                                                     magic_and_prev))
                    != magic) {
-                       tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
-                                  "enqueue_in_free: %llu bad head"
-                                  " prev %llu",
-                                  (long long)new.next, (long long)b_off);
-                       return -1;
+                       return tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+                                         "enqueue_in_free: %llu bad head"
+                                         " prev %llu",
+                                         (long long)new.next,
+                                         (long long)b_off);
                }
 #endif
                /* next->prev = new. */
@@ -199,32 +195,24 @@ static int enqueue_in_free(struct tdb_context *tdb,
                                                 magic_and_prev),
                                      off | magic);
                if (ecode != TDB_SUCCESS) {
-                       tdb->ecode = ecode;
-                       return -1;
+                       return ecode;
                }
        }
        /* head = new */
        ecode = tdb_write_off(tdb, b_off, off);
        if (ecode != TDB_SUCCESS) {
-               tdb->ecode = ecode;
-               return -1;
+               return ecode;
        }
 
-       ecode = tdb_write_convert(tdb, off, &new, sizeof(new));
-       if (ecode != TDB_SUCCESS) {
-               tdb->ecode = ecode;
-               return -1;
-       }
-       return 0;
+       return tdb_write_convert(tdb, off, &new, sizeof(new));
 }
 
 /* List need not be locked. */
-int add_free_record(struct tdb_context *tdb,
-                   tdb_off_t off, tdb_len_t len_with_header)
+enum TDB_ERROR add_free_record(struct tdb_context *tdb,
+                              tdb_off_t off, tdb_len_t len_with_header)
 {
        tdb_off_t b_off;
        tdb_len_t len;
-       int ret;
        enum TDB_ERROR ecode;
 
        assert(len_with_header >= sizeof(struct tdb_free_record));
@@ -234,13 +222,12 @@ int add_free_record(struct tdb_context *tdb,
        b_off = bucket_off(tdb->ftable_off, size_to_bucket(len));
        ecode = tdb_lock_free_bucket(tdb, b_off, TDB_LOCK_WAIT);
        if (ecode != TDB_SUCCESS) {
-               tdb->ecode = ecode;
-               return -1;
+               return ecode;
        }
 
-       ret = enqueue_in_free(tdb, b_off, off, len);
+       ecode = enqueue_in_free(tdb, b_off, off, len);
        tdb_unlock_free_bucket(tdb, b_off);
-       return ret;
+       return ecode;
 }
 
 static size_t adjust_size(size_t keylen, size_t datalen)
@@ -290,8 +277,9 @@ static tdb_off_t ftable_offset(struct tdb_context *tdb, unsigned int ftable)
 }
 
 /* Note: we unlock the current bucket if we coalesce or fail. */
-static int coalesce(struct tdb_context *tdb,
-                   tdb_off_t off, tdb_off_t b_off, tdb_len_t data_len)
+static tdb_bool_err coalesce(struct tdb_context *tdb,
+                            tdb_off_t off, tdb_off_t b_off,
+                            tdb_len_t data_len)
 {
        tdb_off_t end;
        struct tdb_free_record rec;
@@ -307,7 +295,7 @@ static int coalesce(struct tdb_context *tdb,
 
                r = tdb_access_read(tdb, end, sizeof(*r), true);
                if (TDB_PTR_IS_ERR(r)) {
-                       tdb->ecode = TDB_PTR_ERR(r);
+                       ecode = TDB_PTR_ERR(r);
                        goto err;
                }
 
@@ -319,7 +307,13 @@ static int coalesce(struct tdb_context *tdb,
 
                ftable = frec_ftable(r);
                bucket = size_to_bucket(frec_len(r));
-               nb_off = bucket_off(ftable_offset(tdb, ftable), bucket);
+               nb_off = ftable_offset(tdb, ftable);
+               if (TDB_OFF_IS_ERR(nb_off)) {
+                       tdb_access_release(tdb, r);
+                       ecode = nb_off;
+                       goto err;
+               }
+               nb_off = bucket_off(nb_off, bucket);
                tdb_access_release(tdb, r);
 
                /* We may be violating lock order here, so best effort. */
@@ -332,7 +326,6 @@ static int coalesce(struct tdb_context *tdb,
                /* Now we have lock, re-check. */
                ecode = tdb_read_convert(tdb, end, &rec, sizeof(rec));
                if (ecode != TDB_SUCCESS) {
-                       tdb->ecode = ecode;
                        tdb_unlock_free_bucket(tdb, nb_off);
                        goto err;
                }
@@ -350,7 +343,8 @@ static int coalesce(struct tdb_context *tdb,
                        break;
                }
 
-               if (remove_from_list(tdb, nb_off, end, &rec) == -1) {
+               ecode = remove_from_list(tdb, nb_off, end, &rec);
+               if (ecode != TDB_SUCCESS) {
                        tdb_unlock_free_bucket(tdb, nb_off);
                        goto err;
                }
@@ -362,24 +356,25 @@ static int coalesce(struct tdb_context *tdb,
 
        /* Didn't find any adjacent free? */
        if (end == off + sizeof(struct tdb_used_record) + data_len)
-               return 0;
+               return false;
 
        /* OK, expand initial record */
        ecode = tdb_read_convert(tdb, off, &rec, sizeof(rec));
        if (ecode != TDB_SUCCESS) {
-               tdb->ecode = ecode;
                goto err;
        }
 
        if (frec_len(&rec) != data_len) {
-               tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
-                          "coalesce: expected data len %zu not %zu",
-                          (size_t)data_len, (size_t)frec_len(&rec));
+               ecode = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+                                  "coalesce: expected data len %zu not %zu",
+                                  (size_t)data_len, (size_t)frec_len(&rec));
                goto err;
        }
 
-       if (remove_from_list(tdb, b_off, off, &rec) == -1)
+       ecode = remove_from_list(tdb, b_off, off, &rec);
+       if (ecode != TDB_SUCCESS) {
                goto err;
+       }
 
        /* We have to drop this to avoid deadlocks, so make sure record
         * doesn't get coalesced by someone else! */
@@ -389,21 +384,23 @@ static int coalesce(struct tdb_context *tdb,
                                                  ftable_and_len),
                              rec.ftable_and_len);
        if (ecode != TDB_SUCCESS) {
-               tdb->ecode = ecode;
                goto err;
        }
 
        add_stat(tdb, alloc_coalesce_succeeded, 1);
        tdb_unlock_free_bucket(tdb, b_off);
 
-       if (add_free_record(tdb, off, end - off) == -1)
-               return -1;
-       return 1;
+       ecode = add_free_record(tdb, off, end - off);
+       if (ecode != TDB_SUCCESS) {
+               tdb->ecode = ecode;
+               return ecode;
+       }
+       return true;
 
 err:
        /* To unify error paths, we *always* unlock bucket on error. */
        tdb_unlock_free_bucket(tdb, b_off);
-       return -1;
+       return ecode;
 }
 
 /* We need size bytes to put our key and data in. */
@@ -429,8 +426,7 @@ again:
        /* Lock this bucket. */
        ecode = tdb_lock_free_bucket(tdb, b_off, TDB_LOCK_WAIT);
        if (ecode != TDB_SUCCESS) {
-               tdb->ecode = ecode;
-               return TDB_OFF_ERR;
+               return ecode;
        }
 
        best.ftable_and_len = -1ULL;
@@ -446,7 +442,7 @@ again:
         * as we go. */
        off = tdb_read_off(tdb, b_off);
        if (TDB_OFF_IS_ERR(off)) {
-               tdb->ecode = off;
+               ecode = off;
                goto unlock_err;
        }
 
@@ -454,18 +450,21 @@ again:
                const struct tdb_free_record *r;
                tdb_len_t len;
                tdb_off_t next;
+               int coal;
 
                r = tdb_access_read(tdb, off, sizeof(*r), true);
                if (TDB_PTR_IS_ERR(r)) {
-                       tdb->ecode = TDB_PTR_ERR(r);
+                       ecode = TDB_PTR_ERR(r);
                        goto unlock_err;
                }
 
                if (frec_magic(r) != TDB_FREE_MAGIC) {
                        tdb_access_release(tdb, r);
-                       tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
-                                "lock_and_alloc: %llu non-free 0x%llx",
-                                (long long)off, (long long)r->magic_and_prev);
+                       ecode = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+                                          "lock_and_alloc:"
+                                          " %llu non-free 0x%llx",
+                                          (long long)off,
+                                          (long long)r->magic_and_prev);
                        goto unlock_err;
                }
 
@@ -486,14 +485,15 @@ again:
                tdb_access_release(tdb, r);
 
                /* Since we're going slow anyway, try coalescing here. */
-               switch (coalesce(tdb, off, b_off, len)) {
-               case -1:
-                       /* This has already unlocked on error. */
-                       return -1;
-               case 1:
+               coal = coalesce(tdb, off, b_off, len);
+               if (coal == 1) {
                        /* This has unlocked list, restart. */
                        goto again;
                }
+               if (coal < 0) {
+                       /* This has already unlocked on error. */
+                       return coal;
+               }
                off = next;
        }
 
@@ -503,8 +503,10 @@ again:
                size_t leftover;
 
                /* We're happy with this size: take it. */
-               if (remove_from_list(tdb, b_off, best_off, &best) != 0)
+               ecode = remove_from_list(tdb, b_off, best_off, &best);
+               if (ecode != TDB_SUCCESS) {
                        goto unlock_err;
+               }
 
                leftover = record_leftover(keylen, datalen, want_extra,
                                           frec_len(&best));
@@ -512,13 +514,14 @@ again:
                assert(keylen + datalen + leftover <= frec_len(&best));
                /* We need to mark non-free before we drop lock, otherwise
                 * coalesce() could try to merge it! */
-               if (set_header(tdb, &rec, magic, keylen, datalen,
-                              frec_len(&best) - leftover, hashlow) != 0)
+               ecode = set_header(tdb, &rec, magic, keylen, datalen,
+                                  frec_len(&best) - leftover, hashlow);
+               if (ecode != TDB_SUCCESS) {
                        goto unlock_err;
+               }
 
                ecode = tdb_write_convert(tdb, best_off, &rec, sizeof(rec));
                if (ecode != TDB_SUCCESS) {
-                       tdb->ecode = ecode;
                        goto unlock_err;
                }
 
@@ -526,11 +529,13 @@ again:
                 * locking is allowed. */
                if (leftover) {
                        add_stat(tdb, alloc_leftover, 1);
-                       if (add_free_record(tdb,
-                                           best_off + sizeof(rec)
-                                           + frec_len(&best) - leftover,
-                                           leftover))
-                               best_off = TDB_OFF_ERR;
+                       ecode = add_free_record(tdb,
+                                               best_off + sizeof(rec)
+                                               + frec_len(&best) - leftover,
+                                               leftover);
+                       if (ecode != TDB_SUCCESS) {
+                               best_off = ecode;
+                       }
                }
                tdb_unlock_free_bucket(tdb, b_off);
 
@@ -542,10 +547,10 @@ again:
 
 unlock_err:
        tdb_unlock_free_bucket(tdb, b_off);
-       return TDB_OFF_ERR;
+       return ecode;
 }
 
-/* Get a free block from current free list, or 0 if none. */
+/* Get a free block from current free list, or 0 if none, -ve on error. */
 static tdb_off_t get_free(struct tdb_context *tdb,
                          size_t keylen, size_t datalen, bool want_extra,
                          unsigned magic, unsigned hashlow)
@@ -572,8 +577,8 @@ static tdb_off_t get_free(struct tdb_context *tdb,
                        off = lock_and_alloc(tdb, ftable_off,
                                             b, keylen, datalen, want_extra,
                                             magic, hashlow);
-                       if (off == TDB_OFF_ERR)
-                               return TDB_OFF_ERR;
+                       if (TDB_OFF_IS_ERR(off))
+                               return off;
                        if (off != 0) {
                                if (b == start_b)
                                        add_stat(tdb, alloc_bucket_exact, 1);
@@ -588,15 +593,13 @@ static tdb_off_t get_free(struct tdb_context *tdb,
                }
 
                if (TDB_OFF_IS_ERR(b)) {
-                       tdb->ecode = b;
-                       return 0;
+                       return b;
                }
 
                /* Hmm, try next table. */
                ftable_off = next_ftable(tdb, ftable_off);
                if (TDB_OFF_IS_ERR(ftable_off)) {
-                       tdb->ecode = ftable_off;
-                       return 0;
+                       return ftable_off;
                }
                ftable++;
 
@@ -604,8 +607,7 @@ static tdb_off_t get_free(struct tdb_context *tdb,
                        wrapped = true;
                        ftable_off = first_ftable(tdb);
                        if (TDB_OFF_IS_ERR(ftable_off)) {
-                               tdb->ecode = ftable_off;
-                               return 0;
+                               return ftable_off;
                        }
                        ftable = 0;
                }
@@ -614,10 +616,10 @@ static tdb_off_t get_free(struct tdb_context *tdb,
        return 0;
 }
 
-int set_header(struct tdb_context *tdb,
-              struct tdb_used_record *rec,
-              unsigned magic, uint64_t keylen, uint64_t datalen,
-              uint64_t actuallen, unsigned hashlow)
+enum TDB_ERROR set_header(struct tdb_context *tdb,
+                         struct tdb_used_record *rec,
+                         unsigned magic, uint64_t keylen, uint64_t datalen,
+                         uint64_t actuallen, unsigned hashlow)
 {
        uint64_t keybits = (fls64(keylen) + 1) / 2;
 
@@ -632,17 +634,16 @@ int set_header(struct tdb_context *tdb,
        if (rec_key_length(rec) != keylen
            || rec_data_length(rec) != datalen
            || rec_extra_padding(rec) != actuallen - (keylen + datalen)) {
-               tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
-                        "Could not encode k=%llu,d=%llu,a=%llu",
-                        (long long)keylen, (long long)datalen,
-                        (long long)actuallen);
-               return -1;
+               return tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+                                 "Could not encode k=%llu,d=%llu,a=%llu",
+                                 (long long)keylen, (long long)datalen,
+                                 (long long)actuallen);
        }
-       return 0;
+       return TDB_SUCCESS;
 }
 
 /* Expand the database. */
-static int tdb_expand(struct tdb_context *tdb, tdb_len_t size)
+static enum TDB_ERROR tdb_expand(struct tdb_context *tdb, tdb_len_t size)
 {
        uint64_t old_size;
        tdb_len_t wanted;
@@ -654,9 +655,8 @@ static int tdb_expand(struct tdb_context *tdb, tdb_len_t size)
        /* Need to hold a hash lock to expand DB: transactions rely on it. */
        if (!(tdb->flags & TDB_NOLOCK)
            && !tdb->allrecord_lock.count && !tdb_has_hash_locks(tdb)) {
-               tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
-                          "tdb_expand: must hold lock during expand");
-               return -1;
+               return tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
+                                 "tdb_expand: must hold lock during expand");
        }
 
        /* always make room for at least 100 more records, and at
@@ -670,8 +670,7 @@ static int tdb_expand(struct tdb_context *tdb, tdb_len_t size)
        /* Only one person can expand file at a time. */
        ecode = tdb_lock_expand(tdb, F_WRLCK);
        if (ecode != TDB_SUCCESS) {
-               tdb->ecode = ecode;
-               return -1;
+               return ecode;
        }
 
        /* Someone else may have expanded the file, so retry. */
@@ -679,14 +678,13 @@ static int tdb_expand(struct tdb_context *tdb, tdb_len_t size)
        tdb->methods->oob(tdb, tdb->map_size + 1, true);
        if (tdb->map_size != old_size) {
                tdb_unlock_expand(tdb, F_WRLCK);
-               return 0;
+               return TDB_SUCCESS;
        }
 
        ecode = tdb->methods->expand_file(tdb, wanted);
        if (ecode != TDB_SUCCESS) {
-               tdb->ecode = ecode;
                tdb_unlock_expand(tdb, F_WRLCK);
-               return -1;
+               return ecode;
        }
 
        /* We need to drop this lock before adding free record. */
@@ -706,12 +704,15 @@ tdb_off_t alloc(struct tdb_context *tdb, size_t keylen, size_t datalen,
        assert(!tdb->direct_access);
 
        for (;;) {
+               enum TDB_ERROR ecode;
                off = get_free(tdb, keylen, datalen, growing, magic, hash);
                if (likely(off != 0))
                        break;
 
-               if (tdb_expand(tdb, adjust_size(keylen, datalen)))
-                       return TDB_OFF_ERR;
+               ecode = tdb_expand(tdb, adjust_size(keylen, datalen));
+               if (ecode != TDB_SUCCESS) {
+                       return ecode;
+               }
        }
 
        return off;