Branch data Line data Source code
1 : : /*
2 : : * Copyright (C) 2001 Jens Axboe <axboe@kernel.dk>
3 : : *
4 : : * This program is free software; you can redistribute it and/or modify
5 : : * it under the terms of the GNU General Public License version 2 as
6 : : * published by the Free Software Foundation.
7 : : *
8 : : * This program is distributed in the hope that it will be useful,
9 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 : : * GNU General Public License for more details.
12 : : *
13 : : * You should have received a copy of the GNU General Public Licens
14 : : * along with this program; if not, write to the Free Software
15 : : * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-
16 : : *
17 : : */
18 : : #include <linux/mm.h>
19 : : #include <linux/swap.h>
20 : : #include <linux/bio.h>
21 : : #include <linux/blkdev.h>
22 : : #include <linux/uio.h>
23 : : #include <linux/iocontext.h>
24 : : #include <linux/slab.h>
25 : : #include <linux/init.h>
26 : : #include <linux/kernel.h>
27 : : #include <linux/export.h>
28 : : #include <linux/mempool.h>
29 : : #include <linux/workqueue.h>
30 : : #include <linux/cgroup.h>
31 : : #include <scsi/sg.h> /* for struct sg_iovec */
32 : :
33 : : #include <trace/events/block.h>
34 : :
35 : : /*
36 : : * Test patch to inline a certain number of bi_io_vec's inside the bio
37 : : * itself, to shrink a bio data allocation from two mempool calls to one
38 : : */
39 : : #define BIO_INLINE_VECS 4
40 : :
41 : : /*
42 : : * if you change this list, also change bvec_alloc or things will
43 : : * break badly! cannot be bigger than what you can fit into an
44 : : * unsigned short
45 : : */
46 : : #define BV(x) { .nr_vecs = x, .name = "biovec-"__stringify(x) }
47 : : static struct biovec_slab bvec_slabs[BIOVEC_NR_POOLS] __read_mostly = {
48 : : BV(1), BV(4), BV(16), BV(64), BV(128), BV(BIO_MAX_PAGES),
49 : : };
50 : : #undef BV
51 : :
52 : : /*
53 : : * fs_bio_set is the bio_set containing bio and iovec memory pools used by
54 : : * IO code that does not need private memory pools.
55 : : */
56 : : struct bio_set *fs_bio_set;
57 : : EXPORT_SYMBOL(fs_bio_set);
58 : :
59 : : /*
60 : : * Our slab pool management
61 : : */
62 : : struct bio_slab {
63 : : struct kmem_cache *slab;
64 : : unsigned int slab_ref;
65 : : unsigned int slab_size;
66 : : char name[8];
67 : : };
68 : : static DEFINE_MUTEX(bio_slab_lock);
69 : : static struct bio_slab *bio_slabs;
70 : : static unsigned int bio_slab_nr, bio_slab_max;
71 : :
72 : 0 : static struct kmem_cache *bio_find_or_create_slab(unsigned int extra_size)
73 : : {
74 : 0 : unsigned int sz = sizeof(struct bio) + extra_size;
75 : : struct kmem_cache *slab = NULL;
76 : : struct bio_slab *bslab, *new_bio_slabs;
77 : : unsigned int new_bio_slab_max;
78 : : unsigned int i, entry = -1;
79 : :
80 : 0 : mutex_lock(&bio_slab_lock);
81 : :
82 : : i = 0;
83 [ # # ]: 0 : while (i < bio_slab_nr) {
84 : 0 : bslab = &bio_slabs[i];
85 : :
86 [ # # ][ # # ]: 0 : if (!bslab->slab && entry == -1)
87 : : entry = i;
88 [ # # ]: 0 : else if (bslab->slab_size == sz) {
89 : : slab = bslab->slab;
90 : 0 : bslab->slab_ref++;
91 : 0 : break;
92 : : }
93 : 0 : i++;
94 : : }
95 : :
96 [ # # ]: 0 : if (slab)
97 : : goto out_unlock;
98 : :
99 [ # # ][ # # ]: 0 : if (bio_slab_nr == bio_slab_max && entry == -1) {
100 : 0 : new_bio_slab_max = bio_slab_max << 1;
101 : 0 : new_bio_slabs = krealloc(bio_slabs,
102 : : new_bio_slab_max * sizeof(struct bio_slab),
103 : : GFP_KERNEL);
104 [ # # ]: 0 : if (!new_bio_slabs)
105 : : goto out_unlock;
106 : 0 : bio_slab_max = new_bio_slab_max;
107 : 0 : bio_slabs = new_bio_slabs;
108 : : }
109 [ # # ]: 0 : if (entry == -1)
110 : 0 : entry = bio_slab_nr++;
111 : :
112 : 0 : bslab = &bio_slabs[entry];
113 : :
114 : 0 : snprintf(bslab->name, sizeof(bslab->name), "bio-%d", entry);
115 : 0 : slab = kmem_cache_create(bslab->name, sz, 0, SLAB_HWCACHE_ALIGN, NULL);
116 [ # # ]: 0 : if (!slab)
117 : : goto out_unlock;
118 : :
119 : 0 : printk(KERN_INFO "bio: create slab <%s> at %d\n", bslab->name, entry);
120 : 0 : bslab->slab = slab;
121 : 0 : bslab->slab_ref = 1;
122 : 0 : bslab->slab_size = sz;
123 : : out_unlock:
124 : 0 : mutex_unlock(&bio_slab_lock);
125 : 0 : return slab;
126 : : }
127 : :
128 : 0 : static void bio_put_slab(struct bio_set *bs)
129 : : {
130 : : struct bio_slab *bslab = NULL;
131 : : unsigned int i;
132 : :
133 : 0 : mutex_lock(&bio_slab_lock);
134 : :
135 [ # # ]: 0 : for (i = 0; i < bio_slab_nr; i++) {
136 [ # # ]: 0 : if (bs->bio_slab == bio_slabs[i].slab) {
137 : : bslab = &bio_slabs[i];
138 : : break;
139 : : }
140 : : }
141 : :
142 [ # # ][ # # ]: 0 : if (WARN(!bslab, KERN_ERR "bio: unable to find slab!\n"))
143 : : goto out;
144 : :
145 [ # # ]: 0 : WARN_ON(!bslab->slab_ref);
146 : :
147 [ # # ]: 0 : if (--bslab->slab_ref)
148 : : goto out;
149 : :
150 : 0 : kmem_cache_destroy(bslab->slab);
151 : 0 : bslab->slab = NULL;
152 : :
153 : : out:
154 : 0 : mutex_unlock(&bio_slab_lock);
155 : 0 : }
156 : :
157 : 0 : unsigned int bvec_nr_vecs(unsigned short idx)
158 : : {
159 : 0 : return bvec_slabs[idx].nr_vecs;
160 : : }
161 : :
162 : 0 : void bvec_free(mempool_t *pool, struct bio_vec *bv, unsigned int idx)
163 : : {
164 [ - + ]: 248977 : BIO_BUG_ON(idx >= BIOVEC_NR_POOLS);
165 : :
166 [ - + ]: 248977 : if (idx == BIOVEC_MAX_IDX)
167 : 0 : mempool_free(bv, pool);
168 : : else {
169 : 248977 : struct biovec_slab *bvs = bvec_slabs + idx;
170 : :
171 : 248977 : kmem_cache_free(bvs->slab, bv);
172 : : }
173 : 248977 : }
174 : :
175 : 0 : struct bio_vec *bvec_alloc(gfp_t gfp_mask, int nr, unsigned long *idx,
176 : : mempool_t *pool)
177 : : {
178 : : struct bio_vec *bvl;
179 : :
180 : : /*
181 : : * see comment near bvec_array define!
182 : : */
183 [ - - + + : 248958 : switch (nr) {
- - + ]
184 : : case 1:
185 : 0 : *idx = 0;
186 : 0 : break;
187 : : case 2 ... 4:
188 : 0 : *idx = 1;
189 : 0 : break;
190 : : case 5 ... 16:
191 : 34005 : *idx = 2;
192 : 34005 : break;
193 : : case 17 ... 64:
194 : 214916 : *idx = 3;
195 : 214916 : break;
196 : : case 65 ... 128:
197 : 0 : *idx = 4;
198 : 0 : break;
199 : : case 129 ... BIO_MAX_PAGES:
200 : 0 : *idx = 5;
201 : 0 : break;
202 : : default:
203 : : return NULL;
204 : : }
205 : :
206 : : /*
207 : : * idx now points to the pool we want to allocate from. only the
208 : : * 1-vec entry pool is mempool backed.
209 : : */
210 [ + + ]: 248921 : if (*idx == BIOVEC_MAX_IDX) {
211 : : fallback:
212 : 69 : bvl = mempool_alloc(pool, gfp_mask);
213 : : } else {
214 : 248852 : struct biovec_slab *bvs = bvec_slabs + *idx;
215 : 248852 : gfp_t __gfp_mask = gfp_mask & ~(__GFP_WAIT | __GFP_IO);
216 : :
217 : : /*
218 : : * Make this allocation restricted and don't dump info on
219 : : * allocation failures, since we'll fallback to the mempool
220 : : * in case of failure.
221 : : */
222 : 248852 : __gfp_mask |= __GFP_NOMEMALLOC | __GFP_NORETRY | __GFP_NOWARN;
223 : :
224 : : /*
225 : : * Try a slab allocation. If this fails and __GFP_WAIT
226 : : * is set, retry with the 1-entry mempool
227 : : */
228 : 248852 : bvl = kmem_cache_alloc(bvs->slab, __gfp_mask);
229 [ - + ][ # # ]: 248948 : if (unlikely(!bvl && (gfp_mask & __GFP_WAIT))) {
230 : 0 : *idx = BIOVEC_MAX_IDX;
231 : 0 : goto fallback;
232 : : }
233 : : }
234 : :
235 : 248954 : return bvl;
236 : : }
237 : :
238 : : static void __bio_free(struct bio *bio)
239 : : {
240 : : bio_disassociate_task(bio);
241 : :
242 : : if (bio_integrity(bio))
243 : : bio_integrity_free(bio);
244 : : }
245 : :
246 : 0 : static void bio_free(struct bio *bio)
247 : : {
248 : 742177 : struct bio_set *bs = bio->bi_pool;
249 : : void *p;
250 : :
251 : : __bio_free(bio);
252 : :
253 [ + - ]: 742177 : if (bs) {
254 [ + + ]: 742177 : if (bio_flagged(bio, BIO_OWNS_VEC))
255 : 248977 : bvec_free(bs->bvec_pool, bio->bi_io_vec, BIO_POOL_IDX(bio));
256 : :
257 : : /*
258 : : * If we have front padding, adjust the bio pointer before freeing
259 : : */
260 : : p = bio;
261 : 0 : p -= bs->front_pad;
262 : :
263 : 742177 : mempool_free(p, bs->bio_pool);
264 : : } else {
265 : : /* Bio was allocated by bio_kmalloc() */
266 : 0 : kfree(bio);
267 : : }
268 : 742180 : }
269 : :
270 : 0 : void bio_init(struct bio *bio)
271 : : {
272 : 742130 : memset(bio, 0, sizeof(*bio));
273 : 742137 : bio->bi_flags = 1 << BIO_UPTODATE;
274 : 742137 : atomic_set(&bio->bi_remaining, 1);
275 : 742137 : atomic_set(&bio->bi_cnt, 1);
276 : 0 : }
277 : : EXPORT_SYMBOL(bio_init);
278 : :
279 : : /**
280 : : * bio_reset - reinitialize a bio
281 : : * @bio: bio to reset
282 : : *
283 : : * Description:
284 : : * After calling bio_reset(), @bio will be in the same state as a freshly
285 : : * allocated bio returned bio bio_alloc_bioset() - the only fields that are
286 : : * preserved are the ones that are initialized by bio_alloc_bioset(). See
287 : : * comment in struct bio.
288 : : */
289 : 0 : void bio_reset(struct bio *bio)
290 : : {
291 : 0 : unsigned long flags = bio->bi_flags & (~0UL << BIO_RESET_BITS);
292 : :
293 : : __bio_free(bio);
294 : :
295 : 0 : memset(bio, 0, BIO_RESET_BYTES);
296 : 0 : bio->bi_flags = flags|(1 << BIO_UPTODATE);
297 : 0 : atomic_set(&bio->bi_remaining, 1);
298 : 0 : }
299 : : EXPORT_SYMBOL(bio_reset);
300 : :
301 : 0 : static void bio_chain_endio(struct bio *bio, int error)
302 : : {
303 : 0 : bio_endio(bio->bi_private, error);
304 : 0 : bio_put(bio);
305 : 0 : }
306 : :
307 : : /**
308 : : * bio_chain - chain bio completions
309 : : *
310 : : * The caller won't have a bi_end_io called when @bio completes - instead,
311 : : * @parent's bi_end_io won't be called until both @parent and @bio have
312 : : * completed; the chained bio will also be freed when it completes.
313 : : *
314 : : * The caller must not set bi_private or bi_end_io in @bio.
315 : : */
316 : 0 : void bio_chain(struct bio *bio, struct bio *parent)
317 : : {
318 [ # # ][ # # ]: 0 : BUG_ON(bio->bi_private || bio->bi_end_io);
319 : :
320 : 0 : bio->bi_private = parent;
321 : 0 : bio->bi_end_io = bio_chain_endio;
322 : 0 : atomic_inc(&parent->bi_remaining);
323 : 0 : }
324 : : EXPORT_SYMBOL(bio_chain);
325 : :
326 : 0 : static void bio_alloc_rescue(struct work_struct *work)
327 : : {
328 : : struct bio_set *bs = container_of(work, struct bio_set, rescue_work);
329 : : struct bio *bio;
330 : :
331 : : while (1) {
332 : : spin_lock(&bs->rescue_lock);
333 : : bio = bio_list_pop(&bs->rescue_list);
334 : : spin_unlock(&bs->rescue_lock);
335 : :
336 [ # # ]: 0 : if (!bio)
337 : : break;
338 : :
339 : 0 : generic_make_request(bio);
340 : 0 : }
341 : 0 : }
342 : :
343 : 0 : static void punt_bios_to_rescuer(struct bio_set *bs)
344 : : {
345 : : struct bio_list punt, nopunt;
346 : : struct bio *bio;
347 : :
348 : : /*
349 : : * In order to guarantee forward progress we must punt only bios that
350 : : * were allocated from this bio_set; otherwise, if there was a bio on
351 : : * there for a stacking driver higher up in the stack, processing it
352 : : * could require allocating bios from this bio_set, and doing that from
353 : : * our own rescuer would be bad.
354 : : *
355 : : * Since bio lists are singly linked, pop them all instead of trying to
356 : : * remove from the middle of the list:
357 : : */
358 : :
359 : : bio_list_init(&punt);
360 : : bio_list_init(&nopunt);
361 : :
362 [ # # ]: 0 : while ((bio = bio_list_pop(current->bio_list)))
363 [ # # ]: 0 : bio_list_add(bio->bi_pool == bs ? &punt : &nopunt, bio);
364 : :
365 : 0 : *current->bio_list = nopunt;
366 : :
367 : : spin_lock(&bs->rescue_lock);
368 : : bio_list_merge(&bs->rescue_list, &punt);
369 : : spin_unlock(&bs->rescue_lock);
370 : :
371 : 0 : queue_work(bs->rescue_workqueue, &bs->rescue_work);
372 : 0 : }
373 : :
374 : : /**
375 : : * bio_alloc_bioset - allocate a bio for I/O
376 : : * @gfp_mask: the GFP_ mask given to the slab allocator
377 : : * @nr_iovecs: number of iovecs to pre-allocate
378 : : * @bs: the bio_set to allocate from.
379 : : *
380 : : * Description:
381 : : * If @bs is NULL, uses kmalloc() to allocate the bio; else the allocation is
382 : : * backed by the @bs's mempool.
383 : : *
384 : : * When @bs is not NULL, if %__GFP_WAIT is set then bio_alloc will always be
385 : : * able to allocate a bio. This is due to the mempool guarantees. To make this
386 : : * work, callers must never allocate more than 1 bio at a time from this pool.
387 : : * Callers that need to allocate more than 1 bio must always submit the
388 : : * previously allocated bio for IO before attempting to allocate a new one.
389 : : * Failure to do so can cause deadlocks under memory pressure.
390 : : *
391 : : * Note that when running under generic_make_request() (i.e. any block
392 : : * driver), bios are not submitted until after you return - see the code in
393 : : * generic_make_request() that converts recursion into iteration, to prevent
394 : : * stack overflows.
395 : : *
396 : : * This would normally mean allocating multiple bios under
397 : : * generic_make_request() would be susceptible to deadlocks, but we have
398 : : * deadlock avoidance code that resubmits any blocked bios from a rescuer
399 : : * thread.
400 : : *
401 : : * However, we do not guarantee forward progress for allocations from other
402 : : * mempools. Doing multiple allocations from the same mempool under
403 : : * generic_make_request() should be avoided - instead, use bio_set's front_pad
404 : : * for per bio allocations.
405 : : *
406 : : * RETURNS:
407 : : * Pointer to new bio on success, NULL on failure.
408 : : */
409 : 0 : struct bio *bio_alloc_bioset(gfp_t gfp_mask, int nr_iovecs, struct bio_set *bs)
410 : : {
411 : : gfp_t saved_gfp = gfp_mask;
412 : : unsigned front_pad;
413 : : unsigned inline_vecs;
414 : 742073 : unsigned long idx = BIO_POOL_NONE;
415 : : struct bio_vec *bvl = NULL;
416 : : struct bio *bio;
417 : : void *p;
418 : :
419 [ - + ]: 742073 : if (!bs) {
420 [ # # ]: 0 : if (nr_iovecs > UIO_MAXIOV)
421 : : return NULL;
422 : :
423 : 0 : p = kmalloc(sizeof(struct bio) +
424 : 0 : nr_iovecs * sizeof(struct bio_vec),
425 : : gfp_mask);
426 : : front_pad = 0;
427 : : inline_vecs = nr_iovecs;
428 : : } else {
429 : : /*
430 : : * generic_make_request() converts recursion to iteration; this
431 : : * means if we're running beneath it, any bios we allocate and
432 : : * submit will not be submitted (and thus freed) until after we
433 : : * return.
434 : : *
435 : : * This exposes us to a potential deadlock if we allocate
436 : : * multiple bios from the same bio_set() while running
437 : : * underneath generic_make_request(). If we were to allocate
438 : : * multiple bios (say a stacking block driver that was splitting
439 : : * bios), we would deadlock if we exhausted the mempool's
440 : : * reserve.
441 : : *
442 : : * We solve this, and guarantee forward progress, with a rescuer
443 : : * workqueue per bio_set. If we go to allocate and there are
444 : : * bios on current->bio_list, we first try the allocation
445 : : * without __GFP_WAIT; if that fails, we punt those bios we
446 : : * would be blocking to the rescuer workqueue before we retry
447 : : * with the original gfp_flags.
448 : : */
449 : :
450 [ + + ][ - + ]: 742073 : if (current->bio_list && !bio_list_empty(current->bio_list))
451 : 0 : gfp_mask &= ~__GFP_WAIT;
452 : :
453 : 742073 : p = mempool_alloc(bs->bio_pool, gfp_mask);
454 [ - + ]: 742137 : if (!p && gfp_mask != saved_gfp) {
455 : 0 : punt_bios_to_rescuer(bs);
456 : : gfp_mask = saved_gfp;
457 : 0 : p = mempool_alloc(bs->bio_pool, gfp_mask);
458 : : }
459 : :
460 : 742137 : front_pad = bs->front_pad;
461 : : inline_vecs = BIO_INLINE_VECS;
462 : : }
463 : :
464 [ + + ]: 742137 : if (unlikely(!p))
465 : : return NULL;
466 : :
467 : 742130 : bio = p + front_pad;
468 : : bio_init(bio);
469 : :
470 [ + + ]: 742137 : if (nr_iovecs > inline_vecs) {
471 : 248965 : bvl = bvec_alloc(gfp_mask, nr_iovecs, &idx, bs->bvec_pool);
472 [ - + ]: 248934 : if (!bvl && gfp_mask != saved_gfp) {
473 : 0 : punt_bios_to_rescuer(bs);
474 : : gfp_mask = saved_gfp;
475 : 0 : bvl = bvec_alloc(gfp_mask, nr_iovecs, &idx, bs->bvec_pool);
476 : : }
477 : :
478 [ + - ]: 248943 : if (unlikely(!bvl))
479 : : goto err_free;
480 : :
481 : 248943 : bio->bi_flags |= 1 << BIO_OWNS_VEC;
482 [ + + ]: 493172 : } else if (nr_iovecs) {
483 : 490990 : bvl = bio->bi_inline_vecs;
484 : : }
485 : :
486 : 742115 : bio->bi_pool = bs;
487 : 742115 : bio->bi_flags |= idx << BIO_POOL_OFFSET;
488 : 742115 : bio->bi_max_vecs = nr_iovecs;
489 : 742115 : bio->bi_io_vec = bvl;
490 : 742115 : return bio;
491 : :
492 : : err_free:
493 : 0 : mempool_free(p, bs->bio_pool);
494 : 0 : return NULL;
495 : : }
496 : : EXPORT_SYMBOL(bio_alloc_bioset);
497 : :
498 : 0 : void zero_fill_bio(struct bio *bio)
499 : : {
500 : : unsigned long flags;
501 : : struct bio_vec bv;
502 : : struct bvec_iter iter;
503 : :
504 [ # # ]: 0 : bio_for_each_segment(bv, bio, iter) {
505 : : char *data = bvec_kmap_irq(&bv, &flags);
506 [ # # ]: 0 : memset(data, 0, bv.bv_len);
507 : 0 : flush_dcache_page(bv.bv_page);
508 : : bvec_kunmap_irq(data, &flags);
509 : : }
510 : 0 : }
511 : : EXPORT_SYMBOL(zero_fill_bio);
512 : :
513 : : /**
514 : : * bio_put - release a reference to a bio
515 : : * @bio: bio to release reference to
516 : : *
517 : : * Description:
518 : : * Put a reference to a &struct bio, either one you have gotten with
519 : : * bio_alloc, bio_get or bio_clone. The last put of a bio will free it.
520 : : **/
521 : 0 : void bio_put(struct bio *bio)
522 : : {
523 [ - + ]: 1030179 : BIO_BUG_ON(!atomic_read(&bio->bi_cnt));
524 : :
525 : : /*
526 : : * last put frees it
527 : : */
528 [ + + ]: 1030155 : if (atomic_dec_and_test(&bio->bi_cnt))
529 : 742178 : bio_free(bio);
530 : 0 : }
531 : : EXPORT_SYMBOL(bio_put);
532 : :
533 : 0 : inline int bio_phys_segments(struct request_queue *q, struct bio *bio)
534 : : {
535 [ + + ]: 454873 : if (unlikely(!bio_flagged(bio, BIO_SEG_VALID)))
536 : 387913 : blk_recount_segments(q, bio);
537 : :
538 : 0 : return bio->bi_phys_segments;
539 : : }
540 : : EXPORT_SYMBOL(bio_phys_segments);
541 : :
542 : : /**
543 : : * __bio_clone_fast - clone a bio that shares the original bio's biovec
544 : : * @bio: destination bio
545 : : * @bio_src: bio to clone
546 : : *
547 : : * Clone a &bio. Caller will own the returned bio, but not
548 : : * the actual data it points to. Reference count of returned
549 : : * bio will be one.
550 : : *
551 : : * Caller must ensure that @bio_src is not freed before @bio.
552 : : */
553 : 0 : void __bio_clone_fast(struct bio *bio, struct bio *bio_src)
554 : : {
555 [ # # ][ # # ]: 0 : BUG_ON(bio->bi_pool && BIO_POOL_IDX(bio) != BIO_POOL_NONE);
556 : :
557 : : /*
558 : : * most users will be overriding ->bi_bdev with a new target,
559 : : * so we don't set nor calculate new physical/hw segment counts here
560 : : */
561 : 0 : bio->bi_bdev = bio_src->bi_bdev;
562 : 0 : bio->bi_flags |= 1 << BIO_CLONED;
563 : 0 : bio->bi_rw = bio_src->bi_rw;
564 : 0 : bio->bi_iter = bio_src->bi_iter;
565 : 0 : bio->bi_io_vec = bio_src->bi_io_vec;
566 : 0 : }
567 : : EXPORT_SYMBOL(__bio_clone_fast);
568 : :
569 : : /**
570 : : * bio_clone_fast - clone a bio that shares the original bio's biovec
571 : : * @bio: bio to clone
572 : : * @gfp_mask: allocation priority
573 : : * @bs: bio_set to allocate from
574 : : *
575 : : * Like __bio_clone_fast, only also allocates the returned bio
576 : : */
577 : 0 : struct bio *bio_clone_fast(struct bio *bio, gfp_t gfp_mask, struct bio_set *bs)
578 : : {
579 : : struct bio *b;
580 : :
581 : 0 : b = bio_alloc_bioset(gfp_mask, 0, bs);
582 [ # # ]: 0 : if (!b)
583 : : return NULL;
584 : :
585 : 0 : __bio_clone_fast(b, bio);
586 : :
587 : : if (bio_integrity(bio)) {
588 : : int ret;
589 : :
590 : : ret = bio_integrity_clone(b, bio, gfp_mask);
591 : :
592 : : if (ret < 0) {
593 : : bio_put(b);
594 : : return NULL;
595 : : }
596 : : }
597 : :
598 : 0 : return b;
599 : : }
600 : : EXPORT_SYMBOL(bio_clone_fast);
601 : :
602 : : /**
603 : : * bio_clone_bioset - clone a bio
604 : : * @bio_src: bio to clone
605 : : * @gfp_mask: allocation priority
606 : : * @bs: bio_set to allocate from
607 : : *
608 : : * Clone bio. Caller will own the returned bio, but not the actual data it
609 : : * points to. Reference count of returned bio will be one.
610 : : */
611 : 0 : struct bio *bio_clone_bioset(struct bio *bio_src, gfp_t gfp_mask,
612 : : struct bio_set *bs)
613 : : {
614 : : struct bvec_iter iter;
615 : : struct bio_vec bv;
616 : : struct bio *bio;
617 : :
618 : : /*
619 : : * Pre immutable biovecs, __bio_clone() used to just do a memcpy from
620 : : * bio_src->bi_io_vec to bio->bi_io_vec.
621 : : *
622 : : * We can't do that anymore, because:
623 : : *
624 : : * - The point of cloning the biovec is to produce a bio with a biovec
625 : : * the caller can modify: bi_idx and bi_bvec_done should be 0.
626 : : *
627 : : * - The original bio could've had more than BIO_MAX_PAGES biovecs; if
628 : : * we tried to clone the whole thing bio_alloc_bioset() would fail.
629 : : * But the clone should succeed as long as the number of biovecs we
630 : : * actually need to allocate is fewer than BIO_MAX_PAGES.
631 : : *
632 : : * - Lastly, bi_vcnt should not be looked at or relied upon by code
633 : : * that does not own the bio - reason being drivers don't use it for
634 : : * iterating over the biovec anymore, so expecting it to be kept up
635 : : * to date (i.e. for clones that share the parent biovec) is just
636 : : * asking for trouble and would force extra work on
637 : : * __bio_clone_fast() anyways.
638 : : */
639 : :
640 : 278794 : bio = bio_alloc_bioset(gfp_mask, bio_segments(bio_src), bs);
641 [ + + ]: 278792 : if (!bio)
642 : : return NULL;
643 : :
644 : 278759 : bio->bi_bdev = bio_src->bi_bdev;
645 : 278759 : bio->bi_rw = bio_src->bi_rw;
646 : 278759 : bio->bi_iter.bi_sector = bio_src->bi_iter.bi_sector;
647 : 278759 : bio->bi_iter.bi_size = bio_src->bi_iter.bi_size;
648 : :
649 [ + ]: 278759 : if (bio->bi_rw & REQ_DISCARD)
650 : : goto integrity_clone;
651 : :
652 [ - + ]: 278800 : if (bio->bi_rw & REQ_WRITE_SAME) {
653 : 0 : bio->bi_io_vec[bio->bi_vcnt++] = bio_src->bi_io_vec[0];
654 : 0 : goto integrity_clone;
655 : : }
656 : :
657 [ + + ]: 1534485 : bio_for_each_segment(bv, bio_src, iter)
658 : 1255666 : bio->bi_io_vec[bio->bi_vcnt++] = bv;
659 : :
660 : : integrity_clone:
661 : : if (bio_integrity(bio_src)) {
662 : : int ret;
663 : :
664 : : ret = bio_integrity_clone(bio, bio_src, gfp_mask);
665 : : if (ret < 0) {
666 : : bio_put(bio);
667 : : return NULL;
668 : : }
669 : : }
670 : :
671 : 278778 : return bio;
672 : : }
673 : : EXPORT_SYMBOL(bio_clone_bioset);
674 : :
675 : : /**
676 : : * bio_get_nr_vecs - return approx number of vecs
677 : : * @bdev: I/O target
678 : : *
679 : : * Return the approximate number of pages we can send to this target.
680 : : * There's no guarantee that you will be able to fit this number of pages
681 : : * into a bio, it does not account for dynamic restrictions that vary
682 : : * on offset.
683 : : */
684 : 0 : int bio_get_nr_vecs(struct block_device *bdev)
685 : : {
686 : 685086 : struct request_queue *q = bdev_get_queue(bdev);
687 : : int nr_pages;
688 : :
689 : 685086 : nr_pages = min_t(unsigned,
690 : : queue_max_segments(q),
691 : : queue_max_sectors(q) / (PAGE_SIZE >> 9) + 1);
692 : :
693 : 342543 : return min_t(unsigned, nr_pages, BIO_MAX_PAGES);
694 : :
695 : : }
696 : : EXPORT_SYMBOL(bio_get_nr_vecs);
697 : :
698 : 0 : static int __bio_add_page(struct request_queue *q, struct bio *bio, struct page
699 : : *page, unsigned int len, unsigned int offset,
700 : : unsigned int max_sectors)
701 : : {
702 : : int retried_segments = 0;
703 : : struct bio_vec *bvec;
704 : :
705 : : /*
706 : : * cloned bio must not modify vec list
707 : : */
708 [ + ]: 1595798 : if (unlikely(bio_flagged(bio, BIO_CLONED)))
709 : : return 0;
710 : :
711 [ + + ]: 1595806 : if (((bio->bi_iter.bi_size + len) >> 9) > max_sectors)
712 : : return 0;
713 : :
714 : : /*
715 : : * For filesystems with a blocksize smaller than the pagesize
716 : : * we will often be called with the same page as last time and
717 : : * a consecutive offset. Optimize this special case.
718 : : */
719 [ + + ]: 1575929 : if (bio->bi_vcnt > 0) {
720 : 1233318 : struct bio_vec *prev = &bio->bi_io_vec[bio->bi_vcnt - 1];
721 : :
722 [ - + ][ # # ]: 1233318 : if (page == prev->bv_page &&
723 : 0 : offset == prev->bv_offset + prev->bv_len) {
724 : : unsigned int prev_bv_len = prev->bv_len;
725 : 11 : prev->bv_len += len;
726 : :
727 [ - + ]: 11 : if (q->merge_bvec_fn) {
728 : 0 : struct bvec_merge_data bvm = {
729 : : /* prev_bvec is already charged in
730 : : bi_size, discharge it in order to
731 : : simulate merging updated prev_bvec
732 : : as new bvec. */
733 : 0 : .bi_bdev = bio->bi_bdev,
734 : 0 : .bi_sector = bio->bi_iter.bi_sector,
735 : 0 : .bi_size = bio->bi_iter.bi_size -
736 : : prev_bv_len,
737 : 0 : .bi_rw = bio->bi_rw,
738 : : };
739 : :
740 [ # # ]: 0 : if (q->merge_bvec_fn(q, &bvm, prev) < prev->bv_len) {
741 : 0 : prev->bv_len -= len;
742 : 0 : return 0;
743 : : }
744 : : }
745 : :
746 : : goto done;
747 : : }
748 : : }
749 : :
750 [ + ]: 1575918 : if (bio->bi_vcnt >= bio->bi_max_vecs)
751 : : return 0;
752 : :
753 : : /*
754 : : * we might lose a segment or two here, but rather that than
755 : : * make this too complex.
756 : : */
757 : :
758 [ - + ]: 1575828 : while (bio->bi_phys_segments >= queue_max_segments(q)) {
759 : :
760 [ # # ]: 0 : if (retried_segments)
761 : : return 0;
762 : :
763 : : retried_segments = 1;
764 : 0 : blk_recount_segments(q, bio);
765 : : }
766 : :
767 : : /*
768 : : * setup the new entry, we might clear it again later if we
769 : : * cannot add the page
770 : : */
771 : 1575828 : bvec = &bio->bi_io_vec[bio->bi_vcnt];
772 : 1575828 : bvec->bv_page = page;
773 : 1575828 : bvec->bv_len = len;
774 : 1575828 : bvec->bv_offset = offset;
775 : :
776 : : /*
777 : : * if queue has other restrictions (eg varying max sector size
778 : : * depending on offset), it can specify a merge_bvec_fn in the
779 : : * queue to get further control
780 : : */
781 [ - + ]: 1575828 : if (q->merge_bvec_fn) {
782 : 0 : struct bvec_merge_data bvm = {
783 : 0 : .bi_bdev = bio->bi_bdev,
784 : 0 : .bi_sector = bio->bi_iter.bi_sector,
785 : 0 : .bi_size = bio->bi_iter.bi_size,
786 : 0 : .bi_rw = bio->bi_rw,
787 : : };
788 : :
789 : : /*
790 : : * merge_bvec_fn() returns number of bytes it can accept
791 : : * at this offset
792 : : */
793 [ # # ]: 0 : if (q->merge_bvec_fn(q, &bvm, bvec) < bvec->bv_len) {
794 : 0 : bvec->bv_page = NULL;
795 : 0 : bvec->bv_len = 0;
796 : 0 : bvec->bv_offset = 0;
797 : 0 : return 0;
798 : : }
799 : : }
800 : :
801 : : /* If we may be able to merge these biovecs, force a recount */
802 [ + + ][ + + ]: 1575828 : if (bio->bi_vcnt && (BIOVEC_PHYS_MERGEABLE(bvec-1, bvec)))
803 : 583032 : bio->bi_flags &= ~(1 << BIO_SEG_VALID);
804 : :
805 : 1575828 : bio->bi_vcnt++;
806 : 1575828 : bio->bi_phys_segments++;
807 : : done:
808 : 1575839 : bio->bi_iter.bi_size += len;
809 : 1575839 : return len;
810 : : }
811 : :
812 : : /**
813 : : * bio_add_pc_page - attempt to add page to bio
814 : : * @q: the target queue
815 : : * @bio: destination bio
816 : : * @page: page to add
817 : : * @len: vec entry length
818 : : * @offset: vec entry offset
819 : : *
820 : : * Attempt to add a page to the bio_vec maplist. This can fail for a
821 : : * number of reasons, such as the bio being full or target block device
822 : : * limitations. The target block device must allow bio's up to PAGE_SIZE,
823 : : * so it is always possible to add a single page to an empty bio.
824 : : *
825 : : * This should only be used by REQ_PC bios.
826 : : */
827 : 0 : int bio_add_pc_page(struct request_queue *q, struct bio *bio, struct page *page,
828 : : unsigned int len, unsigned int offset)
829 : : {
830 : 0 : return __bio_add_page(q, bio, page, len, offset,
831 : : queue_max_hw_sectors(q));
832 : : }
833 : : EXPORT_SYMBOL(bio_add_pc_page);
834 : :
835 : : /**
836 : : * bio_add_page - attempt to add page to bio
837 : : * @bio: destination bio
838 : : * @page: page to add
839 : : * @len: vec entry length
840 : : * @offset: vec entry offset
841 : : *
842 : : * Attempt to add a page to the bio_vec maplist. This can fail for a
843 : : * number of reasons, such as the bio being full or target block device
844 : : * limitations. The target block device must allow bio's up to PAGE_SIZE,
845 : : * so it is always possible to add a single page to an empty bio.
846 : : */
847 : 0 : int bio_add_page(struct bio *bio, struct page *page, unsigned int len,
848 : : unsigned int offset)
849 : : {
850 : 3191582 : struct request_queue *q = bdev_get_queue(bio->bi_bdev);
851 : 1595791 : return __bio_add_page(q, bio, page, len, offset, queue_max_sectors(q));
852 : : }
853 : : EXPORT_SYMBOL(bio_add_page);
854 : :
855 : : struct submit_bio_ret {
856 : : struct completion event;
857 : : int error;
858 : : };
859 : :
860 : 0 : static void submit_bio_wait_endio(struct bio *bio, int error)
861 : : {
862 : 2065 : struct submit_bio_ret *ret = bio->bi_private;
863 : :
864 : 2065 : ret->error = error;
865 : 2065 : complete(&ret->event);
866 : 2065 : }
867 : :
868 : : /**
869 : : * submit_bio_wait - submit a bio, and wait until it completes
870 : : * @rw: whether to %READ or %WRITE, or maybe to %READA (read ahead)
871 : : * @bio: The &struct bio which describes the I/O
872 : : *
873 : : * Simple wrapper around submit_bio(). Returns 0 on success, or the error from
874 : : * bio_endio() on failure.
875 : : */
876 : 0 : int submit_bio_wait(int rw, struct bio *bio)
877 : : {
878 : : struct submit_bio_ret ret;
879 : :
880 : 2052 : rw |= REQ_SYNC;
881 : : init_completion(&ret.event);
882 : 2043 : bio->bi_private = &ret;
883 : 2043 : bio->bi_end_io = submit_bio_wait_endio;
884 : 2043 : submit_bio(rw, bio);
885 : 2057 : wait_for_completion(&ret.event);
886 : :
887 : 2065 : return ret.error;
888 : : }
889 : : EXPORT_SYMBOL(submit_bio_wait);
890 : :
891 : : /**
892 : : * bio_advance - increment/complete a bio by some number of bytes
893 : : * @bio: bio to advance
894 : : * @bytes: number of bytes to complete
895 : : *
896 : : * This updates bi_sector, bi_size and bi_idx; if the number of bytes to
897 : : * complete doesn't align with a bvec boundary, then bv_len and bv_offset will
898 : : * be updated on the last bvec as well.
899 : : *
900 : : * @bio will then represent the remaining, uncompleted portion of the io.
901 : : */
902 : 0 : void bio_advance(struct bio *bio, unsigned bytes)
903 : : {
904 : : if (bio_integrity(bio))
905 : : bio_integrity_advance(bio, bytes);
906 : :
907 : : bio_advance_iter(bio, &bio->bi_iter, bytes);
908 : 0 : }
909 : : EXPORT_SYMBOL(bio_advance);
910 : :
911 : : /**
912 : : * bio_alloc_pages - allocates a single page for each bvec in a bio
913 : : * @bio: bio to allocate pages for
914 : : * @gfp_mask: flags for allocation
915 : : *
916 : : * Allocates pages up to @bio->bi_vcnt.
917 : : *
918 : : * Returns 0 on success, -ENOMEM on failure. On failure, any allocated pages are
919 : : * freed.
920 : : */
921 : 0 : int bio_alloc_pages(struct bio *bio, gfp_t gfp_mask)
922 : : {
923 : : int i;
924 : : struct bio_vec *bv;
925 : :
926 [ # # ]: 0 : bio_for_each_segment_all(bv, bio, i) {
927 : 0 : bv->bv_page = alloc_page(gfp_mask);
928 [ # # ]: 0 : if (!bv->bv_page) {
929 [ # # ]: 0 : while (--bv >= bio->bi_io_vec)
930 : 0 : __free_page(bv->bv_page);
931 : : return -ENOMEM;
932 : : }
933 : : }
934 : :
935 : : return 0;
936 : : }
937 : : EXPORT_SYMBOL(bio_alloc_pages);
938 : :
939 : : /**
940 : : * bio_copy_data - copy contents of data buffers from one chain of bios to
941 : : * another
942 : : * @src: source bio list
943 : : * @dst: destination bio list
944 : : *
945 : : * If @src and @dst are single bios, bi_next must be NULL - otherwise, treats
946 : : * @src and @dst as linked lists of bios.
947 : : *
948 : : * Stops when it reaches the end of either @src or @dst - that is, copies
949 : : * min(src->bi_size, dst->bi_size) bytes (or the equivalent for lists of bios).
950 : : */
951 : 0 : void bio_copy_data(struct bio *dst, struct bio *src)
952 : : {
953 : : struct bvec_iter src_iter, dst_iter;
954 : : struct bio_vec src_bv, dst_bv;
955 : : void *src_p, *dst_p;
956 : : unsigned bytes;
957 : :
958 : 0 : src_iter = src->bi_iter;
959 : 0 : dst_iter = dst->bi_iter;
960 : :
961 : : while (1) {
962 [ # # ]: 0 : if (!src_iter.bi_size) {
963 : 0 : src = src->bi_next;
964 [ # # ]: 0 : if (!src)
965 : : break;
966 : :
967 : 0 : src_iter = src->bi_iter;
968 : : }
969 : :
970 [ # # ]: 0 : if (!dst_iter.bi_size) {
971 : 0 : dst = dst->bi_next;
972 [ # # ]: 0 : if (!dst)
973 : : break;
974 : :
975 : 0 : dst_iter = dst->bi_iter;
976 : : }
977 : :
978 : 0 : src_bv = bio_iter_iovec(src, src_iter);
979 : 0 : dst_bv = bio_iter_iovec(dst, dst_iter);
980 : :
981 : 0 : bytes = min(src_bv.bv_len, dst_bv.bv_len);
982 : :
983 : 0 : src_p = kmap_atomic(src_bv.bv_page);
984 : 0 : dst_p = kmap_atomic(dst_bv.bv_page);
985 : :
986 : 0 : memcpy(dst_p + dst_bv.bv_offset,
987 : : src_p + src_bv.bv_offset,
988 : : bytes);
989 : :
990 : 0 : kunmap_atomic(dst_p);
991 : 0 : kunmap_atomic(src_p);
992 : :
993 : : bio_advance_iter(src, &src_iter, bytes);
994 : : bio_advance_iter(dst, &dst_iter, bytes);
995 : : }
996 : 0 : }
997 : : EXPORT_SYMBOL(bio_copy_data);
998 : :
999 : : struct bio_map_data {
1000 : : int nr_sgvecs;
1001 : : int is_our_pages;
1002 : : struct sg_iovec sgvecs[];
1003 : : };
1004 : :
1005 : : static void bio_set_map_data(struct bio_map_data *bmd, struct bio *bio,
1006 : : struct sg_iovec *iov, int iov_count,
1007 : : int is_our_pages)
1008 : : {
1009 : 0 : memcpy(bmd->sgvecs, iov, sizeof(struct sg_iovec) * iov_count);
1010 : 0 : bmd->nr_sgvecs = iov_count;
1011 : 0 : bmd->is_our_pages = is_our_pages;
1012 : 0 : bio->bi_private = bmd;
1013 : : }
1014 : :
1015 : 0 : static struct bio_map_data *bio_alloc_map_data(int nr_segs,
1016 : : unsigned int iov_count,
1017 : : gfp_t gfp_mask)
1018 : : {
1019 [ # # ]: 0 : if (iov_count > UIO_MAXIOV)
1020 : : return NULL;
1021 : :
1022 : 0 : return kmalloc(sizeof(struct bio_map_data) +
1023 : : sizeof(struct sg_iovec) * iov_count, gfp_mask);
1024 : : }
1025 : :
1026 : 0 : static int __bio_copy_iov(struct bio *bio, struct sg_iovec *iov, int iov_count,
1027 : : int to_user, int from_user, int do_free_page)
1028 : : {
1029 : : int ret = 0, i;
1030 : : struct bio_vec *bvec;
1031 : : int iov_idx = 0;
1032 : : unsigned int iov_off = 0;
1033 : :
1034 [ # # ]: 0 : bio_for_each_segment_all(bvec, bio, i) {
1035 : 0 : char *bv_addr = page_address(bvec->bv_page);
1036 : 0 : unsigned int bv_len = bvec->bv_len;
1037 : :
1038 [ # # ]: 0 : while (bv_len && iov_idx < iov_count) {
1039 : : unsigned int bytes;
1040 : : char __user *iov_addr;
1041 : :
1042 : 0 : bytes = min_t(unsigned int,
1043 : : iov[iov_idx].iov_len - iov_off, bv_len);
1044 : 0 : iov_addr = iov[iov_idx].iov_base + iov_off;
1045 : :
1046 [ # # ]: 0 : if (!ret) {
1047 [ # # ]: 0 : if (to_user)
1048 : 0 : ret = copy_to_user(iov_addr, bv_addr,
1049 : : bytes);
1050 : :
1051 [ # # ]: 0 : if (from_user)
1052 : 0 : ret = copy_from_user(bv_addr, iov_addr,
1053 : : bytes);
1054 : :
1055 [ # # ]: 0 : if (ret)
1056 : : ret = -EFAULT;
1057 : : }
1058 : :
1059 : 0 : bv_len -= bytes;
1060 : 0 : bv_addr += bytes;
1061 : : iov_addr += bytes;
1062 : 0 : iov_off += bytes;
1063 : :
1064 [ # # ]: 0 : if (iov[iov_idx].iov_len == iov_off) {
1065 : 0 : iov_idx++;
1066 : : iov_off = 0;
1067 : : }
1068 : : }
1069 : :
1070 [ # # ]: 0 : if (do_free_page)
1071 : 0 : __free_page(bvec->bv_page);
1072 : : }
1073 : :
1074 : 0 : return ret;
1075 : : }
1076 : :
1077 : : /**
1078 : : * bio_uncopy_user - finish previously mapped bio
1079 : : * @bio: bio being terminated
1080 : : *
1081 : : * Free pages allocated from bio_copy_user() and write back data
1082 : : * to user space in case of a read.
1083 : : */
1084 : 0 : int bio_uncopy_user(struct bio *bio)
1085 : : {
1086 : 0 : struct bio_map_data *bmd = bio->bi_private;
1087 : : struct bio_vec *bvec;
1088 : : int ret = 0, i;
1089 : :
1090 [ # # ]: 0 : if (!bio_flagged(bio, BIO_NULL_MAPPED)) {
1091 : : /*
1092 : : * if we're in a workqueue, the request is orphaned, so
1093 : : * don't copy into a random user address space, just free.
1094 : : */
1095 [ # # ]: 0 : if (current->mm)
1096 : 0 : ret = __bio_copy_iov(bio, bmd->sgvecs, bmd->nr_sgvecs,
1097 : 0 : bio_data_dir(bio) == READ,
1098 : : 0, bmd->is_our_pages);
1099 [ # # ]: 0 : else if (bmd->is_our_pages)
1100 [ # # ]: 0 : bio_for_each_segment_all(bvec, bio, i)
1101 : 0 : __free_page(bvec->bv_page);
1102 : : }
1103 : 0 : kfree(bmd);
1104 : 0 : bio_put(bio);
1105 : 0 : return ret;
1106 : : }
1107 : : EXPORT_SYMBOL(bio_uncopy_user);
1108 : :
1109 : : /**
1110 : : * bio_copy_user_iov - copy user data to bio
1111 : : * @q: destination block queue
1112 : : * @map_data: pointer to the rq_map_data holding pages (if necessary)
1113 : : * @iov: the iovec.
1114 : : * @iov_count: number of elements in the iovec
1115 : : * @write_to_vm: bool indicating writing to pages or not
1116 : : * @gfp_mask: memory allocation flags
1117 : : *
1118 : : * Prepares and returns a bio for indirect user io, bouncing data
1119 : : * to/from kernel pages as necessary. Must be paired with
1120 : : * call bio_uncopy_user() on io completion.
1121 : : */
1122 : 0 : struct bio *bio_copy_user_iov(struct request_queue *q,
1123 : : struct rq_map_data *map_data,
1124 : : struct sg_iovec *iov, int iov_count,
1125 : : int write_to_vm, gfp_t gfp_mask)
1126 : : {
1127 : : struct bio_map_data *bmd;
1128 : : struct bio_vec *bvec;
1129 : : struct page *page;
1130 : 0 : struct bio *bio;
1131 : : int i, ret;
1132 : : int nr_pages = 0;
1133 : : unsigned int len = 0;
1134 [ # # ]: 0 : unsigned int offset = map_data ? map_data->offset & ~PAGE_MASK : 0;
1135 : :
1136 [ # # ]: 0 : for (i = 0; i < iov_count; i++) {
1137 : : unsigned long uaddr;
1138 : : unsigned long end;
1139 : : unsigned long start;
1140 : :
1141 : 0 : uaddr = (unsigned long)iov[i].iov_base;
1142 : 0 : end = (uaddr + iov[i].iov_len + PAGE_SIZE - 1) >> PAGE_SHIFT;
1143 : 0 : start = uaddr >> PAGE_SHIFT;
1144 : :
1145 : : /*
1146 : : * Overflow, abort
1147 : : */
1148 [ # # ]: 0 : if (end < start)
1149 : : return ERR_PTR(-EINVAL);
1150 : :
1151 : 0 : nr_pages += end - start;
1152 : 0 : len += iov[i].iov_len;
1153 : : }
1154 : :
1155 [ # # ]: 0 : if (offset)
1156 : 0 : nr_pages++;
1157 : :
1158 : 0 : bmd = bio_alloc_map_data(nr_pages, iov_count, gfp_mask);
1159 [ # # ]: 0 : if (!bmd)
1160 : : return ERR_PTR(-ENOMEM);
1161 : :
1162 : : ret = -ENOMEM;
1163 : : bio = bio_kmalloc(gfp_mask, nr_pages);
1164 [ # # ]: 0 : if (!bio)
1165 : : goto out_bmd;
1166 : :
1167 [ # # ]: 0 : if (!write_to_vm)
1168 : 0 : bio->bi_rw |= REQ_WRITE;
1169 : :
1170 : : ret = 0;
1171 : :
1172 [ # # ]: 0 : if (map_data) {
1173 : 0 : nr_pages = 1 << map_data->page_order;
1174 : 0 : i = map_data->offset / PAGE_SIZE;
1175 : : }
1176 [ # # ]: 0 : while (len) {
1177 : : unsigned int bytes = PAGE_SIZE;
1178 : :
1179 : 0 : bytes -= offset;
1180 : :
1181 [ # # ]: 0 : if (bytes > len)
1182 : : bytes = len;
1183 : :
1184 [ # # ]: 0 : if (map_data) {
1185 [ # # ]: 0 : if (i == map_data->nr_entries * nr_pages) {
1186 : : ret = -ENOMEM;
1187 : : break;
1188 : : }
1189 : :
1190 : 0 : page = map_data->pages[i / nr_pages];
1191 : 0 : page += (i % nr_pages);
1192 : :
1193 : 0 : i++;
1194 : : } else {
1195 : 0 : page = alloc_page(q->bounce_gfp | gfp_mask);
1196 [ # # ]: 0 : if (!page) {
1197 : : ret = -ENOMEM;
1198 : : break;
1199 : : }
1200 : : }
1201 : :
1202 [ # # ]: 0 : if (bio_add_pc_page(q, bio, page, bytes, offset) < bytes)
1203 : : break;
1204 : :
1205 : 0 : len -= bytes;
1206 : : offset = 0;
1207 : : }
1208 : :
1209 [ # # ]: 0 : if (ret)
1210 : : goto cleanup;
1211 : :
1212 : : /*
1213 : : * success
1214 : : */
1215 [ # # ][ # # ]: 0 : if ((!write_to_vm && (!map_data || !map_data->null_mapped)) ||
[ # # ][ # # ]
1216 [ # # ]: 0 : (map_data && map_data->from_user)) {
1217 : 0 : ret = __bio_copy_iov(bio, iov, iov_count, 0, 1, 0);
1218 [ # # ]: 0 : if (ret)
1219 : : goto cleanup;
1220 : : }
1221 : :
1222 : 0 : bio_set_map_data(bmd, bio, iov, iov_count, map_data ? 0 : 1);
1223 : 0 : return bio;
1224 : : cleanup:
1225 [ # # ]: 0 : if (!map_data)
1226 [ # # ]: 0 : bio_for_each_segment_all(bvec, bio, i)
1227 : 0 : __free_page(bvec->bv_page);
1228 : :
1229 : 0 : bio_put(bio);
1230 : : out_bmd:
1231 : 0 : kfree(bmd);
1232 : 0 : return ERR_PTR(ret);
1233 : : }
1234 : :
1235 : : /**
1236 : : * bio_copy_user - copy user data to bio
1237 : : * @q: destination block queue
1238 : : * @map_data: pointer to the rq_map_data holding pages (if necessary)
1239 : : * @uaddr: start of user address
1240 : : * @len: length in bytes
1241 : : * @write_to_vm: bool indicating writing to pages or not
1242 : : * @gfp_mask: memory allocation flags
1243 : : *
1244 : : * Prepares and returns a bio for indirect user io, bouncing data
1245 : : * to/from kernel pages as necessary. Must be paired with
1246 : : * call bio_uncopy_user() on io completion.
1247 : : */
1248 : 0 : struct bio *bio_copy_user(struct request_queue *q, struct rq_map_data *map_data,
1249 : : unsigned long uaddr, unsigned int len,
1250 : : int write_to_vm, gfp_t gfp_mask)
1251 : : {
1252 : : struct sg_iovec iov;
1253 : :
1254 : 0 : iov.iov_base = (void __user *)uaddr;
1255 : 0 : iov.iov_len = len;
1256 : :
1257 : 0 : return bio_copy_user_iov(q, map_data, &iov, 1, write_to_vm, gfp_mask);
1258 : : }
1259 : : EXPORT_SYMBOL(bio_copy_user);
1260 : :
1261 : 0 : static struct bio *__bio_map_user_iov(struct request_queue *q,
1262 : : struct block_device *bdev,
1263 : : struct sg_iovec *iov, int iov_count,
1264 : : int write_to_vm, gfp_t gfp_mask)
1265 : : {
1266 : : int i, j;
1267 : : int nr_pages = 0;
1268 : : struct page **pages;
1269 : : struct bio *bio;
1270 : : int cur_page = 0;
1271 : : int ret, offset;
1272 : :
1273 [ # # ]: 0 : for (i = 0; i < iov_count; i++) {
1274 : 0 : unsigned long uaddr = (unsigned long)iov[i].iov_base;
1275 : 0 : unsigned long len = iov[i].iov_len;
1276 : 0 : unsigned long end = (uaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
1277 : 0 : unsigned long start = uaddr >> PAGE_SHIFT;
1278 : :
1279 : : /*
1280 : : * Overflow, abort
1281 : : */
1282 [ # # ]: 0 : if (end < start)
1283 : : return ERR_PTR(-EINVAL);
1284 : :
1285 : 0 : nr_pages += end - start;
1286 : : /*
1287 : : * buffer must be aligned to at least hardsector size for now
1288 : : */
1289 [ # # ]: 0 : if (uaddr & queue_dma_alignment(q))
1290 : : return ERR_PTR(-EINVAL);
1291 : : }
1292 : :
1293 [ # # ]: 0 : if (!nr_pages)
1294 : : return ERR_PTR(-EINVAL);
1295 : :
1296 : : bio = bio_kmalloc(gfp_mask, nr_pages);
1297 [ # # ]: 0 : if (!bio)
1298 : : return ERR_PTR(-ENOMEM);
1299 : :
1300 : : ret = -ENOMEM;
1301 : 0 : pages = kcalloc(nr_pages, sizeof(struct page *), gfp_mask);
1302 [ # # ]: 0 : if (!pages)
1303 : : goto out;
1304 : :
1305 [ # # ]: 0 : for (i = 0; i < iov_count; i++) {
1306 : 0 : unsigned long uaddr = (unsigned long)iov[i].iov_base;
1307 : 0 : unsigned long len = iov[i].iov_len;
1308 : 0 : unsigned long end = (uaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
1309 : 0 : unsigned long start = uaddr >> PAGE_SHIFT;
1310 : 0 : const int local_nr_pages = end - start;
1311 : 0 : const int page_limit = cur_page + local_nr_pages;
1312 : :
1313 : 0 : ret = get_user_pages_fast(uaddr, local_nr_pages,
1314 : 0 : write_to_vm, &pages[cur_page]);
1315 [ # # ]: 0 : if (ret < local_nr_pages) {
1316 : : ret = -EFAULT;
1317 : : goto out_unmap;
1318 : : }
1319 : :
1320 : 0 : offset = uaddr & ~PAGE_MASK;
1321 [ # # ]: 0 : for (j = cur_page; j < page_limit; j++) {
1322 : 0 : unsigned int bytes = PAGE_SIZE - offset;
1323 : :
1324 [ # # ]: 0 : if (len <= 0)
1325 : : break;
1326 : :
1327 [ # # ]: 0 : if (bytes > len)
1328 : : bytes = len;
1329 : :
1330 : : /*
1331 : : * sorry...
1332 : : */
1333 [ # # ]: 0 : if (bio_add_pc_page(q, bio, pages[j], bytes, offset) <
1334 : : bytes)
1335 : : break;
1336 : :
1337 : 0 : len -= bytes;
1338 : : offset = 0;
1339 : : }
1340 : :
1341 : : cur_page = j;
1342 : : /*
1343 : : * release the pages we didn't map into the bio, if any
1344 : : */
1345 [ # # ]: 0 : while (j < page_limit)
1346 : 0 : page_cache_release(pages[j++]);
1347 : : }
1348 : :
1349 : 0 : kfree(pages);
1350 : :
1351 : : /*
1352 : : * set data direction, and check if mapped pages need bouncing
1353 : : */
1354 [ # # ]: 0 : if (!write_to_vm)
1355 : 0 : bio->bi_rw |= REQ_WRITE;
1356 : :
1357 : 0 : bio->bi_bdev = bdev;
1358 : 0 : bio->bi_flags |= (1 << BIO_USER_MAPPED);
1359 : 0 : return bio;
1360 : :
1361 : : out_unmap:
1362 [ # # ]: 0 : for (i = 0; i < nr_pages; i++) {
1363 [ # # ]: 0 : if(!pages[i])
1364 : : break;
1365 : 0 : page_cache_release(pages[i]);
1366 : : }
1367 : : out:
1368 : 0 : kfree(pages);
1369 : 0 : bio_put(bio);
1370 : 0 : return ERR_PTR(ret);
1371 : : }
1372 : :
1373 : : /**
1374 : : * bio_map_user - map user address into bio
1375 : : * @q: the struct request_queue for the bio
1376 : : * @bdev: destination block device
1377 : : * @uaddr: start of user address
1378 : : * @len: length in bytes
1379 : : * @write_to_vm: bool indicating writing to pages or not
1380 : : * @gfp_mask: memory allocation flags
1381 : : *
1382 : : * Map the user space address into a bio suitable for io to a block
1383 : : * device. Returns an error pointer in case of error.
1384 : : */
1385 : 0 : struct bio *bio_map_user(struct request_queue *q, struct block_device *bdev,
1386 : : unsigned long uaddr, unsigned int len, int write_to_vm,
1387 : : gfp_t gfp_mask)
1388 : : {
1389 : : struct sg_iovec iov;
1390 : :
1391 : 0 : iov.iov_base = (void __user *)uaddr;
1392 : 0 : iov.iov_len = len;
1393 : :
1394 : 0 : return bio_map_user_iov(q, bdev, &iov, 1, write_to_vm, gfp_mask);
1395 : : }
1396 : : EXPORT_SYMBOL(bio_map_user);
1397 : :
1398 : : /**
1399 : : * bio_map_user_iov - map user sg_iovec table into bio
1400 : : * @q: the struct request_queue for the bio
1401 : : * @bdev: destination block device
1402 : : * @iov: the iovec.
1403 : : * @iov_count: number of elements in the iovec
1404 : : * @write_to_vm: bool indicating writing to pages or not
1405 : : * @gfp_mask: memory allocation flags
1406 : : *
1407 : : * Map the user space address into a bio suitable for io to a block
1408 : : * device. Returns an error pointer in case of error.
1409 : : */
1410 : 0 : struct bio *bio_map_user_iov(struct request_queue *q, struct block_device *bdev,
1411 : : struct sg_iovec *iov, int iov_count,
1412 : : int write_to_vm, gfp_t gfp_mask)
1413 : : {
1414 : : struct bio *bio;
1415 : :
1416 : 0 : bio = __bio_map_user_iov(q, bdev, iov, iov_count, write_to_vm,
1417 : : gfp_mask);
1418 [ # # ]: 0 : if (IS_ERR(bio))
1419 : : return bio;
1420 : :
1421 : : /*
1422 : : * subtle -- if __bio_map_user() ended up bouncing a bio,
1423 : : * it would normally disappear when its bi_end_io is run.
1424 : : * however, we need it for the unmap, so grab an extra
1425 : : * reference to it
1426 : : */
1427 : 0 : bio_get(bio);
1428 : :
1429 : 0 : return bio;
1430 : : }
1431 : :
1432 : 0 : static void __bio_unmap_user(struct bio *bio)
1433 : : {
1434 : : struct bio_vec *bvec;
1435 : : int i;
1436 : :
1437 : : /*
1438 : : * make sure we dirty pages we wrote to
1439 : : */
1440 [ # # ]: 0 : bio_for_each_segment_all(bvec, bio, i) {
1441 [ # # ]: 0 : if (bio_data_dir(bio) == READ)
1442 : 0 : set_page_dirty_lock(bvec->bv_page);
1443 : :
1444 : 0 : page_cache_release(bvec->bv_page);
1445 : : }
1446 : :
1447 : 0 : bio_put(bio);
1448 : 0 : }
1449 : :
1450 : : /**
1451 : : * bio_unmap_user - unmap a bio
1452 : : * @bio: the bio being unmapped
1453 : : *
1454 : : * Unmap a bio previously mapped by bio_map_user(). Must be called with
1455 : : * a process context.
1456 : : *
1457 : : * bio_unmap_user() may sleep.
1458 : : */
1459 : 0 : void bio_unmap_user(struct bio *bio)
1460 : : {
1461 : 0 : __bio_unmap_user(bio);
1462 : 0 : bio_put(bio);
1463 : 0 : }
1464 : : EXPORT_SYMBOL(bio_unmap_user);
1465 : :
1466 : 0 : static void bio_map_kern_endio(struct bio *bio, int err)
1467 : : {
1468 : 0 : bio_put(bio);
1469 : 0 : }
1470 : :
1471 : 0 : static struct bio *__bio_map_kern(struct request_queue *q, void *data,
1472 : : unsigned int len, gfp_t gfp_mask)
1473 : : {
1474 : 0 : unsigned long kaddr = (unsigned long)data;
1475 : 0 : unsigned long end = (kaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
1476 : 0 : unsigned long start = kaddr >> PAGE_SHIFT;
1477 : 0 : const int nr_pages = end - start;
1478 : : int offset, i;
1479 : : struct bio *bio;
1480 : :
1481 : : bio = bio_kmalloc(gfp_mask, nr_pages);
1482 [ # # ]: 0 : if (!bio)
1483 : : return ERR_PTR(-ENOMEM);
1484 : :
1485 : 0 : offset = offset_in_page(kaddr);
1486 [ # # ]: 0 : for (i = 0; i < nr_pages; i++) {
1487 : 0 : unsigned int bytes = PAGE_SIZE - offset;
1488 : :
1489 [ # # ]: 0 : if (len <= 0)
1490 : : break;
1491 : :
1492 [ # # ]: 0 : if (bytes > len)
1493 : : bytes = len;
1494 : :
1495 [ # # ]: 0 : if (bio_add_pc_page(q, bio, virt_to_page(data), bytes,
1496 : 0 : offset) < bytes)
1497 : : break;
1498 : :
1499 : 0 : data += bytes;
1500 : 0 : len -= bytes;
1501 : : offset = 0;
1502 : : }
1503 : :
1504 : 0 : bio->bi_end_io = bio_map_kern_endio;
1505 : 0 : return bio;
1506 : : }
1507 : :
1508 : : /**
1509 : : * bio_map_kern - map kernel address into bio
1510 : : * @q: the struct request_queue for the bio
1511 : : * @data: pointer to buffer to map
1512 : : * @len: length in bytes
1513 : : * @gfp_mask: allocation flags for bio allocation
1514 : : *
1515 : : * Map the kernel address into a bio suitable for io to a block
1516 : : * device. Returns an error pointer in case of error.
1517 : : */
1518 : 0 : struct bio *bio_map_kern(struct request_queue *q, void *data, unsigned int len,
1519 : : gfp_t gfp_mask)
1520 : : {
1521 : : struct bio *bio;
1522 : :
1523 : 0 : bio = __bio_map_kern(q, data, len, gfp_mask);
1524 [ # # ]: 0 : if (IS_ERR(bio))
1525 : : return bio;
1526 : :
1527 [ # # ]: 0 : if (bio->bi_iter.bi_size == len)
1528 : : return bio;
1529 : :
1530 : : /*
1531 : : * Don't support partial mappings.
1532 : : */
1533 : 0 : bio_put(bio);
1534 : 0 : return ERR_PTR(-EINVAL);
1535 : : }
1536 : : EXPORT_SYMBOL(bio_map_kern);
1537 : :
1538 : 0 : static void bio_copy_kern_endio(struct bio *bio, int err)
1539 : : {
1540 : : struct bio_vec *bvec;
1541 : 0 : const int read = bio_data_dir(bio) == READ;
1542 : 0 : struct bio_map_data *bmd = bio->bi_private;
1543 : : int i;
1544 : 0 : char *p = bmd->sgvecs[0].iov_base;
1545 : :
1546 [ # # ]: 0 : bio_for_each_segment_all(bvec, bio, i) {
1547 : 0 : char *addr = page_address(bvec->bv_page);
1548 : :
1549 [ # # ]: 0 : if (read)
1550 : 0 : memcpy(p, addr, bvec->bv_len);
1551 : :
1552 : 0 : __free_page(bvec->bv_page);
1553 : 0 : p += bvec->bv_len;
1554 : : }
1555 : :
1556 : 0 : kfree(bmd);
1557 : 0 : bio_put(bio);
1558 : 0 : }
1559 : :
1560 : : /**
1561 : : * bio_copy_kern - copy kernel address into bio
1562 : : * @q: the struct request_queue for the bio
1563 : : * @data: pointer to buffer to copy
1564 : : * @len: length in bytes
1565 : : * @gfp_mask: allocation flags for bio and page allocation
1566 : : * @reading: data direction is READ
1567 : : *
1568 : : * copy the kernel address into a bio suitable for io to a block
1569 : : * device. Returns an error pointer in case of error.
1570 : : */
1571 : 0 : struct bio *bio_copy_kern(struct request_queue *q, void *data, unsigned int len,
1572 : : gfp_t gfp_mask, int reading)
1573 : : {
1574 : : struct bio *bio;
1575 : : struct bio_vec *bvec;
1576 : : int i;
1577 : :
1578 : : bio = bio_copy_user(q, NULL, (unsigned long)data, len, 1, gfp_mask);
1579 [ # # ]: 0 : if (IS_ERR(bio))
1580 : : return bio;
1581 : :
1582 [ # # ]: 0 : if (!reading) {
1583 : : void *p = data;
1584 : :
1585 [ # # ]: 0 : bio_for_each_segment_all(bvec, bio, i) {
1586 : 0 : char *addr = page_address(bvec->bv_page);
1587 : :
1588 : 0 : memcpy(addr, p, bvec->bv_len);
1589 : 0 : p += bvec->bv_len;
1590 : : }
1591 : : }
1592 : :
1593 : 0 : bio->bi_end_io = bio_copy_kern_endio;
1594 : :
1595 : 0 : return bio;
1596 : : }
1597 : : EXPORT_SYMBOL(bio_copy_kern);
1598 : :
1599 : : /*
1600 : : * bio_set_pages_dirty() and bio_check_pages_dirty() are support functions
1601 : : * for performing direct-IO in BIOs.
1602 : : *
1603 : : * The problem is that we cannot run set_page_dirty() from interrupt context
1604 : : * because the required locks are not interrupt-safe. So what we can do is to
1605 : : * mark the pages dirty _before_ performing IO. And in interrupt context,
1606 : : * check that the pages are still dirty. If so, fine. If not, redirty them
1607 : : * in process context.
1608 : : *
1609 : : * We special-case compound pages here: normally this means reads into hugetlb
1610 : : * pages. The logic in here doesn't really work right for compound pages
1611 : : * because the VM does not uniformly chase down the head page in all cases.
1612 : : * But dirtiness of compound pages is pretty meaningless anyway: the VM doesn't
1613 : : * handle them at all. So we skip compound pages here at an early stage.
1614 : : *
1615 : : * Note that this code is very hard to test under normal circumstances because
1616 : : * direct-io pins the pages with get_user_pages(). This makes
1617 : : * is_page_cache_freeable return false, and the VM will not clean the pages.
1618 : : * But other code (eg, flusher threads) could clean the pages if they are mapped
1619 : : * pagecache.
1620 : : *
1621 : : * Simply disabling the call to bio_set_pages_dirty() is a good way to test the
1622 : : * deferred bio dirtying paths.
1623 : : */
1624 : :
1625 : : /*
1626 : : * bio_set_pages_dirty() will mark all the bio's pages as dirty.
1627 : : */
1628 : 0 : void bio_set_pages_dirty(struct bio *bio)
1629 : : {
1630 : : struct bio_vec *bvec;
1631 : : int i;
1632 : :
1633 [ # # ]: 0 : bio_for_each_segment_all(bvec, bio, i) {
1634 : 0 : struct page *page = bvec->bv_page;
1635 : :
1636 [ # # ][ # # ]: 0 : if (page && !PageCompound(page))
1637 : 0 : set_page_dirty_lock(page);
1638 : : }
1639 : 0 : }
1640 : :
1641 : 0 : static void bio_release_pages(struct bio *bio)
1642 : : {
1643 : : struct bio_vec *bvec;
1644 : : int i;
1645 : :
1646 [ # # ]: 0 : bio_for_each_segment_all(bvec, bio, i) {
1647 : 0 : struct page *page = bvec->bv_page;
1648 : :
1649 [ # # ]: 0 : if (page)
1650 : 0 : put_page(page);
1651 : : }
1652 : 0 : }
1653 : :
1654 : : /*
1655 : : * bio_check_pages_dirty() will check that all the BIO's pages are still dirty.
1656 : : * If they are, then fine. If, however, some pages are clean then they must
1657 : : * have been written out during the direct-IO read. So we take another ref on
1658 : : * the BIO and the offending pages and re-dirty the pages in process context.
1659 : : *
1660 : : * It is expected that bio_check_pages_dirty() will wholly own the BIO from
1661 : : * here on. It will run one page_cache_release() against each page and will
1662 : : * run one bio_put() against the BIO.
1663 : : */
1664 : :
1665 : : static void bio_dirty_fn(struct work_struct *work);
1666 : :
1667 : : static DECLARE_WORK(bio_dirty_work, bio_dirty_fn);
1668 : : static DEFINE_SPINLOCK(bio_dirty_lock);
1669 : : static struct bio *bio_dirty_list;
1670 : :
1671 : : /*
1672 : : * This runs in process context
1673 : : */
1674 : 0 : static void bio_dirty_fn(struct work_struct *work)
1675 : : {
1676 : : unsigned long flags;
1677 : 0 : struct bio *bio;
1678 : :
1679 : 0 : spin_lock_irqsave(&bio_dirty_lock, flags);
1680 : 0 : bio = bio_dirty_list;
1681 : 0 : bio_dirty_list = NULL;
1682 : : spin_unlock_irqrestore(&bio_dirty_lock, flags);
1683 : :
1684 [ # # ]: 0 : while (bio) {
1685 : 0 : struct bio *next = bio->bi_private;
1686 : :
1687 : 0 : bio_set_pages_dirty(bio);
1688 : 0 : bio_release_pages(bio);
1689 : 0 : bio_put(bio);
1690 : : bio = next;
1691 : : }
1692 : 0 : }
1693 : :
1694 : 0 : void bio_check_pages_dirty(struct bio *bio)
1695 : : {
1696 : : struct bio_vec *bvec;
1697 : : int nr_clean_pages = 0;
1698 : : int i;
1699 : :
1700 [ # # ]: 0 : bio_for_each_segment_all(bvec, bio, i) {
1701 : 0 : struct page *page = bvec->bv_page;
1702 : :
1703 [ # # ][ # # ]: 0 : if (PageDirty(page) || PageCompound(page)) {
1704 : 0 : page_cache_release(page);
1705 : 0 : bvec->bv_page = NULL;
1706 : : } else {
1707 : 0 : nr_clean_pages++;
1708 : : }
1709 : : }
1710 : :
1711 [ # # ]: 0 : if (nr_clean_pages) {
1712 : : unsigned long flags;
1713 : :
1714 : 0 : spin_lock_irqsave(&bio_dirty_lock, flags);
1715 : 0 : bio->bi_private = bio_dirty_list;
1716 : 0 : bio_dirty_list = bio;
1717 : : spin_unlock_irqrestore(&bio_dirty_lock, flags);
1718 : : schedule_work(&bio_dirty_work);
1719 : : } else {
1720 : 0 : bio_put(bio);
1721 : : }
1722 : 0 : }
1723 : :
1724 : : #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
1725 : 0 : void bio_flush_dcache_pages(struct bio *bi)
1726 : : {
1727 : : struct bio_vec bvec;
1728 : : struct bvec_iter iter;
1729 : :
1730 [ # # ]: 0 : bio_for_each_segment(bvec, bi, iter)
1731 : 0 : flush_dcache_page(bvec.bv_page);
1732 : 0 : }
1733 : : EXPORT_SYMBOL(bio_flush_dcache_pages);
1734 : : #endif
1735 : :
1736 : : /**
1737 : : * bio_endio - end I/O on a bio
1738 : : * @bio: bio
1739 : : * @error: error, if any
1740 : : *
1741 : : * Description:
1742 : : * bio_endio() will end I/O on the whole bio. bio_endio() is the
1743 : : * preferred way to end I/O on a bio, it takes care of clearing
1744 : : * BIO_UPTODATE on error. @error is 0 on success, and and one of the
1745 : : * established -Exxxx (-EIO, for instance) error values in case
1746 : : * something went wrong. No one should call bi_end_io() directly on a
1747 : : * bio unless they own it and thus know that it has an end_io
1748 : : * function.
1749 : : **/
1750 : 0 : void bio_endio(struct bio *bio, int error)
1751 : : {
1752 [ + + ]: 1484077 : while (bio) {
1753 [ - + ]: 742038 : BUG_ON(atomic_read(&bio->bi_remaining) <= 0);
1754 : :
1755 [ - + ]: 742038 : if (error)
1756 : 0 : clear_bit(BIO_UPTODATE, &bio->bi_flags);
1757 [ - + ]: 742038 : else if (!test_bit(BIO_UPTODATE, &bio->bi_flags))
1758 : : error = -EIO;
1759 : :
1760 [ + ]: 742037 : if (!atomic_dec_and_test(&bio->bi_remaining))
1761 : 742037 : return;
1762 : :
1763 : : /*
1764 : : * Need to have a real endio function for chained bios,
1765 : : * otherwise various corner cases will break (like stacking
1766 : : * block devices that save/restore bi_end_io) - however, we want
1767 : : * to avoid unbounded recursion and blowing the stack. Tail call
1768 : : * optimization would handle this, but compiling with frame
1769 : : * pointers also disables gcc's sibling call optimization.
1770 : : */
1771 [ - + ]: 742039 : if (bio->bi_end_io == bio_chain_endio) {
1772 : 0 : struct bio *parent = bio->bi_private;
1773 : 0 : bio_put(bio);
1774 : : bio = parent;
1775 : : } else {
1776 [ + + ]: 742039 : if (bio->bi_end_io)
1777 : 742037 : bio->bi_end_io(bio, error);
1778 : : bio = NULL;
1779 : : }
1780 : : }
1781 : : }
1782 : : EXPORT_SYMBOL(bio_endio);
1783 : :
1784 : : /**
1785 : : * bio_endio_nodec - end I/O on a bio, without decrementing bi_remaining
1786 : : * @bio: bio
1787 : : * @error: error, if any
1788 : : *
1789 : : * For code that has saved and restored bi_end_io; thing hard before using this
1790 : : * function, probably you should've cloned the entire bio.
1791 : : **/
1792 : 0 : void bio_endio_nodec(struct bio *bio, int error)
1793 : : {
1794 : 0 : atomic_inc(&bio->bi_remaining);
1795 : 0 : bio_endio(bio, error);
1796 : 0 : }
1797 : : EXPORT_SYMBOL(bio_endio_nodec);
1798 : :
1799 : : /**
1800 : : * bio_split - split a bio
1801 : : * @bio: bio to split
1802 : : * @sectors: number of sectors to split from the front of @bio
1803 : : * @gfp: gfp mask
1804 : : * @bs: bio set to allocate from
1805 : : *
1806 : : * Allocates and returns a new bio which represents @sectors from the start of
1807 : : * @bio, and updates @bio to represent the remaining sectors.
1808 : : *
1809 : : * The newly allocated bio will point to @bio's bi_io_vec; it is the caller's
1810 : : * responsibility to ensure that @bio is not freed before the split.
1811 : : */
1812 : 0 : struct bio *bio_split(struct bio *bio, int sectors,
1813 : : gfp_t gfp, struct bio_set *bs)
1814 : : {
1815 : : struct bio *split = NULL;
1816 : :
1817 [ # # ]: 0 : BUG_ON(sectors <= 0);
1818 [ # # ]: 0 : BUG_ON(sectors >= bio_sectors(bio));
1819 : :
1820 : 0 : split = bio_clone_fast(bio, gfp, bs);
1821 [ # # ]: 0 : if (!split)
1822 : : return NULL;
1823 : :
1824 : 0 : split->bi_iter.bi_size = sectors << 9;
1825 : :
1826 : : if (bio_integrity(split))
1827 : : bio_integrity_trim(split, 0, sectors);
1828 : :
1829 : 0 : bio_advance(bio, split->bi_iter.bi_size);
1830 : :
1831 : 0 : return split;
1832 : : }
1833 : : EXPORT_SYMBOL(bio_split);
1834 : :
1835 : : /**
1836 : : * bio_trim - trim a bio
1837 : : * @bio: bio to trim
1838 : : * @offset: number of sectors to trim from the front of @bio
1839 : : * @size: size we want to trim @bio to, in sectors
1840 : : */
1841 : 0 : void bio_trim(struct bio *bio, int offset, int size)
1842 : : {
1843 : : /* 'bio' is a cloned bio which we need to trim to match
1844 : : * the given offset and size.
1845 : : */
1846 : :
1847 : 0 : size <<= 9;
1848 [ # # ][ # # ]: 0 : if (offset == 0 && size == bio->bi_iter.bi_size)
1849 : 0 : return;
1850 : :
1851 : 0 : clear_bit(BIO_SEG_VALID, &bio->bi_flags);
1852 : :
1853 : 0 : bio_advance(bio, offset << 9);
1854 : :
1855 : 0 : bio->bi_iter.bi_size = size;
1856 : : }
1857 : : EXPORT_SYMBOL_GPL(bio_trim);
1858 : :
1859 : : /*
1860 : : * create memory pools for biovec's in a bio_set.
1861 : : * use the global biovec slabs created for general use.
1862 : : */
1863 : 0 : mempool_t *biovec_create_pool(struct bio_set *bs, int pool_entries)
1864 : : {
1865 : : struct biovec_slab *bp = bvec_slabs + BIOVEC_MAX_IDX;
1866 : :
1867 : 0 : return mempool_create_slab_pool(pool_entries, bp->slab);
1868 : : }
1869 : :
1870 : 0 : void bioset_free(struct bio_set *bs)
1871 : : {
1872 [ # # ]: 0 : if (bs->rescue_workqueue)
1873 : 0 : destroy_workqueue(bs->rescue_workqueue);
1874 : :
1875 [ # # ]: 0 : if (bs->bio_pool)
1876 : 0 : mempool_destroy(bs->bio_pool);
1877 : :
1878 [ # # ]: 0 : if (bs->bvec_pool)
1879 : 0 : mempool_destroy(bs->bvec_pool);
1880 : :
1881 : : bioset_integrity_free(bs);
1882 : 0 : bio_put_slab(bs);
1883 : :
1884 : 0 : kfree(bs);
1885 : 0 : }
1886 : : EXPORT_SYMBOL(bioset_free);
1887 : :
1888 : : /**
1889 : : * bioset_create - Create a bio_set
1890 : : * @pool_size: Number of bio and bio_vecs to cache in the mempool
1891 : : * @front_pad: Number of bytes to allocate in front of the returned bio
1892 : : *
1893 : : * Description:
1894 : : * Set up a bio_set to be used with @bio_alloc_bioset. Allows the caller
1895 : : * to ask for a number of bytes to be allocated in front of the bio.
1896 : : * Front pad allocation is useful for embedding the bio inside
1897 : : * another structure, to avoid allocating extra data to go with the bio.
1898 : : * Note that the bio must be embedded at the END of that structure always,
1899 : : * or things will break badly.
1900 : : */
1901 : 0 : struct bio_set *bioset_create(unsigned int pool_size, unsigned int front_pad)
1902 : : {
1903 : : unsigned int back_pad = BIO_INLINE_VECS * sizeof(struct bio_vec);
1904 : : struct bio_set *bs;
1905 : :
1906 : : bs = kzalloc(sizeof(*bs), GFP_KERNEL);
1907 [ # # ]: 0 : if (!bs)
1908 : : return NULL;
1909 : :
1910 : 0 : bs->front_pad = front_pad;
1911 : :
1912 : 0 : spin_lock_init(&bs->rescue_lock);
1913 : : bio_list_init(&bs->rescue_list);
1914 : 0 : INIT_WORK(&bs->rescue_work, bio_alloc_rescue);
1915 : :
1916 : 0 : bs->bio_slab = bio_find_or_create_slab(front_pad + back_pad);
1917 [ # # ]: 0 : if (!bs->bio_slab) {
1918 : 0 : kfree(bs);
1919 : 0 : return NULL;
1920 : : }
1921 : :
1922 : 0 : bs->bio_pool = mempool_create_slab_pool(pool_size, bs->bio_slab);
1923 [ # # ]: 0 : if (!bs->bio_pool)
1924 : : goto bad;
1925 : :
1926 : 0 : bs->bvec_pool = biovec_create_pool(bs, pool_size);
1927 [ # # ]: 0 : if (!bs->bvec_pool)
1928 : : goto bad;
1929 : :
1930 : 0 : bs->rescue_workqueue = alloc_workqueue("bioset", WQ_MEM_RECLAIM, 0);
1931 [ # # ]: 0 : if (!bs->rescue_workqueue)
1932 : : goto bad;
1933 : :
1934 : : return bs;
1935 : : bad:
1936 : 0 : bioset_free(bs);
1937 : 0 : return NULL;
1938 : : }
1939 : : EXPORT_SYMBOL(bioset_create);
1940 : :
1941 : : #ifdef CONFIG_BLK_CGROUP
1942 : : /**
1943 : : * bio_associate_current - associate a bio with %current
1944 : : * @bio: target bio
1945 : : *
1946 : : * Associate @bio with %current if it hasn't been associated yet. Block
1947 : : * layer will treat @bio as if it were issued by %current no matter which
1948 : : * task actually issues it.
1949 : : *
1950 : : * This function takes an extra reference of @task's io_context and blkcg
1951 : : * which will be put when @bio is released. The caller must own @bio,
1952 : : * ensure %current->io_context exists, and is responsible for synchronizing
1953 : : * calls to this function.
1954 : : */
1955 : : int bio_associate_current(struct bio *bio)
1956 : : {
1957 : : struct io_context *ioc;
1958 : : struct cgroup_subsys_state *css;
1959 : :
1960 : : if (bio->bi_ioc)
1961 : : return -EBUSY;
1962 : :
1963 : : ioc = current->io_context;
1964 : : if (!ioc)
1965 : : return -ENOENT;
1966 : :
1967 : : /* acquire active ref on @ioc and associate */
1968 : : get_io_context_active(ioc);
1969 : : bio->bi_ioc = ioc;
1970 : :
1971 : : /* associate blkcg if exists */
1972 : : rcu_read_lock();
1973 : : css = task_css(current, blkio_subsys_id);
1974 : : if (css && css_tryget(css))
1975 : : bio->bi_css = css;
1976 : : rcu_read_unlock();
1977 : :
1978 : : return 0;
1979 : : }
1980 : :
1981 : : /**
1982 : : * bio_disassociate_task - undo bio_associate_current()
1983 : : * @bio: target bio
1984 : : */
1985 : : void bio_disassociate_task(struct bio *bio)
1986 : : {
1987 : : if (bio->bi_ioc) {
1988 : : put_io_context(bio->bi_ioc);
1989 : : bio->bi_ioc = NULL;
1990 : : }
1991 : : if (bio->bi_css) {
1992 : : css_put(bio->bi_css);
1993 : : bio->bi_css = NULL;
1994 : : }
1995 : : }
1996 : :
1997 : : #endif /* CONFIG_BLK_CGROUP */
1998 : :
1999 : 0 : static void __init biovec_init_slabs(void)
2000 : : {
2001 : : int i;
2002 : :
2003 [ # # ]: 0 : for (i = 0; i < BIOVEC_NR_POOLS; i++) {
2004 : : int size;
2005 : 0 : struct biovec_slab *bvs = bvec_slabs + i;
2006 : :
2007 [ # # ]: 0 : if (bvs->nr_vecs <= BIO_INLINE_VECS) {
2008 : 0 : bvs->slab = NULL;
2009 : 0 : continue;
2010 : : }
2011 : :
2012 : 0 : size = bvs->nr_vecs * sizeof(struct bio_vec);
2013 : 0 : bvs->slab = kmem_cache_create(bvs->name, size, 0,
2014 : : SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
2015 : : }
2016 : 0 : }
2017 : :
2018 : 0 : static int __init init_bio(void)
2019 : : {
2020 : 0 : bio_slab_max = 2;
2021 : 0 : bio_slab_nr = 0;
2022 : 0 : bio_slabs = kzalloc(bio_slab_max * sizeof(struct bio_slab), GFP_KERNEL);
2023 [ # # ]: 0 : if (!bio_slabs)
2024 : 0 : panic("bio: can't allocate bios\n");
2025 : :
2026 : : bio_integrity_init();
2027 : 0 : biovec_init_slabs();
2028 : :
2029 : 0 : fs_bio_set = bioset_create(BIO_POOL_SIZE, 0);
2030 [ # # ]: 0 : if (!fs_bio_set)
2031 : 0 : panic("bio: can't allocate bios\n");
2032 : :
2033 : : if (bioset_integrity_create(fs_bio_set, BIO_POOL_SIZE))
2034 : : panic("bio: can't create integrity pool\n");
2035 : :
2036 : 0 : return 0;
2037 : : }
2038 : : subsys_initcall(init_bio);
|
