filemap: add a kiocb_invalidate_post_write helper

Add a helper to invalidate page cache after a dio write.

Signed-off-by: Christoph Hellwig <hch@lst.de>

diff --git a/fs/direct-io.c b/fs/direct-io.c
index ab0d7ea89813a6c99e77da8381c7e4b8dfec3bd2..f2d2e544c259dc608e27313a496d3111eb5ac757 100644 (file)
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -286,14 +286,8 @@ static ssize_t dio_complete(struct dio *dio, ssize_t ret, unsigned int flags)
         * zeros from unwritten extents.
         */
        if (flags & DIO_COMPLETE_INVALIDATE &&
-           ret > 0 && dio_op == REQ_OP_WRITE &&
-           dio->inode->i_mapping->nrpages) {
-               err = invalidate_inode_pages2_range(dio->inode->i_mapping,
-                                       offset >> PAGE_SHIFT,
-                                       (offset + ret - 1) >> PAGE_SHIFT);
-               if (err)
-                       dio_warn_stale_pagecache(dio->iocb->ki_filp);
-       }
+           ret > 0 && dio_op == REQ_OP_WRITE)
+               kiocb_invalidate_post_write(dio->iocb, ret);
 
        inode_dio_end(dio->inode);
 

diff --git a/fs/iomap/direct-io.c b/fs/iomap/direct-io.c
index f771001574d008fd9c138d5a985cf13b2eda9f9e..2bf8d6846756159dc97fa33fec6f466ce62913e9 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;
 
@@ -109,15 +108,8 @@ 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_write(iocb, dio->size);
 
        inode_dio_end(file_inode(iocb->ki_filp));
        /*

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 933245d07ae8ed22f0562d9403dedcdf659c5742..5ffee8efb5e9c1f19e69c30e093420a86e5162e1 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2186,6 +2186,7 @@ int kiocb_modified(struct kiocb *iocb);
 
 int kiocb_write_and_wait(struct kiocb *iocb, size_t count);
 int kiocb_invalidate_pages(struct kiocb *iocb, size_t count);
+void kiocb_invalidate_post_write(struct kiocb *iocb, size_t count);
 
 int sync_inode_metadata(struct inode *inode, int wait);
 
@@ -2821,11 +2822,6 @@ static inline void inode_dio_end(struct inode *inode)
                wake_up_bit(&inode->i_state, __I_DIO_WAKEUP);
 }
 
-/*
- * Warn about a page cache invalidation failure diring a direct I/O write.
- */
-void dio_warn_stale_pagecache(struct file *filp);
-
 extern void inode_set_flags(struct inode *inode, unsigned int flags,
                            unsigned int mask);
 

diff --git a/mm/filemap.c b/mm/filemap.c
index d67c0abbff6c40c9cee6e7843c28fae130d8e690..931ffe67b395771273e15ab24347aaa3aca3a50d 100644 (file)
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -3821,7 +3821,7 @@ EXPORT_SYMBOL(read_cache_page_gfp);
 /*
  * Warn about a page cache invalidation failure during a direct I/O write.
  */
-void dio_warn_stale_pagecache(struct file *filp)
+static void dio_warn_stale_pagecache(struct file *filp)
 {
        static DEFINE_RATELIMIT_STATE(_rs, 86400 * HZ, DEFAULT_RATELIMIT_BURST);
        char pathname[128];
@@ -3838,19 +3838,23 @@ void dio_warn_stale_pagecache(struct file *filp)
        }
 }
 
+void kiocb_invalidate_post_write(struct kiocb *iocb, size_t count)
+{
+       struct address_space *mapping = iocb->ki_filp->f_mapping;
+       loff_t pos = iocb->ki_pos;
+
+       if (mapping->nrpages &&
+           invalidate_inode_pages2_range(mapping, pos >> PAGE_SHIFT,
+                       (pos + count - 1) >> PAGE_SHIFT))
+               dio_warn_stale_pagecache(iocb->ki_filp);
+}
+
 ssize_t
 generic_file_direct_write(struct kiocb *iocb, struct iov_iter *from)
 {
-       struct file     *file = iocb->ki_filp;
-       struct address_space *mapping = file->f_mapping;
-       struct inode    *inode = mapping->host;
-       loff_t          pos = iocb->ki_pos;
-       ssize_t         written;
-       size_t          write_len;
-       pgoff_t         end;
-
-       write_len = iov_iter_count(from);
-       end = (pos + write_len - 1) >> PAGE_SHIFT;
+       struct address_space *mapping = iocb->ki_filp->f_mapping;
+       size_t write_len = iov_iter_count(from);
+       ssize_t written;
 
        /*
         * If a page can not be invalidated, return 0 to fall back
@@ -3860,7 +3864,7 @@ generic_file_direct_write(struct kiocb *iocb, struct iov_iter *from)
        if (written) {
                if (written == -EBUSY)
                        return 0;
-               goto out;
+               return written;
        }
 
        written = mapping->a_ops->direct_IO(iocb, from);
@@ -3882,11 +3886,11 @@ generic_file_direct_write(struct kiocb *iocb, struct iov_iter *from)
         *
         * Skip invalidation for async writes or if mapping has no pages.
         */
-       if (written > 0 && mapping->nrpages &&
-           invalidate_inode_pages2_range(mapping, pos >> PAGE_SHIFT, end))
-               dio_warn_stale_pagecache(file);
-
        if (written > 0) {
+               struct inode *inode = mapping->host;
+               loff_t pos = iocb->ki_pos;
+
+               kiocb_invalidate_post_write(iocb, write_len);
                pos += written;
                write_len -= written;
                if (pos > i_size_read(inode) && !S_ISBLK(inode->i_mode)) {
@@ -3897,7 +3901,6 @@ generic_file_direct_write(struct kiocb *iocb, struct iov_iter *from)
        }
        if (written != -EIOCBQUEUED)
                iov_iter_revert(from, write_len - iov_iter_count(from));
-out:
        return written;
 }
 EXPORT_SYMBOL(generic_file_direct_write);