xfs: don't use delalloc extents for COW on files with extsize hints

While using delalloc for extsize hints is generally a good idea, the
current code that does so only for COW doesn't help us much and creates
a lot of special cases.  Switch it to use real allocations like we
do for direct I/O.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index df6eda3..be9d2a4 100644 (file)
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -918,22 +918,29 @@ xfs_file_iomap_begin(
         * been done up front, so we don't need to do them here.
         */
        if (xfs_is_reflink_inode(ip)) {
+               struct xfs_bmbt_irec    orig = imap;
+
                /* if zeroing doesn't need COW allocation, then we are done. */
                if ((flags & IOMAP_ZERO) &&
                    !needs_cow_for_zeroing(&imap, nimaps))
                        goto out_found;
 
-               if (flags & IOMAP_DIRECT) {
-                       /* may drop and re-acquire the ilock */
-                       error = xfs_reflink_allocate_cow(ip, &imap, &shared,
-                                       &lockmode);
-                       if (error)
-                               goto out_unlock;
-               } else {
-                       error = xfs_reflink_reserve_cow(ip, &imap);
-                       if (error)
-                               goto out_unlock;
-               }
+               /* may drop and re-acquire the ilock */
+               error = xfs_reflink_allocate_cow(ip, &imap, &shared, &lockmode,
+                                                flags);
+               if (error)
+                       goto out_unlock;
+
+               /*
+                * For buffered writes we need to report the address of the
+                * previous block (if there was any) so that the higher level
+                * write code can perform read-modify-write operations.  For
+                * direct I/O code, which must be block aligned we need to
+                * report the newly allocated address.
+                */
+               if (!(flags & IOMAP_DIRECT) &&
+                   orig.br_startblock != HOLESTARTBLOCK)
+                       imap = orig;
 
                end_fsb = imap.br_startoff + imap.br_blockcount;
                length = XFS_FSB_TO_B(mp, end_fsb) - offset;

diff --git a/fs/xfs/xfs_reflink.c b/fs/xfs/xfs_reflink.c
index 2babc2c..8a5353d 100644 (file)
--- a/fs/xfs/xfs_reflink.c
+++ b/fs/xfs/xfs_reflink.c
@@ -397,7 +397,8 @@ xfs_reflink_allocate_cow(
        struct xfs_inode        *ip,
        struct xfs_bmbt_irec    *imap,
        bool                    *shared,
-       uint                    *lockmode)
+       uint                    *lockmode,
+       unsigned                iomap_flags)
 {
        struct xfs_mount        *mp = ip->i_mount;
        xfs_fileoff_t           offset_fsb = imap->br_startoff;
@@ -471,6 +472,13 @@ xfs_reflink_allocate_cow(
        if (nimaps == 0)
                return -ENOSPC;
 convert:
+       /*
+        * COW fork extents are supposed to remain unwritten until we're ready
+        * to initiate a disk write.  For direct I/O we are going to write the
+        * data and need the conversion, but for buffered writes we're done.
+        */
+       if (!(iomap_flags & IOMAP_DIRECT))
+               return 0;
        return xfs_reflink_convert_cow_extent(ip, imap, offset_fsb, count_fsb);
 
 out_unreserve:

diff --git a/fs/xfs/xfs_reflink.h b/fs/xfs/xfs_reflink.h
index 6d73dae..70d68a1 100644 (file)
--- a/fs/xfs/xfs_reflink.h
+++ b/fs/xfs/xfs_reflink.h
@@ -15,7 +15,8 @@ extern int xfs_reflink_trim_around_shared(struct xfs_inode *ip,
 extern int xfs_reflink_reserve_cow(struct xfs_inode *ip,
                struct xfs_bmbt_irec *imap);
 extern int xfs_reflink_allocate_cow(struct xfs_inode *ip,
-               struct xfs_bmbt_irec *imap, bool *shared, uint *lockmode);
+               struct xfs_bmbt_irec *imap, bool *shared, uint *lockmode,
+               unsigned iomap_flags);
 extern int xfs_reflink_convert_cow(struct xfs_inode *ip, xfs_off_t offset,
                xfs_off_t count);