nvdimm.lists.linux.dev archive mirror
 help / color / mirror / Atom feed
From: "Darrick J. Wong" <djwong@kernel.org>
To: Christoph Hellwig <hch@lst.de>
Cc: Dan Williams <dan.j.williams@intel.com>,
	Matthew Wilcox <willy@infradead.org>,
	Andreas Gruenbacher <agruenba@redhat.com>,
	Shiyang Ruan <ruansy.fnst@fujitsu.com>,
	linux-xfs@vger.kernel.org, linux-fsdevel@vger.kernel.org,
	linux-btrfs@vger.kernel.org, nvdimm@lists.linux.dev,
	cluster-devel@redhat.com
Subject: Re: [PATCH 11/30] iomap: add the new iomap_iter model
Date: Tue, 10 Aug 2021 17:31:18 -0700	[thread overview]
Message-ID: <20210811003118.GT3601466@magnolia> (raw)
In-Reply-To: <20210809061244.1196573-12-hch@lst.de>

On Mon, Aug 09, 2021 at 08:12:25AM +0200, Christoph Hellwig wrote:
> 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: Christoph Hellwig <hch@lst.de>
> ---
>  fs/iomap/Makefile     |  1 +
>  fs/iomap/core.c       | 79 +++++++++++++++++++++++++++++++++++++++++++
>  fs/iomap/trace.h      | 37 +++++++++++++++++++-
>  include/linux/iomap.h | 56 ++++++++++++++++++++++++++++++
>  4 files changed, 172 insertions(+), 1 deletion(-)
>  create mode 100644 fs/iomap/core.c
> 
> diff --git a/fs/iomap/Makefile b/fs/iomap/Makefile
> index eef2722d93a183..6b56b10ded347a 100644
> --- a/fs/iomap/Makefile
> +++ b/fs/iomap/Makefile
> @@ -10,6 +10,7 @@ obj-$(CONFIG_FS_IOMAP)		+= iomap.o
>  
>  iomap-y				+= trace.o \
>  				   apply.o \
> +				   core.o \
>  				   buffered-io.o \
>  				   direct-io.o \
>  				   fiemap.o \
> diff --git a/fs/iomap/core.c b/fs/iomap/core.c
> new file mode 100644
> index 00000000000000..89a87a1654e8e6
> --- /dev/null
> +++ b/fs/iomap/core.c
> @@ -0,0 +1,79 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (c) 2021 Christoph Hellwig.
> + */
> +#include <linux/fs.h>
> +#include <linux/iomap.h>
> +#include "trace.h"
> +
> +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)

I wonder why this is a separate function, since it only has debugging
warnings and tracepoints?

> +{
> +	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.

Thanks for improving the documentation.

Modulo the question about iomap_iter_done, I guess this looks all right
to me.  As far as apply.c vs. core.c, I'm not wildly passionate about
either naming choice (I would have called it iter.c) but ... fmeh.

Reviewed-by: Darrick J. Wong <djwong@kernel.org>

--D

> + */
> +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;
> +}
> diff --git a/fs/iomap/trace.h b/fs/iomap/trace.h
> index e9cd5cc0d6ba40..1012d7af6b689b 100644
> --- a/fs/iomap/trace.h
> +++ b/fs/iomap/trace.h
> @@ -1,6 +1,6 @@
>  /* 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
> diff --git a/include/linux/iomap.h b/include/linux/iomap.h
> index 76bfc5d16ef49d..aac4176ea16439 100644
> --- a/include/linux/iomap.h
> +++ b/include/linux/iomap.h
> @@ -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.
>   */
> -- 
> 2.30.2
> 

  parent reply	other threads:[~2021-08-11  0:31 UTC|newest]

