Commit 44fff0fa authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Andrew Morton
Browse files

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: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarDamien Le Moal <dlemoal@kernel.org>
Reviewed-by: default avatarMiklos Szeredi <mszeredi@redhat.com>
Reviewed-by: default avatarDarrick 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: default avatarAndrew Morton <akpm@linux-foundation.org>
parent 8ee93b4b

fs/libfs.c

+41 −0
Original line number Diff line number Diff line
@@ -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);

include/linux/fs.h

+2 −0
Original line number Diff line number Diff line
@@ -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);

mm/filemap.c

+15 −51
Original line number Diff line number Diff line
@@ -3980,22 +3980,18 @@ 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;

	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);