Commit c117a437 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'vfs-6.10.iomap' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs 

Pull vfs iomap updates from Christian Brauner:
 "This contains a few cleanups to the iomap code. Nothing particularly
  stands out"

* tag 'vfs-6.10.iomap' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs:
  iomap: do some small logical cleanup in buffered write
  iomap: make iomap_write_end() return a boolean
  iomap: use a new variable to handle the written bytes in iomap_write_iter()
  iomap: don't increase i_size if it's not a write operation
  iomap: drop the write failure handles when unsharing and zeroing
  iomap: convert iomap_writepages to writeack_iter
parents 8815da98 e1f453d4

fs/iomap/buffered-io.c

+65 −54
Original line number Diff line number Diff line
@@ -824,12 +824,11 @@ static int iomap_write_begin(struct iomap_iter *iter, loff_t pos, 


out_unlock:

	__iomap_put_folio(iter, pos, 0, folio);

	iomap_write_failed(iter->inode, pos, len);



	return status;

}



static size_t __iomap_write_end(struct inode *inode, loff_t pos, size_t len,

static bool __iomap_write_end(struct inode *inode, loff_t pos, size_t len,

		size_t copied, struct folio *folio)

{

	flush_dcache_folio(folio);
@@ -846,14 +845,14 @@ static size_t __iomap_write_end(struct inode *inode, loff_t pos, size_t len, 
	 * redo the whole thing.

	 */

	if (unlikely(copied < len && !folio_test_uptodate(folio)))

		return 0;

		return false;

	iomap_set_range_uptodate(folio, offset_in_folio(folio, pos), len);

	iomap_set_range_dirty(folio, offset_in_folio(folio, pos), copied);

	filemap_dirty_folio(inode->i_mapping, folio);

	return copied;

	return true;

}



static size_t iomap_write_end_inline(const struct iomap_iter *iter,

static void iomap_write_end_inline(const struct iomap_iter *iter,

		struct folio *folio, loff_t pos, size_t copied)

{

	const struct iomap *iomap = &iter->iomap;
@@ -868,42 +867,32 @@ static size_t iomap_write_end_inline(const struct iomap_iter *iter, 
	kunmap_local(addr);



	mark_inode_dirty(iter->inode);

	return copied;

}



/* Returns the number of bytes copied.  May be 0.  Cannot be an errno. */

static size_t iomap_write_end(struct iomap_iter *iter, loff_t pos, size_t len,

/*

 * Returns true if all copied bytes have been written to the pagecache,

 * otherwise return false.

 */

static bool iomap_write_end(struct iomap_iter *iter, loff_t pos, size_t len,

		size_t copied, struct folio *folio)

{

	const struct iomap *srcmap = iomap_iter_srcmap(iter);

	loff_t old_size = iter->inode->i_size;

	size_t ret;



	if (srcmap->type == IOMAP_INLINE) {

		ret = iomap_write_end_inline(iter, folio, pos, copied);

	} else if (srcmap->flags & IOMAP_F_BUFFER_HEAD) {

		ret = block_write_end(NULL, iter->inode->i_mapping, pos, len,

				copied, &folio->page, NULL);

	} else {

		ret = __iomap_write_end(iter->inode, pos, len, copied, folio);

		iomap_write_end_inline(iter, folio, pos, copied);

		return true;

	}



	/*

	 * Update the in-memory inode size after copying the data into the page

	 * cache.  It's up to the file system to write the updated size to disk,

	 * preferably after I/O completion so that no stale data is exposed.

	 */

	if (pos + ret > old_size) {

		i_size_write(iter->inode, pos + ret);

		iter->iomap.flags |= IOMAP_F_SIZE_CHANGED;

	if (srcmap->flags & IOMAP_F_BUFFER_HEAD) {

		size_t bh_written;



		bh_written = block_write_end(NULL, iter->inode->i_mapping, pos,

					len, copied, &folio->page, NULL);

		WARN_ON_ONCE(bh_written != copied && bh_written != 0);

		return bh_written == copied;

	}

	__iomap_put_folio(iter, pos, ret, folio);



	if (old_size < pos)

		pagecache_isize_extended(iter->inode, old_size, pos);

	if (ret < len)

		iomap_write_failed(iter->inode, pos + ret, len - ret);

	return ret;

	return __iomap_write_end(iter->inode, pos, len, copied, folio);

}



static loff_t iomap_write_iter(struct iomap_iter *iter, struct iov_iter *i)
@@ -911,16 +900,18 @@ static loff_t iomap_write_iter(struct iomap_iter *iter, struct iov_iter *i) 
	loff_t length = iomap_length(iter);

	size_t chunk = PAGE_SIZE << MAX_PAGECACHE_ORDER;

	loff_t pos = iter->pos;

	ssize_t written = 0;

	ssize_t total_written = 0;

	long status = 0;

	struct address_space *mapping = iter->inode->i_mapping;

	unsigned int bdp_flags = (iter->flags & IOMAP_NOWAIT) ? BDP_ASYNC : 0;



	do {

		struct folio *folio;

		loff_t old_size;

		size_t offset;		/* Offset into folio */

		size_t bytes;		/* Bytes to write to folio */

		size_t copied;		/* Bytes copied from user */

		size_t written;		/* Bytes have been written */



		bytes = iov_iter_count(i);

retry:
@@ -950,8 +941,10 @@ static loff_t iomap_write_iter(struct iomap_iter *iter, struct iov_iter *i) 
		}



		status = iomap_write_begin(iter, pos, bytes, &folio);

		if (unlikely(status))

		if (unlikely(status)) {

			iomap_write_failed(iter->inode, pos, bytes);

			break;

		}

		if (iter->iomap.flags & IOMAP_F_STALE)

			break;
@@ -963,19 +956,37 @@ static loff_t iomap_write_iter(struct iomap_iter *iter, struct iov_iter *i) 
			flush_dcache_folio(folio);



		copied = copy_folio_from_iter_atomic(folio, offset, bytes, i);

		status = iomap_write_end(iter, pos, bytes, copied, folio);

		written = iomap_write_end(iter, pos, bytes, copied, folio) ?

			  copied : 0;



		if (unlikely(copied != status))

			iov_iter_revert(i, copied - status);

		/*

		 * Update the in-memory inode size after copying the data into

		 * the page cache.  It's up to the file system to write the

		 * updated size to disk, preferably after I/O completion so that

		 * no stale data is exposed.  Only once that's done can we

		 * unlock and release the folio.

		 */

		old_size = iter->inode->i_size;

		if (pos + written > old_size) {

			i_size_write(iter->inode, pos + written);

			iter->iomap.flags |= IOMAP_F_SIZE_CHANGED;

		}

		__iomap_put_folio(iter, pos, written, folio);



		if (old_size < pos)

			pagecache_isize_extended(iter->inode, old_size, pos);



		cond_resched();

		if (unlikely(status == 0)) {

		if (unlikely(written == 0)) {

			/*

			 * A short copy made iomap_write_end() reject the

			 * thing entirely.  Might be memory poisoning

			 * halfway through, might be a race with munmap,

			 * might be severe memory pressure.

			 */

			iomap_write_failed(iter->inode, pos, bytes);

			iov_iter_revert(i, copied);



			if (chunk > PAGE_SIZE)

				chunk /= 2;

			if (copied) {
@@ -983,17 +994,17 @@ static loff_t iomap_write_iter(struct iomap_iter *iter, struct iov_iter *i) 
				goto retry;

			}

		} else {

			pos += status;

			written += status;

			length -= status;

			pos += written;

			total_written += written;

			length -= written;

		}

	} while (iov_iter_count(i) && length);



	if (status == -EAGAIN) {

		iov_iter_revert(i, written);

		iov_iter_revert(i, total_written);

		return -EAGAIN;

	}

	return written ? written : status;

	return total_written ? total_written : status;

}



ssize_t
@@ -1322,6 +1333,7 @@ static loff_t iomap_unshare_iter(struct iomap_iter *iter) 
		int status;

		size_t offset;

		size_t bytes = min_t(u64, SIZE_MAX, length);

		bool ret;



		status = iomap_write_begin(iter, pos, bytes, &folio);

		if (unlikely(status))
@@ -1333,8 +1345,9 @@ static loff_t iomap_unshare_iter(struct iomap_iter *iter) 
		if (bytes > folio_size(folio) - offset)

			bytes = folio_size(folio) - offset;



		bytes = iomap_write_end(iter, pos, bytes, bytes, folio);

		if (WARN_ON_ONCE(bytes == 0))

		ret = iomap_write_end(iter, pos, bytes, bytes, folio);

		__iomap_put_folio(iter, pos, bytes, folio);

		if (WARN_ON_ONCE(!ret))

			return -EIO;



		cond_resched();
@@ -1383,6 +1396,7 @@ static loff_t iomap_zero_iter(struct iomap_iter *iter, bool *did_zero) 
		int status;

		size_t offset;

		size_t bytes = min_t(u64, SIZE_MAX, length);

		bool ret;



		status = iomap_write_begin(iter, pos, bytes, &folio);

		if (status)
@@ -1397,8 +1411,9 @@ static loff_t iomap_zero_iter(struct iomap_iter *iter, bool *did_zero) 
		folio_zero_range(folio, offset, bytes);

		folio_mark_accessed(folio);



		bytes = iomap_write_end(iter, pos, bytes, bytes, folio);

		if (WARN_ON_ONCE(bytes == 0))

		ret = iomap_write_end(iter, pos, bytes, bytes, folio);

		__iomap_put_folio(iter, pos, bytes, folio);

		if (WARN_ON_ONCE(!ret))

			return -EIO;



		pos += bytes;
@@ -1958,18 +1973,13 @@ static int iomap_writepage_map(struct iomap_writepage_ctx *wpc, 
	return error;

}



static int iomap_do_writepage(struct folio *folio,

		struct writeback_control *wbc, void *data)

{

	return iomap_writepage_map(data, wbc, folio);

}



int

iomap_writepages(struct address_space *mapping, struct writeback_control *wbc,

		struct iomap_writepage_ctx *wpc,

		const struct iomap_writeback_ops *ops)

{

	int			ret;

	struct folio *folio = NULL;

	int error;



	/*

	 * Writeback from reclaim context should never happen except in the case
@@ -1980,8 +1990,9 @@ iomap_writepages(struct address_space *mapping, struct writeback_control *wbc, 
		return -EIO;



	wpc->ops = ops;

	ret = write_cache_pages(mapping, wbc, iomap_do_writepage, wpc);

	return iomap_submit_ioend(wpc, ret);

	while ((folio = writeback_iter(mapping, wbc, folio, &error)))

		error = iomap_writepage_map(wpc, wbc, folio);

	return iomap_submit_ioend(wpc, error);

}

EXPORT_SYMBOL_GPL(iomap_writepages);