Unverified Commit edd3e3b7 authored by Brian Foster's avatar Brian Foster Committed by Christian Brauner
Browse files

iomap: rename iomap_iter processed field to status 



The iter.processed field name is no longer appropriate now that
iomap operations do not return the number of bytes processed. Rename
the field to iter.status to reflect that a success or error code is
expected.

Also change the type to int as there is no longer a need for an s64.
This reduces the size of iomap_iter by 8 bytes due to a combination
of smaller type and reduction in structure padding. While here, fix
up the return types of various _iter() helpers to reflect the type
change.

Signed-off-by: default avatarBrian Foster <bfoster@redhat.com>
Link: https://lore.kernel.org/r/20250224144757.237706-12-bfoster@redhat.com


Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatar"Darrick J. Wong" <djwong@kernel.org>
Signed-off-by: default avatarChristian Brauner <brauner@kernel.org>
parent 469739f1

fs/dax.c

+10 −10
Original line number Diff line number Diff line
@@ -1258,7 +1258,7 @@ static vm_fault_t dax_pmd_load_hole(struct xa_state *xas, struct vm_fault *vmf, 
}

#endif /* CONFIG_FS_DAX_PMD */



static s64 dax_unshare_iter(struct iomap_iter *iter)

static int dax_unshare_iter(struct iomap_iter *iter)

{

	struct iomap *iomap = &iter->iomap;

	const struct iomap *srcmap = iomap_iter_srcmap(iter);
@@ -1328,7 +1328,7 @@ int dax_file_unshare(struct inode *inode, loff_t pos, loff_t len, 


	iter.len = min(len, size - pos);

	while ((ret = iomap_iter(&iter, ops)) > 0)

		iter.processed = dax_unshare_iter(&iter);

		iter.status = dax_unshare_iter(&iter);

	return ret;

}

EXPORT_SYMBOL_GPL(dax_file_unshare);
@@ -1356,12 +1356,12 @@ static int dax_memzero(struct iomap_iter *iter, loff_t pos, size_t size) 
	return ret;

}



static s64 dax_zero_iter(struct iomap_iter *iter, bool *did_zero)

static int dax_zero_iter(struct iomap_iter *iter, bool *did_zero)

