1 files changed, 17 insertions, 62 deletions

diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index b927ea9abe33..c68517b0f248 100644
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -333,10 +333,7 @@ xfs_file_dax_read(
         struct kiocb            *iocb,
         struct iov_iter         *to)
 {
-        struct address_space    *mapping = iocb->ki_filp->f_mapping;
-        struct inode            *inode = mapping->host;
-        struct xfs_inode        *ip = XFS_I(inode);
-        struct iov_iter         data = *to;
+        struct xfs_inode        *ip = XFS_I(iocb->ki_filp->f_mapping->host);
         size_t                  count = iov_iter_count(to);
         ssize_t                 ret = 0;
 
@@ -346,11 +343,7 @@ xfs_file_dax_read(
                 return 0; /* skip atime */
 
         xfs_rw_ilock(ip, XFS_IOLOCK_SHARED);
-        ret = dax_do_io(iocb, inode, &data, xfs_get_blocks_direct, NULL, 0);
-        if (ret > 0) {
-                iocb->ki_pos += ret;
-                iov_iter_advance(to, ret);
-        }
+        ret = iomap_dax_rw(iocb, to, &xfs_iomap_ops);
         xfs_rw_iunlock(ip, XFS_IOLOCK_SHARED);
 
         file_accessed(iocb->ki_filp);
@@ -712,70 +705,32 @@ xfs_file_dax_write(
         struct kiocb            *iocb,
         struct iov_iter         *from)
 {
-        struct address_space    *mapping = iocb->ki_filp->f_mapping;
-        struct inode            *inode = mapping->host;
+        struct inode            *inode = iocb->ki_filp->f_mapping->host;
         struct xfs_inode        *ip = XFS_I(inode);
-        struct xfs_mount        *mp = ip->i_mount;
-        ssize_t                 ret = 0;
-        int                     unaligned_io = 0;
-        int                     iolock;
-        struct iov_iter         data;
+        int                     iolock = XFS_IOLOCK_EXCL;
+        ssize_t                 ret, error = 0;
+        size_t                  count;
+        loff_t                  pos;
 
-        /* "unaligned" here means not aligned to a filesystem block */
-        if ((iocb->ki_pos & mp->m_blockmask) ||
-            ((iocb->ki_pos + iov_iter_count(from)) & mp->m_blockmask)) {
-                unaligned_io = 1;
-                iolock = XFS_IOLOCK_EXCL;
-        } else if (mapping->nrpages) {
-                iolock = XFS_IOLOCK_EXCL;
-        } else {
-                iolock = XFS_IOLOCK_SHARED;
-        }
         xfs_rw_ilock(ip, iolock);
-
         ret = xfs_file_aio_write_checks(iocb, from, &iolock);
         if (ret)
                 goto out;
 
-        /*
-         * Yes, even DAX files can have page cache attached to them:  A zeroed
-         * page is inserted into the pagecache when we have to serve a write
-         * fault on a hole.  It should never be dirtied and can simply be
-         * dropped from the pagecache once we get real data for the page.
-         *
-         * XXX: This is racy against mmap, and there's nothing we can do about
-         * it. dax_do_io() should really do this invalidation internally as
-         * it will know if we've allocated over a holei for this specific IO and
-         * if so it needs to update the mapping tree and invalidate existing
-         * PTEs over the newly allocated range. Remove this invalidation when
-         * dax_do_io() is fixed up.
-         */
-        if (mapping->nrpages) {
-                loff_t end = iocb->ki_pos + iov_iter_count(from) - 1;
+        pos = iocb->ki_pos;
+        count = iov_iter_count(from);
 
-                ret = invalidate_inode_pages2_range(mapping,
-                                                    iocb->ki_pos >> PAGE_SHIFT,
-                                                    end >> PAGE_SHIFT);
-                WARN_ON_ONCE(ret);
-        }
+        trace_xfs_file_dax_write(ip, count, pos);
 
-        if (iolock == XFS_IOLOCK_EXCL && !unaligned_io) {
-                xfs_rw_ilock_demote(ip, XFS_IOLOCK_EXCL);
-                iolock = XFS_IOLOCK_SHARED;
+        ret = iomap_dax_rw(iocb, from, &xfs_iomap_ops);
+        if (ret > 0 && iocb->ki_pos > i_size_read(inode)) {
+                i_size_write(inode, iocb->ki_pos);
+                error = xfs_setfilesize(ip, pos, ret);
         }
 
-        trace_xfs_file_dax_write(ip, iov_iter_count(from), iocb->ki_pos);
-
-        data = *from;
-        ret = dax_do_io(iocb, inode, &data, xfs_get_blocks_direct,
-                        xfs_end_io_direct_write, 0);
-        if (ret > 0) {
-                iocb->ki_pos += ret;
-                iov_iter_advance(from, ret);
-        }
 out:
         xfs_rw_iunlock(ip, iolock);
-        return ret;
+        return error ? error : ret;
 }
 
 STATIC ssize_t
@@ -1514,7 +1469,7 @@ xfs_filemap_page_mkwrite(
         xfs_ilock(XFS_I(inode), XFS_MMAPLOCK_SHARED);
 
         if (IS_DAX(inode)) {
-                ret = dax_mkwrite(vma, vmf, xfs_get_blocks_dax_fault);
+                ret = iomap_dax_fault(vma, vmf, &xfs_iomap_ops);
         } else {
                 ret = iomap_page_mkwrite(vma, vmf, &xfs_iomap_ops);
                 ret = block_page_mkwrite_return(ret);
@@ -1548,7 +1503,7 @@ xfs_filemap_fault(
                  * changes to xfs_get_blocks_direct() to map unwritten extent
                  * ioend for conversion on read-only mappings.
                  */
-                ret = dax_fault(vma, vmf, xfs_get_blocks_dax_fault);
+                ret = iomap_dax_fault(vma, vmf, &xfs_iomap_ops);
         } else
                 ret = filemap_fault(vma, vmf);
         xfs_iunlock(XFS_I(inode), XFS_MMAPLOCK_SHARED);