tdb: handle processes dying during transaction commit.
[ccan] / ccan / tdb / transaction.c
index a6cffb35d5e7e83943c027b70070b05cf2ae1802..11194773647e255f1a7c8743cd69d5c85bfeda59 100644 (file)
@@ -408,33 +408,12 @@ static int transaction_expand_file(struct tdb_context *tdb, tdb_off_t size,
        return 0;
 }
 
-/*
-  brlock during a transaction - ignore them
-*/
-static int transaction_brlock(struct tdb_context *tdb,
-                             int rw_type, tdb_off_t offset, size_t len,
-                             enum tdb_lock_flags flags)
-{
-       /* FIXME: We actually grab the open lock during a transaction. */
-       if (offset == OPEN_LOCK)
-               return tdb_brlock(tdb, rw_type, offset, len, flags);
-       return 0;
-}
-
-static int transaction_brunlock(struct tdb_context *tdb,
-                               int rw_type, tdb_off_t offset, size_t len)
-{
-       return 0;
-}
-
 static const struct tdb_methods transaction_methods = {
        transaction_read,
        transaction_write,
        transaction_next_hash_chain,
        transaction_oob,
        transaction_expand_file,
-       transaction_brlock,
-       transaction_brunlock
 };
 
 /*
@@ -466,8 +445,8 @@ static int transaction_sync(struct tdb_context *tdb, tdb_off_t offset, tdb_len_t
        return 0;
 }
 
-/* ltype is F_WRLCK after prepare. */
-int _tdb_transaction_cancel(struct tdb_context *tdb, int ltype)
+
+static int _tdb_transaction_cancel(struct tdb_context *tdb)
 {
        int i, ret = 0;
 
@@ -632,11 +611,8 @@ fail_allrecord_lock:
 */
 int tdb_transaction_cancel(struct tdb_context *tdb)
 {
-       int ltype = F_RDLCK;
        tdb_trace(tdb, "tdb_transaction_cancel");
-       if (tdb->transaction && tdb->transaction->prepared)
-               ltype = F_WRLCK;
-       return _tdb_transaction_cancel(tdb, ltype);
+       return _tdb_transaction_cancel(tdb);
 }
 
 /*
@@ -686,10 +662,16 @@ static int tdb_recovery_allocate(struct tdb_context *tdb,
 
        rec.rec_len = 0;
 
-       if (recovery_head != 0 && 
-           methods->tdb_read(tdb, recovery_head, &rec, sizeof(rec), DOCONV()) == -1) {
-               TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_recovery_allocate: failed to read recovery record\n"));
-               return -1;
+       if (recovery_head != 0) {
+               if (methods->tdb_read(tdb, recovery_head, &rec, sizeof(rec), DOCONV()) == -1) {
+                       TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_recovery_allocate: failed to read recovery record\n"));
+                       return -1;
+               }
+               /* ignore invalid recovery regions: can happen in crash */
+               if (rec.magic != TDB_RECOVERY_MAGIC &&
+                   rec.magic != TDB_RECOVERY_INVALID_MAGIC) {
+                       recovery_head = 0;
+               }
        }
 
        *recovery_size = tdb_recovery_size(tdb);
@@ -896,14 +878,14 @@ static int _tdb_transaction_prepare_commit(struct tdb_context *tdb)
 
        if (tdb->transaction->prepared) {
                tdb->ecode = TDB_ERR_EINVAL;
-               _tdb_transaction_cancel(tdb, F_WRLCK);
+               _tdb_transaction_cancel(tdb);
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_prepare_commit: transaction already prepared\n"));
                return -1;
        }
 
        if (tdb->transaction->transaction_error) {
                tdb->ecode = TDB_ERR_IO;
-               _tdb_transaction_cancel(tdb, F_RDLCK);
+               _tdb_transaction_cancel(tdb);
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_prepare_commit: transaction error pending\n"));
                return -1;
        }
@@ -926,14 +908,14 @@ static int _tdb_transaction_prepare_commit(struct tdb_context *tdb)
        if (tdb_have_extra_locks(tdb)) {
                tdb->ecode = TDB_ERR_LOCK;
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_prepare_commit: locks pending on commit\n"));
-               _tdb_transaction_cancel(tdb, F_RDLCK);
+               _tdb_transaction_cancel(tdb);
                return -1;
        }
 
        /* upgrade the main transaction lock region to a write lock */
        if (tdb_allrecord_upgrade(tdb) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_prepare_commit: failed to upgrade hash locks\n"));
-               _tdb_transaction_cancel(tdb, F_RDLCK);
+               _tdb_transaction_cancel(tdb);
                return -1;
        }
 
