Lines Matching full:transaction
18 #include "transaction.h"
41 * Transaction states and transitions
43 * No running transaction (fs tree blocks are not modified)
48 * Transaction N [[TRANS_STATE_RUNNING]]
50 * | New trans handles can be attached to transaction N by calling all
55 * | transaction N
57 * Transaction N [[TRANS_STATE_COMMIT_PREP]]
60 * | the race and the rest will wait for the winner to commit the transaction.
62 * | The winner will wait for previous running transaction to completely finish
65 * Transaction N [[TRANS_STATE_COMMIT_START]]
70 * | - Wait for current transaction to be committed by others.
74 * | to this running transaction.
76 * | transaction N+1.
79 * | Caller is chosen to commit transaction N, and all other trans handle
82 * Transaction N [[TRANS_STATE_COMMIT_DOING]]
84 * | The heavy lifting transaction work is started.
91 * | transaction to finish and attach to transaction N+1.
96 * Transaction N [[TRANS_STATE_UNBLOCKED]]
97 * | Transaction N+1
102 * | At this stage, new transaction is allowed to |
111 * Transaction N [[TRANS_STATE_COMPLETED]] V
112 * All tree blocks and super blocks are written. Transaction N+1
113 * This transaction is finished and all its [[TRANS_STATE_COMMIT_START]]
141 void btrfs_put_transaction(struct btrfs_transaction *transaction) in btrfs_put_transaction() argument
143 WARN_ON(refcount_read(&transaction->use_count) == 0); in btrfs_put_transaction()
144 if (refcount_dec_and_test(&transaction->use_count)) { in btrfs_put_transaction()
145 BUG_ON(!list_empty(&transaction->list)); in btrfs_put_transaction()
147 &transaction->delayed_refs.href_root.rb_root)); in btrfs_put_transaction()
149 &transaction->delayed_refs.dirty_extent_root)); in btrfs_put_transaction()
150 if (transaction->delayed_refs.pending_csums) in btrfs_put_transaction()
151 btrfs_err(transaction->fs_info, in btrfs_put_transaction()
153 transaction->delayed_refs.pending_csums); in btrfs_put_transaction()
156 * because the transaction was aborted and a commit did not in btrfs_put_transaction()
161 while (!list_empty(&transaction->deleted_bgs)) { in btrfs_put_transaction()
164 cache = list_first_entry(&transaction->deleted_bgs, in btrfs_put_transaction()
171 WARN_ON(!list_empty(&transaction->dev_update_list)); in btrfs_put_transaction()
172 kfree(transaction); in btrfs_put_transaction()
178 struct btrfs_transaction *cur_trans = trans->transaction; in switch_commit_roots()
183 * At this point no one can be using this transaction to modify any tree in switch_commit_roots()
184 * and no one can start another transaction to modify any tree either. in switch_commit_roots()
263 * either allocate a new transaction or hop into the existing one
300 * current transaction, and commit it. If there is no transaction, just in join_transaction()
307 * JOIN_NOLOCK only happens during the transaction commit, so in join_transaction()
322 * someone started a transaction after we unlocked. Make sure in join_transaction()
347 * commit the transaction. in join_transaction()
360 * although the tree mod log is per file system and not per transaction, in join_transaction()
361 * the log must never go across transaction boundaries. in join_transaction()
365 WARN(1, KERN_ERR "BTRFS: tree_mod_seq_list not empty when creating a fresh transaction\n"); in join_transaction()
367 WARN(1, KERN_ERR "BTRFS: tree_mod_log rb tree not empty when creating a fresh transaction\n"); in join_transaction()
398 * is properly recorded in a given transaction. This is required to make sure
399 * the old root from before we joined the transaction is deleted when the
400 * transaction commits.
439 * this transaction. in record_root_in_trans()
467 struct btrfs_transaction *cur_trans = trans->transaction; in btrfs_add_dropped_root()
469 /* Add ourselves to the transaction dropped list */ in btrfs_add_dropped_root()
514 /* wait for commit against the current transaction to become unblocked
515 * when this is done, it is safe to start a new transaction, but the current
516 * transaction might not be fully on disk.
591 * Do the reservation before we join the transaction so we can do all in start_transaction()
601 * transaction that could free this reserved space prematurely in start_transaction()
611 * we only do 1 enospc flushing cycle per transaction start. We in start_transaction()
664 * If we are JOIN_NOLOCK we're already committing a transaction and in start_transaction()
671 * transaction and commit it, so we needn't do sb_start_intwrite(). in start_transaction()
695 h->transaction = cur_trans; in start_transaction()
711 trace_btrfs_space_reservation(fs_info, "transaction", in start_transaction()
738 * transaction. in start_transaction()
746 * The transaction handle is fully initialized and linked with in start_transaction()
754 * Now that we have found a transaction to be a part of, convert the in start_transaction()
755 * qgroup reservation from prealloc to pertrans. A different transaction in start_transaction()
804 * Similar to regular join but it never starts a transaction when none is
807 * happen if the transaction commit already started but it's not yet in the
817 * btrfs_attach_transaction() - catch the running transaction
819 * It is used when we want to commit the current the transaction, but
823 * running transaction. But it is possible that the inactive transaction
825 * inactive transaction in the fs when -ENOENT is returned, you should
836 * btrfs_attach_transaction_barrier() - catch the running transaction
860 /* Wait for a transaction commit to reach at least the given state. */
886 * A transaction isn't really completed until all of the in wait_for_commit()
889 * transaction. Wait for those. in wait_for_commit()
915 /* find specified transaction */ in btrfs_wait_for_commit()
932 * The specified transaction doesn't exist, or we in btrfs_wait_for_commit()
941 /* find newest transaction that is committing | committed */ in btrfs_wait_for_commit()
972 struct btrfs_transaction *cur_trans = trans->transaction; in btrfs_should_end_transaction()
998 trace_btrfs_space_reservation(fs_info, "transaction", in btrfs_trans_release_metadata()
1009 struct btrfs_transaction *cur_trans = trans->transaction; in __btrfs_end_transaction()
1101 * the transaction (through extent_io_tree_release()). in btrfs_write_marked_extents()
1124 * those extents are on disk for transaction or log commit. We wait
1141 * When committing the transaction, we'll remove any entries in __btrfs_wait_marked_extents()
1144 * concurrently - we do it only at transaction commit time when in __btrfs_wait_marked_extents()
1205 * This function ensures such extents are persisted on disk for transaction or
1208 * @trans: transaction whose dirty pages we'd like to write
1214 struct extent_io_tree *dirty_pages = &trans->transaction->dirty_pages; in btrfs_write_and_wait_transaction()
1223 extent_io_tree_release(&trans->transaction->dirty_pages); in btrfs_write_and_wait_transaction()
1283 struct list_head *dirty_bgs = &trans->transaction->dirty_bgs; in commit_cowonly_roots()
1284 struct list_head *io_bgs = &trans->transaction->io_bgs; in commit_cowonly_roots()
1290 * At this point no one can be using this transaction to modify any tree in commit_cowonly_roots()
1291 * and no one can start another transaction to modify any tree either. in commit_cowonly_roots()
1293 ASSERT(trans->transaction->state == TRANS_STATE_COMMIT_DOING); in commit_cowonly_roots()
1327 &trans->transaction->switch_commits); in commit_cowonly_roots()
1424 * At this point no one can be using this transaction to modify any tree in commit_fs_roots()
1425 * and no one can start another transaction to modify any tree either. in commit_fs_roots()
1427 ASSERT(trans->transaction->state == TRANS_STATE_COMMIT_DOING); in commit_fs_roots()
1466 &trans->transaction->switch_commits); in commit_fs_roots()
1526 * roots inside one transaction and write all btree into disk, to make
1587 * Now we do a simplified commit transaction, which will: in qgroup_account_snapshot()
1605 "Error while writing out transaction for qgroup"); in qgroup_account_snapshot()
1621 * transaction commit. This does the actual creation.
1624 * If the error which may affect the commitment of the current transaction
1660 * We're inside a transaction and must make sure that any potential in create_pending_snapshot()
1700 trace_btrfs_space_reservation(fs_info, "transaction", in create_pending_snapshot()
1739 if (ret) { /* Transaction aborted */ in create_pending_snapshot()
1907 struct list_head *head = &trans->transaction->pending_snapshots; in create_pending_snapshots()
1974 /* Kick the transaction kthread. */ in btrfs_commit_transaction_async()
1978 /* take transaction reference */ in btrfs_commit_transaction_async()
1979 cur_trans = trans->transaction; in btrfs_commit_transaction_async()
1985 * Wait for the current transaction commit to start and block in btrfs_commit_transaction_async()
1986 * subsequent transaction joins in btrfs_commit_transaction_async()
1998 struct btrfs_transaction *cur_trans = trans->transaction; in cleanup_transaction()
2007 * If the transaction is removed from the list, it means this in cleanup_transaction()
2008 * transaction has been committed successfully, so it is impossible in cleanup_transaction()
2029 * Now that we know no one else is still using the transaction we can in cleanup_transaction()
2030 * remove the transaction from the list of transactions. This avoids in cleanup_transaction()
2031 * the transaction kthread from cleaning up the transaction while some in cleanup_transaction()
2033 * on things like log trees, as it forces the transaction kthread to in cleanup_transaction()
2034 * wait for this transaction to be cleaned up by us. in cleanup_transaction()
2040 btrfs_cleanup_one_transaction(trans->transaction, fs_info); in cleanup_transaction()
2060 * pauses scrub, then starts and commits a transaction before unpausing in cleanup_transaction()
2061 * scrub. If the transaction commit is being done by the relocation in cleanup_transaction()
2076 * transaction and remove them from the list
2097 * from already being in a transaction and our join_transaction doesn't in btrfs_start_delalloc_flush()
2120 * Add a pending snapshot associated with the given transaction handle to the
2121 * respective handle. This must be called after the transaction commit started
2129 struct btrfs_transaction *cur_trans = trans->transaction; in add_pending_snapshot()
2152 struct btrfs_transaction *cur_trans = trans->transaction; in btrfs_commit_transaction()
2173 * We only want one transaction commit doing the flushing so we do not in btrfs_commit_transaction()
2197 * will wait for the transaction to commit if it in btrfs_commit_transaction()
2270 * The previous transaction was aborted and was already removed in btrfs_commit_transaction()
2303 * The thread has started/joined the transaction thus it holds the in btrfs_commit_transaction()
2323 * transaction. Otherwise if this transaction commits before the ordered in btrfs_commit_transaction()
2333 * commit the transaction. We could have started a join before setting in btrfs_commit_transaction()
2342 * The thread has started/joined the transaction thus it holds the in btrfs_commit_transaction()
2363 * do an async commit but somebody else started before the transaction in btrfs_commit_transaction()
2413 WARN_ON(cur_trans != trans->transaction); in btrfs_commit_transaction()
2483 * Before changing the transaction state to TRANS_STATE_UNBLOCKED and in btrfs_commit_transaction()
2486 * start a new transaction and commit a log tree before we commit our in btrfs_commit_transaction()
2509 "Error while writing out transaction"); in btrfs_commit_transaction()
2582 btrfs_warn(fs_info, "Skipping commit of aborted transaction."); in btrfs_commit_transaction()
2640 * We only mark the transaction aborted and then set the file system read-only.
2646 * further cleanup. The transaction should complete as it normally would
2659 WRITE_ONCE(trans->transaction->aborted, errno); in __btrfs_abort_transaction()
2662 /* Wake up anybody who may be waiting on this transaction */ in __btrfs_abort_transaction()