fs: factor out a direct_write_fallback helper

Add a helper dealing with handling the syncing of a buffered write
fallback for direct I/O.

Link: https://lkml.kernel.org/r/20230601145904.1385409-10-hch@lst.de
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Damien Le Moal <dlemoal@kernel.org>
Reviewed-by: Miklos Szeredi <mszeredi@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Andreas Gruenbacher <agruenba@redhat.com>
Cc: Anna Schumaker <anna@kernel.org>
Cc: Chao Yu <chao@kernel.org>
Cc: Christian Brauner <brauner@kernel.org>
Cc: Hannes Reinecke <hare@suse.de>
Cc: Ilya Dryomov <idryomov@gmail.com>
Cc: Jaegeuk Kim <jaegeuk@kernel.org>
Cc: Jens Axboe <axboe@kernel.dk>
Cc: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Cc: Matthew Wilcox <willy@infradead.org>
Cc: Miklos Szeredi <miklos@szeredi.hu>
Cc: Theodore Ts'o <tytso@mit.edu>
Cc: Trond Myklebust <trond.myklebust@hammerspace.com>
Cc: Xiubo Li <xiubli@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/fs/libfs.c b/fs/libfs.c
index 89cf614..5b85131 100644 (file)
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -1613,3 +1613,44 @@ u64 inode_query_iversion(struct inode *inode)
        return cur >> I_VERSION_QUERIED_SHIFT;
 }
 EXPORT_SYMBOL(inode_query_iversion);
+
+ssize_t direct_write_fallback(struct kiocb *iocb, struct iov_iter *iter,
+               ssize_t direct_written, ssize_t buffered_written)
+{
+       struct address_space *mapping = iocb->ki_filp->f_mapping;
+       loff_t pos = iocb->ki_pos - buffered_written;
+       loff_t end = iocb->ki_pos - 1;
+       int err;
+
+       /*
+        * If the buffered write fallback returned an error, we want to return
+        * the number of bytes which were written by direct I/O, or the error
+        * code if that was zero.
+        *
+        * Note that this differs from normal direct-io semantics, which will
+        * return -EFOO even if some bytes were written.
+        */
+       if (unlikely(buffered_written < 0)) {
+               if (direct_written)
+                       return direct_written;
+               return buffered_written;
+       }
+
+       /*
+        * We need to ensure that the page cache pages are written to disk and
+        * invalidated to preserve the expected O_DIRECT semantics.
+        */
+       err = filemap_write_and_wait_range(mapping, pos, end);
+       if (err < 0) {
+               /*
+                * We don't know how much we wrote, so just return the number of
+                * bytes which were direct-written
+                */
+               if (direct_written)
+                       return direct_written;
+               return err;
+       }
+       invalidate_mapping_pages(mapping, pos >> PAGE_SHIFT, end >> PAGE_SHIFT);
+       return direct_written + buffered_written;
+}
+EXPORT_SYMBOL_GPL(direct_write_fallback);

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 4f196f8..c363f86 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2744,6 +2744,8 @@ extern ssize_t __generic_file_write_iter(struct kiocb *, struct iov_iter *);
 extern ssize_t generic_file_write_iter(struct kiocb *, struct iov_iter *);
 extern ssize_t generic_file_direct_write(struct kiocb *, struct iov_iter *);
 ssize_t generic_perform_write(struct kiocb *, struct iov_iter *);
+ssize_t direct_write_fallback(struct kiocb *iocb, struct iov_iter *iter,
+               ssize_t direct_written, ssize_t buffered_written);
 
 ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos,
                rwf_t flags);

diff --git a/mm/filemap.c b/mm/filemap.c
index b45506f..916b7c6 100644 (file)
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -3979,23 +3979,19 @@ ssize_t __generic_file_write_iter(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;
-       ssize_t         written = 0;
-       ssize_t         err;
-       ssize_t         status;
+       struct inode *inode = mapping->host;
+       ssize_t ret;
 
-       err = file_remove_privs(file);
-       if (err)
-               goto out;
+       ret = file_remove_privs(file);
+       if (ret)
+               return ret;
 
-       err = file_update_time(file);
-       if (err)
-               goto out;
+       ret = file_update_time(file);
+       if (ret)
+               return ret;
 
        if (iocb->ki_flags & IOCB_DIRECT) {
-               loff_t pos, endbyte;
-
-               written = generic_file_direct_write(iocb, from);
+               ret = generic_file_direct_write(iocb, from);
                /*
                 * If the write stopped short of completing, fall back to
                 * buffered writes.  Some filesystems do this for writes to
@@ -4003,45 +3999,13 @@ ssize_t __generic_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
                 * not succeed (even if it did, DAX does not handle dirty
                 * page-cache pages correctly).
                 */
-               if (written < 0 || !iov_iter_count(from) || IS_DAX(inode))
-                       goto out;
-
-               pos = iocb->ki_pos;
-               status = generic_perform_write(iocb, from);
-               /*
-                * If generic_perform_write() returned a synchronous error
-                * then we want to return the number of bytes which were
-                * direct-written, or the error code if that was zero.  Note
-                * that this differs from normal direct-io semantics, which
-                * will return -EFOO even if some bytes were written.
-                */
-               if (unlikely(status < 0)) {
-                       err = status;
-                       goto out;
-               }
-               /*
-                * We need to ensure that the page cache pages are written to
-                * disk and invalidated to preserve the expected O_DIRECT
-                * semantics.
-                */
-               endbyte = pos + status - 1;
-               err = filemap_write_and_wait_range(mapping, pos, endbyte);
-               if (err == 0) {
-                       written += status;
-                       invalidate_mapping_pages(mapping,
-                                                pos >> PAGE_SHIFT,
-                                                endbyte >> PAGE_SHIFT);
-               } else {
-                       /*
-                        * We don't know how much we wrote, so just return
-                        * the number of bytes which were direct-written
-                        */
-               }
-       } else {
-               written = generic_perform_write(iocb, from);
+               if (ret < 0 || !iov_iter_count(from) || IS_DAX(inode))
+                       return ret;
+               return direct_write_fallback(iocb, from, ret,
+                               generic_perform_write(iocb, from));
        }
-out:
-       return written ? written : err;
+
+       return generic_perform_write(iocb, from);
 }
 EXPORT_SYMBOL(__generic_file_write_iter);