1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Copyright (C) 2010 Red Hat, Inc. |
4 | * Copyright (c) 2016-2021 Christoph Hellwig. |
5 | */ |
6 | #include <linux/fs.h> |
7 | #include <linux/iomap.h> |
8 | #include "trace.h" |
9 | |
10 | /* |
11 | * Advance to the next range we need to map. |
12 | * |
13 | * If the iomap is marked IOMAP_F_STALE, it means the existing map was not fully |
14 | * processed - it was aborted because the extent the iomap spanned may have been |
15 | * changed during the operation. In this case, the iteration behaviour is to |
16 | * remap the unprocessed range of the iter, and that means we may need to remap |
17 | * even when we've made no progress (i.e. iter->processed = 0). Hence the |
18 | * "finished iterating" case needs to distinguish between |
19 | * (processed = 0) meaning we are done and (processed = 0 && stale) meaning we |
20 | * need to remap the entire remaining range. |
21 | */ |
22 | static inline int iomap_iter_advance(struct iomap_iter *iter) |
23 | { |
24 | bool stale = iter->iomap.flags & IOMAP_F_STALE; |
25 | |
26 | /* handle the previous iteration (if any) */ |
27 | if (iter->iomap.length) { |
28 | if (iter->processed < 0) |
29 | return iter->processed; |
30 | if (!iter->processed && !stale) |
31 | return 0; |
32 | if (WARN_ON_ONCE(iter->processed > iomap_length(iter))) |
33 | return -EIO; |
34 | iter->pos += iter->processed; |
35 | iter->len -= iter->processed; |
36 | if (!iter->len) |
37 | return 0; |
38 | } |
39 | |
40 | /* clear the state for the next iteration */ |
41 | iter->processed = 0; |
42 | memset(&iter->iomap, 0, sizeof(iter->iomap)); |
43 | memset(&iter->srcmap, 0, sizeof(iter->srcmap)); |
44 | return 1; |
45 | } |
46 | |
47 | static inline void iomap_iter_done(struct iomap_iter *iter) |
48 | { |
49 | WARN_ON_ONCE(iter->iomap.offset > iter->pos); |
50 | WARN_ON_ONCE(iter->iomap.length == 0); |
51 | WARN_ON_ONCE(iter->iomap.offset + iter->iomap.length <= iter->pos); |
52 | WARN_ON_ONCE(iter->iomap.flags & IOMAP_F_STALE); |
53 | |
54 | trace_iomap_iter_dstmap(inode: iter->inode, iomap: &iter->iomap); |
55 | if (iter->srcmap.type != IOMAP_HOLE) |
56 | trace_iomap_iter_srcmap(inode: iter->inode, iomap: &iter->srcmap); |
57 | } |
58 | |
59 | /** |
60 | * iomap_iter - iterate over a ranges in a file |
61 | * @iter: iteration structue |
62 | * @ops: iomap ops provided by the file system |
63 | * |
64 | * Iterate over filesystem-provided space mappings for the provided file range. |
65 | * |
66 | * This function handles cleanup of resources acquired for iteration when the |
67 | * filesystem indicates there are no more space mappings, which means that this |
68 | * function must be called in a loop that continues as long it returns a |
69 | * positive value. If 0 or a negative value is returned, the caller must not |
70 | * return to the loop body. Within a loop body, there are two ways to break out |
71 | * of the loop body: leave @iter.processed unchanged, or set it to a negative |
72 | * errno. |
73 | */ |
74 | int iomap_iter(struct iomap_iter *iter, const struct iomap_ops *ops) |
75 | { |
76 | int ret; |
77 | |
78 | if (iter->iomap.length && ops->iomap_end) { |
79 | ret = ops->iomap_end(iter->inode, iter->pos, iomap_length(iter), |
80 | iter->processed > 0 ? iter->processed : 0, |
81 | iter->flags, &iter->iomap); |
82 | if (ret < 0 && !iter->processed) |
83 | return ret; |
84 | } |
85 | |
86 | trace_iomap_iter(iter, ops, _RET_IP_); |
87 | ret = iomap_iter_advance(iter); |
88 | if (ret <= 0) |
89 | return ret; |
90 | |
91 | ret = ops->iomap_begin(iter->inode, iter->pos, iter->len, iter->flags, |
92 | &iter->iomap, &iter->srcmap); |
93 | if (ret < 0) |
94 | return ret; |
95 | iomap_iter_done(iter); |
96 | return 1; |
97 | } |
98 | |