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
302 * current transaction, and commit it. If there is no transaction, just in join_transaction()
309 * JOIN_NOLOCK only happens during the transaction commit, so in join_transaction()
324 * someone started a transaction after we unlocked. Make sure in join_transaction()
349 * commit the transaction. in join_transaction()
362 * although the tree mod log is per file system and not per transaction, in join_transaction()
363 * the log must never go across transaction boundaries. in join_transaction()
367 WARN(1, KERN_ERR "BTRFS: tree_mod_seq_list not empty when creating a fresh transaction\n"); in join_transaction()
369 WARN(1, KERN_ERR "BTRFS: tree_mod_log rb tree not empty when creating a fresh transaction\n"); in join_transaction()
400 * is properly recorded in a given transaction. This is required to make sure
401 * the old root from before we joined the transaction is deleted when the
402 * transaction commits.
441 * this transaction. in record_root_in_trans()
469 struct btrfs_transaction *cur_trans = trans->transaction; in btrfs_add_dropped_root()
471 /* Add ourselves to the transaction dropped list */ in btrfs_add_dropped_root()
516 /* wait for commit against the current transaction to become unblocked
517 * when this is done, it is safe to start a new transaction, but the current
518 * transaction might not be fully on disk.
593 * Do the reservation before we join the transaction so we can do all in start_transaction()
603 * transaction that could free this reserved space prematurely in start_transaction()
613 * we only do 1 enospc flushing cycle per transaction start. We in start_transaction()
666 * If we are JOIN_NOLOCK we're already committing a transaction and in start_transaction()
673 * transaction and commit it, so we needn't do sb_start_intwrite(). in start_transaction()
697 h->transaction = cur_trans; in start_transaction()
713 trace_btrfs_space_reservation(fs_info, "transaction", in start_transaction()
740 * transaction. in start_transaction()
748 * The transaction handle is fully initialized and linked with in start_transaction()
756 * Now that we have found a transaction to be a part of, convert the in start_transaction()
757 * qgroup reservation from prealloc to pertrans. A different transaction in start_transaction()
806 * Similar to regular join but it never starts a transaction when none is
809 * happen if the transaction commit already started but it's not yet in the
819 * btrfs_attach_transaction() - catch the running transaction
821 * It is used when we want to commit the current the transaction, but
825 * running transaction. But it is possible that the inactive transaction
827 * inactive transaction in the fs when -ENOENT is returned, you should
838 * btrfs_attach_transaction_barrier() - catch the running transaction
862 /* Wait for a transaction commit to reach at least the given state. */
888 * A transaction isn't really completed until all of the in wait_for_commit()
891 * transaction. Wait for those. in wait_for_commit()
917 /* find specified transaction */ in btrfs_wait_for_commit()
934 * The specified transaction doesn't exist, or we in btrfs_wait_for_commit()
943 /* find newest transaction that is committing | committed */ in btrfs_wait_for_commit()
974 struct btrfs_transaction *cur_trans = trans->transaction; in btrfs_should_end_transaction()
1000 trace_btrfs_space_reservation(fs_info, "transaction", in btrfs_trans_release_metadata()
1011 struct btrfs_transaction *cur_trans = trans->transaction; in __btrfs_end_transaction()
1103 * the transaction (through extent_io_tree_release()). in btrfs_write_marked_extents()
1126 * those extents are on disk for transaction or log commit. We wait
1143 * When committing the transaction, we'll remove any entries in __btrfs_wait_marked_extents()
1146 * concurrently - we do it only at transaction commit time when in __btrfs_wait_marked_extents()
1207 * This function ensures such extents are persisted on disk for transaction or
1210 * @trans: transaction whose dirty pages we'd like to write
1216 struct extent_io_tree *dirty_pages = &trans->transaction->dirty_pages; in btrfs_write_and_wait_transaction()
1225 extent_io_tree_release(&trans->transaction->dirty_pages); in btrfs_write_and_wait_transaction()
1285 struct list_head *dirty_bgs = &trans->transaction->dirty_bgs; in commit_cowonly_roots()
1286 struct list_head *io_bgs = &trans->transaction->io_bgs; in commit_cowonly_roots()
1292 * At this point no one can be using this transaction to modify any tree in commit_cowonly_roots()
1293 * and no one can start another transaction to modify any tree either. in commit_cowonly_roots()
1295 ASSERT(trans->transaction->state == TRANS_STATE_COMMIT_DOING); in commit_cowonly_roots()
1329 &trans->transaction->switch_commits); in commit_cowonly_roots()
1426 * At this point no one can be using this transaction to modify any tree in commit_fs_roots()
1427 * and no one can start another transaction to modify any tree either. in commit_fs_roots()
1429 ASSERT(trans->transaction->state == TRANS_STATE_COMMIT_DOING); in commit_fs_roots()
1468 &trans->transaction->switch_commits); in commit_fs_roots()
1528 * roots inside one transaction and write all btree into disk, to make
1589 * Now we do a simplified commit transaction, which will: in qgroup_account_snapshot()
1607 "Error while writing out transaction for qgroup"); in qgroup_account_snapshot()
1623 * transaction commit. This does the actual creation.
1626 * If the error which may affect the commitment of the current transaction
1662 * We're inside a transaction and must make sure that any potential in create_pending_snapshot()
1702 trace_btrfs_space_reservation(fs_info, "transaction", in create_pending_snapshot()
1741 if (ret) { /* Transaction aborted */ in create_pending_snapshot()
1909 struct list_head *head = &trans->transaction->pending_snapshots; in create_pending_snapshots()
1976 /* Kick the transaction kthread. */ in btrfs_commit_transaction_async()
1980 /* take transaction reference */ in btrfs_commit_transaction_async()
1981 cur_trans = trans->transaction; in btrfs_commit_transaction_async()
1987 * Wait for the current transaction commit to start and block in btrfs_commit_transaction_async()
1988 * subsequent transaction joins in btrfs_commit_transaction_async()
2000 struct btrfs_transaction *cur_trans = trans->transaction; in cleanup_transaction()
2009 * If the transaction is removed from the list, it means this in cleanup_transaction()
2010 * transaction has been committed successfully, so it is impossible in cleanup_transaction()
2031 * Now that we know no one else is still using the transaction we can in cleanup_transaction()
2032 * remove the transaction from the list of transactions. This avoids in cleanup_transaction()
2033 * the transaction kthread from cleaning up the transaction while some in cleanup_transaction()
2035 * on things like log trees, as it forces the transaction kthread to in cleanup_transaction()
2036 * wait for this transaction to be cleaned up by us. in cleanup_transaction()
2042 btrfs_cleanup_one_transaction(trans->transaction, fs_info); in cleanup_transaction()
2062 * pauses scrub, then starts and commits a transaction before unpausing in cleanup_transaction()
2063 * scrub. If the transaction commit is being done by the relocation in cleanup_transaction()
2078 * transaction and remove them from the list
2099 * from already being in a transaction and our join_transaction doesn't in btrfs_start_delalloc_flush()
2122 * Add a pending snapshot associated with the given transaction handle to the
2123 * respective handle. This must be called after the transaction commit started
2131 struct btrfs_transaction *cur_trans = trans->transaction; in add_pending_snapshot()
2154 struct btrfs_transaction *cur_trans = trans->transaction; in btrfs_commit_transaction()
2175 * We only want one transaction commit doing the flushing so we do not in btrfs_commit_transaction()
2199 * will wait for the transaction to commit if it in btrfs_commit_transaction()
2272 * The previous transaction was aborted and was already removed in btrfs_commit_transaction()
2305 * The thread has started/joined the transaction thus it holds the in btrfs_commit_transaction()
2325 * transaction. Otherwise if this transaction commits before the ordered in btrfs_commit_transaction()
2335 * commit the transaction. We could have started a join before setting in btrfs_commit_transaction()
2344 * The thread has started/joined the transaction thus it holds the in btrfs_commit_transaction()
2365 * do an async commit but somebody else started before the transaction in btrfs_commit_transaction()
2415 WARN_ON(cur_trans != trans->transaction); in btrfs_commit_transaction()
2485 * Before changing the transaction state to TRANS_STATE_UNBLOCKED and in btrfs_commit_transaction()
2488 * start a new transaction and commit a log tree before we commit our in btrfs_commit_transaction()
2511 "Error while writing out transaction"); in btrfs_commit_transaction()
2584 btrfs_warn(fs_info, "Skipping commit of aborted transaction."); in btrfs_commit_transaction()
2642 * We only mark the transaction aborted and then set the file system read-only.
2648 * further cleanup. The transaction should complete as it normally would
2661 WRITE_ONCE(trans->transaction->aborted, errno); in __btrfs_abort_transaction()
2664 /* Wake up anybody who may be waiting on this transaction */ in __btrfs_abort_transaction()