From: Christoph Hellwig <hch@lst.de> To: "Darrick J. Wong" <djwong@kernel.org> 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: [PATCH 11/30] iomap: add the new iomap_iter model Date: Mon, 9 Aug 2021 08:12:25 +0200 [thread overview] Message-ID: <20210809061244.1196573-12-hch@lst.de> (raw) In-Reply-To: <20210809061244.1196573-1-hch@lst.de> 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) +{ + 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; +} 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
next prev parent reply other threads:[~2021-08-09 6:23 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 ` Christoph Hellwig [this message] 2021-08-09 22:10 ` [PATCH 11/30] iomap: add the new iomap_iter model 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 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=20210809061244.1196573-12-hch@lst.de \ --to=hch@lst.de \ --cc=agruenba@redhat.com \ --cc=cluster-devel@redhat.com \ --cc=dan.j.williams@intel.com \ --cc=djwong@kernel.org \ --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).