]>
Commit | Line | Data |
---|---|---|
8c16567d | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
8fc55455 ML |
2 | /* |
3 | * bvec iterator | |
4 | * | |
5 | * Copyright (C) 2001 Ming Lei <ming.lei@canonical.com> | |
8fc55455 ML |
6 | */ |
7 | #ifndef __LINUX_BVEC_ITER_H | |
8 | #define __LINUX_BVEC_ITER_H | |
9 | ||
0781e79e | 10 | #include <linux/bug.h> |
b1fb2c52 | 11 | #include <linux/errno.h> |
b296a6d5 AS |
12 | #include <linux/limits.h> |
13 | #include <linux/minmax.h> | |
3d75ca0a | 14 | #include <linux/mm.h> |
b296a6d5 AS |
15 | #include <linux/types.h> |
16 | ||
17 | struct page; | |
0781e79e | 18 | |
854b5f01 BVA |
19 | /** |
20 | * struct bio_vec - a contiguous range of physical memory addresses | |
21 | * @bv_page: First page associated with the address range. | |
22 | * @bv_len: Number of bytes in the address range. | |
23 | * @bv_offset: Start of the address range relative to the start of @bv_page. | |
24 | * | |
25 | * The following holds for a bvec if n * PAGE_SIZE < bv_offset + bv_len: | |
26 | * | |
27 | * nth_page(@bv_page, n) == @bv_page + n | |
28 | * | |
29 | * This holds because page_is_mergeable() checks the above property. | |
0781e79e ML |
30 | */ |
31 | struct bio_vec { | |
32 | struct page *bv_page; | |
33 | unsigned int bv_len; | |
34 | unsigned int bv_offset; | |
35 | }; | |
36 | ||
37 | struct bvec_iter { | |
38 | sector_t bi_sector; /* device address in 512 byte | |
39 | sectors */ | |
40 | unsigned int bi_size; /* residual I/O count */ | |
41 | ||
42 | unsigned int bi_idx; /* current index into bvl_vec */ | |
43 | ||
44 | unsigned int bi_bvec_done; /* number of bytes completed in | |
45 | current bvec */ | |
46 | }; | |
8fc55455 | 47 | |
6dc4f100 ML |
48 | struct bvec_iter_all { |
49 | struct bio_vec bv; | |
50 | int idx; | |
51 | unsigned done; | |
52 | }; | |
53 | ||
8fc55455 ML |
54 | /* |
55 | * various member access, note that bio_data should of course not be used | |
56 | * on highmem page vectors | |
57 | */ | |
58 | #define __bvec_iter_bvec(bvec, iter) (&(bvec)[(iter).bi_idx]) | |
59 | ||
3d75ca0a ML |
60 | /* multi-page (mp_bvec) helpers */ |
61 | #define mp_bvec_iter_page(bvec, iter) \ | |
8fc55455 ML |
62 | (__bvec_iter_bvec((bvec), (iter))->bv_page) |
63 | ||
3d75ca0a | 64 | #define mp_bvec_iter_len(bvec, iter) \ |
8fc55455 ML |
65 | min((iter).bi_size, \ |
66 | __bvec_iter_bvec((bvec), (iter))->bv_len - (iter).bi_bvec_done) | |
67 | ||
3d75ca0a | 68 | #define mp_bvec_iter_offset(bvec, iter) \ |
8fc55455 ML |
69 | (__bvec_iter_bvec((bvec), (iter))->bv_offset + (iter).bi_bvec_done) |
70 | ||
3d75ca0a ML |
71 | #define mp_bvec_iter_page_idx(bvec, iter) \ |
72 | (mp_bvec_iter_offset((bvec), (iter)) / PAGE_SIZE) | |
73 | ||
74 | #define mp_bvec_iter_bvec(bvec, iter) \ | |
75 | ((struct bio_vec) { \ | |
76 | .bv_page = mp_bvec_iter_page((bvec), (iter)), \ | |
77 | .bv_len = mp_bvec_iter_len((bvec), (iter)), \ | |
78 | .bv_offset = mp_bvec_iter_offset((bvec), (iter)), \ | |
79 | }) | |
80 | ||
81 | /* For building single-page bvec in flight */ | |
82 | #define bvec_iter_offset(bvec, iter) \ | |
83 | (mp_bvec_iter_offset((bvec), (iter)) % PAGE_SIZE) | |
84 | ||
85 | #define bvec_iter_len(bvec, iter) \ | |
86 | min_t(unsigned, mp_bvec_iter_len((bvec), (iter)), \ | |
87 | PAGE_SIZE - bvec_iter_offset((bvec), (iter))) | |
88 | ||
89 | #define bvec_iter_page(bvec, iter) \ | |
52d52d1c CH |
90 | (mp_bvec_iter_page((bvec), (iter)) + \ |
91 | mp_bvec_iter_page_idx((bvec), (iter))) | |
3d75ca0a | 92 | |
8fc55455 ML |
93 | #define bvec_iter_bvec(bvec, iter) \ |
94 | ((struct bio_vec) { \ | |
95 | .bv_page = bvec_iter_page((bvec), (iter)), \ | |
96 | .bv_len = bvec_iter_len((bvec), (iter)), \ | |
97 | .bv_offset = bvec_iter_offset((bvec), (iter)), \ | |
98 | }) | |
99 | ||
b1fb2c52 DM |
100 | static inline bool bvec_iter_advance(const struct bio_vec *bv, |
101 | struct bvec_iter *iter, unsigned bytes) | |
8fc55455 | 102 | { |
795ee49c PB |
103 | unsigned int idx = iter->bi_idx; |
104 | ||
b1fb2c52 DM |
105 | if (WARN_ONCE(bytes > iter->bi_size, |
106 | "Attempted to advance past end of bvec iter\n")) { | |
107 | iter->bi_size = 0; | |
108 | return false; | |
109 | } | |
8fc55455 | 110 | |
795ee49c PB |
111 | iter->bi_size -= bytes; |
112 | bytes += iter->bi_bvec_done; | |
8fc55455 | 113 | |
795ee49c PB |
114 | while (bytes && bytes >= bv[idx].bv_len) { |
115 | bytes -= bv[idx].bv_len; | |
116 | idx++; | |
8fc55455 | 117 | } |
795ee49c PB |
118 | |
119 | iter->bi_idx = idx; | |
120 | iter->bi_bvec_done = bytes; | |
b1fb2c52 | 121 | return true; |
8fc55455 ML |
122 | } |
123 | ||
6b6667aa PB |
124 | /* |
125 | * A simpler version of bvec_iter_advance(), @bytes should not span | |
126 | * across multiple bvec entries, i.e. bytes <= bv[i->bi_idx].bv_len | |
127 | */ | |
128 | static inline void bvec_iter_advance_single(const struct bio_vec *bv, | |
129 | struct bvec_iter *iter, unsigned int bytes) | |
7e249690 | 130 | { |
6b6667aa PB |
131 | unsigned int done = iter->bi_bvec_done + bytes; |
132 | ||
133 | if (done == bv[iter->bi_idx].bv_len) { | |
134 | done = 0; | |
135 | iter->bi_idx++; | |
136 | } | |
137 | iter->bi_bvec_done = done; | |
138 | iter->bi_size -= bytes; | |
7e249690 ML |
139 | } |
140 | ||
8fc55455 ML |
141 | #define for_each_bvec(bvl, bio_vec, iter, start) \ |
142 | for (iter = (start); \ | |
143 | (iter).bi_size && \ | |
144 | ((bvl = bvec_iter_bvec((bio_vec), (iter))), 1); \ | |
6b6667aa | 145 | bvec_iter_advance_single((bio_vec), &(iter), (bvl).bv_len)) |
8fc55455 | 146 | |
3c892a09 ML |
147 | /* for iterating one bio from start to end */ |
148 | #define BVEC_ITER_ALL_INIT (struct bvec_iter) \ | |
149 | { \ | |
150 | .bi_sector = 0, \ | |
151 | .bi_size = UINT_MAX, \ | |
152 | .bi_idx = 0, \ | |
153 | .bi_bvec_done = 0, \ | |
154 | } | |
155 | ||
6dc4f100 ML |
156 | static inline struct bio_vec *bvec_init_iter_all(struct bvec_iter_all *iter_all) |
157 | { | |
6dc4f100 | 158 | iter_all->done = 0; |
1200e07f | 159 | iter_all->idx = 0; |
6dc4f100 ML |
160 | |
161 | return &iter_all->bv; | |
162 | } | |
163 | ||
1200e07f ML |
164 | static inline void bvec_advance(const struct bio_vec *bvec, |
165 | struct bvec_iter_all *iter_all) | |
6dc4f100 ML |
166 | { |
167 | struct bio_vec *bv = &iter_all->bv; | |
168 | ||
1200e07f | 169 | if (iter_all->done) { |
52d52d1c | 170 | bv->bv_page++; |
6dc4f100 ML |
171 | bv->bv_offset = 0; |
172 | } else { | |
b8753433 | 173 | bv->bv_page = bvec->bv_page + (bvec->bv_offset >> PAGE_SHIFT); |
6bedf00e | 174 | bv->bv_offset = bvec->bv_offset & ~PAGE_MASK; |
6dc4f100 ML |
175 | } |
176 | bv->bv_len = min_t(unsigned int, PAGE_SIZE - bv->bv_offset, | |
177 | bvec->bv_len - iter_all->done); | |
1200e07f ML |
178 | iter_all->done += bv->bv_len; |
179 | ||
180 | if (iter_all->done == bvec->bv_len) { | |
181 | iter_all->idx++; | |
182 | iter_all->done = 0; | |
183 | } | |
6dc4f100 ML |
184 | } |
185 | ||
8fc55455 | 186 | #endif /* __LINUX_BVEC_ITER_H */ |