25  * Called with the ail lock held, but we don't want to assert fail with it
26  * held otherwise we'll lock everything up and won't be able to debug the
27  * cause. Hence we sample and check the state under the AIL lock and return if
28  * everything is fine, otherwise we drop the lock and run the ASSERT checks.
109  * We need the AIL lock in order to get a coherent read of the lsn of the last
190  * When the traversal is complete, we need to remove the cursor from the list
205  * freed object. We set the low bit of the cursor item pointer so we can
288  * Splice the log item list into the AIL at the given LSN. We splice to the
306 	 * provided.  If not, or if the one we got is not valid,  in xfs_ail_splice()
314 	 * If a cursor is provided, we know we're processing the AIL  in xfs_ail_splice()
317 	 * cursor to point to that last item, now while we have a  in xfs_ail_splice()
351  * We clear the log item failed state here as well, but we have to be careful
353  * may be the failed log items. Hence if we clear the log item failed state
354  * before queuing the buffer for IO we can release all active references to
357  * order we process them in - the buffer is locked, and we own the buffer list
358  * so nothing on them is going to change while we are performing this action.
360  * Hence we can safely queue the buffer for IO before we clear the failed log
431 	 * If we encountered pinned items or did not finish writing out all  in xfsaild_push()
432 	 * buffers the last time we ran, force the log first and wait for it  in xfsaild_push()
451 	/* we're done if the AIL is empty or our push has reached the end */  in xfsaild_push()
463 		 * Note that iop_push may unlock and reacquire the AIL lock.  We  in xfsaild_push()
480 			 * inode buffer is locked because we already pushed the  in xfsaild_push()
483 			 * We do not want to stop flushing just because lots  in xfsaild_push()
484 			 * of items are already being flushed, but we need to  in xfsaild_push()
516 		 * Are there too many items we can't do anything with?  in xfsaild_push()
518 		 * If we are skipping too many items because we can't flush  in xfsaild_push()
519 		 * them or they are already being flushed, we back off and  in xfsaild_push()
521 		 * done. i.e. remove pressure from the AIL while we can't make  in xfsaild_push()
546 		 * We reached the target or the AIL is empty, so wait a bit  in xfsaild_push()
548 		 * AIL before we start the next scan from the start of the AIL.  in xfsaild_push()
554 		 * Either there is a lot of contention on the AIL or we are  in xfsaild_push()
556 		 * is defined as >90% of the items we tried to push were stuck.  in xfsaild_push()
567 		 * Assume we have more work to do in a short while.  in xfsaild_push()
593 		 * Check kthread_should_stop() after we set the task state to  in xfsaild()
594 		 * guarantee that we either see the stop bit and exit or the  in xfsaild()
614 			 * happen if we're shutting down, so this is the last  in xfsaild()
626 		 * Idle if the AIL is empty and we are not racing with a target  in xfsaild()
627 		 * update. We check the AIL after we set the task to a sleep  in xfsaild()
628 		 * state to guarantee that we either catch an ail_target update  in xfsaild()
630 		 * Otherwise, we run the risk of sleeping indefinitely.  in xfsaild()
666  * We don't want to interrupt any push that is in progress, hence we only queue
667  * work if we set the pushing bit appropriately.
669  * We do this unlocked - we only need to know whether there is anything in the
670  * AIL at the time we are called. We don't need to access the contents of
761  * it to the AIL. If we move the first item in the AIL, update the log tail to
766  * lock held. As a result, once we have the AIL lock, we need to check each log
769  * To optimise the insert operation, we delete all the items from the AIL in
796 			/* check if we really need to move the item */  in xfs_trans_ail_update_bulk()
833  * that we can use it to check if the LSN of the tail of the log has moved