Thread overview: 70+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2021-08-09  6:12 switch iomap to an iterator model v2 Christoph Hellwig
2021-08-09  6:12 ` [PATCH 01/30] iomap: fix a trivial comment typo in trace.h Christoph Hellwig
2021-08-09  6:12 ` [PATCH 02/30] iomap: remove the iomap arguments to ->page_{prepare,done} Christoph Hellwig
2021-08-09  6:12 ` [PATCH 03/30] iomap: mark the iomap argument to iomap_sector const Christoph Hellwig
2021-08-09  6:12 ` [PATCH 04/30] iomap: mark the iomap argument to iomap_inline_data const Christoph Hellwig
2021-08-09 16:17   ` Darrick J. Wong
2021-08-09  6:12 ` [PATCH 05/30] iomap: mark the iomap argument to iomap_inline_data_valid const Christoph Hellwig
2021-08-09 16:17   ` Darrick J. Wong
2021-08-09  6:12 ` [PATCH 06/30] fs: mark the iomap argument to __block_write_begin_int const Christoph Hellwig
2021-08-09  6:12 ` [PATCH 07/30] fsdax: mark the iomap argument to dax_iomap_sector as const Christoph Hellwig
2021-08-19 20:35   ` Dan Williams
2021-08-09  6:12 ` [PATCH 08/30] iomap: mark the iomap argument to iomap_read_inline_data const Christoph Hellwig
2021-08-09  6:12 ` [PATCH 09/30] iomap: mark the iomap argument to iomap_read_page_sync const Christoph Hellwig
2021-08-09  6:12 ` [PATCH 10/30] iomap: fix the iomap_readpage_actor return value for inline data Christoph Hellwig
2021-08-10 23:31   ` Darrick J. Wong
2021-08-09  6:12 ` [PATCH 11/30] iomap: add the new iomap_iter model Christoph Hellwig
2021-08-09 22:10   ` Dave Chinner
2021-08-10  6:45     ` Darrick J. Wong
2021-08-10  7:13       ` Christoph Hellwig
2021-08-11  0:31   ` Darrick J. Wong [this message]
2021-08-11  5:38     ` Christoph Hellwig
2021-08-11 19:17       ` Darrick J. Wong
2021-08-12  6:49         ` Christoph Hellwig
2021-08-12 18:20           ` Darrick J. Wong
2021-08-13  7:29             ` Christoph Hellwig
2021-08-11 19:17   ` [PATCH v2.1 " Darrick J. Wong
2021-08-17  2:34     ` Dave Chinner
2021-08-19 21:25   ` [PATCH " Dan Williams
2021-08-20  4:11     ` Christoph Hellwig
2021-08-20 15:27       ` Dan Williams
2021-08-09  6:12 ` [PATCH 12/30] iomap: switch readahead and readpage to use iomap_iter Christoph Hellwig
2021-08-10 23:46   ` Darrick J. Wong
2021-08-09  6:12 ` [PATCH 13/30] iomap: switch iomap_file_buffered_write " Christoph Hellwig
2021-08-10 23:53   ` Darrick J. Wong
2021-08-09  6:12 ` [PATCH 14/30] iomap: switch iomap_file_unshare " Christoph Hellwig
2021-08-10 23:54   ` Darrick J. Wong
2021-08-09  6:12 ` [PATCH 15/30] iomap: switch iomap_zero_range " Christoph Hellwig
2021-08-10 23:54   ` Darrick J. Wong
2021-08-09  6:12 ` [PATCH 16/30] iomap: switch iomap_page_mkwrite " Christoph Hellwig
2021-08-10 23:58   ` Darrick J. Wong
2021-08-09  6:12 ` [PATCH 17/30] iomap: switch __iomap_dio_rw " Christoph Hellwig
2021-08-11  0:17   ` Darrick J. Wong
2021-08-09  6:12 ` [PATCH 18/30] iomap: switch iomap_fiemap " Christoph Hellwig
2021-08-11  0:05   ` Darrick J. Wong
2021-08-09  6:12 ` [PATCH 19/30] iomap: switch iomap_bmap " Christoph Hellwig
2021-08-10  6:39   ` Darrick J. Wong
2021-08-10  7:13     ` Christoph Hellwig
2021-08-11 19:18   ` [PATCH v2.1 " Darrick J. Wong
2021-08-12  6:50     ` Christoph Hellwig
2021-08-17  2:35     ` Dave Chinner
2021-08-09  6:12 ` [PATCH 20/30] iomap: switch iomap_seek_hole " Christoph Hellwig
2021-08-11  0:13   ` Darrick J. Wong
2021-08-09  6:12 ` [PATCH 21/30] iomap: switch iomap_seek_data " Christoph Hellwig
2021-08-11  0:12   ` Darrick J. Wong
2021-08-09  6:12 ` [PATCH 22/30] iomap: switch iomap_swapfile_activate " Christoph Hellwig
2021-08-11  0:08   ` Darrick J. Wong
2021-08-09  6:12 ` [PATCH 23/30] fsdax: switch dax_iomap_rw " Christoph Hellwig
2021-08-11  0:07   ` Darrick J. Wong
2021-08-19 21:55   ` Dan Williams
2021-08-09  6:12 ` [PATCH 24/30] iomap: remove iomap_apply Christoph Hellwig
2021-08-11 19:18   ` [PATCH v2.1 " Darrick J. Wong
2021-08-17  2:36     ` Dave Chinner
2021-08-09  6:12 ` [PATCH 25/30] iomap: pass an iomap_iter to various buffered I/O helpers Christoph Hellwig
2021-08-09  6:12 ` [PATCH 26/30] iomap: rework unshare flag Christoph Hellwig
2021-08-09  6:12 ` [PATCH 27/30] fsdax: factor out helpers to simplify the dax fault code Christoph Hellwig
2021-08-09  6:12 ` [PATCH 28/30] fsdax: factor out a dax_fault_actor() helper Christoph Hellwig
2021-08-09  6:12 ` [PATCH 29/30] fsdax: switch the fault handlers to use iomap_iter Christoph Hellwig
2021-08-09  6:12 ` [PATCH 30/30] iomap: constify iomap_iter_srcmap Christoph Hellwig
2021-08-11 19:19 ` [PATCH 31/30] iomap: move iomap iteration code to iter.c Darrick J. Wong
2021-08-17  2:37   ` Dave Chinner

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20210811003118.GT3601466@magnolia \
    --to=djwong@kernel.org \
    --cc=agruenba@redhat.com \
    --cc=cluster-devel@redhat.com \
    --cc=dan.j.williams@intel.com \
    --cc=hch@lst.de \
    --cc=linux-btrfs@vger.kernel.org \
    --cc=linux-fsdevel@vger.kernel.org \
    --cc=linux-xfs@vger.kernel.org \
    --cc=nvdimm@lists.linux.dev \
    --cc=ruansy.fnst@fujitsu.com \
    --cc=willy@infradead.org \
    --subject='Re: [PATCH 11/30] iomap: add the new iomap_iter model' \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).