38  * we can roll the transaction to adhere to AG locking order rules and
49  * roll a transaction to facilitate this, but using this facility
61  * start, we define "rolling a deferred-op transaction" as follows:
70  * > Roll the transaction.
72  * NOTE: To avoid exceeding the transaction reservation, we limit the
78  *   - Roll the deferred-op transaction as above.
85  *       wants a new transaction.  See the "Requesting a Fresh
86  *       Transaction while Finishing Deferred Work" section below for
90  * work items every time we roll the transaction, and that we must log
95  * Requesting a Fresh Transaction while Finishing Deferred Work
97  * If ->finish_item decides that it needs a fresh transaction to
101  * to be at risk of exceeding the transaction reservation.
103  * To get a fresh transaction, we want to log the existing log done
106  * transaction, and re-call ->finish_item wherever it left off.  The
108  * transaction or atomicity cannot be guaranteed; defer_finish ensures
112  * defer_finish.  Upon deciding to request a new transaction,
119  * transaction and picks up processing where it left off.  It is
121  * transaction reservation to fit the new log intent item.
251 	 * Mark the transaction dirty, even on error. This ensures the  in xfs_defer_create_done()
252 	 * transaction is aborted, which:  in xfs_defer_create_done()
383  * transaction commits.  Caller is responsible for zero-initializing @dres.
435 /* Attach the held resources to the transaction. */
456 /* Roll a transaction so we can do some deferred op processing. */
471 	 * Roll the transaction.  Rolling always given a new transaction (even  in xfs_defer_trans_roll()
473 	 * join the held resources to the new transaction so that we always  in xfs_defer_trans_roll()
526  * The caller should provide a fresh transaction and roll it after we're done.
598 			 * Caller wants a fresh transaction; put the work item  in xfs_defer_finish_one()
601 			 * Transaction while Finishing Deferred Work" above.  in xfs_defer_finish_one()
645  * any work items that wandered in since the last transaction roll (if
646  * one has even happened), rolling the transaction, and finishing the
649  * If an inode is provided, relog it to the new transaction.
710 	/* Requeue the paused items in the outgoing transaction. */  in xfs_defer_finish_noroll()
736 	 * Finish and roll the transaction once more to avoid returning to the  in xfs_defer_finish()
737 	 * caller with a dirty transaction.  in xfs_defer_finish()
772  * Return the last pending work item attached to this transaction if it matches
797  * to the transaction.
819 /* Create a new pending item at the end of the transaction list. */
929  * Move deferred ops from one transaction to another and reset the source to
931  * transaction rolls with pending dfops.
943 	 * transaction rolls. Transfer low mode on a dfops move to preserve  in xfs_defer_move()
960  * transaction is then ready for the caller to commit it.  If there are no
986 	/* Move the dfops chain and transaction state to the capture struct. */  in xfs_defer_ops_capture()
1011 	 * transaction.  in xfs_defer_ops_capture()
1045  * Capture any deferred ops and commit the transaction.  This is the last step
1061 	/* If we don't capture anything, commit transaction and exit. */  in xfs_defer_ops_capture_and_commit()
1070 	/* Commit the transaction and add the capture structure to the list. */  in xfs_defer_ops_capture_and_commit()
1082  * Attach a chain of captured deferred ops to a new transaction and free the
1084  * caller with ILOCK_EXCL held and joined to the transaction with lockflags==0.
1098 	/* Lock the captured resources to the new transaction. */  in xfs_defer_ops_continue()
1108 	/* Join the captured resources to the new transaction. */  in xfs_defer_ops_continue()
1113 	/* Move captured dfops chain and state to the transaction. */  in xfs_defer_ops_continue()
1221  * next transaction roll.