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