treewide: remove SPDX "WITH Linux-syscall-note" from kernel-space headers
[sfrench/cifs-2.6.git] / block / bio.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2001 Jens Axboe <axboe@kernel.dk>
4  */
5 #include <linux/mm.h>
6 #include <linux/swap.h>
7 #include <linux/bio.h>
8 #include <linux/blkdev.h>
9 #include <linux/uio.h>
10 #include <linux/iocontext.h>
11 #include <linux/slab.h>
12 #include <linux/init.h>
13 #include <linux/kernel.h>
14 #include <linux/export.h>
15 #include <linux/mempool.h>
16 #include <linux/workqueue.h>
17 #include <linux/cgroup.h>
18 #include <linux/blk-cgroup.h>
19
20 #include <trace/events/block.h>
21 #include "blk.h"
22 #include "blk-rq-qos.h"
23
24 /*
25  * Test patch to inline a certain number of bi_io_vec's inside the bio
26  * itself, to shrink a bio data allocation from two mempool calls to one
27  */
28 #define BIO_INLINE_VECS         4
29
30 /*
31  * if you change this list, also change bvec_alloc or things will
32  * break badly! cannot be bigger than what you can fit into an
33  * unsigned short
34  */
35 #define BV(x, n) { .nr_vecs = x, .name = "biovec-"#n }
36 static struct biovec_slab bvec_slabs[BVEC_POOL_NR] __read_mostly = {
37         BV(1, 1), BV(4, 4), BV(16, 16), BV(64, 64), BV(128, 128), BV(BIO_MAX_PAGES, max),
38 };
39 #undef BV
40
41 /*
42  * fs_bio_set is the bio_set containing bio and iovec memory pools used by
43  * IO code that does not need private memory pools.
44  */
45 struct bio_set fs_bio_set;
46 EXPORT_SYMBOL(fs_bio_set);
47
48 /*
49  * Our slab pool management
50  */
51 struct bio_slab {
52         struct kmem_cache *slab;
53         unsigned int slab_ref;
54         unsigned int slab_size;
55         char name[8];
56 };
57 static DEFINE_MUTEX(bio_slab_lock);
58 static struct bio_slab *bio_slabs;
59 static unsigned int bio_slab_nr, bio_slab_max;
60
61 static struct kmem_cache *bio_find_or_create_slab(unsigned int extra_size)
62 {
63         unsigned int sz = sizeof(struct bio) + extra_size;
64         struct kmem_cache *slab = NULL;
65         struct bio_slab *bslab, *new_bio_slabs;
66         unsigned int new_bio_slab_max;
67         unsigned int i, entry = -1;
68
69         mutex_lock(&bio_slab_lock);
70
71         i = 0;
72         while (i < bio_slab_nr) {
73                 bslab = &bio_slabs[i];
74
75                 if (!bslab->slab && entry == -1)
76                         entry = i;
77                 else if (bslab->slab_size == sz) {
78                         slab = bslab->slab;
79                         bslab->slab_ref++;
80                         break;
81                 }
82                 i++;
83         }
84
85         if (slab)
86                 goto out_unlock;
87
88         if (bio_slab_nr == bio_slab_max && entry == -1) {
89                 new_bio_slab_max = bio_slab_max << 1;
90                 new_bio_slabs = krealloc(bio_slabs,
91                                          new_bio_slab_max * sizeof(struct bio_slab),
92                                          GFP_KERNEL);
93                 if (!new_bio_slabs)
94                         goto out_unlock;
95                 bio_slab_max = new_bio_slab_max;
96                 bio_slabs = new_bio_slabs;
97         }
98         if (entry == -1)
99                 entry = bio_slab_nr++;
100
101         bslab = &bio_slabs[entry];
102
103         snprintf(bslab->name, sizeof(bslab->name), "bio-%d", entry);
104         slab = kmem_cache_create(bslab->name, sz, ARCH_KMALLOC_MINALIGN,
105                                  SLAB_HWCACHE_ALIGN, NULL);
106         if (!slab)
107                 goto out_unlock;
108
109         bslab->slab = slab;
110         bslab->slab_ref = 1;
111         bslab->slab_size = sz;
112 out_unlock:
113         mutex_unlock(&bio_slab_lock);
114         return slab;
115 }
116
117 static void bio_put_slab(struct bio_set *bs)
118 {
119         struct bio_slab *bslab = NULL;
120         unsigned int i;
121
122         mutex_lock(&bio_slab_lock);
123
124         for (i = 0; i < bio_slab_nr; i++) {
125                 if (bs->bio_slab == bio_slabs[i].slab) {
126                         bslab = &bio_slabs[i];
127                         break;
128                 }
129         }
130
131         if (WARN(!bslab, KERN_ERR "bio: unable to find slab!\n"))
132                 goto out;
133
134         WARN_ON(!bslab->slab_ref);
135
136         if (--bslab->slab_ref)
137                 goto out;
138
139         kmem_cache_destroy(bslab->slab);
140         bslab->slab = NULL;
141
142 out:
143         mutex_unlock(&bio_slab_lock);
144 }
145
146 unsigned int bvec_nr_vecs(unsigned short idx)
147 {
148         return bvec_slabs[--idx].nr_vecs;
149 }
150
151 void bvec_free(mempool_t *pool, struct bio_vec *bv, unsigned int idx)
152 {
153         if (!idx)
154                 return;
155         idx--;
156
157         BIO_BUG_ON(idx >= BVEC_POOL_NR);
158
159         if (idx == BVEC_POOL_MAX) {
160                 mempool_free(bv, pool);
161         } else {
162                 struct biovec_slab *bvs = bvec_slabs + idx;
163
164                 kmem_cache_free(bvs->slab, bv);
165         }
166 }
167
168 struct bio_vec *bvec_alloc(gfp_t gfp_mask, int nr, unsigned long *idx,
169                            mempool_t *pool)
170 {
171         struct bio_vec *bvl;
172
173         /*
174          * see comment near bvec_array define!
175          */
176         switch (nr) {
177         case 1:
178                 *idx = 0;
179                 break;
180         case 2 ... 4:
181                 *idx = 1;
182                 break;
183         case 5 ... 16:
184                 *idx = 2;
185                 break;
186         case 17 ... 64:
187                 *idx = 3;
188                 break;
189         case 65 ... 128:
190                 *idx = 4;
191                 break;
192         case 129 ... BIO_MAX_PAGES:
193                 *idx = 5;
194                 break;
195         default:
196                 return NULL;
197         }
198
199         /*
200          * idx now points to the pool we want to allocate from. only the
201          * 1-vec entry pool is mempool backed.
202          */
203         if (*idx == BVEC_POOL_MAX) {
204 fallback:
205                 bvl = mempool_alloc(pool, gfp_mask);
206         } else {
207                 struct biovec_slab *bvs = bvec_slabs + *idx;
208                 gfp_t __gfp_mask = gfp_mask & ~(__GFP_DIRECT_RECLAIM | __GFP_IO);
209
210                 /*
211                  * Make this allocation restricted and don't dump info on
212                  * allocation failures, since we'll fallback to the mempool
213                  * in case of failure.
214                  */
215                 __gfp_mask |= __GFP_NOMEMALLOC | __GFP_NORETRY | __GFP_NOWARN;
216
217                 /*
218                  * Try a slab allocation. If this fails and __GFP_DIRECT_RECLAIM
219                  * is set, retry with the 1-entry mempool
220                  */
221                 bvl = kmem_cache_alloc(bvs->slab, __gfp_mask);
222                 if (unlikely(!bvl && (gfp_mask & __GFP_DIRECT_RECLAIM))) {
223                         *idx = BVEC_POOL_MAX;
224                         goto fallback;
225                 }
226         }
227
228         (*idx)++;
229         return bvl;
230 }
231
232 void bio_uninit(struct bio *bio)
233 {
234         bio_disassociate_blkg(bio);
235 }
236 EXPORT_SYMBOL(bio_uninit);
237
238 static void bio_free(struct bio *bio)
239 {
240         struct bio_set *bs = bio->bi_pool;
241         void *p;
242
243         bio_uninit(bio);
244
245         if (bs) {
246                 bvec_free(&bs->bvec_pool, bio->bi_io_vec, BVEC_POOL_IDX(bio));
247
248                 /*
249                  * If we have front padding, adjust the bio pointer before freeing
250                  */
251                 p = bio;
252                 p -= bs->front_pad;
253
254                 mempool_free(p, &bs->bio_pool);
255         } else {
256                 /* Bio was allocated by bio_kmalloc() */
257                 kfree(bio);
258         }
259 }
260
261 /*
262  * Users of this function have their own bio allocation. Subsequently,
263  * they must remember to pair any call to bio_init() with bio_uninit()
264  * when IO has completed, or when the bio is released.
265  */
266 void bio_init(struct bio *bio, struct bio_vec *table,
267               unsigned short max_vecs)
268 {
269         memset(bio, 0, sizeof(*bio));
270         atomic_set(&bio->__bi_remaining, 1);
271         atomic_set(&bio->__bi_cnt, 1);
272
273         bio->bi_io_vec = table;
274         bio->bi_max_vecs = max_vecs;
275 }
276 EXPORT_SYMBOL(bio_init);
277
278 /**
279  * bio_reset - reinitialize a bio
280  * @bio:        bio to reset
281  *
282  * Description:
283  *   After calling bio_reset(), @bio will be in the same state as a freshly
284  *   allocated bio returned bio bio_alloc_bioset() - the only fields that are
285  *   preserved are the ones that are initialized by bio_alloc_bioset(). See
286  *   comment in struct bio.
287  */
288 void bio_reset(struct bio *bio)
289 {
290         unsigned long flags = bio->bi_flags & (~0UL << BIO_RESET_BITS);
291
292         bio_uninit(bio);
293
294         memset(bio, 0, BIO_RESET_BYTES);
295         bio->bi_flags = flags;
296         atomic_set(&bio->__bi_remaining, 1);
297 }
298 EXPORT_SYMBOL(bio_reset);
299
300 static struct bio *__bio_chain_endio(struct bio *bio)
301 {
302         struct bio *parent = bio->bi_private;
303
304         if (!parent->bi_status)
305                 parent->bi_status = bio->bi_status;
306         bio_put(bio);
307         return parent;
308 }
309
310 static void bio_chain_endio(struct bio *bio)
311 {
312         bio_endio(__bio_chain_endio(bio));
313 }
314
315 /**
316  * bio_chain - chain bio completions
317  * @bio: the target bio
318  * @parent: the @bio's parent bio
319  *
320  * The caller won't have a bi_end_io called when @bio completes - instead,
321  * @parent's bi_end_io won't be called until both @parent and @bio have
322  * completed; the chained bio will also be freed when it completes.
323  *
324  * The caller must not set bi_private or bi_end_io in @bio.
325  */
326 void bio_chain(struct bio *bio, struct bio *parent)
327 {
328         BUG_ON(bio->bi_private || bio->bi_end_io);
329
330         bio->bi_private = parent;
331         bio->bi_end_io  = bio_chain_endio;
332         bio_inc_remaining(parent);
333 }
334 EXPORT_SYMBOL(bio_chain);
335
336 static void bio_alloc_rescue(struct work_struct *work)
337 {
338         struct bio_set *bs = container_of(work, struct bio_set, rescue_work);
339         struct bio *bio;
340
341         while (1) {
342                 spin_lock(&bs->rescue_lock);
343                 bio = bio_list_pop(&bs->rescue_list);
344                 spin_unlock(&bs->rescue_lock);
345
346                 if (!bio)
347                         break;
348
349                 generic_make_request(bio);
350         }
351 }
352
353 static void punt_bios_to_rescuer(struct bio_set *bs)
354 {
355         struct bio_list punt, nopunt;
356         struct bio *bio;
357
358         if (WARN_ON_ONCE(!bs->rescue_workqueue))
359                 return;
360         /*
361          * In order to guarantee forward progress we must punt only bios that
362          * were allocated from this bio_set; otherwise, if there was a bio on
363          * there for a stacking driver higher up in the stack, processing it
364          * could require allocating bios from this bio_set, and doing that from
365          * our own rescuer would be bad.
366          *
367          * Since bio lists are singly linked, pop them all instead of trying to
368          * remove from the middle of the list:
369          */
370
371         bio_list_init(&punt);
372         bio_list_init(&nopunt);
373
374         while ((bio = bio_list_pop(&current->bio_list[0])))
375                 bio_list_add(bio->bi_pool == bs ? &punt : &nopunt, bio);
376         current->bio_list[0] = nopunt;
377
378         bio_list_init(&nopunt);
379         while ((bio = bio_list_pop(&current->bio_list[1])))
380                 bio_list_add(bio->bi_pool == bs ? &punt : &nopunt, bio);
381         current->bio_list[1] = nopunt;
382
383         spin_lock(&bs->rescue_lock);
384         bio_list_merge(&bs->rescue_list, &punt);
385         spin_unlock(&bs->rescue_lock);
386
387         queue_work(bs->rescue_workqueue, &bs->rescue_work);
388 }
389
390 /**
391  * bio_alloc_bioset - allocate a bio for I/O
392  * @gfp_mask:   the GFP_* mask given to the slab allocator
393  * @nr_iovecs:  number of iovecs to pre-allocate
394  * @bs:         the bio_set to allocate from.
395  *
396  * Description:
397  *   If @bs is NULL, uses kmalloc() to allocate the bio; else the allocation is
398  *   backed by the @bs's mempool.
399  *
400  *   When @bs is not NULL, if %__GFP_DIRECT_RECLAIM is set then bio_alloc will
401  *   always be able to allocate a bio. This is due to the mempool guarantees.
402  *   To make this work, callers must never allocate more than 1 bio at a time
403  *   from this pool. Callers that need to allocate more than 1 bio must always
404  *   submit the previously allocated bio for IO before attempting to allocate
405  *   a new one. Failure to do so can cause deadlocks under memory pressure.
406  *
407  *   Note that when running under generic_make_request() (i.e. any block
408  *   driver), bios are not submitted until after you return - see the code in
409  *   generic_make_request() that converts recursion into iteration, to prevent
410  *   stack overflows.
411  *
412  *   This would normally mean allocating multiple bios under
413  *   generic_make_request() would be susceptible to deadlocks, but we have
414  *   deadlock avoidance code that resubmits any blocked bios from a rescuer
415  *   thread.
416  *
417  *   However, we do not guarantee forward progress for allocations from other
418  *   mempools. Doing multiple allocations from the same mempool under
419  *   generic_make_request() should be avoided - instead, use bio_set's front_pad
420  *   for per bio allocations.
421  *
422  *   RETURNS:
423  *   Pointer to new bio on success, NULL on failure.
424  */
425 struct bio *bio_alloc_bioset(gfp_t gfp_mask, unsigned int nr_iovecs,
426                              struct bio_set *bs)
427 {
428         gfp_t saved_gfp = gfp_mask;
429         unsigned front_pad;
430         unsigned inline_vecs;
431         struct bio_vec *bvl = NULL;
432         struct bio *bio;
433         void *p;
434
435         if (!bs) {
436                 if (nr_iovecs > UIO_MAXIOV)
437                         return NULL;
438
439                 p = kmalloc(sizeof(struct bio) +
440                             nr_iovecs * sizeof(struct bio_vec),
441                             gfp_mask);
442                 front_pad = 0;
443                 inline_vecs = nr_iovecs;
444         } else {
445                 /* should not use nobvec bioset for nr_iovecs > 0 */
446                 if (WARN_ON_ONCE(!mempool_initialized(&bs->bvec_pool) &&
447                                  nr_iovecs > 0))
448                         return NULL;
449                 /*
450                  * generic_make_request() converts recursion to iteration; this
451                  * means if we're running beneath it, any bios we allocate and
452                  * submit will not be submitted (and thus freed) until after we
453                  * return.
454                  *
455                  * This exposes us to a potential deadlock if we allocate
456                  * multiple bios from the same bio_set() while running
457                  * underneath generic_make_request(). If we were to allocate
458                  * multiple bios (say a stacking block driver that was splitting
459                  * bios), we would deadlock if we exhausted the mempool's
460                  * reserve.
461                  *
462                  * We solve this, and guarantee forward progress, with a rescuer
463                  * workqueue per bio_set. If we go to allocate and there are
464                  * bios on current->bio_list, we first try the allocation
465                  * without __GFP_DIRECT_RECLAIM; if that fails, we punt those
466                  * bios we would be blocking to the rescuer workqueue before
467                  * we retry with the original gfp_flags.
468                  */
469
470                 if (current->bio_list &&
471                     (!bio_list_empty(&current->bio_list[0]) ||
472                      !bio_list_empty(&current->bio_list[1])) &&
473                     bs->rescue_workqueue)
474                         gfp_mask &= ~__GFP_DIRECT_RECLAIM;
475
476                 p = mempool_alloc(&bs->bio_pool, gfp_mask);
477                 if (!p && gfp_mask != saved_gfp) {
478                         punt_bios_to_rescuer(bs);
479                         gfp_mask = saved_gfp;
480                         p = mempool_alloc(&bs->bio_pool, gfp_mask);
481                 }
482
483                 front_pad = bs->front_pad;
484                 inline_vecs = BIO_INLINE_VECS;
485         }
486
487         if (unlikely(!p))
488                 return NULL;
489
490         bio = p + front_pad;
491         bio_init(bio, NULL, 0);
492
493         if (nr_iovecs > inline_vecs) {
494                 unsigned long idx = 0;
495
496                 bvl = bvec_alloc(gfp_mask, nr_iovecs, &idx, &bs->bvec_pool);
497                 if (!bvl && gfp_mask != saved_gfp) {
498                         punt_bios_to_rescuer(bs);
499                         gfp_mask = saved_gfp;
500                         bvl = bvec_alloc(gfp_mask, nr_iovecs, &idx, &bs->bvec_pool);
501                 }
502
503                 if (unlikely(!bvl))
504                         goto err_free;
505
506                 bio->bi_flags |= idx << BVEC_POOL_OFFSET;
507         } else if (nr_iovecs) {
508                 bvl = bio->bi_inline_vecs;
509         }
510
511         bio->bi_pool = bs;
512         bio->bi_max_vecs = nr_iovecs;
513         bio->bi_io_vec = bvl;
514         return bio;
515
516 err_free:
517         mempool_free(p, &bs->bio_pool);
518         return NULL;
519 }
520 EXPORT_SYMBOL(bio_alloc_bioset);
521
522 void zero_fill_bio_iter(struct bio *bio, struct bvec_iter start)
523 {
524         unsigned long flags;
525         struct bio_vec bv;
526         struct bvec_iter iter;
527
528         __bio_for_each_segment(bv, bio, iter, start) {
529                 char *data = bvec_kmap_irq(&bv, &flags);
530                 memset(data, 0, bv.bv_len);
531                 flush_dcache_page(bv.bv_page);
532                 bvec_kunmap_irq(data, &flags);
533         }
534 }
535 EXPORT_SYMBOL(zero_fill_bio_iter);
536
537 /**
538  * bio_put - release a reference to a bio
539  * @bio:   bio to release reference to
540  *
541  * Description:
542  *   Put a reference to a &struct bio, either one you have gotten with
543  *   bio_alloc, bio_get or bio_clone_*. The last put of a bio will free it.
544  **/
545 void bio_put(struct bio *bio)
546 {
547         if (!bio_flagged(bio, BIO_REFFED))
548                 bio_free(bio);
549         else {
550                 BIO_BUG_ON(!atomic_read(&bio->__bi_cnt));
551
552                 /*
553                  * last put frees it
554                  */
555                 if (atomic_dec_and_test(&bio->__bi_cnt))
556                         bio_free(bio);
557         }
558 }
559 EXPORT_SYMBOL(bio_put);
560
561 int bio_phys_segments(struct request_queue *q, struct bio *bio)
562 {
563         if (unlikely(!bio_flagged(bio, BIO_SEG_VALID)))
564                 blk_recount_segments(q, bio);
565
566         return bio->bi_phys_segments;
567 }
568
569 /**
570  *      __bio_clone_fast - clone a bio that shares the original bio's biovec
571  *      @bio: destination bio
572  *      @bio_src: bio to clone
573  *
574  *      Clone a &bio. Caller will own the returned bio, but not
575  *      the actual data it points to. Reference count of returned
576  *      bio will be one.
577  *
578  *      Caller must ensure that @bio_src is not freed before @bio.
579  */
580 void __bio_clone_fast(struct bio *bio, struct bio *bio_src)
581 {
582         BUG_ON(bio->bi_pool && BVEC_POOL_IDX(bio));
583
584         /*
585          * most users will be overriding ->bi_disk with a new target,
586          * so we don't set nor calculate new physical/hw segment counts here
587          */
588         bio->bi_disk = bio_src->bi_disk;
589         bio->bi_partno = bio_src->bi_partno;
590         bio_set_flag(bio, BIO_CLONED);
591         if (bio_flagged(bio_src, BIO_THROTTLED))
592                 bio_set_flag(bio, BIO_THROTTLED);
593         bio->bi_opf = bio_src->bi_opf;
594         bio->bi_ioprio = bio_src->bi_ioprio;
595         bio->bi_write_hint = bio_src->bi_write_hint;
596         bio->bi_iter = bio_src->bi_iter;
597         bio->bi_io_vec = bio_src->bi_io_vec;
598
599         bio_clone_blkg_association(bio, bio_src);
600         blkcg_bio_issue_init(bio);
601 }
602 EXPORT_SYMBOL(__bio_clone_fast);
603
604 /**
605  *      bio_clone_fast - clone a bio that shares the original bio's biovec
606  *      @bio: bio to clone
607  *      @gfp_mask: allocation priority
608  *      @bs: bio_set to allocate from
609  *
610  *      Like __bio_clone_fast, only also allocates the returned bio
611  */
612 struct bio *bio_clone_fast(struct bio *bio, gfp_t gfp_mask, struct bio_set *bs)
613 {
614         struct bio *b;
615
616         b = bio_alloc_bioset(gfp_mask, 0, bs);
617         if (!b)
618                 return NULL;
619
620         __bio_clone_fast(b, bio);
621
622         if (bio_integrity(bio)) {
623                 int ret;
624
625                 ret = bio_integrity_clone(b, bio, gfp_mask);
626
627                 if (ret < 0) {
628                         bio_put(b);
629                         return NULL;
630                 }
631         }
632
633         return b;
634 }
635 EXPORT_SYMBOL(bio_clone_fast);
636
637 static inline bool page_is_mergeable(const struct bio_vec *bv,
638                 struct page *page, unsigned int len, unsigned int off,
639                 bool same_page)
640 {
641         phys_addr_t vec_end_addr = page_to_phys(bv->bv_page) +
642                 bv->bv_offset + bv->bv_len - 1;
643         phys_addr_t page_addr = page_to_phys(page);
644
645         if (vec_end_addr + 1 != page_addr + off)
646                 return false;
647         if (xen_domain() && !xen_biovec_phys_mergeable(bv, page))
648                 return false;
649
650         if ((vec_end_addr & PAGE_MASK) != page_addr) {
651                 if (same_page)
652                         return false;
653                 if (pfn_to_page(PFN_DOWN(vec_end_addr)) + 1 != page)
654                         return false;
655         }
656
657         WARN_ON_ONCE(same_page && (len + off) > PAGE_SIZE);
658
659         return true;
660 }
661
662 /*
663  * Check if the @page can be added to the current segment(@bv), and make
664  * sure to call it only if page_is_mergeable(@bv, @page) is true
665  */
666 static bool can_add_page_to_seg(struct request_queue *q,
667                 struct bio_vec *bv, struct page *page, unsigned len,
668                 unsigned offset)
669 {
670         unsigned long mask = queue_segment_boundary(q);
671         phys_addr_t addr1 = page_to_phys(bv->bv_page) + bv->bv_offset;
672         phys_addr_t addr2 = page_to_phys(page) + offset + len - 1;
673
674         if ((addr1 | mask) != (addr2 | mask))
675                 return false;
676
677         if (bv->bv_len + len > queue_max_segment_size(q))
678                 return false;
679
680         return true;
681 }
682
683 /**
684  *      __bio_add_pc_page       - attempt to add page to passthrough bio
685  *      @q: the target queue
686  *      @bio: destination bio
687  *      @page: page to add
688  *      @len: vec entry length
689  *      @offset: vec entry offset
690  *      @put_same_page: put the page if it is same with last added page
691  *
692  *      Attempt to add a page to the bio_vec maplist. This can fail for a
693  *      number of reasons, such as the bio being full or target block device
694  *      limitations. The target block device must allow bio's up to PAGE_SIZE,
695  *      so it is always possible to add a single page to an empty bio.
696  *
697  *      This should only be used by passthrough bios.
698  */
699 static int __bio_add_pc_page(struct request_queue *q, struct bio *bio,
700                 struct page *page, unsigned int len, unsigned int offset,
701                 bool put_same_page)
702 {
703         struct bio_vec *bvec;
704
705         /*
706          * cloned bio must not modify vec list
707          */
708         if (unlikely(bio_flagged(bio, BIO_CLONED)))
709                 return 0;
710
711         if (((bio->bi_iter.bi_size + len) >> 9) > queue_max_hw_sectors(q))
712                 return 0;
713
714         if (bio->bi_vcnt > 0) {
715                 bvec = &bio->bi_io_vec[bio->bi_vcnt - 1];
716
717                 if (page == bvec->bv_page &&
718                     offset == bvec->bv_offset + bvec->bv_len) {
719                         if (put_same_page)
720                                 put_page(page);
721                         bvec->bv_len += len;
722                         goto done;
723                 }
724
725                 /*
726                  * If the queue doesn't support SG gaps and adding this
727                  * offset would create a gap, disallow it.
728                  */
729                 if (bvec_gap_to_prev(q, bvec, offset))
730                         return 0;
731
732                 if (page_is_mergeable(bvec, page, len, offset, false) &&
733                     can_add_page_to_seg(q, bvec, page, len, offset)) {
734                         bvec->bv_len += len;
735                         goto done;
736                 }
737         }
738
739         if (bio_full(bio))
740                 return 0;
741
742         if (bio->bi_phys_segments >= queue_max_segments(q))
743                 return 0;
744
745         bvec = &bio->bi_io_vec[bio->bi_vcnt];
746         bvec->bv_page = page;
747         bvec->bv_len = len;
748         bvec->bv_offset = offset;
749         bio->bi_vcnt++;
750  done:
751         bio->bi_iter.bi_size += len;
752         bio->bi_phys_segments = bio->bi_vcnt;
753         bio_set_flag(bio, BIO_SEG_VALID);
754         return len;
755 }
756
757 int bio_add_pc_page(struct request_queue *q, struct bio *bio,
758                 struct page *page, unsigned int len, unsigned int offset)
759 {
760         return __bio_add_pc_page(q, bio, page, len, offset, false);
761 }
762 EXPORT_SYMBOL(bio_add_pc_page);
763
764 /**
765  * __bio_try_merge_page - try appending data to an existing bvec.
766  * @bio: destination bio
767  * @page: start page to add
768  * @len: length of the data to add
769  * @off: offset of the data relative to @page
770  * @same_page: if %true only merge if the new data is in the same physical
771  *              page as the last segment of the bio.
772  *
773  * Try to add the data at @page + @off to the last bvec of @bio.  This is a
774  * a useful optimisation for file systems with a block size smaller than the
775  * page size.
776  *
777  * Warn if (@len, @off) crosses pages in case that @same_page is true.
778  *
779  * Return %true on success or %false on failure.
780  */
781 bool __bio_try_merge_page(struct bio *bio, struct page *page,
782                 unsigned int len, unsigned int off, bool same_page)
783 {
784         if (WARN_ON_ONCE(bio_flagged(bio, BIO_CLONED)))
785                 return false;
786
787         if (bio->bi_vcnt > 0) {
788                 struct bio_vec *bv = &bio->bi_io_vec[bio->bi_vcnt - 1];
789
790                 if (page_is_mergeable(bv, page, len, off, same_page)) {
791                         bv->bv_len += len;
792                         bio->bi_iter.bi_size += len;
793                         return true;
794                 }
795         }
796         return false;
797 }
798 EXPORT_SYMBOL_GPL(__bio_try_merge_page);
799
800 /**
801  * __bio_add_page - add page(s) to a bio in a new segment
802  * @bio: destination bio
803  * @page: start page to add
804  * @len: length of the data to add, may cross pages
805  * @off: offset of the data relative to @page, may cross pages
806  *
807  * Add the data at @page + @off to @bio as a new bvec.  The caller must ensure
808  * that @bio has space for another bvec.
809  */
810 void __bio_add_page(struct bio *bio, struct page *page,
811                 unsigned int len, unsigned int off)
812 {
813         struct bio_vec *bv = &bio->bi_io_vec[bio->bi_vcnt];
814
815         WARN_ON_ONCE(bio_flagged(bio, BIO_CLONED));
816         WARN_ON_ONCE(bio_full(bio));
817
818         bv->bv_page = page;
819         bv->bv_offset = off;
820         bv->bv_len = len;
821
822         bio->bi_iter.bi_size += len;
823         bio->bi_vcnt++;
824 }
825 EXPORT_SYMBOL_GPL(__bio_add_page);
826
827 /**
828  *      bio_add_page    -       attempt to add page(s) to bio
829  *      @bio: destination bio
830  *      @page: start page to add
831  *      @len: vec entry length, may cross pages
832  *      @offset: vec entry offset relative to @page, may cross pages
833  *
834  *      Attempt to add page(s) to the bio_vec maplist. This will only fail
835  *      if either bio->bi_vcnt == bio->bi_max_vecs or it's a cloned bio.
836  */
837 int bio_add_page(struct bio *bio, struct page *page,
838                  unsigned int len, unsigned int offset)
839 {
840         if (!__bio_try_merge_page(bio, page, len, offset, false)) {
841                 if (bio_full(bio))
842                         return 0;
843                 __bio_add_page(bio, page, len, offset);
844         }
845         return len;
846 }
847 EXPORT_SYMBOL(bio_add_page);
848
849 static void bio_get_pages(struct bio *bio)
850 {
851         struct bvec_iter_all iter_all;
852         struct bio_vec *bvec;
853
854         bio_for_each_segment_all(bvec, bio, iter_all)
855                 get_page(bvec->bv_page);
856 }
857
858 static void bio_release_pages(struct bio *bio)
859 {
860         struct bvec_iter_all iter_all;
861         struct bio_vec *bvec;
862
863         bio_for_each_segment_all(bvec, bio, iter_all)
864                 put_page(bvec->bv_page);
865 }
866
867 static int __bio_iov_bvec_add_pages(struct bio *bio, struct iov_iter *iter)
868 {
869         const struct bio_vec *bv = iter->bvec;
870         unsigned int len;
871         size_t size;
872
873         if (WARN_ON_ONCE(iter->iov_offset > bv->bv_len))
874                 return -EINVAL;
875
876         len = min_t(size_t, bv->bv_len - iter->iov_offset, iter->count);
877         size = bio_add_page(bio, bv->bv_page, len,
878                                 bv->bv_offset + iter->iov_offset);
879         if (unlikely(size != len))
880                 return -EINVAL;
881         iov_iter_advance(iter, size);
882         return 0;
883 }
884
885 #define PAGE_PTRS_PER_BVEC     (sizeof(struct bio_vec) / sizeof(struct page *))
886
887 /**
888  * __bio_iov_iter_get_pages - pin user or kernel pages and add them to a bio
889  * @bio: bio to add pages to
890  * @iter: iov iterator describing the region to be mapped
891  *
892  * Pins pages from *iter and appends them to @bio's bvec array. The
893  * pages will have to be released using put_page() when done.
894  * For multi-segment *iter, this function only adds pages from the
895  * the next non-empty segment of the iov iterator.
896  */
897 static int __bio_iov_iter_get_pages(struct bio *bio, struct iov_iter *iter)
898 {
899         unsigned short nr_pages = bio->bi_max_vecs - bio->bi_vcnt;
900         unsigned short entries_left = bio->bi_max_vecs - bio->bi_vcnt;
901         struct bio_vec *bv = bio->bi_io_vec + bio->bi_vcnt;
902         struct page **pages = (struct page **)bv;
903         ssize_t size, left;
904         unsigned len, i;
905         size_t offset;
906
907         /*
908          * Move page array up in the allocated memory for the bio vecs as far as
909          * possible so that we can start filling biovecs from the beginning
910          * without overwriting the temporary page array.
911         */
912         BUILD_BUG_ON(PAGE_PTRS_PER_BVEC < 2);
913         pages += entries_left * (PAGE_PTRS_PER_BVEC - 1);
914
915         size = iov_iter_get_pages(iter, pages, LONG_MAX, nr_pages, &offset);
916         if (unlikely(size <= 0))
917                 return size ? size : -EFAULT;
918
919         for (left = size, i = 0; left > 0; left -= len, i++) {
920                 struct page *page = pages[i];
921
922                 len = min_t(size_t, PAGE_SIZE - offset, left);
923                 if (WARN_ON_ONCE(bio_add_page(bio, page, len, offset) != len))
924                         return -EINVAL;
925                 offset = 0;
926         }
927
928         iov_iter_advance(iter, size);
929         return 0;
930 }
931
932 /**
933  * bio_iov_iter_get_pages - add user or kernel pages to a bio
934  * @bio: bio to add pages to
935  * @iter: iov iterator describing the region to be added
936  *
937  * This takes either an iterator pointing to user memory, or one pointing to
938  * kernel pages (BVEC iterator). If we're adding user pages, we pin them and
939  * map them into the kernel. On IO completion, the caller should put those
940  * pages. If we're adding kernel pages, and the caller told us it's safe to
941  * do so, we just have to add the pages to the bio directly. We don't grab an
942  * extra reference to those pages (the user should already have that), and we
943  * don't put the page on IO completion. The caller needs to check if the bio is
944  * flagged BIO_NO_PAGE_REF on IO completion. If it isn't, then pages should be
945  * released.
946  *
947  * The function tries, but does not guarantee, to pin as many pages as
948  * fit into the bio, or are requested in *iter, whatever is smaller. If
949  * MM encounters an error pinning the requested pages, it stops. Error
950  * is returned only if 0 pages could be pinned.
951  */
952 int bio_iov_iter_get_pages(struct bio *bio, struct iov_iter *iter)
953 {
954         const bool is_bvec = iov_iter_is_bvec(iter);
955         int ret;
956
957         if (WARN_ON_ONCE(bio->bi_vcnt))
958                 return -EINVAL;
959
960         do {
961                 if (is_bvec)
962                         ret = __bio_iov_bvec_add_pages(bio, iter);
963                 else
964                         ret = __bio_iov_iter_get_pages(bio, iter);
965         } while (!ret && iov_iter_count(iter) && !bio_full(bio));
966
967         if (iov_iter_bvec_no_ref(iter))
968                 bio_set_flag(bio, BIO_NO_PAGE_REF);
969         else if (is_bvec)
970                 bio_get_pages(bio);
971
972         return bio->bi_vcnt ? 0 : ret;
973 }
974
975 static void submit_bio_wait_endio(struct bio *bio)
976 {
977         complete(bio->bi_private);
978 }
979
980 /**
981  * submit_bio_wait - submit a bio, and wait until it completes
982  * @bio: The &struct bio which describes the I/O
983  *
984  * Simple wrapper around submit_bio(). Returns 0 on success, or the error from
985  * bio_endio() on failure.
986  *
987  * WARNING: Unlike to how submit_bio() is usually used, this function does not
988  * result in bio reference to be consumed. The caller must drop the reference
989  * on his own.
990  */
991 int submit_bio_wait(struct bio *bio)
992 {
993         DECLARE_COMPLETION_ONSTACK_MAP(done, bio->bi_disk->lockdep_map);
994
995         bio->bi_private = &done;
996         bio->bi_end_io = submit_bio_wait_endio;
997         bio->bi_opf |= REQ_SYNC;
998         submit_bio(bio);
999         wait_for_completion_io(&done);
1000
1001         return blk_status_to_errno(bio->bi_status);
1002 }
1003 EXPORT_SYMBOL(submit_bio_wait);
1004
1005 /**
1006  * bio_advance - increment/complete a bio by some number of bytes
1007  * @bio:        bio to advance
1008  * @bytes:      number of bytes to complete
1009  *
1010  * This updates bi_sector, bi_size and bi_idx; if the number of bytes to
1011  * complete doesn't align with a bvec boundary, then bv_len and bv_offset will
1012  * be updated on the last bvec as well.
1013  *
1014  * @bio will then represent the remaining, uncompleted portion of the io.
1015  */
1016 void bio_advance(struct bio *bio, unsigned bytes)
1017 {
1018         if (bio_integrity(bio))
1019                 bio_integrity_advance(bio, bytes);
1020
1021         bio_advance_iter(bio, &bio->bi_iter, bytes);
1022 }
1023 EXPORT_SYMBOL(bio_advance);
1024
1025 void bio_copy_data_iter(struct bio *dst, struct bvec_iter *dst_iter,
1026                         struct bio *src, struct bvec_iter *src_iter)
1027 {
1028         struct bio_vec src_bv, dst_bv;
1029         void *src_p, *dst_p;
1030         unsigned bytes;
1031
1032         while (src_iter->bi_size && dst_iter->bi_size) {
1033                 src_bv = bio_iter_iovec(src, *src_iter);
1034                 dst_bv = bio_iter_iovec(dst, *dst_iter);
1035
1036                 bytes = min(src_bv.bv_len, dst_bv.bv_len);
1037
1038                 src_p = kmap_atomic(src_bv.bv_page);
1039                 dst_p = kmap_atomic(dst_bv.bv_page);
1040
1041                 memcpy(dst_p + dst_bv.bv_offset,
1042                        src_p + src_bv.bv_offset,
1043                        bytes);
1044
1045                 kunmap_atomic(dst_p);
1046                 kunmap_atomic(src_p);
1047
1048                 flush_dcache_page(dst_bv.bv_page);
1049
1050                 bio_advance_iter(src, src_iter, bytes);
1051                 bio_advance_iter(dst, dst_iter, bytes);
1052         }
1053 }
1054 EXPORT_SYMBOL(bio_copy_data_iter);
1055
1056 /**
1057  * bio_copy_data - copy contents of data buffers from one bio to another
1058  * @src: source bio
1059  * @dst: destination bio
1060  *
1061  * Stops when it reaches the end of either @src or @dst - that is, copies
1062  * min(src->bi_size, dst->bi_size) bytes (or the equivalent for lists of bios).
1063  */
1064 void bio_copy_data(struct bio *dst, struct bio *src)
1065 {
1066         struct bvec_iter src_iter = src->bi_iter;
1067         struct bvec_iter dst_iter = dst->bi_iter;
1068
1069         bio_copy_data_iter(dst, &dst_iter, src, &src_iter);
1070 }
1071 EXPORT_SYMBOL(bio_copy_data);
1072
1073 /**
1074  * bio_list_copy_data - copy contents of data buffers from one chain of bios to
1075  * another
1076  * @src: source bio list
1077  * @dst: destination bio list
1078  *
1079  * Stops when it reaches the end of either the @src list or @dst list - that is,
1080  * copies min(src->bi_size, dst->bi_size) bytes (or the equivalent for lists of
1081  * bios).
1082  */
1083 void bio_list_copy_data(struct bio *dst, struct bio *src)
1084 {
1085         struct bvec_iter src_iter = src->bi_iter;
1086         struct bvec_iter dst_iter = dst->bi_iter;
1087
1088         while (1) {
1089                 if (!src_iter.bi_size) {
1090                         src = src->bi_next;
1091                         if (!src)
1092                                 break;
1093
1094                         src_iter = src->bi_iter;
1095                 }
1096
1097                 if (!dst_iter.bi_size) {
1098                         dst = dst->bi_next;
1099                         if (!dst)
1100                                 break;
1101
1102                         dst_iter = dst->bi_iter;
1103                 }
1104
1105                 bio_copy_data_iter(dst, &dst_iter, src, &src_iter);
1106         }
1107 }
1108 EXPORT_SYMBOL(bio_list_copy_data);
1109
1110 struct bio_map_data {
1111         int is_our_pages;
1112         struct iov_iter iter;
1113         struct iovec iov[];
1114 };
1115
1116 static struct bio_map_data *bio_alloc_map_data(struct iov_iter *data,
1117                                                gfp_t gfp_mask)
1118 {
1119         struct bio_map_data *bmd;
1120         if (data->nr_segs > UIO_MAXIOV)
1121                 return NULL;
1122
1123         bmd = kmalloc(sizeof(struct bio_map_data) +
1124                        sizeof(struct iovec) * data->nr_segs, gfp_mask);
1125         if (!bmd)
1126                 return NULL;
1127         memcpy(bmd->iov, data->iov, sizeof(struct iovec) * data->nr_segs);
1128         bmd->iter = *data;
1129         bmd->iter.iov = bmd->iov;
1130         return bmd;
1131 }
1132
1133 /**
1134  * bio_copy_from_iter - copy all pages from iov_iter to bio
1135  * @bio: The &struct bio which describes the I/O as destination
1136  * @iter: iov_iter as source
1137  *
1138  * Copy all pages from iov_iter to bio.
1139  * Returns 0 on success, or error on failure.
1140  */
1141 static int bio_copy_from_iter(struct bio *bio, struct iov_iter *iter)
1142 {
1143         struct bio_vec *bvec;
1144         struct bvec_iter_all iter_all;
1145
1146         bio_for_each_segment_all(bvec, bio, iter_all) {
1147                 ssize_t ret;
1148
1149                 ret = copy_page_from_iter(bvec->bv_page,
1150                                           bvec->bv_offset,
1151                                           bvec->bv_len,
1152                                           iter);
1153
1154                 if (!iov_iter_count(iter))
1155                         break;
1156
1157                 if (ret < bvec->bv_len)
1158                         return -EFAULT;
1159         }
1160
1161         return 0;
1162 }
1163
1164 /**
1165  * bio_copy_to_iter - copy all pages from bio to iov_iter
1166  * @bio: The &struct bio which describes the I/O as source
1167  * @iter: iov_iter as destination
1168  *
1169  * Copy all pages from bio to iov_iter.
1170  * Returns 0 on success, or error on failure.
1171  */
1172 static int bio_copy_to_iter(struct bio *bio, struct iov_iter iter)
1173 {
1174         struct bio_vec *bvec;
1175         struct bvec_iter_all iter_all;
1176
1177         bio_for_each_segment_all(bvec, bio, iter_all) {
1178                 ssize_t ret;
1179
1180                 ret = copy_page_to_iter(bvec->bv_page,
1181                                         bvec->bv_offset,
1182                                         bvec->bv_len,
1183                                         &iter);
1184
1185                 if (!iov_iter_count(&iter))
1186                         break;
1187
1188                 if (ret < bvec->bv_len)
1189                         return -EFAULT;
1190         }
1191
1192         return 0;
1193 }
1194
1195 void bio_free_pages(struct bio *bio)
1196 {
1197         struct bio_vec *bvec;
1198         struct bvec_iter_all iter_all;
1199
1200         bio_for_each_segment_all(bvec, bio, iter_all)
1201                 __free_page(bvec->bv_page);
1202 }
1203 EXPORT_SYMBOL(bio_free_pages);
1204
1205 /**
1206  *      bio_uncopy_user -       finish previously mapped bio
1207  *      @bio: bio being terminated
1208  *
1209  *      Free pages allocated from bio_copy_user_iov() and write back data
1210  *      to user space in case of a read.
1211  */
1212 int bio_uncopy_user(struct bio *bio)
1213 {
1214         struct bio_map_data *bmd = bio->bi_private;
1215         int ret = 0;
1216
1217         if (!bio_flagged(bio, BIO_NULL_MAPPED)) {
1218                 /*
1219                  * if we're in a workqueue, the request is orphaned, so
1220                  * don't copy into a random user address space, just free
1221                  * and return -EINTR so user space doesn't expect any data.
1222                  */
1223                 if (!current->mm)
1224                         ret = -EINTR;
1225                 else if (bio_data_dir(bio) == READ)
1226                         ret = bio_copy_to_iter(bio, bmd->iter);
1227                 if (bmd->is_our_pages)
1228                         bio_free_pages(bio);
1229         }
1230         kfree(bmd);
1231         bio_put(bio);
1232         return ret;
1233 }
1234
1235 /**
1236  *      bio_copy_user_iov       -       copy user data to bio
1237  *      @q:             destination block queue
1238  *      @map_data:      pointer to the rq_map_data holding pages (if necessary)
1239  *      @iter:          iovec iterator
1240  *      @gfp_mask:      memory allocation flags
1241  *
1242  *      Prepares and returns a bio for indirect user io, bouncing data
1243  *      to/from kernel pages as necessary. Must be paired with
1244  *      call bio_uncopy_user() on io completion.
1245  */
1246 struct bio *bio_copy_user_iov(struct request_queue *q,
1247                               struct rq_map_data *map_data,
1248                               struct iov_iter *iter,
1249                               gfp_t gfp_mask)
1250 {
1251         struct bio_map_data *bmd;
1252         struct page *page;
1253         struct bio *bio;
1254         int i = 0, ret;
1255         int nr_pages;
1256         unsigned int len = iter->count;
1257         unsigned int offset = map_data ? offset_in_page(map_data->offset) : 0;
1258
1259         bmd = bio_alloc_map_data(iter, gfp_mask);
1260         if (!bmd)
1261                 return ERR_PTR(-ENOMEM);
1262
1263         /*
1264          * We need to do a deep copy of the iov_iter including the iovecs.
1265          * The caller provided iov might point to an on-stack or otherwise
1266          * shortlived one.
1267          */
1268         bmd->is_our_pages = map_data ? 0 : 1;
1269
1270         nr_pages = DIV_ROUND_UP(offset + len, PAGE_SIZE);
1271         if (nr_pages > BIO_MAX_PAGES)
1272                 nr_pages = BIO_MAX_PAGES;
1273
1274         ret = -ENOMEM;
1275         bio = bio_kmalloc(gfp_mask, nr_pages);
1276         if (!bio)
1277                 goto out_bmd;
1278
1279         ret = 0;
1280
1281         if (map_data) {
1282                 nr_pages = 1 << map_data->page_order;
1283                 i = map_data->offset / PAGE_SIZE;
1284         }
1285         while (len) {
1286                 unsigned int bytes = PAGE_SIZE;
1287
1288                 bytes -= offset;
1289
1290                 if (bytes > len)
1291                         bytes = len;
1292
1293                 if (map_data) {
1294                         if (i == map_data->nr_entries * nr_pages) {
1295                                 ret = -ENOMEM;
1296                                 break;
1297                         }
1298
1299                         page = map_data->pages[i / nr_pages];
1300                         page += (i % nr_pages);
1301
1302                         i++;
1303                 } else {
1304                         page = alloc_page(q->bounce_gfp | gfp_mask);
1305                         if (!page) {
1306                                 ret = -ENOMEM;
1307                                 break;
1308                         }
1309                 }
1310
1311                 if (bio_add_pc_page(q, bio, page, bytes, offset) < bytes) {
1312                         if (!map_data)
1313                                 __free_page(page);
1314                         break;
1315                 }
1316
1317                 len -= bytes;
1318                 offset = 0;
1319         }
1320
1321         if (ret)
1322                 goto cleanup;
1323
1324         if (map_data)
1325                 map_data->offset += bio->bi_iter.bi_size;
1326
1327         /*
1328          * success
1329          */
1330         if ((iov_iter_rw(iter) == WRITE && (!map_data || !map_data->null_mapped)) ||
1331             (map_data && map_data->from_user)) {
1332                 ret = bio_copy_from_iter(bio, iter);
1333                 if (ret)
1334                         goto cleanup;
1335         } else {
1336                 if (bmd->is_our_pages)
1337                         zero_fill_bio(bio);
1338                 iov_iter_advance(iter, bio->bi_iter.bi_size);
1339         }
1340
1341         bio->bi_private = bmd;
1342         if (map_data && map_data->null_mapped)
1343                 bio_set_flag(bio, BIO_NULL_MAPPED);
1344         return bio;
1345 cleanup:
1346         if (!map_data)
1347                 bio_free_pages(bio);
1348         bio_put(bio);
1349 out_bmd:
1350         kfree(bmd);
1351         return ERR_PTR(ret);
1352 }
1353
1354 /**
1355  *      bio_map_user_iov - map user iovec into bio
1356  *      @q:             the struct request_queue for the bio
1357  *      @iter:          iovec iterator
1358  *      @gfp_mask:      memory allocation flags
1359  *
1360  *      Map the user space address into a bio suitable for io to a block
1361  *      device. Returns an error pointer in case of error.
1362  */
1363 struct bio *bio_map_user_iov(struct request_queue *q,
1364                              struct iov_iter *iter,
1365                              gfp_t gfp_mask)
1366 {
1367         int j;
1368         struct bio *bio;
1369         int ret;
1370         struct bio_vec *bvec;
1371         struct bvec_iter_all iter_all;
1372
1373         if (!iov_iter_count(iter))
1374                 return ERR_PTR(-EINVAL);
1375
1376         bio = bio_kmalloc(gfp_mask, iov_iter_npages(iter, BIO_MAX_PAGES));
1377         if (!bio)
1378                 return ERR_PTR(-ENOMEM);
1379
1380         while (iov_iter_count(iter)) {
1381                 struct page **pages;
1382                 ssize_t bytes;
1383                 size_t offs, added = 0;
1384                 int npages;
1385
1386                 bytes = iov_iter_get_pages_alloc(iter, &pages, LONG_MAX, &offs);
1387                 if (unlikely(bytes <= 0)) {
1388                         ret = bytes ? bytes : -EFAULT;
1389                         goto out_unmap;
1390                 }
1391
1392                 npages = DIV_ROUND_UP(offs + bytes, PAGE_SIZE);
1393
1394                 if (unlikely(offs & queue_dma_alignment(q))) {
1395                         ret = -EINVAL;
1396                         j = 0;
1397                 } else {
1398                         for (j = 0; j < npages; j++) {
1399                                 struct page *page = pages[j];
1400                                 unsigned int n = PAGE_SIZE - offs;
1401
1402                                 if (n > bytes)
1403                                         n = bytes;
1404
1405                                 if (!__bio_add_pc_page(q, bio, page, n, offs,
1406                                                         true))
1407                                         break;
1408
1409                                 added += n;
1410                                 bytes -= n;
1411                                 offs = 0;
1412                         }
1413                         iov_iter_advance(iter, added);
1414                 }
1415                 /*
1416                  * release the pages we didn't map into the bio, if any
1417                  */
1418                 while (j < npages)
1419                         put_page(pages[j++]);
1420                 kvfree(pages);
1421                 /* couldn't stuff something into bio? */
1422                 if (bytes)
1423                         break;
1424         }
1425
1426         bio_set_flag(bio, BIO_USER_MAPPED);
1427
1428         /*
1429          * subtle -- if bio_map_user_iov() ended up bouncing a bio,
1430          * it would normally disappear when its bi_end_io is run.
1431          * however, we need it for the unmap, so grab an extra
1432          * reference to it
1433          */
1434         bio_get(bio);
1435         return bio;
1436
1437  out_unmap:
1438         bio_for_each_segment_all(bvec, bio, iter_all) {
1439                 put_page(bvec->bv_page);
1440         }
1441         bio_put(bio);
1442         return ERR_PTR(ret);
1443 }
1444
1445 static void __bio_unmap_user(struct bio *bio)
1446 {
1447         struct bio_vec *bvec;
1448         struct bvec_iter_all iter_all;
1449
1450         /*
1451          * make sure we dirty pages we wrote to
1452          */
1453         bio_for_each_segment_all(bvec, bio, iter_all) {
1454                 if (bio_data_dir(bio) == READ)
1455                         set_page_dirty_lock(bvec->bv_page);
1456
1457                 put_page(bvec->bv_page);
1458         }
1459
1460         bio_put(bio);
1461 }
1462
1463 /**
1464  *      bio_unmap_user  -       unmap a bio
1465  *      @bio:           the bio being unmapped
1466  *
1467  *      Unmap a bio previously mapped by bio_map_user_iov(). Must be called from
1468  *      process context.
1469  *
1470  *      bio_unmap_user() may sleep.
1471  */
1472 void bio_unmap_user(struct bio *bio)
1473 {
1474         __bio_unmap_user(bio);
1475         bio_put(bio);
1476 }
1477
1478 static void bio_map_kern_endio(struct bio *bio)
1479 {
1480         bio_put(bio);
1481 }
1482
1483 /**
1484  *      bio_map_kern    -       map kernel address into bio
1485  *      @q: the struct request_queue for the bio
1486  *      @data: pointer to buffer to map
1487  *      @len: length in bytes
1488  *      @gfp_mask: allocation flags for bio allocation
1489  *
1490  *      Map the kernel address into a bio suitable for io to a block
1491  *      device. Returns an error pointer in case of error.
1492  */
1493 struct bio *bio_map_kern(struct request_queue *q, void *data, unsigned int len,
1494                          gfp_t gfp_mask)
1495 {
1496         unsigned long kaddr = (unsigned long)data;
1497         unsigned long end = (kaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
1498         unsigned long start = kaddr >> PAGE_SHIFT;
1499         const int nr_pages = end - start;
1500         int offset, i;
1501         struct bio *bio;
1502
1503         bio = bio_kmalloc(gfp_mask, nr_pages);
1504         if (!bio)
1505                 return ERR_PTR(-ENOMEM);
1506
1507         offset = offset_in_page(kaddr);
1508         for (i = 0; i < nr_pages; i++) {
1509                 unsigned int bytes = PAGE_SIZE - offset;
1510
1511                 if (len <= 0)
1512                         break;
1513
1514                 if (bytes > len)
1515                         bytes = len;
1516
1517                 if (bio_add_pc_page(q, bio, virt_to_page(data), bytes,
1518                                     offset) < bytes) {
1519                         /* we don't support partial mappings */
1520                         bio_put(bio);
1521                         return ERR_PTR(-EINVAL);
1522                 }
1523
1524                 data += bytes;
1525                 len -= bytes;
1526                 offset = 0;
1527         }
1528
1529         bio->bi_end_io = bio_map_kern_endio;
1530         return bio;
1531 }
1532 EXPORT_SYMBOL(bio_map_kern);
1533
1534 static void bio_copy_kern_endio(struct bio *bio)
1535 {
1536         bio_free_pages(bio);
1537         bio_put(bio);
1538 }
1539
1540 static void bio_copy_kern_endio_read(struct bio *bio)
1541 {
1542         char *p = bio->bi_private;
1543         struct bio_vec *bvec;
1544         struct bvec_iter_all iter_all;
1545
1546         bio_for_each_segment_all(bvec, bio, iter_all) {
1547                 memcpy(p, page_address(bvec->bv_page), bvec->bv_len);
1548                 p += bvec->bv_len;
1549         }
1550
1551         bio_copy_kern_endio(bio);
1552 }
1553
1554 /**
1555  *      bio_copy_kern   -       copy kernel address into bio
1556  *      @q: the struct request_queue for the bio
1557  *      @data: pointer to buffer to copy
1558  *      @len: length in bytes
1559  *      @gfp_mask: allocation flags for bio and page allocation
1560  *      @reading: data direction is READ
1561  *
1562  *      copy the kernel address into a bio suitable for io to a block
1563  *      device. Returns an error pointer in case of error.
1564  */
1565 struct bio *bio_copy_kern(struct request_queue *q, void *data, unsigned int len,
1566                           gfp_t gfp_mask, int reading)
1567 {
1568         unsigned long kaddr = (unsigned long)data;
1569         unsigned long end = (kaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
1570         unsigned long start = kaddr >> PAGE_SHIFT;
1571         struct bio *bio;
1572         void *p = data;
1573         int nr_pages = 0;
1574
1575         /*
1576          * Overflow, abort
1577          */
1578         if (end < start)
1579                 return ERR_PTR(-EINVAL);
1580
1581         nr_pages = end - start;
1582         bio = bio_kmalloc(gfp_mask, nr_pages);
1583         if (!bio)
1584                 return ERR_PTR(-ENOMEM);
1585
1586         while (len) {
1587                 struct page *page;
1588                 unsigned int bytes = PAGE_SIZE;
1589
1590                 if (bytes > len)
1591                         bytes = len;
1592
1593                 page = alloc_page(q->bounce_gfp | gfp_mask);
1594                 if (!page)
1595                         goto cleanup;
1596
1597                 if (!reading)
1598                         memcpy(page_address(page), p, bytes);
1599
1600                 if (bio_add_pc_page(q, bio, page, bytes, 0) < bytes)
1601                         break;
1602
1603                 len -= bytes;
1604                 p += bytes;
1605         }
1606
1607         if (reading) {
1608                 bio->bi_end_io = bio_copy_kern_endio_read;
1609                 bio->bi_private = data;
1610         } else {
1611                 bio->bi_end_io = bio_copy_kern_endio;
1612         }
1613
1614         return bio;
1615
1616 cleanup:
1617         bio_free_pages(bio);
1618         bio_put(bio);
1619         return ERR_PTR(-ENOMEM);
1620 }
1621
1622 /*
1623  * bio_set_pages_dirty() and bio_check_pages_dirty() are support functions
1624  * for performing direct-IO in BIOs.
1625  *
1626  * The problem is that we cannot run set_page_dirty() from interrupt context
1627  * because the required locks are not interrupt-safe.  So what we can do is to
1628  * mark the pages dirty _before_ performing IO.  And in interrupt context,
1629  * check that the pages are still dirty.   If so, fine.  If not, redirty them
1630  * in process context.
1631  *
1632  * We special-case compound pages here: normally this means reads into hugetlb
1633  * pages.  The logic in here doesn't really work right for compound pages
1634  * because the VM does not uniformly chase down the head page in all cases.
1635  * But dirtiness of compound pages is pretty meaningless anyway: the VM doesn't
1636  * handle them at all.  So we skip compound pages here at an early stage.
1637  *
1638  * Note that this code is very hard to test under normal circumstances because
1639  * direct-io pins the pages with get_user_pages().  This makes
1640  * is_page_cache_freeable return false, and the VM will not clean the pages.
1641  * But other code (eg, flusher threads) could clean the pages if they are mapped
1642  * pagecache.
1643  *
1644  * Simply disabling the call to bio_set_pages_dirty() is a good way to test the
1645  * deferred bio dirtying paths.
1646  */
1647
1648 /*
1649  * bio_set_pages_dirty() will mark all the bio's pages as dirty.
1650  */
1651 void bio_set_pages_dirty(struct bio *bio)
1652 {
1653         struct bio_vec *bvec;
1654         struct bvec_iter_all iter_all;
1655
1656         bio_for_each_segment_all(bvec, bio, iter_all) {
1657                 if (!PageCompound(bvec->bv_page))
1658                         set_page_dirty_lock(bvec->bv_page);
1659         }
1660 }
1661
1662 /*
1663  * bio_check_pages_dirty() will check that all the BIO's pages are still dirty.
1664  * If they are, then fine.  If, however, some pages are clean then they must
1665  * have been written out during the direct-IO read.  So we take another ref on
1666  * the BIO and re-dirty the pages in process context.
1667  *
1668  * It is expected that bio_check_pages_dirty() will wholly own the BIO from
1669  * here on.  It will run one put_page() against each page and will run one
1670  * bio_put() against the BIO.
1671  */
1672
1673 static void bio_dirty_fn(struct work_struct *work);
1674
1675 static DECLARE_WORK(bio_dirty_work, bio_dirty_fn);
1676 static DEFINE_SPINLOCK(bio_dirty_lock);
1677 static struct bio *bio_dirty_list;
1678
1679 /*
1680  * This runs in process context
1681  */
1682 static void bio_dirty_fn(struct work_struct *work)
1683 {
1684         struct bio *bio, *next;
1685
1686         spin_lock_irq(&bio_dirty_lock);
1687         next = bio_dirty_list;
1688         bio_dirty_list = NULL;
1689         spin_unlock_irq(&bio_dirty_lock);
1690
1691         while ((bio = next) != NULL) {
1692                 next = bio->bi_private;
1693
1694                 bio_set_pages_dirty(bio);
1695                 if (!bio_flagged(bio, BIO_NO_PAGE_REF))
1696                         bio_release_pages(bio);
1697                 bio_put(bio);
1698         }
1699 }
1700
1701 void bio_check_pages_dirty(struct bio *bio)
1702 {
1703         struct bio_vec *bvec;
1704         unsigned long flags;
1705         struct bvec_iter_all iter_all;
1706
1707         bio_for_each_segment_all(bvec, bio, iter_all) {
1708                 if (!PageDirty(bvec->bv_page) && !PageCompound(bvec->bv_page))
1709                         goto defer;
1710         }
1711
1712         if (!bio_flagged(bio, BIO_NO_PAGE_REF))
1713                 bio_release_pages(bio);
1714         bio_put(bio);
1715         return;
1716 defer:
1717         spin_lock_irqsave(&bio_dirty_lock, flags);
1718         bio->bi_private = bio_dirty_list;
1719         bio_dirty_list = bio;
1720         spin_unlock_irqrestore(&bio_dirty_lock, flags);
1721         schedule_work(&bio_dirty_work);
1722 }
1723
1724 void update_io_ticks(struct hd_struct *part, unsigned long now)
1725 {
1726         unsigned long stamp;
1727 again:
1728         stamp = READ_ONCE(part->stamp);
1729         if (unlikely(stamp != now)) {
1730                 if (likely(cmpxchg(&part->stamp, stamp, now) == stamp)) {
1731                         __part_stat_add(part, io_ticks, 1);
1732                 }
1733         }
1734         if (part->partno) {
1735                 part = &part_to_disk(part)->part0;
1736                 goto again;
1737         }
1738 }
1739
1740 void generic_start_io_acct(struct request_queue *q, int op,
1741                            unsigned long sectors, struct hd_struct *part)
1742 {
1743         const int sgrp = op_stat_group(op);
1744
1745         part_stat_lock();
1746
1747         update_io_ticks(part, jiffies);
1748         part_stat_inc(part, ios[sgrp]);
1749         part_stat_add(part, sectors[sgrp], sectors);
1750         part_inc_in_flight(q, part, op_is_write(op));
1751
1752         part_stat_unlock();
1753 }
1754 EXPORT_SYMBOL(generic_start_io_acct);
1755
1756 void generic_end_io_acct(struct request_queue *q, int req_op,
1757                          struct hd_struct *part, unsigned long start_time)
1758 {
1759         unsigned long now = jiffies;
1760         unsigned long duration = now - start_time;
1761         const int sgrp = op_stat_group(req_op);
1762
1763         part_stat_lock();
1764
1765         update_io_ticks(part, now);
1766         part_stat_add(part, nsecs[sgrp], jiffies_to_nsecs(duration));
1767         part_stat_add(part, time_in_queue, duration);
1768         part_dec_in_flight(q, part, op_is_write(req_op));
1769
1770         part_stat_unlock();
1771 }
1772 EXPORT_SYMBOL(generic_end_io_acct);
1773
1774 #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
1775 void bio_flush_dcache_pages(struct bio *bi)
1776 {
1777         struct bio_vec bvec;
1778         struct bvec_iter iter;
1779
1780         bio_for_each_segment(bvec, bi, iter)
1781                 flush_dcache_page(bvec.bv_page);
1782 }
1783 EXPORT_SYMBOL(bio_flush_dcache_pages);
1784 #endif
1785
1786 static inline bool bio_remaining_done(struct bio *bio)
1787 {
1788         /*
1789          * If we're not chaining, then ->__bi_remaining is always 1 and
1790          * we always end io on the first invocation.
1791          */
1792         if (!bio_flagged(bio, BIO_CHAIN))
1793                 return true;
1794
1795         BUG_ON(atomic_read(&bio->__bi_remaining) <= 0);
1796
1797         if (atomic_dec_and_test(&bio->__bi_remaining)) {
1798                 bio_clear_flag(bio, BIO_CHAIN);
1799                 return true;
1800         }
1801
1802         return false;
1803 }
1804
1805 /**
1806  * bio_endio - end I/O on a bio
1807  * @bio:        bio
1808  *
1809  * Description:
1810  *   bio_endio() will end I/O on the whole bio. bio_endio() is the preferred
1811  *   way to end I/O on a bio. No one should call bi_end_io() directly on a
1812  *   bio unless they own it and thus know that it has an end_io function.
1813  *
1814  *   bio_endio() can be called several times on a bio that has been chained
1815  *   using bio_chain().  The ->bi_end_io() function will only be called the
1816  *   last time.  At this point the BLK_TA_COMPLETE tracing event will be
1817  *   generated if BIO_TRACE_COMPLETION is set.
1818  **/
1819 void bio_endio(struct bio *bio)
1820 {
1821 again:
1822         if (!bio_remaining_done(bio))
1823                 return;
1824         if (!bio_integrity_endio(bio))
1825                 return;
1826
1827         if (bio->bi_disk)
1828                 rq_qos_done_bio(bio->bi_disk->queue, bio);
1829
1830         /*
1831          * Need to have a real endio function for chained bios, otherwise
1832          * various corner cases will break (like stacking block devices that
1833          * save/restore bi_end_io) - however, we want to avoid unbounded
1834          * recursion and blowing the stack. Tail call optimization would
1835          * handle this, but compiling with frame pointers also disables
1836          * gcc's sibling call optimization.
1837          */
1838         if (bio->bi_end_io == bio_chain_endio) {
1839                 bio = __bio_chain_endio(bio);
1840                 goto again;
1841         }
1842
1843         if (bio->bi_disk && bio_flagged(bio, BIO_TRACE_COMPLETION)) {
1844                 trace_block_bio_complete(bio->bi_disk->queue, bio,
1845                                          blk_status_to_errno(bio->bi_status));
1846                 bio_clear_flag(bio, BIO_TRACE_COMPLETION);
1847         }
1848
1849         blk_throtl_bio_endio(bio);
1850         /* release cgroup info */
1851         bio_uninit(bio);
1852         if (bio->bi_end_io)
1853                 bio->bi_end_io(bio);
1854 }
1855 EXPORT_SYMBOL(bio_endio);
1856
1857 /**
1858  * bio_split - split a bio
1859  * @bio:        bio to split
1860  * @sectors:    number of sectors to split from the front of @bio
1861  * @gfp:        gfp mask
1862  * @bs:         bio set to allocate from
1863  *
1864  * Allocates and returns a new bio which represents @sectors from the start of
1865  * @bio, and updates @bio to represent the remaining sectors.
1866  *
1867  * Unless this is a discard request the newly allocated bio will point
1868  * to @bio's bi_io_vec; it is the caller's responsibility to ensure that
1869  * @bio is not freed before the split.
1870  */
1871 struct bio *bio_split(struct bio *bio, int sectors,
1872                       gfp_t gfp, struct bio_set *bs)
1873 {
1874         struct bio *split;
1875
1876         BUG_ON(sectors <= 0);
1877         BUG_ON(sectors >= bio_sectors(bio));
1878
1879         split = bio_clone_fast(bio, gfp, bs);
1880         if (!split)
1881                 return NULL;
1882
1883         split->bi_iter.bi_size = sectors << 9;
1884
1885         if (bio_integrity(split))
1886                 bio_integrity_trim(split);
1887
1888         bio_advance(bio, split->bi_iter.bi_size);
1889
1890         if (bio_flagged(bio, BIO_TRACE_COMPLETION))
1891                 bio_set_flag(split, BIO_TRACE_COMPLETION);
1892
1893         return split;
1894 }
1895 EXPORT_SYMBOL(bio_split);
1896
1897 /**
1898  * bio_trim - trim a bio
1899  * @bio:        bio to trim
1900  * @offset:     number of sectors to trim from the front of @bio
1901  * @size:       size we want to trim @bio to, in sectors
1902  */
1903 void bio_trim(struct bio *bio, int offset, int size)
1904 {
1905         /* 'bio' is a cloned bio which we need to trim to match
1906          * the given offset and size.
1907          */
1908
1909         size <<= 9;
1910         if (offset == 0 && size == bio->bi_iter.bi_size)
1911                 return;
1912
1913         bio_clear_flag(bio, BIO_SEG_VALID);
1914
1915         bio_advance(bio, offset << 9);
1916
1917         bio->bi_iter.bi_size = size;
1918
1919         if (bio_integrity(bio))
1920                 bio_integrity_trim(bio);
1921
1922 }
1923 EXPORT_SYMBOL_GPL(bio_trim);
1924
1925 /*
1926  * create memory pools for biovec's in a bio_set.
1927  * use the global biovec slabs created for general use.
1928  */
1929 int biovec_init_pool(mempool_t *pool, int pool_entries)
1930 {
1931         struct biovec_slab *bp = bvec_slabs + BVEC_POOL_MAX;
1932
1933         return mempool_init_slab_pool(pool, pool_entries, bp->slab);
1934 }
1935
1936 /*
1937  * bioset_exit - exit a bioset initialized with bioset_init()
1938  *
1939  * May be called on a zeroed but uninitialized bioset (i.e. allocated with
1940  * kzalloc()).
1941  */
1942 void bioset_exit(struct bio_set *bs)
1943 {
1944         if (bs->rescue_workqueue)
1945                 destroy_workqueue(bs->rescue_workqueue);
1946         bs->rescue_workqueue = NULL;
1947
1948         mempool_exit(&bs->bio_pool);
1949         mempool_exit(&bs->bvec_pool);
1950
1951         bioset_integrity_free(bs);
1952         if (bs->bio_slab)
1953                 bio_put_slab(bs);
1954         bs->bio_slab = NULL;
1955 }
1956 EXPORT_SYMBOL(bioset_exit);
1957
1958 /**
1959  * bioset_init - Initialize a bio_set
1960  * @bs:         pool to initialize
1961  * @pool_size:  Number of bio and bio_vecs to cache in the mempool
1962  * @front_pad:  Number of bytes to allocate in front of the returned bio
1963  * @flags:      Flags to modify behavior, currently %BIOSET_NEED_BVECS
1964  *              and %BIOSET_NEED_RESCUER
1965  *
1966  * Description:
1967  *    Set up a bio_set to be used with @bio_alloc_bioset. Allows the caller
1968  *    to ask for a number of bytes to be allocated in front of the bio.
1969  *    Front pad allocation is useful for embedding the bio inside
1970  *    another structure, to avoid allocating extra data to go with the bio.
1971  *    Note that the bio must be embedded at the END of that structure always,
1972  *    or things will break badly.
1973  *    If %BIOSET_NEED_BVECS is set in @flags, a separate pool will be allocated
1974  *    for allocating iovecs.  This pool is not needed e.g. for bio_clone_fast().
1975  *    If %BIOSET_NEED_RESCUER is set, a workqueue is created which can be used to
1976  *    dispatch queued requests when the mempool runs out of space.
1977  *
1978  */
1979 int bioset_init(struct bio_set *bs,
1980                 unsigned int pool_size,
1981                 unsigned int front_pad,
1982                 int flags)
1983 {
1984         unsigned int back_pad = BIO_INLINE_VECS * sizeof(struct bio_vec);
1985
1986         bs->front_pad = front_pad;
1987
1988         spin_lock_init(&bs->rescue_lock);
1989         bio_list_init(&bs->rescue_list);
1990         INIT_WORK(&bs->rescue_work, bio_alloc_rescue);
1991
1992         bs->bio_slab = bio_find_or_create_slab(front_pad + back_pad);
1993         if (!bs->bio_slab)
1994                 return -ENOMEM;
1995
1996         if (mempool_init_slab_pool(&bs->bio_pool, pool_size, bs->bio_slab))
1997                 goto bad;
1998
1999         if ((flags & BIOSET_NEED_BVECS) &&
2000             biovec_init_pool(&bs->bvec_pool, pool_size))
2001                 goto bad;
2002
2003         if (!(flags & BIOSET_NEED_RESCUER))
2004                 return 0;
2005
2006         bs->rescue_workqueue = alloc_workqueue("bioset", WQ_MEM_RECLAIM, 0);
2007         if (!bs->rescue_workqueue)
2008                 goto bad;
2009
2010         return 0;
2011 bad:
2012         bioset_exit(bs);
2013         return -ENOMEM;
2014 }
2015 EXPORT_SYMBOL(bioset_init);
2016
2017 /*
2018  * Initialize and setup a new bio_set, based on the settings from
2019  * another bio_set.
2020  */
2021 int bioset_init_from_src(struct bio_set *bs, struct bio_set *src)
2022 {
2023         int flags;
2024
2025         flags = 0;
2026         if (src->bvec_pool.min_nr)
2027                 flags |= BIOSET_NEED_BVECS;
2028         if (src->rescue_workqueue)
2029                 flags |= BIOSET_NEED_RESCUER;
2030
2031         return bioset_init(bs, src->bio_pool.min_nr, src->front_pad, flags);
2032 }
2033 EXPORT_SYMBOL(bioset_init_from_src);
2034
2035 #ifdef CONFIG_BLK_CGROUP
2036
2037 /**
2038  * bio_disassociate_blkg - puts back the blkg reference if associated
2039  * @bio: target bio
2040  *
2041  * Helper to disassociate the blkg from @bio if a blkg is associated.
2042  */
2043 void bio_disassociate_blkg(struct bio *bio)
2044 {
2045         if (bio->bi_blkg) {
2046                 blkg_put(bio->bi_blkg);
2047                 bio->bi_blkg = NULL;
2048         }
2049 }
2050 EXPORT_SYMBOL_GPL(bio_disassociate_blkg);
2051
2052 /**
2053  * __bio_associate_blkg - associate a bio with the a blkg
2054  * @bio: target bio
2055  * @blkg: the blkg to associate
2056  *
2057  * This tries to associate @bio with the specified @blkg.  Association failure
2058  * is handled by walking up the blkg tree.  Therefore, the blkg associated can
2059  * be anything between @blkg and the root_blkg.  This situation only happens
2060  * when a cgroup is dying and then the remaining bios will spill to the closest
2061  * alive blkg.
2062  *
2063  * A reference will be taken on the @blkg and will be released when @bio is
2064  * freed.
2065  */
2066 static void __bio_associate_blkg(struct bio *bio, struct blkcg_gq *blkg)
2067 {
2068         bio_disassociate_blkg(bio);
2069
2070         bio->bi_blkg = blkg_tryget_closest(blkg);
2071 }
2072
2073 /**
2074  * bio_associate_blkg_from_css - associate a bio with a specified css
2075  * @bio: target bio
2076  * @css: target css
2077  *
2078  * Associate @bio with the blkg found by combining the css's blkg and the
2079  * request_queue of the @bio.  This falls back to the queue's root_blkg if
2080  * the association fails with the css.
2081  */
2082 void bio_associate_blkg_from_css(struct bio *bio,
2083                                  struct cgroup_subsys_state *css)
2084 {
2085         struct request_queue *q = bio->bi_disk->queue;
2086         struct blkcg_gq *blkg;
2087
2088         rcu_read_lock();
2089
2090         if (!css || !css->parent)
2091                 blkg = q->root_blkg;
2092         else
2093                 blkg = blkg_lookup_create(css_to_blkcg(css), q);
2094
2095         __bio_associate_blkg(bio, blkg);
2096
2097         rcu_read_unlock();
2098 }
2099 EXPORT_SYMBOL_GPL(bio_associate_blkg_from_css);
2100
2101 #ifdef CONFIG_MEMCG
2102 /**
2103  * bio_associate_blkg_from_page - associate a bio with the page's blkg
2104  * @bio: target bio
2105  * @page: the page to lookup the blkcg from
2106  *
2107  * Associate @bio with the blkg from @page's owning memcg and the respective
2108  * request_queue.  If cgroup_e_css returns %NULL, fall back to the queue's
2109  * root_blkg.
2110  */
2111 void bio_associate_blkg_from_page(struct bio *bio, struct page *page)
2112 {
2113         struct cgroup_subsys_state *css;
2114
2115         if (!page->mem_cgroup)
2116                 return;
2117
2118         rcu_read_lock();
2119
2120         css = cgroup_e_css(page->mem_cgroup->css.cgroup, &io_cgrp_subsys);
2121         bio_associate_blkg_from_css(bio, css);
2122
2123         rcu_read_unlock();
2124 }
2125 #endif /* CONFIG_MEMCG */
2126
2127 /**
2128  * bio_associate_blkg - associate a bio with a blkg
2129  * @bio: target bio
2130  *
2131  * Associate @bio with the blkg found from the bio's css and request_queue.
2132  * If one is not found, bio_lookup_blkg() creates the blkg.  If a blkg is
2133  * already associated, the css is reused and association redone as the
2134  * request_queue may have changed.
2135  */
2136 void bio_associate_blkg(struct bio *bio)
2137 {
2138         struct cgroup_subsys_state *css;
2139
2140         rcu_read_lock();
2141
2142         if (bio->bi_blkg)
2143                 css = &bio_blkcg(bio)->css;
2144         else
2145                 css = blkcg_css();
2146
2147         bio_associate_blkg_from_css(bio, css);
2148
2149         rcu_read_unlock();
2150 }
2151 EXPORT_SYMBOL_GPL(bio_associate_blkg);
2152
2153 /**
2154  * bio_clone_blkg_association - clone blkg association from src to dst bio
2155  * @dst: destination bio
2156  * @src: source bio
2157  */
2158 void bio_clone_blkg_association(struct bio *dst, struct bio *src)
2159 {
2160         rcu_read_lock();
2161
2162         if (src->bi_blkg)
2163                 __bio_associate_blkg(dst, src->bi_blkg);
2164
2165         rcu_read_unlock();
2166 }
2167 EXPORT_SYMBOL_GPL(bio_clone_blkg_association);
2168 #endif /* CONFIG_BLK_CGROUP */
2169
2170 static void __init biovec_init_slabs(void)
2171 {
2172         int i;
2173
2174         for (i = 0; i < BVEC_POOL_NR; i++) {
2175                 int size;
2176                 struct biovec_slab *bvs = bvec_slabs + i;
2177
2178                 if (bvs->nr_vecs <= BIO_INLINE_VECS) {
2179                         bvs->slab = NULL;
2180                         continue;
2181                 }
2182
2183                 size = bvs->nr_vecs * sizeof(struct bio_vec);
2184                 bvs->slab = kmem_cache_create(bvs->name, size, 0,
2185                                 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
2186         }
2187 }
2188
2189 static int __init init_bio(void)
2190 {
2191         bio_slab_max = 2;
2192         bio_slab_nr = 0;
2193         bio_slabs = kcalloc(bio_slab_max, sizeof(struct bio_slab),
2194                             GFP_KERNEL);
2195
2196         BUILD_BUG_ON(BIO_FLAG_LAST > BVEC_POOL_OFFSET);
2197
2198         if (!bio_slabs)
2199                 panic("bio: can't allocate bios\n");
2200
2201         bio_integrity_init();
2202         biovec_init_slabs();
2203
2204         if (bioset_init(&fs_bio_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS))
2205                 panic("bio: can't allocate bios\n");
2206
2207         if (bioset_integrity_create(&fs_bio_set, BIO_POOL_SIZE))
2208                 panic("bio: can't create integrity pool\n");
2209
2210         return 0;
2211 }
2212 subsys_initcall(init_bio);