Commit f4b896c2 authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Darrick J. Wong
Browse files

iomap: add the new iomap_iter model 



The iomap_iter struct provides a convenient way to package up and
maintain all the arguments to the various mapping and operation
functions.  It is operated on using the iomap_iter() function that
is called in loop until the whole range has been processed.  Compared
to the existing iomap_apply() function this avoid an indirect call
for each iteration.

For now iomap_iter() calls back into the existing ->iomap_begin and
->iomap_end methods, but in the future this could be further optimized
to avoid indirect calls entirely.

Based on an earlier patch from Matthew Wilcox <willy@infradead.org>.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
[djwong: add to apply.c to preserve git history of iomap loop control]
Reviewed-by: default avatarDarrick J. Wong <djwong@kernel.org>
Signed-off-by: default avatarDarrick J. Wong <djwong@kernel.org>
Reviewed-by: default avatarDave Chinner <dchinner@redhat.com>
parent 740499c7

fs/iomap/apply.c

+73 −1
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * Copyright (C) 2010 Red Hat, Inc.

 * Copyright (c) 2016-2018 Christoph Hellwig.

 * Copyright (c) 2016-2021 Christoph Hellwig.

 */

#include <linux/module.h>

#include <linux/compiler.h>
@@ -97,3 +97,75 @@ iomap_apply(struct inode *inode, loff_t pos, loff_t length, unsigned flags, 


	return written ? written : ret;

}



static inline int iomap_iter_advance(struct iomap_iter *iter)

{

	/* handle the previous iteration (if any) */

	if (iter->iomap.length) {

		if (iter->processed <= 0)

			return iter->processed;

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

			return -EIO;

		iter->pos += iter->processed;

		iter->len -= iter->processed;

		if (!iter->len)

			return 0;

	}



	/* clear the state for the next iteration */

	iter->processed = 0;

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

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

	return 1;

}



static inline void iomap_iter_done(struct iomap_iter *iter)

{

	WARN_ON_ONCE(iter->iomap.offset > iter->pos);

	WARN_ON_ONCE(iter->iomap.length == 0);

	WARN_ON_ONCE(iter->iomap.offset + iter->iomap.length <= iter->pos);



	trace_iomap_iter_dstmap(iter->inode, &iter->iomap);

	if (iter->srcmap.type != IOMAP_HOLE)

		trace_iomap_iter_srcmap(iter->inode, &iter->srcmap);

}



/**

 * iomap_iter - iterate over a ranges in a file

 * @iter: iteration structue

 * @ops: iomap ops provided by the file system

 *

 * Iterate over filesystem-provided space mappings for the provided file range.

 *

 * This function handles cleanup of resources acquired for iteration when the

 * filesystem indicates there are no more space mappings, which means that this

 * 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

 * errno.

 */

int iomap_iter(struct iomap_iter *iter, const struct iomap_ops *ops)

{

	int ret;



	if (iter->iomap.length && ops->iomap_end) {

		ret = ops->iomap_end(iter->inode, iter->pos, iomap_length(iter),

				iter->processed > 0 ? iter->processed : 0,

				iter->flags, &iter->iomap);

		if (ret < 0 && !iter->processed)

			return ret;

	}



	trace_iomap_iter(iter, ops, _RET_IP_);

	ret = iomap_iter_advance(iter);

	if (ret <= 0)

		return ret;



	ret = ops->iomap_begin(iter->inode, iter->pos, iter->len, iter->flags,

			       &iter->iomap, &iter->srcmap);

	if (ret < 0)

		return ret;

	iomap_iter_done(iter);

	return 1;

}

fs/iomap/trace.h

+36 −1
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

