tdb2: don't continue if tdb1_find fails.
[ccan] / ccan / tdb2 / tdb1_tdb.c
index a50303c33ce4e6333e823ceea2cceff6788e60f7..6f6f080da2298497127fd7ae602472f30ed8908d 100644 (file)
@@ -28,8 +28,6 @@
 #include "tdb1_private.h"
 #include <assert.h>
 
-TDB_DATA tdb1_null;
-
 /*
   non-blocking increment of the tdb sequence number if the tdb has been opened using
   the TDB_SEQNUM flag
@@ -70,13 +68,17 @@ static void tdb1_increment_seqnum(struct tdb_context *tdb)
        tdb1_nest_unlock(tdb, TDB1_SEQNUM_OFS, F_WRLCK);
 }
 
-static int tdb1_key_compare(TDB_DATA key, TDB_DATA data, void *private_data)
+static enum TDB_ERROR tdb1_key_compare(TDB_DATA key, TDB_DATA data,
+                                      void *matches_)
 {
-       return memcmp(data.dptr, key.dptr, data.dsize);
+       bool *matches = matches_;
+       *matches = (memcmp(data.dptr, key.dptr, data.dsize) == 0);
+       return TDB_SUCCESS;
 }
 
-/* Returns 0 on fail.  On success, return offset of record, and fills
-   in rec */
+/* Returns 0 on fail; last_error will be TDB_ERR_NOEXIST if it simply
+ * wasn't there, otherwise a real error.
+ * On success, return offset of record, and fills in rec */
 static tdb1_off_t tdb1_find(struct tdb_context *tdb, TDB_DATA key, uint32_t hash,
                        struct tdb1_record *r)
 {
@@ -91,12 +93,30 @@ static tdb1_off_t tdb1_find(struct tdb_context *tdb, TDB_DATA key, uint32_t hash
                if (tdb1_rec_read(tdb, rec_ptr, r) == -1)
                        return 0;
 
-               if (!TDB1_DEAD(r) && hash==r->full_hash
-                   && key.dsize==r->key_len
-                   && tdb1_parse_data(tdb, key, rec_ptr + sizeof(*r),
-                                     r->key_len, tdb1_key_compare,
-                                     NULL) == 0) {
-                       return rec_ptr;
+               tdb->stats.compares++;
+               if (TDB1_DEAD(r)) {
+                       tdb->stats.compare_wrong_bucket++;
+               } else if (key.dsize != r->key_len) {
+                       tdb->stats.compare_wrong_keylen++;
+               } else if (hash != r->full_hash) {
+                       tdb->stats.compare_wrong_rechash++;
+               } else {
+                       enum TDB_ERROR ecode;
+                       bool matches;
+                       ecode = tdb1_parse_data(tdb, key, rec_ptr + sizeof(*r),
+                                               r->key_len, tdb1_key_compare,
+                                               &matches);
+
+                       if (ecode != TDB_SUCCESS) {
+                               tdb->last_error = ecode;
+                               return 0;
+                       }
+
+                       if (!matches) {
+                               tdb->stats.compare_wrong_keycmp++;
+                       } else {
+                               return rec_ptr;
+                       }
                }
                /* detect tight infinite loop */
                if (rec_ptr == r->next) {
@@ -191,8 +211,11 @@ static TDB_DATA _tdb1_fetch(struct tdb_context *tdb, TDB_DATA key)
 
        /* find which hash bucket it is in */
        hash = tdb_hash(tdb, key.dptr, key.dsize);
-       if (!(rec_ptr = tdb1_find_lock_hash(tdb,key,hash,F_RDLCK,&rec)))
-               return tdb1_null;
+       if (!(rec_ptr = tdb1_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
+               ret.dptr = NULL;
+               ret.dsize = 0;
+               return ret;
+       }
 
        ret.dptr = tdb1_alloc_read(tdb, rec_ptr + sizeof(rec) + rec.key_len,
                                  rec.data_len);
@@ -224,8 +247,7 @@ enum TDB_ERROR tdb1_parse_record(struct tdb_context *tdb, TDB_DATA key,
        hash = tdb_hash(tdb, key.dptr, key.dsize);
 
        if (!(rec_ptr = tdb1_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
-               /* record not found */
-               return TDB_ERR_NOEXIST;
+               return tdb->last_error;
        }
 
        ret = tdb1_parse_data(tdb, key, rec_ptr + sizeof(rec) + rec.key_len,
@@ -465,16 +487,23 @@ static int _tdb1_store(struct tdb_context *tdb, TDB_DATA key,
                        tdb->last_error = TDB_ERR_EXISTS;
                        goto fail;
                }
+               if (tdb->last_error != TDB_ERR_NOEXIST) {
+                       goto fail;
+               }
        } else {
                /* first try in-place update, on modify or replace. */
                if (tdb1_update_hash(tdb, key, hash, dbuf) == 0) {
                        goto done;
                }
-               if (tdb->last_error == TDB_ERR_NOEXIST &&
-                   flag == TDB_MODIFY) {
-                       /* if the record doesn't exist and we are in TDB1_MODIFY mode then
-                        we should fail the store */
-                       goto fail;
+               if (tdb->last_error != TDB_SUCCESS) {
+                       if (tdb->last_error != TDB_ERR_NOEXIST) {
+                               goto fail;
+                       }
+                       if (flag == TDB_MODIFY) {
+                               /* if the record doesn't exist and we are in TDB1_MODIFY mode then
+                                  we should fail the store */
+                               goto fail;
+                       }
                }
        }
        /* reset the error code potentially set by the tdb1_update() */
@@ -490,7 +519,9 @@ static int _tdb1_store(struct tdb_context *tdb, TDB_DATA key,
           fails and we are left with a dead spot in the tdb. */
 
        if (!(p = (char *)malloc(key.dsize + dbuf.dsize))) {
-               tdb->last_error = TDB_ERR_OOM;
+               tdb->last_error = tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR,
+                                            "tdb1_store: out of memory"
+                                            " allocating copy");
                goto fail;
        }
 
@@ -590,7 +621,9 @@ int tdb1_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
        assert(tdb->flags & TDB_VERSION1);
 
        if ((tdb->flags & TDB_RDONLY) || tdb->tdb1.traverse_read) {
-               tdb->last_error = TDB_ERR_RDONLY;
+               tdb->last_error = tdb_logerr(tdb, TDB_ERR_RDONLY,
+                                            TDB_LOG_USE_ERROR,
+                                            "tdb_store: read-only tdb");
                return -1;
        }
 
@@ -783,6 +816,7 @@ int tdb1_wipe_all(struct tdb_context *tdb)
                }
        }
 
+       tdb1_increment_seqnum_nonblock(tdb);
        tdb_unlockall(tdb);
        return 0;
 
@@ -791,108 +825,6 @@ failed:
        return -1;
 }
 
-struct traverse_state {
-       enum TDB_ERROR error;
-       struct tdb_context *dest_db;
-};
-
-/*
-  traverse function for repacking
- */
-static int repack_traverse(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *private_data)
-{
-       struct traverse_state *state = (struct traverse_state *)private_data;
-       if (tdb1_store(state->dest_db, key, data, TDB_INSERT) != 0) {
-               state->error = state->dest_db->last_error;
-               return -1;
-       }
-       return 0;
-}
-
-/*
-  repack a tdb
- */
-int tdb1_repack(struct tdb_context *tdb)
-{
-       struct tdb_context *tmp_db;
-       struct traverse_state state;
-       union tdb_attribute hsize;
-
-       hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
-       hsize.base.next = NULL;
-       hsize.tdb1_hashsize.hsize = tdb->tdb1.header.hash_size;
-
-       if (tdb1_transaction_start(tdb) != 0) {
-               tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
-                          __location__ " Failed to start transaction");
-               return -1;
-       }
-
-       tmp_db = tdb_open("tmpdb", TDB_INTERNAL, O_RDWR|O_CREAT, 0, &hsize);
-       if (tmp_db == NULL) {
-               tdb->last_error = tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR,
-                                       __location__ " Failed to create tmp_db");
-               tdb1_transaction_cancel(tdb);
-               return -1;
-       }
-
-       state.error = TDB_SUCCESS;
-       state.dest_db = tmp_db;
-
-       if (tdb1_traverse(tdb, repack_traverse, &state) == -1) {
-               tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
-                          __location__ " Failed to traverse copying out");
-               tdb1_transaction_cancel(tdb);
-               tdb_close(tmp_db);
-               return -1;
-       }
-
-       if (state.error != TDB_SUCCESS) {
-               tdb->last_error = tdb_logerr(tdb, state.error, TDB_LOG_ERROR,
-                                       __location__ " Error during traversal");
-               tdb1_transaction_cancel(tdb);
-               tdb_close(tmp_db);
-               return -1;
-       }
-
-       if (tdb1_wipe_all(tdb) != 0) {
-               tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
-                          __location__ " Failed to wipe database\n");
-               tdb1_transaction_cancel(tdb);
-               tdb_close(tmp_db);
-               return -1;
-       }
-
-       state.error = TDB_SUCCESS;
-       state.dest_db = tdb;
-
-       if (tdb1_traverse(tmp_db, repack_traverse, &state) == -1) {
-               tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
-                          __location__ " Failed to traverse copying back");
-               tdb1_transaction_cancel(tdb);
-               tdb_close(tmp_db);
-               return -1;
-       }
-
-       if (state.error) {
-               tdb->last_error = tdb_logerr(tdb, state.error, TDB_LOG_ERROR,
-                                       __location__ " Error during second traversal");
-               tdb1_transaction_cancel(tdb);
-               tdb_close(tmp_db);
-               return -1;
-       }
-
-       tdb_close(tmp_db);
-
-       if (tdb1_transaction_commit(tdb) != 0) {
-               tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
-                          __location__ " Failed to commit");
-               return -1;
-       }
-
-       return 0;
-}
-
 /* Even on files, we can get partial writes due to signals. */
 bool tdb1_write_all(int fd, const void *buf, size_t count)
 {