Merge tag 'mm-stable-2023-06-24-19-15' of git://git.kernel.org/pub/scm/linux/kernel...

[linux-2.6-microblaze.git] / fs / iomap / direct-io.c

diff --git a/fs/iomap/direct-io.c b/fs/iomap/direct-io.c
index 08873f0..ea3b868 100644 (file)
--- a/fs/iomap/direct-io.c
+++ b/fs/iomap/direct-io.c
@@ -81,7 +81,6 @@ ssize_t iomap_dio_complete(struct iomap_dio *dio)
 {
        const struct iomap_dio_ops *dops = dio->dops;
        struct kiocb *iocb = dio->iocb;
-       struct inode *inode = file_inode(iocb->ki_filp);
        loff_t offset = iocb->ki_pos;
        ssize_t ret = dio->error;
 
@@ -94,7 +93,6 @@ ssize_t iomap_dio_complete(struct iomap_dio *dio)
                if (offset + ret > dio->i_size &&
                    !(dio->flags & IOMAP_DIO_WRITE))
                        ret = dio->i_size - offset;
-               iocb->ki_pos += ret;
        }
 
        /*
@@ -109,30 +107,25 @@ ssize_t iomap_dio_complete(struct iomap_dio *dio)
         * ->end_io() when necessary, otherwise a racing buffer read would cache
         * zeros from unwritten extents.
         */
-       if (!dio->error && dio->size &&
-           (dio->flags & IOMAP_DIO_WRITE) && inode->i_mapping->nrpages) {
-               int err;
-               err = invalidate_inode_pages2_range(inode->i_mapping,
-                               offset >> PAGE_SHIFT,
-                               (offset + dio->size - 1) >> PAGE_SHIFT);
-               if (err)
-                       dio_warn_stale_pagecache(iocb->ki_filp);
-       }
+       if (!dio->error && dio->size && (dio->flags & IOMAP_DIO_WRITE))
+               kiocb_invalidate_post_direct_write(iocb, dio->size);
 
        inode_dio_end(file_inode(iocb->ki_filp));
-       /*
-        * If this is a DSYNC write, make sure we push it to stable storage now
-        * that we've written data.
-        */
-       if (ret > 0 && (dio->flags & IOMAP_DIO_NEED_SYNC))
-               ret = generic_write_sync(iocb, ret);
 
-       if (ret > 0)
-               ret += dio->done_before;
+       if (ret > 0) {
+               iocb->ki_pos += ret;
 
+               /*
+                * If this is a DSYNC write, make sure we push it to stable
+                * storage now that we've written data.
+                */
+               if (dio->flags & IOMAP_DIO_NEED_SYNC)
+                       ret = generic_write_sync(iocb, ret);
+               if (ret > 0)
+                       ret += dio->done_before;
+       }
        trace_iomap_dio_complete(iocb, dio->error, ret);
        kfree(dio);
-
        return ret;
 }
 EXPORT_SYMBOL_GPL(iomap_dio_complete);
@@ -478,7 +471,6 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
                const struct iomap_ops *ops, const struct iomap_dio_ops *dops,
                unsigned int dio_flags, void *private, size_t done_before)
 {
-       struct address_space *mapping = iocb->ki_filp->f_mapping;
        struct inode *inode = file_inode(iocb->ki_filp);
        struct iomap_iter iomi = {
                .inode          = inode,
@@ -487,11 +479,11 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
                .flags          = IOMAP_DIRECT,
                .private        = private,
        };
-       loff_t end = iomi.pos + iomi.len - 1, ret = 0;
        bool wait_for_completion =
                is_sync_kiocb(iocb) || (dio_flags & IOMAP_DIO_FORCE_WAIT);
        struct blk_plug plug;
        struct iomap_dio *dio;
+       loff_t ret = 0;
 
        trace_iomap_dio_rw_begin(iocb, iter, dio_flags, done_before);
 
@@ -515,31 +507,29 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
        dio->submit.waiter = current;
        dio->submit.poll_bio = NULL;
 
+       if (iocb->ki_flags & IOCB_NOWAIT)
+               iomi.flags |= IOMAP_NOWAIT;
+
        if (iov_iter_rw(iter) == READ) {
                if (iomi.pos >= dio->i_size)
                        goto out_free_dio;
 
-               if (iocb->ki_flags & IOCB_NOWAIT) {
-                       if (filemap_range_needs_writeback(mapping, iomi.pos,
-                                       end)) {
-                               ret = -EAGAIN;
-                               goto out_free_dio;
-                       }
-                       iomi.flags |= IOMAP_NOWAIT;
-               }
-
                if (user_backed_iter(iter))
                        dio->flags |= IOMAP_DIO_DIRTY;
+
+               ret = kiocb_write_and_wait(iocb, iomi.len);
+               if (ret)
+                       goto out_free_dio;
        } else {
                iomi.flags |= IOMAP_WRITE;
                dio->flags |= IOMAP_DIO_WRITE;
 
-               if (iocb->ki_flags & IOCB_NOWAIT) {
-                       if (filemap_range_has_page(mapping, iomi.pos, end)) {
-                               ret = -EAGAIN;
+               if (dio_flags & IOMAP_DIO_OVERWRITE_ONLY) {
+                       ret = -EAGAIN;
+                       if (iomi.pos >= dio->i_size ||
+                           iomi.pos + iomi.len > dio->i_size)
                                goto out_free_dio;
-                       }
-                       iomi.flags |= IOMAP_NOWAIT;
+                       iomi.flags |= IOMAP_OVERWRITE_ONLY;
                }
 
                /* for data sync or sync, we need sync completion processing */
@@ -555,31 +545,19 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
                        if (!(iocb->ki_flags & IOCB_SYNC))
                                dio->flags |= IOMAP_DIO_WRITE_FUA;
                }
-       }
 
-       if (dio_flags & IOMAP_DIO_OVERWRITE_ONLY) {
-               ret = -EAGAIN;
-               if (iomi.pos >= dio->i_size ||
-                   iomi.pos + iomi.len > dio->i_size)
-                       goto out_free_dio;
-               iomi.flags |= IOMAP_OVERWRITE_ONLY;
-       }
-
-       ret = filemap_write_and_wait_range(mapping, iomi.pos, end);
-       if (ret)
-               goto out_free_dio;
-
-       if (iov_iter_rw(iter) == WRITE) {
                /*
                 * Try to invalidate cache pages for the range we are writing.
                 * If this invalidation fails, let the caller fall back to
                 * buffered I/O.
                 */
-               if (invalidate_inode_pages2_range(mapping,
-                               iomi.pos >> PAGE_SHIFT, end >> PAGE_SHIFT)) {
-                       trace_iomap_dio_invalidate_fail(inode, iomi.pos,
-                                                       iomi.len);
-                       ret = -ENOTBLK;
+               ret = kiocb_invalidate_pages(iocb, iomi.len);
+               if (ret) {
+                       if (ret != -EAGAIN) {
+                               trace_iomap_dio_invalidate_fail(inode, iomi.pos,
+                                                               iomi.len);
+                               ret = -ENOTBLK;
+                       }
                        goto out_free_dio;
                }