/*

 * Copyright (c) 2009-2019 Christoph Hellwig

 * Copyright (c) 2009-2021 Christoph Hellwig

 *

 * NOTE: none of these tracepoints shall be considered a stable kernel ABI

 * as they can change at any time.
@@ -140,6 +140,8 @@ DEFINE_EVENT(iomap_class, name, \ 
	TP_ARGS(inode, iomap))

DEFINE_IOMAP_EVENT(iomap_apply_dstmap);

DEFINE_IOMAP_EVENT(iomap_apply_srcmap);

DEFINE_IOMAP_EVENT(iomap_iter_dstmap);

DEFINE_IOMAP_EVENT(iomap_iter_srcmap);



TRACE_EVENT(iomap_apply,

	TP_PROTO(struct inode *inode, loff_t pos, loff_t length,
@@ -179,6 +181,39 @@ TRACE_EVENT(iomap_apply, 
		   __entry->actor)

);



TRACE_EVENT(iomap_iter,

	TP_PROTO(struct iomap_iter *iter, const void *ops,

		 unsigned long caller),

	TP_ARGS(iter, ops, caller),

	TP_STRUCT__entry(

		__field(dev_t, dev)

		__field(u64, ino)

		__field(loff_t, pos)

		__field(loff_t, length)

		__field(unsigned int, flags)

		__field(const void *, ops)

		__field(unsigned long, caller)

	),

	TP_fast_assign(

		__entry->dev = iter->inode->i_sb->s_dev;

		__entry->ino = iter->inode->i_ino;

		__entry->pos = iter->pos;

		__entry->length = iomap_length(iter);

		__entry->flags = iter->flags;

		__entry->ops = ops;

		__entry->caller = caller;

	),

	TP_printk("dev %d:%d ino 0x%llx pos %lld length %lld flags %s (0x%x) ops %ps caller %pS",

		  MAJOR(__entry->dev), MINOR(__entry->dev),

		   __entry->ino,

		   __entry->pos,

		   __entry->length,

		   __print_flags(__entry->flags, "|", IOMAP_FLAGS_STRINGS),

		   __entry->flags,

		   __entry->ops,

		   (void *)__entry->caller)

);



#endif /* _IOMAP_TRACE_H */



#undef TRACE_INCLUDE_PATH

include/linux/iomap.h

+56 −0
Original line number Diff line number Diff line
@@ -161,6 +161,62 @@ struct iomap_ops { 
			ssize_t written, unsigned flags, struct iomap *iomap);

};



/**

 * struct iomap_iter - Iterate through a range of a file

 * @inode: Set at the start of the iteration and should not change.

 * @pos: The current file position we are operating on.  It is updated by

 *	calls to iomap_iter().  Treat as read-only in the body.

 * @len: The remaining length of the file segment we're operating on.

 *	It is updated at the same time as @pos.

 * @processed: The number of bytes processed by the body in the most recent

 *	iteration, or a negative errno. 0 causes the iteration to stop.

 * @flags: Zero or more of the iomap_begin flags above.

 * @iomap: Map describing the I/O iteration

 * @srcmap: Source map for COW operations

 */

struct iomap_iter {

	struct inode *inode;

	loff_t pos;

	u64 len;

	s64 processed;

	unsigned flags;

	struct iomap iomap;

	struct iomap srcmap;

};



int iomap_iter(struct iomap_iter *iter, const struct iomap_ops *ops);



/**

 * iomap_length - length of the current iomap iteration

 * @iter: iteration structure

 *

 * Returns the length that the operation applies to for the current iteration.

 */

static inline u64 iomap_length(const struct iomap_iter *iter)

{

	u64 end = iter->iomap.offset + iter->iomap.length;



	if (iter->srcmap.type != IOMAP_HOLE)

		end = min(end, iter->srcmap.offset + iter->srcmap.length);

	return min(iter->len, end - iter->pos);

}



/**

 * iomap_iter_srcmap - return the source map for the current iomap iteration

 * @i: iteration structure

 *

 * Write operations on file systems with reflink support might require a

 * source and a destination map.  This function retourns the source map

 * for a given operation, which may or may no be identical to the destination

 * map in &i->iomap.

 */

static inline struct iomap *iomap_iter_srcmap(struct iomap_iter *i)

{

	if (i->srcmap.type != IOMAP_HOLE)

		return &i->srcmap;

	return &i->iomap;

}



/*

 * Main iomap iterator function.

 */