net/mlx5: E-switch, Create a second level FDB flow table
[sfrench/cifs-2.6.git] / block / bounce.c
1 // SPDX-License-Identifier: GPL-2.0
2 /* bounce buffer handling for block devices
3  *
4  * - Split from highmem.c
5  */
6
7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
8
9 #include <linux/mm.h>
10 #include <linux/export.h>
11 #include <linux/swap.h>
12 #include <linux/gfp.h>
13 #include <linux/bio.h>
14 #include <linux/pagemap.h>
15 #include <linux/mempool.h>
16 #include <linux/blkdev.h>
17 #include <linux/backing-dev.h>
18 #include <linux/init.h>
19 #include <linux/hash.h>
20 #include <linux/highmem.h>
21 #include <linux/bootmem.h>
22 #include <linux/printk.h>
23 #include <asm/tlbflush.h>
24
25 #include <trace/events/block.h>
26 #include "blk.h"
27
28 #define POOL_SIZE       64
29 #define ISA_POOL_SIZE   16
30
31 static struct bio_set *bounce_bio_set, *bounce_bio_split;
32 static mempool_t *page_pool, *isa_page_pool;
33
34 #if defined(CONFIG_HIGHMEM)
35 static __init int init_emergency_pool(void)
36 {
37 #if defined(CONFIG_HIGHMEM) && !defined(CONFIG_MEMORY_HOTPLUG)
38         if (max_pfn <= max_low_pfn)
39                 return 0;
40 #endif
41
42         page_pool = mempool_create_page_pool(POOL_SIZE, 0);
43         BUG_ON(!page_pool);
44         pr_info("pool size: %d pages\n", POOL_SIZE);
45
46         bounce_bio_set = bioset_create(BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS);
47         BUG_ON(!bounce_bio_set);
48         if (bioset_integrity_create(bounce_bio_set, BIO_POOL_SIZE))
49                 BUG_ON(1);
50
51         bounce_bio_split = bioset_create(BIO_POOL_SIZE, 0, 0);
52         BUG_ON(!bounce_bio_split);
53
54         return 0;
55 }
56
57 __initcall(init_emergency_pool);
58 #endif
59
60 #ifdef CONFIG_HIGHMEM
61 /*
62  * highmem version, map in to vec
63  */
64 static void bounce_copy_vec(struct bio_vec *to, unsigned char *vfrom)
65 {
66         unsigned long flags;
67         unsigned char *vto;
68
69         local_irq_save(flags);
70         vto = kmap_atomic(to->bv_page);
71         memcpy(vto + to->bv_offset, vfrom, to->bv_len);
72         kunmap_atomic(vto);
73         local_irq_restore(flags);
74 }
75
76 #else /* CONFIG_HIGHMEM */
77
78 #define bounce_copy_vec(to, vfrom)      \
79         memcpy(page_address((to)->bv_page) + (to)->bv_offset, vfrom, (to)->bv_len)
80
81 #endif /* CONFIG_HIGHMEM */
82
83 /*
84  * allocate pages in the DMA region for the ISA pool
85  */
86 static void *mempool_alloc_pages_isa(gfp_t gfp_mask, void *data)
87 {
88         return mempool_alloc_pages(gfp_mask | GFP_DMA, data);
89 }
90
91 /*
92  * gets called "every" time someone init's a queue with BLK_BOUNCE_ISA
93  * as the max address, so check if the pool has already been created.
94  */
95 int init_emergency_isa_pool(void)
96 {
97         if (isa_page_pool)
98                 return 0;
99
100         isa_page_pool = mempool_create(ISA_POOL_SIZE, mempool_alloc_pages_isa,
101                                        mempool_free_pages, (void *) 0);
102         BUG_ON(!isa_page_pool);
103
104         pr_info("isa pool size: %d pages\n", ISA_POOL_SIZE);
105         return 0;
106 }
107
108 /*
109  * Simple bounce buffer support for highmem pages. Depending on the
110  * queue gfp mask set, *to may or may not be a highmem page. kmap it
111  * always, it will do the Right Thing
112  */
113 static void copy_to_high_bio_irq(struct bio *to, struct bio *from)
114 {
115         unsigned char *vfrom;
116         struct bio_vec tovec, fromvec;
117         struct bvec_iter iter;
118         /*
119          * The bio of @from is created by bounce, so we can iterate
120          * its bvec from start to end, but the @from->bi_iter can't be
121          * trusted because it might be changed by splitting.
122          */
123         struct bvec_iter from_iter = BVEC_ITER_ALL_INIT;
124
125         bio_for_each_segment(tovec, to, iter) {
126                 fromvec = bio_iter_iovec(from, from_iter);
127                 if (tovec.bv_page != fromvec.bv_page) {
128                         /*
129                          * fromvec->bv_offset and fromvec->bv_len might have
130                          * been modified by the block layer, so use the original
131                          * copy, bounce_copy_vec already uses tovec->bv_len
132                          */
133                         vfrom = page_address(fromvec.bv_page) +
134                                 tovec.bv_offset;
135
136                         bounce_copy_vec(&tovec, vfrom);
137                         flush_dcache_page(tovec.bv_page);
138                 }
139                 bio_advance_iter(from, &from_iter, tovec.bv_len);
140         }
141 }
142
143 static void bounce_end_io(struct bio *bio, mempool_t *pool)
144 {
145         struct bio *bio_orig = bio->bi_private;
146         struct bio_vec *bvec, orig_vec;
147         int i;
148         struct bvec_iter orig_iter = bio_orig->bi_iter;
149
150         /*
151          * free up bounce indirect pages used
152          */
153         bio_for_each_segment_all(bvec, bio, i) {
154                 orig_vec = bio_iter_iovec(bio_orig, orig_iter);
155                 if (bvec->bv_page != orig_vec.bv_page) {
156                         dec_zone_page_state(bvec->bv_page, NR_BOUNCE);
157                         mempool_free(bvec->bv_page, pool);
158                 }
159                 bio_advance_iter(bio_orig, &orig_iter, orig_vec.bv_len);
160         }
161
162         bio_orig->bi_status = bio->bi_status;
163         bio_endio(bio_orig);
164         bio_put(bio);
165 }
166
167 static void bounce_end_io_write(struct bio *bio)
168 {
169         bounce_end_io(bio, page_pool);
170 }
171
172 static void bounce_end_io_write_isa(struct bio *bio)
173 {
174
175         bounce_end_io(bio, isa_page_pool);
176 }
177
178 static void __bounce_end_io_read(struct bio *bio, mempool_t *pool)
179 {
180         struct bio *bio_orig = bio->bi_private;
181
182         if (!bio->bi_status)
183                 copy_to_high_bio_irq(bio_orig, bio);
184
185         bounce_end_io(bio, pool);
186 }
187
188 static void bounce_end_io_read(struct bio *bio)
189 {
190         __bounce_end_io_read(bio, page_pool);
191 }
192
193 static void bounce_end_io_read_isa(struct bio *bio)
194 {
195         __bounce_end_io_read(bio, isa_page_pool);
196 }
197
198 static void __blk_queue_bounce(struct request_queue *q, struct bio **bio_orig,
199                                mempool_t *pool)
200 {
201         struct bio *bio;
202         int rw = bio_data_dir(*bio_orig);
203         struct bio_vec *to, from;
204         struct bvec_iter iter;
205         unsigned i = 0;
206         bool bounce = false;
207         int sectors = 0;
208         bool passthrough = bio_is_passthrough(*bio_orig);
209
210         bio_for_each_segment(from, *bio_orig, iter) {
211                 if (i++ < BIO_MAX_PAGES)
212                         sectors += from.bv_len >> 9;
213                 if (page_to_pfn(from.bv_page) > q->limits.bounce_pfn)
214                         bounce = true;
215         }
216         if (!bounce)
217                 return;
218
219         if (!passthrough && sectors < bio_sectors(*bio_orig)) {
220                 bio = bio_split(*bio_orig, sectors, GFP_NOIO, bounce_bio_split);
221                 bio_chain(bio, *bio_orig);
222                 generic_make_request(*bio_orig);
223                 *bio_orig = bio;
224         }
225         bio = bio_clone_bioset(*bio_orig, GFP_NOIO, passthrough ? NULL :
226                         bounce_bio_set);
227
228         bio_for_each_segment_all(to, bio, i) {
229                 struct page *page = to->bv_page;
230
231                 if (page_to_pfn(page) <= q->limits.bounce_pfn)
232                         continue;
233
234                 to->bv_page = mempool_alloc(pool, q->bounce_gfp);
235                 inc_zone_page_state(to->bv_page, NR_BOUNCE);
236
237                 if (rw == WRITE) {
238                         char *vto, *vfrom;
239
240                         flush_dcache_page(page);
241
242                         vto = page_address(to->bv_page) + to->bv_offset;
243                         vfrom = kmap_atomic(page) + to->bv_offset;
244                         memcpy(vto, vfrom, to->bv_len);
245                         kunmap_atomic(vfrom);
246                 }
247         }
248
249         trace_block_bio_bounce(q, *bio_orig);
250
251         bio->bi_flags |= (1 << BIO_BOUNCED);
252
253         if (pool == page_pool) {
254                 bio->bi_end_io = bounce_end_io_write;
255                 if (rw == READ)
256                         bio->bi_end_io = bounce_end_io_read;
257         } else {
258                 bio->bi_end_io = bounce_end_io_write_isa;
259                 if (rw == READ)
260                         bio->bi_end_io = bounce_end_io_read_isa;
261         }
262
263         bio->bi_private = *bio_orig;
264         *bio_orig = bio;
265 }
266
267 void blk_queue_bounce(struct request_queue *q, struct bio **bio_orig)
268 {
269         mempool_t *pool;
270
271         /*
272          * Data-less bio, nothing to bounce
273          */
274         if (!bio_has_data(*bio_orig))
275                 return;
276
277         /*
278          * for non-isa bounce case, just check if the bounce pfn is equal
279          * to or bigger than the highest pfn in the system -- in that case,
280          * don't waste time iterating over bio segments
281          */
282         if (!(q->bounce_gfp & GFP_DMA)) {
283                 if (q->limits.bounce_pfn >= blk_max_pfn)
284                         return;
285                 pool = page_pool;
286         } else {
287                 BUG_ON(!isa_page_pool);
288                 pool = isa_page_pool;
289         }
290
291         /*
292          * slow path
293          */
294         __blk_queue_bounce(q, bio_orig, pool);
295 }