40  * we can roll the transaction to adhere to AG locking order rules and
51  * roll a transaction to facilitate this, but using this facility
63  * start, we define "rolling a deferred-op transaction" as follows:
72  * > Roll the transaction.
74  * NOTE: To avoid exceeding the transaction reservation, we limit the
80  *   - Roll the deferred-op transaction as above.
87  *       wants a new transaction.  See the "Requesting a Fresh
88  *       Transaction while Finishing Deferred Work" section below for
92  * work items every time we roll the transaction, and that we must log
97  * Requesting a Fresh Transaction while Finishing Deferred Work
99  * If ->finish_item decides that it needs a fresh transaction to
103  * to be at risk of exceeding the transaction reservation.
105  * To get a fresh transaction, we want to log the existing log done
108  * transaction, and re-call ->finish_item wherever it left off.  The
110  * transaction or atomicity cannot be guaranteed; defer_finish ensures
114  * defer_finish.  Upon deciding to request a new transaction,
121  * transaction and picks up processing where it left off.  It is
123  * transaction reservation to fit the new log intent item.
253 	 * Mark the transaction dirty, even on error. This ensures the  in xfs_defer_create_done()
254 	 * transaction is aborted, which:  in xfs_defer_create_done()
385  * transaction commits.  Caller is responsible for zero-initializing @dres.
437 /* Attach the held resources to the transaction. */
458 /* Roll a transaction so we can do some deferred op processing. */
473 	 * Roll the transaction.  Rolling always given a new transaction (even  in xfs_defer_trans_roll()
475 	 * join the held resources to the new transaction so that we always  in xfs_defer_trans_roll()
528  * The caller should provide a fresh transaction and roll it after we're done.
600 			 * Caller wants a fresh transaction; put the work item  in xfs_defer_finish_one()
603 			 * Transaction while Finishing Deferred Work" above.  in xfs_defer_finish_one()
647  * any work items that wandered in since the last transaction roll (if
648  * one has even happened), rolling the transaction, and finishing the
651  * If an inode is provided, relog it to the new transaction.
712 	/* Requeue the paused items in the outgoing transaction. */  in xfs_defer_finish_noroll()
738 	 * Finish and roll the transaction once more to avoid returning to the  in xfs_defer_finish()
739 	 * caller with a dirty transaction.  in xfs_defer_finish()
774  * Return the last pending work item attached to this transaction if it matches
799  * to the transaction.
821 /* Create a new pending item at the end of the transaction list. */
926  * Move deferred ops from one transaction to another and reset the source to
928  * transaction rolls with pending dfops.
940 	 * transaction rolls. Transfer low mode on a dfops move to preserve  in xfs_defer_move()
957  * transaction is then ready for the caller to commit it.  If there are no
983 	/* Move the dfops chain and transaction state to the capture struct. */  in xfs_defer_ops_capture()
1008 	 * transaction.  in xfs_defer_ops_capture()
1042  * Capture any deferred ops and commit the transaction.  This is the last step
1058 	/* If we don't capture anything, commit transaction and exit. */  in xfs_defer_ops_capture_and_commit()
1067 	/* Commit the transaction and add the capture structure to the list. */  in xfs_defer_ops_capture_and_commit()
1079  * Attach a chain of captured deferred ops to a new transaction and free the
1081  * caller with ILOCK_EXCL held and joined to the transaction with lockflags==0.
1095 	/* Lock the captured resources to the new transaction. */  in xfs_defer_ops_continue()
1109 	/* Join the captured resources to the new transaction. */  in xfs_defer_ops_continue()
1114 	/* Move captured dfops chain and state to the transaction. */  in xfs_defer_ops_continue()
1227  * next transaction roll.