{

	const struct iomap *iomap = &iter->iomap;

	const struct iomap *srcmap = iomap_iter_srcmap(iter);

	u64 length = iomap_length(iter);

	s64 ret;

	int ret;



	/* already zeroed?  we're done. */

	if (srcmap->type == IOMAP_HOLE || srcmap->type == IOMAP_UNWRITTEN)
@@ -1416,7 +1416,7 @@ int dax_zero_range(struct inode *inode, loff_t pos, loff_t len, bool *did_zero, 
	int ret;



	while ((ret = iomap_iter(&iter, ops)) > 0)

		iter.processed = dax_zero_iter(&iter, did_zero);

		iter.status = dax_zero_iter(&iter, did_zero);

	return ret;

}

EXPORT_SYMBOL_GPL(dax_zero_range);
@@ -1588,7 +1588,7 @@ dax_iomap_rw(struct kiocb *iocb, struct iov_iter *iter, 
		iomi.flags |= IOMAP_NOWAIT;



	while ((ret = iomap_iter(&iomi, ops)) > 0)

		iomi.processed = dax_iomap_iter(&iomi, iter);

		iomi.status = dax_iomap_iter(&iomi, iter);



	done = iomi.pos - iocb->ki_pos;

	iocb->ki_pos = iomi.pos;
@@ -1759,7 +1759,7 @@ static vm_fault_t dax_iomap_pte_fault(struct vm_fault *vmf, pfn_t *pfnp, 


	while ((error = iomap_iter(&iter, ops)) > 0) {

		if (WARN_ON_ONCE(iomap_length(&iter) < PAGE_SIZE)) {

			iter.processed = -EIO;	/* fs corruption? */

			iter.status = -EIO;	/* fs corruption? */

			continue;

		}
@@ -1773,7 +1773,7 @@ static vm_fault_t dax_iomap_pte_fault(struct vm_fault *vmf, pfn_t *pfnp, 


		if (!(ret & VM_FAULT_ERROR)) {

			u64 length = PAGE_SIZE;

			iter.processed = iomap_iter_advance(&iter, &length);

			iter.status = iomap_iter_advance(&iter, &length);

		}

	}
@@ -1889,7 +1889,7 @@ static vm_fault_t dax_iomap_pmd_fault(struct vm_fault *vmf, pfn_t *pfnp, 
		ret = dax_fault_iter(vmf, &iter, pfnp, &xas, &entry, true);

		if (ret != VM_FAULT_FALLBACK) {

			u64 length = PMD_SIZE;

			iter.processed = iomap_iter_advance(&iter, &length);

			iter.status = iomap_iter_advance(&iter, &length);

		}

	}
@@ -2079,7 +2079,7 @@ int dax_dedupe_file_range_compare(struct inode *src, loff_t srcoff, 
				min(src_iter.len, dst_iter.len), same);

		if (status < 0)

			return ret;

		src_iter.processed = dst_iter.processed = status;

		src_iter.status = dst_iter.status = status;

	}

	return ret;

}

fs/iomap/buffered-io.c

+21 −21
Original line number Diff line number Diff line
@@ -362,7 +362,7 @@ static inline bool iomap_block_needs_zeroing(const struct iomap_iter *iter, 
		pos >= i_size_read(iter->inode);

}



static loff_t iomap_readpage_iter(struct iomap_iter *iter,

static int iomap_readpage_iter(struct iomap_iter *iter,

		struct iomap_readpage_ctx *ctx)

{

	const struct iomap *iomap = &iter->iomap;
@@ -437,10 +437,10 @@ static loff_t iomap_readpage_iter(struct iomap_iter *iter, 
	return iomap_iter_advance(iter, &length);

}



static loff_t iomap_read_folio_iter(struct iomap_iter *iter,

static int iomap_read_folio_iter(struct iomap_iter *iter,

		struct iomap_readpage_ctx *ctx)

{

	loff_t ret;

	int ret;



	while (iomap_length(iter)) {

		ret = iomap_readpage_iter(iter, ctx);
@@ -466,7 +466,7 @@ int iomap_read_folio(struct folio *folio, const struct iomap_ops *ops) 
	trace_iomap_readpage(iter.inode, 1);



	while ((ret = iomap_iter(&iter, ops)) > 0)

		iter.processed = iomap_read_folio_iter(&iter, &ctx);

		iter.status = iomap_read_folio_iter(&iter, &ctx);



	if (ctx.bio) {

		submit_bio(ctx.bio);
@@ -485,10 +485,10 @@ int iomap_read_folio(struct folio *folio, const struct iomap_ops *ops) 
}

EXPORT_SYMBOL_GPL(iomap_read_folio);



static loff_t iomap_readahead_iter(struct iomap_iter *iter,

static int iomap_readahead_iter(struct iomap_iter *iter,

		struct iomap_readpage_ctx *ctx)

{

	loff_t ret;

	int ret;



	while (iomap_length(iter)) {

		if (ctx->cur_folio &&
@@ -538,7 +538,7 @@ void iomap_readahead(struct readahead_control *rac, const struct iomap_ops *ops) 
	trace_iomap_readahead(rac->mapping->host, readahead_count(rac));



	while (iomap_iter(&iter, ops) > 0)

		iter.processed = iomap_readahead_iter(&iter, &ctx);

		iter.status = iomap_readahead_iter(&iter, &ctx);



	if (ctx.bio)

		submit_bio(ctx.bio);
@@ -898,10 +898,10 @@ static bool iomap_write_end(struct iomap_iter *iter, loff_t pos, size_t len, 
	return __iomap_write_end(iter->inode, pos, len, copied, folio);

}



static loff_t iomap_write_iter(struct iomap_iter *iter, struct iov_iter *i)

static int iomap_write_iter(struct iomap_iter *iter, struct iov_iter *i)

{

	ssize_t total_written = 0;

	long status = 0;

	int status = 0;

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

	size_t chunk = mapping_max_folio_size(mapping);

	unsigned int bdp_flags = (iter->flags & IOMAP_NOWAIT) ? BDP_ASYNC : 0;
@@ -1021,7 +1021,7 @@ iomap_file_buffered_write(struct kiocb *iocb, struct iov_iter *i, 
		iter.flags |= IOMAP_NOWAIT;



	while ((ret = iomap_iter(&iter, ops)) > 0)

		iter.processed = iomap_write_iter(&iter, i);

		iter.status = iomap_write_iter(&iter, i);



	if (unlikely(iter.pos == iocb->ki_pos))

		return ret;
@@ -1255,7 +1255,7 @@ void iomap_write_delalloc_release(struct inode *inode, loff_t start_byte, 
}

EXPORT_SYMBOL_GPL(iomap_write_delalloc_release);



static loff_t iomap_unshare_iter(struct iomap_iter *iter)

static int iomap_unshare_iter(struct iomap_iter *iter)

{

	struct iomap *iomap = &iter->iomap;

	u64 bytes = iomap_length(iter);
@@ -1315,7 +1315,7 @@ iomap_file_unshare(struct inode *inode, loff_t pos, loff_t len, 


	iter.len = min(len, size - pos);

	while ((ret = iomap_iter(&iter, ops)) > 0)

		iter.processed = iomap_unshare_iter(&iter);

		iter.status = iomap_unshare_iter(&iter);

	return ret;

}

EXPORT_SYMBOL_GPL(iomap_file_unshare);
@@ -1334,7 +1334,7 @@ static inline int iomap_zero_iter_flush_and_stale(struct iomap_iter *i) 
	return filemap_write_and_wait_range(mapping, i->pos, end);

}



static loff_t iomap_zero_iter(struct iomap_iter *iter, bool *did_zero)

static int iomap_zero_iter(struct iomap_iter *iter, bool *did_zero)

{

	u64 bytes = iomap_length(iter);

	int status;
@@ -1408,7 +1408,7 @@ iomap_zero_range(struct inode *inode, loff_t pos, loff_t len, bool *did_zero, 
	    filemap_range_needs_writeback(mapping, pos, pos + plen - 1)) {

		iter.len = plen;

		while ((ret = iomap_iter(&iter, ops)) > 0)

			iter.processed = iomap_zero_iter(&iter, did_zero);

			iter.status = iomap_zero_iter(&iter, did_zero);



		iter.len = len - (iter.pos - pos);

		if (ret || !iter.len)
@@ -1427,20 +1427,20 @@ iomap_zero_range(struct inode *inode, loff_t pos, loff_t len, bool *did_zero, 


		if (srcmap->type == IOMAP_HOLE ||

		    srcmap->type == IOMAP_UNWRITTEN) {

			s64 proc;

			s64 status;



			if (range_dirty) {

				range_dirty = false;

				proc = iomap_zero_iter_flush_and_stale(&iter);

				status = iomap_zero_iter_flush_and_stale(&iter);

			} else {

				u64 length = iomap_length(&iter);

				proc = iomap_iter_advance(&iter, &length);

				status = iomap_iter_advance(&iter, &length);

			}

			iter.processed = proc;

			iter.status = status;

			continue;

		}



		iter.processed = iomap_zero_iter(&iter, did_zero);

		iter.status = iomap_zero_iter(&iter, did_zero);

	}

	return ret;

}
@@ -1461,7 +1461,7 @@ iomap_truncate_page(struct inode *inode, loff_t pos, bool *did_zero, 
}

EXPORT_SYMBOL_GPL(iomap_truncate_page);



static loff_t iomap_folio_mkwrite_iter(struct iomap_iter *iter,

static int iomap_folio_mkwrite_iter(struct iomap_iter *iter,

		struct folio *folio)

{

	loff_t length = iomap_length(iter);
@@ -1499,7 +1499,7 @@ vm_fault_t iomap_page_mkwrite(struct vm_fault *vmf, const struct iomap_ops *ops, 
	iter.pos = folio_pos(folio);

	iter.len = ret;

	while ((ret = iomap_iter(&iter, ops)) > 0)

		iter.processed = iomap_folio_mkwrite_iter(&iter, folio);

		iter.status = iomap_folio_mkwrite_iter(&iter, folio);



	if (ret < 0)

		goto out_unlock;

fs/iomap/direct-io.c

+1 −1
Original line number Diff line number Diff line
@@ -742,7 +742,7 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter, 


	blk_start_plug(&plug);

	while ((ret = iomap_iter(&iomi, ops)) > 0) {

		iomi.processed = iomap_dio_iter(&iomi, dio);

		iomi.status = iomap_dio_iter(&iomi, dio);



		/*

		 * We can only poll for single bio I/Os.

fs/iomap/fiemap.c

+3 −3
Original line number Diff line number Diff line
@@ -39,7 +39,7 @@ static int iomap_to_fiemap(struct fiemap_extent_info *fi, 
			iomap->length, flags);

}



static loff_t iomap_fiemap_iter(struct iomap_iter *iter,

static int iomap_fiemap_iter(struct iomap_iter *iter,

		struct fiemap_extent_info *fi, struct iomap *prev)

{

	u64 length = iomap_length(iter);
@@ -78,7 +78,7 @@ int iomap_fiemap(struct inode *inode, struct fiemap_extent_info *fi, 
		return ret;



	while ((ret = iomap_iter(&iter, ops)) > 0)

		iter.processed = iomap_fiemap_iter(&iter, fi, &prev);

		iter.status = iomap_fiemap_iter(&iter, fi, &prev);



	if (prev.type != IOMAP_HOLE) {

		ret = iomap_to_fiemap(fi, &prev, FIEMAP_EXTENT_LAST);
@@ -114,7 +114,7 @@ iomap_bmap(struct address_space *mapping, sector_t bno, 
	while ((ret = iomap_iter(&iter, ops)) > 0) {

		if (iter.iomap.type == IOMAP_MAPPED)

			bno = iomap_sector(&iter.iomap, iter.pos) >> blkshift;

		/* leave iter.processed unset to abort loop */

		/* leave iter.status unset to abort loop */

	}

	if (ret)

		return 0;

fs/iomap/iter.c

+6 −6
Original line number Diff line number Diff line
@@ -9,7 +9,7 @@ 


static inline void iomap_iter_reset_iomap(struct iomap_iter *iter)

{

	iter->processed = 0;

	iter->status = 0;

	memset(&iter->iomap, 0, sizeof(iter->iomap));

	memset(&iter->srcmap, 0, sizeof(iter->srcmap));

}
@@ -54,7 +54,7 @@ static inline void iomap_iter_done(struct iomap_iter *iter) 
 * function must be called in a loop that continues as long it returns a

 * positive value.  If 0 or a negative value is returned, the caller must not

 * return to the loop body.  Within a loop body, there are two ways to break out

 * of the loop body:  leave @iter.processed unchanged, or set it to a negative

 * of the loop body:  leave @iter.status unchanged, or set it to a negative

 * errno.

 */

int iomap_iter(struct iomap_iter *iter, const struct iomap_ops *ops)
@@ -86,8 +86,8 @@ int iomap_iter(struct iomap_iter *iter, const struct iomap_ops *ops) 
	}



	/* detect old return semantics where this would advance */

	if (WARN_ON_ONCE(iter->processed > 0))

		iter->processed = -EIO;

	if (WARN_ON_ONCE(iter->status > 0))

		iter->status = -EIO;



	/*

	 * Use iter->len to determine whether to continue onto the next mapping.
@@ -95,8 +95,8 @@ int iomap_iter(struct iomap_iter *iter, const struct iomap_ops *ops) 
	 * advanced at all (i.e. no work was done for some reason) unless the

	 * mapping has been marked stale and needs to be reprocessed.

	 */

	if (iter->processed < 0)

		ret = iter->processed;

	if (iter->status < 0)

		ret = iter->status;

	else if (iter->len == 0 || (!advanced && !stale))

		ret = 0;

	else