X-Git-Url: https://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Ftdb2%2Ftransaction.c;h=3c17bc7dd7cf808c4687880ceaea2feadeedda7f;hp=66565d67c2d762b67cba9169ee3d9f8f661b78d3;hb=1ad66fedf81fdaf0f07a2b00d6787614c58a23ef;hpb=3d917ba6dffe2029608a3d4c870dfdb4033ca4c9 diff --git a/ccan/tdb2/transaction.c b/ccan/tdb2/transaction.c index 66565d67..3c17bc7d 100644 --- a/ccan/tdb2/transaction.c +++ b/ccan/tdb2/transaction.c @@ -53,13 +53,13 @@ - don't allow any locks to be held when a transaction starts, otherwise we can end up with deadlock (plus lack of lock nesting - in posix locks would mean the lock is lost) + in POSIX locks would mean the lock is lost) - if the caller gains a lock during the transaction but doesn't release it then fail the commit - allow for nested calls to tdb_transaction_start(), re-using the - existing transaction record. If the inner transaction is cancelled + existing transaction record. If the inner transaction is canceled then a subsequent commit will fail - keep a mirrored copy of the tdb hash chain heads to allow for the @@ -68,7 +68,7 @@ - allow callers to mix transaction and non-transaction use of tdb, although once a transaction is started then an exclusive lock is - gained until the transaction is committed or cancelled + gained until the transaction is committed or canceled - the commit stategy involves first saving away all modified data into a linearised buffer in the transaction recovery area, then @@ -297,7 +297,7 @@ fail: /* - write while in a transaction - this varient never expands the transaction blocks, it only + write while in a transaction - this variant never expands the transaction blocks, it only updates existing blocks. This means it cannot change the recovery size */ static void transaction_write_existing(struct tdb_context *tdb, tdb_off_t off, @@ -430,7 +430,7 @@ static enum TDB_ERROR transaction_sync(struct tdb_context *tdb, return TDB_SUCCESS; } - if (fsync(tdb->fd) != 0) { + if (fsync(tdb->file->fd) != 0) { return tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR, "tdb_transaction: fsync failed: %s", strerror(errno)); @@ -495,8 +495,8 @@ static void _tdb_transaction_cancel(struct tdb_context *tdb) } } - if (tdb->allrecord_lock.count) - tdb_allrecord_unlock(tdb, tdb->allrecord_lock.ltype); + if (tdb->file->allrecord_lock.count) + tdb_allrecord_unlock(tdb, tdb->file->allrecord_lock.ltype); /* restore the normal io methods */ tdb->methods = tdb->transaction->io_methods; @@ -513,42 +513,38 @@ static void _tdb_transaction_cancel(struct tdb_context *tdb) start a tdb transaction. No token is returned, as only a single transaction is allowed to be pending per tdb_context */ -int tdb_transaction_start(struct tdb_context *tdb) +enum TDB_ERROR tdb_transaction_start(struct tdb_context *tdb) { enum TDB_ERROR ecode; /* some sanity checks */ if (tdb->read_only || (tdb->flags & TDB_INTERNAL)) { - tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR, - "tdb_transaction_start: cannot start a transaction" - " on a read-only or internal db"); - return -1; + return tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR, + "tdb_transaction_start: cannot start a" + " transaction on a read-only or internal db"); } /* cope with nested tdb_transaction_start() calls */ if (tdb->transaction != NULL) { - tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_USE_ERROR, - "tdb_transaction_start:" - " already inside transaction"); - return -1; + return tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_USE_ERROR, + "tdb_transaction_start:" + " already inside transaction"); } if (tdb_has_hash_locks(tdb)) { /* the caller must not have any locks when starting a transaction as otherwise we'll be screwed by lack - of nested locks in posix */ - tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_USE_ERROR, - "tdb_transaction_start: cannot start a transaction" - " with locks held"); - return -1; + of nested locks in POSIX */ + return tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_USE_ERROR, + "tdb_transaction_start: cannot start a" + " transaction with locks held"); } tdb->transaction = (struct tdb_transaction *) calloc(sizeof(struct tdb_transaction), 1); if (tdb->transaction == NULL) { - tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR, - "tdb_transaction_start: cannot allocate"); - return -1; + return tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR, + "tdb_transaction_start: cannot allocate"); } /* get the transaction write lock. This is a blocking lock. As @@ -556,17 +552,15 @@ int tdb_transaction_start(struct tdb_context *tdb) make this async, which we will probably do in the future */ ecode = tdb_transaction_lock(tdb, F_WRLCK); if (ecode != TDB_SUCCESS) { - tdb->ecode = ecode; SAFE_FREE(tdb->transaction->blocks); SAFE_FREE(tdb->transaction); - return -1; + return ecode; } /* get a read lock over entire file. This is upgraded to a write lock during the commit */ ecode = tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, true); if (ecode != TDB_SUCCESS) { - tdb->ecode = ecode; goto fail_allrecord_lock; } @@ -579,13 +573,13 @@ int tdb_transaction_start(struct tdb_context *tdb) transaction specific methods */ tdb->transaction->io_methods = tdb->methods; tdb->methods = &transaction_methods; - return 0; + return TDB_SUCCESS; fail_allrecord_lock: tdb_transaction_unlock(tdb, F_WRLCK); SAFE_FREE(tdb->transaction->blocks); SAFE_FREE(tdb->transaction); - return -1; + return ecode; } @@ -751,11 +745,12 @@ static void set_recovery_header(struct tdb_recovery_record *rec, static enum TDB_ERROR transaction_setup_recovery(struct tdb_context *tdb, tdb_off_t *magic_offset) { - tdb_len_t recovery_size; + /* Initialized for GCC's 4.4.5 overzealous uninitialized warnings. */ + tdb_len_t recovery_size = 0; + tdb_off_t recovery_offset = 0, recovery_max_size = 0; unsigned char *data, *p; const struct tdb_methods *methods = tdb->transaction->io_methods; struct tdb_recovery_record *rec; - tdb_off_t recovery_offset, recovery_max_size; tdb_off_t old_map_size = tdb->transaction->old_map_size; uint64_t magic, tailer; int i; @@ -971,46 +966,42 @@ static enum TDB_ERROR _tdb_transaction_prepare_commit(struct tdb_context *tdb) /* prepare to commit the current transaction */ -int tdb_transaction_prepare_commit(struct tdb_context *tdb) +enum TDB_ERROR tdb_transaction_prepare_commit(struct tdb_context *tdb) { - tdb->ecode = _tdb_transaction_prepare_commit(tdb); - if (tdb->ecode != TDB_SUCCESS) - return -1; - return 0; + return _tdb_transaction_prepare_commit(tdb); } /* commit the current transaction */ -int tdb_transaction_commit(struct tdb_context *tdb) +enum TDB_ERROR tdb_transaction_commit(struct tdb_context *tdb) { const struct tdb_methods *methods; int i; enum TDB_ERROR ecode; if (tdb->transaction == NULL) { - tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR, - "tdb_transaction_commit: no transaction"); - return -1; + return tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR, + "tdb_transaction_commit: no transaction"); } tdb_trace(tdb, "tdb_transaction_commit"); if (tdb->transaction->nesting != 0) { tdb->transaction->nesting--; - return 0; + return TDB_SUCCESS; } /* check for a null transaction */ if (tdb->transaction->blocks == NULL) { _tdb_transaction_cancel(tdb); - return 0; + return TDB_SUCCESS; } if (!tdb->transaction->prepared) { - tdb->ecode = _tdb_transaction_prepare_commit(tdb); - if (tdb->ecode != TDB_SUCCESS) - return -1; + ecode = _tdb_transaction_prepare_commit(tdb); + if (ecode != TDB_SUCCESS) + return ecode; } methods = tdb->transaction->io_methods; @@ -1045,7 +1036,7 @@ int tdb_transaction_commit(struct tdb_context *tdb) _tdb_transaction_cancel(tdb); - return -1; + return ecode; } SAFE_FREE(tdb->transaction->blocks[i]); } @@ -1056,8 +1047,7 @@ int tdb_transaction_commit(struct tdb_context *tdb) /* ensure the new data is on disk */ ecode = transaction_sync(tdb, 0, tdb->map_size); if (ecode != TDB_SUCCESS) { - tdb->ecode = ecode; - return -1; + return ecode; } /* @@ -1079,7 +1069,7 @@ int tdb_transaction_commit(struct tdb_context *tdb) transaction locks */ _tdb_transaction_cancel(tdb); - return 0; + return TDB_SUCCESS; }