xfs/libxfs/xfs_defer.c

27  * we can roll the transaction to adhere to AG locking order rules and
38  * roll a transaction to facilitate this, but using this facility
50  * start, we define "rolling a deferred-op transaction" as follows:
59  * > Roll the transaction.
61  * NOTE: To avoid exceeding the transaction reservation, we limit the
67  *   - Roll the deferred-op transaction as above.
74  *       wants a new transaction.  See the "Requesting a Fresh
75  *       Transaction while Finishing Deferred Work" section below for
79  * work items every time we roll the transaction, and that we must log
84  * Requesting a Fresh Transaction while Finishing Deferred Work
86  * If ->finish_item decides that it needs a fresh transaction to
90  * to be at risk of exceeding the transaction reservation.
92  * To get a fresh transaction, we want to log the existing log done
95  * transaction, and re-call ->finish_item wherever it left off.  The
97  * transaction or atomicity cannot be guaranteed; defer_finish ensures
101  * defer_finish.  Upon deciding to request a new transaction,
108  * transaction and picks up processing where it left off.  It is
110  * transaction reservation to fit the new log intent item.
235 /* Roll a transaction so we can do some deferred op processing. */
291 	 * Roll the transaction.  Rolling always given a new transaction (even  in xfs_defer_trans_roll()
293 	 * join the held resources to the new transaction so that we always  in xfs_defer_trans_roll()
352  * The caller should provide a fresh transaction and roll it after we're done.
424 			 * Caller wants a fresh transaction; put the work item  in xfs_defer_finish_one()
427 			 * Transaction while Finishing Deferred Work" above.  in xfs_defer_finish_one()
451  * any work items that wandered in since the last transaction roll (if
452  * one has even happened), rolling the transaction, and finishing the
455  * If an inode is provided, relog it to the new transaction.
518 	 * Finish and roll the transaction once more to avoid returning to the  in xfs_defer_finish()
519 	 * caller with a dirty transaction.  in xfs_defer_finish()
591  * Move deferred ops from one transaction to another and reset the source to
593  * transaction rolls with pending dfops.
605 	 * transaction rolls. Transfer low mode on a dfops move to preserve  in xfs_defer_move()
622  * transaction is then ready for the caller to commit it.  If there are no
645 	/* Move the dfops chain and transaction state to the capture struct. */  in xfs_defer_ops_capture()
682  * Capture any deferred ops and commit the transaction.  This is the last step
701 	/* If we don't capture anything, commit transaction and exit. */  in xfs_defer_ops_capture_and_commit()
706 	/* Commit the transaction and add the capture structure to the list. */  in xfs_defer_ops_capture_and_commit()
718  * Attach a chain of captured deferred ops to a new transaction and free the
720  * caller with ILOCK_EXCL held and joined to the transaction with lockflags==0.
732 	/* Lock and join the captured inode to the new transaction. */  in xfs_defer_ops_continue()
739 	/* Move captured dfops chain and state to the transaction. */  in xfs_defer_ops_continue()