Commit | Line | Data |
---|---|---|
73ce6aba | 1 | // SPDX-License-Identifier: GPL-2.0 |
ae259a9c CH |
2 | /* |
3 | * Copyright (C) 2010 Red Hat, Inc. | |
f4b896c2 | 4 | * Copyright (c) 2016-2021 Christoph Hellwig. |
ae259a9c | 5 | */ |
ae259a9c CH |
6 | #include <linux/fs.h> |
7 | #include <linux/iomap.h> | |
6334b91e | 8 | #include "trace.h" |
f361bf4a | 9 | |
d7b64041 DC |
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 | */ | |
f4b896c2 CH |
22 | static inline int iomap_iter_advance(struct iomap_iter *iter) |
23 | { | |
d7b64041 DC |
24 | bool stale = iter->iomap.flags & IOMAP_F_STALE; |
25 | ||
f4b896c2 CH |
26 | /* handle the previous iteration (if any) */ |
27 | if (iter->iomap.length) { | |
d7b64041 | 28 | if (iter->processed < 0) |
f4b896c2 | 29 | return iter->processed; |
d7b64041 DC |
30 | if (!iter->processed && !stale) |
31 | return 0; | |
f4b896c2 CH |
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); | |
d7b64041 | 52 | WARN_ON_ONCE(iter->iomap.flags & IOMAP_F_STALE); |
f4b896c2 CH |
53 | |
54 | trace_iomap_iter_dstmap(iter->inode, &iter->iomap); | |
55 | if (iter->srcmap.type != IOMAP_HOLE) | |
56 | trace_iomap_iter_srcmap(iter->inode, &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 | } |