On Thu, Jun 01, 2023 at 04:59:01PM +0200, Christoph Hellwig wrote:
> Add a helper dealing with handling the syncing of a buffered write fallback
> for direct I/O.
>
> Signed-off-by: Christoph Hellwig <hch@xxxxxx>
> Reviewed-by: Damien Le Moal <dlemoal@xxxxxxxxxx>
> Reviewed-by: Miklos Szeredi <mszeredi@xxxxxxxxxx>
Looks good to me; whose tree do you want this to go through?
Reviewed-by: Darrick J. Wong <djwong@xxxxxxxxxx>
--D
> ---
> fs/libfs.c | 41 ++++++++++++++++++++++++++++
> include/linux/fs.h | 2 ++
> mm/filemap.c | 66 +++++++++++-----------------------------------
> 3 files changed, 58 insertions(+), 51 deletions(-)
>
> diff --git a/fs/libfs.c b/fs/libfs.c
> index 89cf614a327158..5b851315eeed03 100644
> --- 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 91021b4e1f6f48..6af25137543824 100644
> --- a/include/linux/fs.h
> +++ b/include/linux/fs.h
> @@ -2738,6 +2738,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 ddb6f8aa86d6ca..137508da5525b6 100644
> --- a/mm/filemap.c
> +++ b/mm/filemap.c
> @@ -4006,23 +4006,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
> @@ -4030,45 +4026,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);
>
> --
> 2.39.2
>
