351  * Take care of zeroing post-EOF blocks when they might exist.
370 	 * We need to serialise against EOF updates that occur in IO completions  in xfs_file_write_zero_eof()
375 	 * XFS_IOLOCK_EXCL so we are guaranteed to see the latest EOF value and  in xfs_file_write_zero_eof()
404 		 * EOF updates during IO completion and hence we now need to  in xfs_file_write_zero_eof()
474 	 * blocks that fall between the existing EOF and the start of this  in xfs_file_write_checks()
478 	 * can only extend EOF.  Truncate is locked out at this point, so the  in xfs_file_write_checks()
479 	 * EOF can not move backwards, only forwards. Hence we only need to take  in xfs_file_write_checks()
480 	 * the slow path when we are at or beyond the current EOF.  in xfs_file_write_checks()
549 	 * have no other method of updating EOF for AIO, so always do it here  in xfs_dio_write_end_io()
552 	 * We need to lock the test/set EOF update as we can be racing with  in xfs_dio_write_end_io()
553 	 * other IO completions here to update the EOF. Failing to serialise  in xfs_dio_write_end_io()
554 	 * here can result in EOF moving backwards and Bad Things Happen when  in xfs_dio_write_end_io()
557 	 * As IO completion only ever extends EOF, we can do an unlocked check  in xfs_dio_write_end_io()
558 	 * here to avoid taking the spinlock. If we land within the current EOF,  in xfs_dio_write_end_io()
561 	 * EOF, then we'll either still be beyond EOF and need to take the lock,  in xfs_dio_write_end_io()
562 	 * or we'll be within EOF and we don't need to take it at all.  in xfs_dio_write_end_io()
653 	 * that the DIO code always does for partial tail blocks beyond EOF, so  in xfs_file_dio_write_unaligned()
945 	 * There is no need to overlap collapse range with EOF, in which case it  in xfs_falloc_collapse_range()
988 	 * past EOF and hence losing access to the data that is contained within  in xfs_falloc_insert_range()
1330 	 * XFS aggressively preallocates post-EOF space to generate contiguous  in xfs_file_release()
1346 	 * When releasing a read-only context, don't flush data or trim post-EOF  in xfs_file_release()
1347 	 * blocks.  This avoids open/read/close workloads from removing EOF  in xfs_file_release()
1350 	 * If we can't get the iolock just skip truncating the blocks past EOF  in xfs_file_release()