16 #include "transaction.h"
29  * Transaction states and transitions
31  * No running transaction (fs tree blocks are not modified)
36  * Transaction N [[TRANS_STATE_RUNNING]]
38  * | New trans handles can be attached to transaction N by calling all
43  * |  transaction N
45  * Transaction N [[TRANS_STATE_COMMIT_START]]
47  * | Will wait for previous running transaction to completely finish if there
53  * | - Wait for current transaction to be committed by others.
57  * | to this running transaction.
59  * | transaction N+1.
62  * |  Caller is chosen to commit transaction N, and all other trans handle
65  * Transaction N [[TRANS_STATE_COMMIT_DOING]]
67  * | The heavy lifting transaction work is started.
74  * | transaction to finish and attach to transaction N+1.
79  * Transaction N [[TRANS_STATE_UNBLOCKED]]
80  * |						    Transaction N+1
85  * | At this stage, new transaction is allowed to   |
94  * Transaction N [[TRANS_STATE_COMPLETED]]	    V
95  *   All tree blocks and super blocks are written.  Transaction N+1
96  *   This transaction is finished and all its	    [[TRANS_STATE_COMMIT_START]]
118 void btrfs_put_transaction(struct btrfs_transaction *transaction)  in btrfs_put_transaction()  argument
120 	WARN_ON(refcount_read(&transaction->use_count) == 0);  in btrfs_put_transaction()
121 	if (refcount_dec_and_test(&transaction->use_count)) {  in btrfs_put_transaction()
122 		BUG_ON(!list_empty(&transaction->list));  in btrfs_put_transaction()
124 				&transaction->delayed_refs.href_root.rb_root));  in btrfs_put_transaction()
126 				&transaction->delayed_refs.dirty_extent_root));  in btrfs_put_transaction()
127 		if (transaction->delayed_refs.pending_csums)  in btrfs_put_transaction()
128 			btrfs_err(transaction->fs_info,  in btrfs_put_transaction()
130 				  transaction->delayed_refs.pending_csums);  in btrfs_put_transaction()
133 		 * because the transaction was aborted and a commit did not  in btrfs_put_transaction()
138 		while (!list_empty(&transaction->deleted_bgs)) {  in btrfs_put_transaction()
141 			cache = list_first_entry(&transaction->deleted_bgs,  in btrfs_put_transaction()
148 		WARN_ON(!list_empty(&transaction->dev_update_list));  in btrfs_put_transaction()
149 		kfree(transaction);  in btrfs_put_transaction()
155 	struct btrfs_transaction *cur_trans = trans->transaction;  in switch_commit_roots()
212  * To be called after all the new block groups attached to the transaction
230  * either allocate a new transaction or hop into the existing one
264 	 * If we are ATTACH, we just want to catch the current transaction,  in join_transaction()
265 	 * and commit it. If there is no transaction, just return ENOENT.  in join_transaction()
271 	 * JOIN_NOLOCK only happens during the transaction commit, so  in join_transaction()
283 		 * someone started a transaction after we unlocked.  Make sure  in join_transaction()
304 	 * commit the transaction.  in join_transaction()
317 	 * although the tree mod log is per file system and not per transaction,  in join_transaction()
318 	 * the log must never go across transaction boundaries.  in join_transaction()
322 		WARN(1, KERN_ERR "BTRFS: tree_mod_seq_list not empty when creating a fresh transaction\n");  in join_transaction()
324 		WARN(1, KERN_ERR "BTRFS: tree_mod_log rb tree not empty when creating a fresh transaction\n");  in join_transaction()
355  * is properly recorded in a given transaction.  This is required to make sure
356  * the old root from before we joined the transaction is deleted when the
357  * transaction commits.
396 		 * this transaction.  in record_root_in_trans()
424 	struct btrfs_transaction *cur_trans = trans->transaction;  in btrfs_add_dropped_root()
426 	/* Add ourselves to the transaction dropped list */  in btrfs_add_dropped_root()
470 /* wait for commit against the current transaction to become unblocked
471  * when this is done, it is safe to start a new transaction, but the current
472  * transaction might not be fully on disk.
549 	 * Do the reservation before we join the transaction so we can do all  in start_transaction()
564 		 * we only do 1 enospc flushing cycle per transaction start.  We  in start_transaction()
616 	 * If we are JOIN_NOLOCK we're already committing a transaction and  in start_transaction()
623 	 * transaction and commit it, so we needn't do sb_start_intwrite().   in start_transaction()
647 	h->transaction = cur_trans;  in start_transaction()
665 		trace_btrfs_space_reservation(fs_info, "transaction",  in start_transaction()
692 	 * transaction.  in start_transaction()
742  * Similar to regular join but it never starts a transaction when none is
752  * btrfs_attach_transaction() - catch the running transaction
754  * It is used when we want to commit the current the transaction, but
758  * running transaction. But it is possible that the inactive transaction
760  * inactive transaction in the fs when -ENOENT is returned, you should
771  * btrfs_attach_transaction_barrier() - catch the running transaction
790 /* wait for a transaction commit to be fully complete */
805 		/* find specified transaction */  in btrfs_wait_for_commit()
822 		 * The specified transaction doesn't exist, or we  in btrfs_wait_for_commit()
831 		/* find newest transaction that is committing | committed */  in btrfs_wait_for_commit()
871 	struct btrfs_transaction *cur_trans = trans->transaction;  in btrfs_should_end_transaction()
895 	trace_btrfs_space_reservation(fs_info, "transaction",  in btrfs_trans_release_metadata()
906 	struct btrfs_transaction *cur_trans = trans->transaction;  in __btrfs_end_transaction()
996 		 * the transaction (through extent_io_tree_release()).  in btrfs_write_marked_extents()
1020  * those extents are on disk for transaction or log commit.  We wait
1037 		 * When committing the transaction, we'll remove any entries  in __btrfs_wait_marked_extents()
1040 		 * concurrently - we do it only at transaction commit time when  in __btrfs_wait_marked_extents()
1101  * This function ensures such extents are persisted on disk for transaction or
1104  * @trans: transaction whose dirty pages we'd like to write
1110 	struct extent_io_tree *dirty_pages = &trans->transaction->dirty_pages;  in btrfs_write_and_wait_transaction()
1119 	extent_io_tree_release(&trans->transaction->dirty_pages);  in btrfs_write_and_wait_transaction()
1179 	struct list_head *dirty_bgs = &trans->transaction->dirty_bgs;  in commit_cowonly_roots()
1180 	struct list_head *io_bgs = &trans->transaction->io_bgs;  in commit_cowonly_roots()
1226 				      &trans->transaction->switch_commits);  in commit_cowonly_roots()
1248 		      &trans->transaction->switch_commits);  in commit_cowonly_roots()
1311 					&trans->transaction->switch_commits);  in commit_fs_roots()
1370  * roots inside one transaction and write all btree into disk, to make
1399 	 * We are going to commit transaction, see btrfs_commit_transaction()  in qgroup_account_snapshot()
1418 	 * Now we do a simplified commit transaction, which will:  in qgroup_account_snapshot()
1436 			"Error while writing out transaction for qgroup");  in qgroup_account_snapshot()
1454  * transaction commit.  This does the actual creation.
1457  * If the error which may affect the commitment of the current transaction
1519 	trace_btrfs_space_reservation(fs_info, "transaction",  in create_pending_snapshot()
1557 	if (ret) {	/* Transaction aborted */  in create_pending_snapshot()
1734 	struct list_head *head = &trans->transaction->pending_snapshots;  in create_pending_snapshots()
1795  * wait for the current transaction commit to start and block subsequent
1796  * transaction joins
1807  * wait for the current transaction to start and then become unblocked.
1821  * returns, any subsequent transaction will not be allowed to join.
1834 	 * We've got freeze protection passed with the transaction.  in do_async_commit()
1865 	/* take transaction reference */  in btrfs_commit_transaction_async()
1866 	cur_trans = trans->transaction;  in btrfs_commit_transaction_async()
1880 	/* wait for transaction to start and unblock */  in btrfs_commit_transaction_async()
1897 	struct btrfs_transaction *cur_trans = trans->transaction;  in cleanup_transaction()
1906 	 * If the transaction is removed from the list, it means this  in cleanup_transaction()
1907 	 * transaction has been committed successfully, so it is impossible  in cleanup_transaction()
1923 	btrfs_cleanup_one_transaction(trans->transaction, fs_info);  in cleanup_transaction()
1946  * transaction and remove them from the list
1969 	 * from already being in a transaction and our join_transaction doesn't  in btrfs_start_delalloc_flush()
1976 		struct list_head *head = &trans->transaction->pending_snapshots;  in btrfs_start_delalloc_flush()
2004 		struct list_head *head = &trans->transaction->pending_snapshots;  in btrfs_wait_delalloc_flush()
2021 	struct btrfs_transaction *cur_trans = trans->transaction;  in btrfs_commit_transaction()
2028 	 * Some places just start a transaction to commit it.  We need to make  in btrfs_commit_transaction()
2030 	 * transaction as failed, so set trans->dirty to make the abort code do  in btrfs_commit_transaction()
2054 	cur_trans = trans->transaction;  in btrfs_commit_transaction()
2057 	 * set the flushing flag so procs in this transaction have to  in btrfs_commit_transaction()
2079 		 * will wait for the transaction to commit if it  in btrfs_commit_transaction()
2140 		 * The previous transaction was aborted and was already removed  in btrfs_commit_transaction()
2173 	 * transaction. Otherwise if this transaction commits before the ordered  in btrfs_commit_transaction()
2182 	 * commit the transaction.  We could have started a join before setting  in btrfs_commit_transaction()
2235 	WARN_ON(cur_trans != trans->transaction);  in btrfs_commit_transaction()
2257 	 * Since the transaction is done, we can apply the pending changes  in btrfs_commit_transaction()
2258 	 * before the next transaction.  in btrfs_commit_transaction()
2339 				      "Error while writing out transaction");  in btrfs_commit_transaction()
2402 	btrfs_warn(fs_info, "Skipping commit of aborted transaction.");  in btrfs_commit_transaction()