Merge tag 'xfs-4.11-merge-7' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux

Pull xfs updates from Darrick Wong:
 "Here are the XFS changes for 4.11. We aren't introducing any major
  features in this release cycle except for this being the first merge
  window I've managed on my own. :)

  Changes since last update:

   - Various cleanups

   - Livelock fixes for eofblocks scanning

   - Improved input verification for on-disk metadata

   - Fix races in the copy on write remap mechanism

   - Fix buffer io error timeout controls

   - Streamlining of directio copy on write

   - Asynchronous discard support

   - Fix asserts when splitting delalloc reservations

   - Don't bloat bmbt when right shifting extents

   - Inode alignment fixes for 32k block sizes"

* tag 'xfs-4.11-merge-7' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux: (39 commits)
  xfs: remove XFS_ALLOCTYPE_ANY_AG and XFS_ALLOCTYPE_START_AG
  xfs: simplify xfs_rtallocate_extent
  xfs: tune down agno asserts in the bmap code
  xfs: Use xfs_icluster_size_fsb() to calculate inode chunk alignment
  xfs: don't reserve blocks for right shift transactions
  xfs: fix len comparison in xfs_extent_busy_trim
  xfs: fix uninitialized variable in _reflink_convert_cow
  xfs: split indlen reservations fairly when under reserved
  xfs: handle indlen shortage on delalloc extent merge
  xfs: resurrect debug mode drop buffered writes mechanism
  xfs: clear delalloc and cache on buffered write failure
  xfs: don't block the log commit handler for discards
  xfs: improve busy extent sorting
  xfs: improve handling of busy extents in the low-level allocator
  xfs: don't fail xfs_extent_busy allocation
  xfs: correct null checks and error processing in xfs_initialize_perag
  xfs: update ctime and mtime on clone destinatation inodes
  xfs: allocate direct I/O COW blocks in iomap_begin
  xfs: go straight to real allocations for direct I/O COW writes
  xfs: return the converted extent in __xfs_reflink_convert_cow
  ...

1 files changed, 28 insertions, 23 deletions

diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index de32f0fe47c8..edfa6a55b064 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -1692,32 +1692,34 @@ xfs_release(
         if (xfs_can_free_eofblocks(ip, false)) {
 
                 /*
+                 * Check if the inode is being opened, written and closed
+                 * frequently and we have delayed allocation blocks outstanding
+                 * (e.g. streaming writes from the NFS server), truncating the
+                 * blocks past EOF will cause fragmentation to occur.
+                 *
+                 * In this case don't do the truncation, but we have to be
+                 * careful how we detect this case. Blocks beyond EOF show up as
+                 * i_delayed_blks even when the inode is clean, so we need to
+                 * truncate them away first before checking for a dirty release.
+                 * Hence on the first dirty close we will still remove the
+                 * speculative allocation, but after that we will leave it in
+                 * place.
+                 */
+                if (xfs_iflags_test(ip, XFS_IDIRTY_RELEASE))
+                        return 0;
+                /*
                  * If we can't get the iolock just skip truncating the blocks
                  * past EOF because we could deadlock with the mmap_sem
-                 * otherwise.  We'll get another chance to drop them once the
+                 * otherwise. We'll get another chance to drop them once the
                  * last reference to the inode is dropped, so we'll never leak
                  * blocks permanently.
-                 *
-                 * Further, check if the inode is being opened, written and
-                 * closed frequently and we have delayed allocation blocks
-                 * outstanding (e.g. streaming writes from the NFS server),
-                 * truncating the blocks past EOF will cause fragmentation to
-                 * occur.
-                 *
-                 * In this case don't do the truncation, either, but we have to
-                 * be careful how we detect this case. Blocks beyond EOF show
-                 * up as i_delayed_blks even when the inode is clean, so we
-                 * need to truncate them away first before checking for a dirty
-                 * release. Hence on the first dirty close we will still remove
-                 * the speculative allocation, but after that we will leave it
-                 * in place.
                  */
-                if (xfs_iflags_test(ip, XFS_IDIRTY_RELEASE))
-                        return 0;
-
-                error = xfs_free_eofblocks(mp, ip, true);
-                if (error && error != -EAGAIN)
-                        return error;
+                if (xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL)) {
+                        error = xfs_free_eofblocks(ip);
+                        xfs_iunlock(ip, XFS_IOLOCK_EXCL);
+                        if (error)
+                                return error;
+                }
 
                 /* delalloc blocks after truncation means it really is dirty */
                 if (ip->i_delayed_blks)
@@ -1904,8 +1906,11 @@ xfs_inactive(
                  * cache. Post-eof blocks must be freed, lest we end up with
                  * broken free space accounting.
                  */
-                if (xfs_can_free_eofblocks(ip, true))
-                        xfs_free_eofblocks(mp, ip, false);
+                if (xfs_can_free_eofblocks(ip, true)) {
+                        xfs_ilock(ip, XFS_IOLOCK_EXCL);
+                        xfs_free_eofblocks(ip);
+                        xfs_iunlock(ip, XFS_IOLOCK_EXCL);
+                }
 
                 return;
         }