@@ -941,7 +923,7 @@ static int _tdb_transaction_prepare_commit(struct tdb_context *tdb)
           during the commit */
        if (tdb_nest_lock(tdb, OPEN_LOCK, F_WRLCK, TDB_LOCK_WAIT) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_prepare_commit: failed to get open lock\n"));
-               _tdb_transaction_cancel(tdb, F_WRLCK);
+               _tdb_transaction_cancel(tdb);
                return -1;
        }
 
@@ -949,7 +931,7 @@ static int _tdb_transaction_prepare_commit(struct tdb_context *tdb)
                /* write the recovery data to the end of the file */
                if (transaction_setup_recovery(tdb, &tdb->transaction->magic_offset) == -1) {
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_prepare_commit: failed to setup recovery data\n"));
-                       _tdb_transaction_cancel(tdb, F_WRLCK);
+                       _tdb_transaction_cancel(tdb);
                        return -1;
                }
        }
@@ -963,7 +945,7 @@ static int _tdb_transaction_prepare_commit(struct tdb_context *tdb)
                                             tdb->transaction->old_map_size) == -1) {
                        tdb->ecode = TDB_ERR_IO;
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_prepare_commit: expansion failed\n"));
-                       _tdb_transaction_cancel(tdb, F_WRLCK);
+                       _tdb_transaction_cancel(tdb);
                        return -1;
                }
                tdb->map_size = tdb->transaction->old_map_size;
@@ -1015,7 +997,7 @@ int tdb_transaction_commit(struct tdb_context *tdb)
 
        /* check for a null transaction */
        if (tdb->transaction->blocks == NULL) {
-               _tdb_transaction_cancel(tdb, F_RDLCK);
+               _tdb_transaction_cancel(tdb);
                return 0;
        }
 
@@ -1051,7 +1033,7 @@ int tdb_transaction_commit(struct tdb_context *tdb)
                        tdb->methods = methods;
                        tdb_transaction_recover(tdb); 
 
-                       _tdb_transaction_cancel(tdb, F_WRLCK);
+                       _tdb_transaction_cancel(tdb);
 
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_commit: write failed\n"));
                        return -1;
@@ -1086,7 +1068,7 @@ int tdb_transaction_commit(struct tdb_context *tdb)
 
        /* use a transaction cancel to free memory and remove the
           transaction locks */
-       _tdb_transaction_cancel(tdb, F_WRLCK);
+       _tdb_transaction_cancel(tdb);
 
        if (need_repack) {
                return tdb_repack(tdb);
@@ -1200,16 +1182,6 @@ int tdb_transaction_recover(struct tdb_context *tdb)
                return -1;                      
        }
        
-       /* reduce the file size to the old size */
-       tdb_munmap(tdb);
-       if (ftruncate(tdb->fd, recovery_eof) != 0) {
-               TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_recover: failed to reduce to recovery size\n"));
-               tdb->ecode = TDB_ERR_IO;
-               return -1;                      
-       }
-       tdb->map_size = recovery_eof;
-       tdb_mmap(tdb);
-
        if (transaction_sync(tdb, 0, recovery_eof) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_recover: failed to sync2 recovery\n"));
                tdb->ecode = TDB_ERR_IO;
@@ -1222,3 +1194,28 @@ int tdb_transaction_recover(struct tdb_context *tdb)
        /* all done */
        return 0;
 }
+
+/* Any I/O failures we say "needs recovery". */
+bool tdb_needs_recovery(struct tdb_context *tdb)
+{
+       tdb_off_t recovery_head;
+       struct tdb_record rec;
+
+       /* find the recovery area */
+       if (tdb_ofs_read(tdb, TDB_RECOVERY_HEAD, &recovery_head) == -1) {
+               return true;
+       }
+
+       if (recovery_head == 0) {
+               /* we have never allocated a recovery record */
+               return false;
+       }
+
+       /* read the recovery record */
+       if (tdb->methods->tdb_read(tdb, recovery_head, &rec,
+                                  sizeof(rec), DOCONV()) == -1) {
+               return true;
+       }
+
+       return (rec.magic == TDB_RECOVERY_MAGIC);
+}