[XFS] avoid race in sync_inodes() that can fail to write out all dirty data

		flags |= FLUSH_SYNC;

	}

	error = xfs_inode_flush(XFS_I(inode), flags);

	if (error == EAGAIN) {

		if (sync)

			error = xfs_inode_flush(XFS_I(inode),

						       flags | FLUSH_LOG);

		else

			error = 0;

	}

	/*

	 * if we failed to write out the inode then mark

	 * it dirty again so we'll try again later.

	 */

	if (error)

		mark_inode_dirty_sync(inode);

	return -error;

}

	int			error;

	int			flags;

	if (unlikely(sb->s_frozen == SB_FREEZE_WRITE)) {

	/*

	 * Treat a sync operation like a freeze.  This is to work

	 * around a race in sync_inodes() which works in two phases

	 * - an asynchronous flush, which can write out an inode

	 * without waiting for file size updates to complete, and a

	 * synchronous flush, which wont do anything because the

	 * async flush removed the inode's dirty flag.  Also

	 * sync_inodes() will not see any files that just have

	 * outstanding transactions to be flushed because we don't

	 * dirty the Linux inode until after the transaction I/O

	 * completes.

	 */

	if (wait || unlikely(sb->s_frozen == SB_FREEZE_WRITE)) {

		/*

		 * First stage of freeze - no more writers will make progress

		 * now we are here, so we flush delwri and delalloc buffers

		 */

		flags = SYNC_DATA_QUIESCE;

	} else

		flags = SYNC_FSDATA | (wait ? SYNC_WAIT : 0);

		flags = SYNC_FSDATA;

	error = xfs_sync(mp, flags);

	sb->s_dirt = 0;