xfs: reclaim speculative preallocations for append only files

The XFS XFS_DIFLAG_APPEND maps to the VFS S_APPEND flag, which forbids
writes that don't append at the current EOF.

But the commit originally adding XFS_DIFLAG_APPEND support (commit
a23321e766d in xfs xfs-import repository) also checked it to skip
releasing speculative preallocations, which doesn't make any sense.

Another commit (dd9f438e3290 in the xfs-import repository) later extended
that flag to also report these speculation preallocations which should
not exist in getbmap.

Remove these checks as nothing XFS_DIFLAG_APPEND implies that
preallocations beyond EOF should exist, but explicitly check for
XFS_DIFLAG_APPEND in xfs_file_release to bypass the algorithm that
discard preallocations on the first close as append only files aren't
expected to be written to only once.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Chandan Babu R <chandanbabu@kernel.org>

diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
index fd9f3ac179f1dcb3b0e460697fec180702ed5cbe..087867be0cf92ddcfb9c0bbfd0a3523d6d7b73a8 100644 (file)
--- a/fs/xfs/xfs_bmap_util.c
+++ b/fs/xfs/xfs_bmap_util.c
@@ -331,8 +331,7 @@ xfs_getbmap(
                }
 
                if (xfs_get_extsz_hint(ip) ||
-                   (ip->i_diflags &
-                    (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)))
+                   (ip->i_diflags & XFS_DIFLAG_PREALLOC))
                        max_len = mp->m_super->s_maxbytes;
                else
                        max_len = XFS_ISIZE(ip);
@@ -524,12 +523,11 @@ xfs_can_free_eofblocks(
                return false;
 
        /*
-        * Only free real extents for inodes with persistent preallocations or
-        * the append-only flag.
+        * Do not free real extents in preallocated files unless the file has
+        * delalloc blocks and we are forced to remove them.
         */
-       if (ip->i_diflags & (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND))
-               if (ip->i_delayed_blks == 0)
-                       return false;
+       if ((ip->i_diflags & XFS_DIFLAG_PREALLOC) && !ip->i_delayed_blks)
+               return false;
 
        /*
         * Do not try to free post-EOF blocks if EOF is beyond the end of the

diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index 986448d1ff3c0cf3fa5d615ca132371750e85454..0d258c21b9897fc2b931061f5cf8e0367d58e73e 100644 (file)
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -1220,6 +1220,9 @@ xfs_file_release(
         * one file after another without going back to it while keeping the
         * preallocation for files that have recurring open/write/close cycles.
         *
+        * This heuristic is skipped for inodes with the append-only flag as
+        * that flag is rather pointless for inodes written only once.
+        *
         * There is no point in freeing blocks here for open but unlinked files
         * as they will be taken care of by the inactivation path soon.
         *
@@ -1234,6 +1237,7 @@ xfs_file_release(
         */
        if (inode->i_nlink &&
            (file->f_mode & FMODE_WRITE) &&
+           !(ip->i_diflags & XFS_DIFLAG_APPEND) &&
            !xfs_iflags_test(ip, XFS_EOFBLOCKS_RELEASED) &&
            xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL)) {
                if (xfs_can_free_eofblocks(ip) &&

diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
index 887d2a01161e427bfdb5764c8821821a8cc8e0af..1a87c56c91c39c39ab6dd3e0f6cd457babcdb3d9 100644 (file)
--- a/fs/xfs/xfs_icache.c
+++ b/fs/xfs/xfs_icache.c
@@ -1159,7 +1159,7 @@ xfs_inode_free_eofblocks(
        if (xfs_can_free_eofblocks(ip))
                return xfs_free_eofblocks(ip);
 
-       /* inode could be preallocated or append-only */
+       /* inode could be preallocated */
        trace_xfs_inode_free_eofblocks_invalid(ip);
        xfs_inode_clear_eofblocks_tag(ip);
        return 0;