Merge tag 'for-6.6-rc2-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave...
[platform/kernel/linux-rpi.git] / block / blk-map.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Functions related to mapping data to requests
4  */
5 #include <linux/kernel.h>
6 #include <linux/sched/task_stack.h>
7 #include <linux/module.h>
8 #include <linux/bio.h>
9 #include <linux/blkdev.h>
10 #include <linux/uio.h>
11
12 #include "blk.h"
13
14 struct bio_map_data {
15         bool is_our_pages : 1;
16         bool is_null_mapped : 1;
17         struct iov_iter iter;
18         struct iovec iov[];
19 };
20
21 static struct bio_map_data *bio_alloc_map_data(struct iov_iter *data,
22                                                gfp_t gfp_mask)
23 {
24         struct bio_map_data *bmd;
25
26         if (data->nr_segs > UIO_MAXIOV)
27                 return NULL;
28
29         bmd = kmalloc(struct_size(bmd, iov, data->nr_segs), gfp_mask);
30         if (!bmd)
31                 return NULL;
32         bmd->iter = *data;
33         if (iter_is_iovec(data)) {
34                 memcpy(bmd->iov, iter_iov(data), sizeof(struct iovec) * data->nr_segs);
35                 bmd->iter.__iov = bmd->iov;
36         }
37         return bmd;
38 }
39
40 /**
41  * bio_copy_from_iter - copy all pages from iov_iter to bio
42  * @bio: The &struct bio which describes the I/O as destination
43  * @iter: iov_iter as source
44  *
45  * Copy all pages from iov_iter to bio.
46  * Returns 0 on success, or error on failure.
47  */
48 static int bio_copy_from_iter(struct bio *bio, struct iov_iter *iter)
49 {
50         struct bio_vec *bvec;
51         struct bvec_iter_all iter_all;
52
53         bio_for_each_segment_all(bvec, bio, iter_all) {
54                 ssize_t ret;
55
56                 ret = copy_page_from_iter(bvec->bv_page,
57                                           bvec->bv_offset,
58                                           bvec->bv_len,
59                                           iter);
60
61                 if (!iov_iter_count(iter))
62                         break;
63
64                 if (ret < bvec->bv_len)
65                         return -EFAULT;
66         }
67
68         return 0;
69 }
70
71 /**
72  * bio_copy_to_iter - copy all pages from bio to iov_iter
73  * @bio: The &struct bio which describes the I/O as source
74  * @iter: iov_iter as destination
75  *
76  * Copy all pages from bio to iov_iter.
77  * Returns 0 on success, or error on failure.
78  */
79 static int bio_copy_to_iter(struct bio *bio, struct iov_iter iter)
80 {
81         struct bio_vec *bvec;
82         struct bvec_iter_all iter_all;
83
84         bio_for_each_segment_all(bvec, bio, iter_all) {
85                 ssize_t ret;
86
87                 ret = copy_page_to_iter(bvec->bv_page,
88                                         bvec->bv_offset,
89                                         bvec->bv_len,
90                                         &iter);
91
92                 if (!iov_iter_count(&iter))
93                         break;
94
95                 if (ret < bvec->bv_len)
96                         return -EFAULT;
97         }
98
99         return 0;
100 }
101
102 /**
103  *      bio_uncopy_user -       finish previously mapped bio
104  *      @bio: bio being terminated
105  *
106  *      Free pages allocated from bio_copy_user_iov() and write back data
107  *      to user space in case of a read.
108  */
109 static int bio_uncopy_user(struct bio *bio)
110 {
111         struct bio_map_data *bmd = bio->bi_private;
112         int ret = 0;
113
114         if (!bmd->is_null_mapped) {
115                 /*
116                  * if we're in a workqueue, the request is orphaned, so
117                  * don't copy into a random user address space, just free
118                  * and return -EINTR so user space doesn't expect any data.
119                  */
120                 if (!current->mm)
121                         ret = -EINTR;
122                 else if (bio_data_dir(bio) == READ)
123                         ret = bio_copy_to_iter(bio, bmd->iter);
124                 if (bmd->is_our_pages)
125                         bio_free_pages(bio);
126         }
127         kfree(bmd);
128         return ret;
129 }
130
131 static int bio_copy_user_iov(struct request *rq, struct rq_map_data *map_data,
132                 struct iov_iter *iter, gfp_t gfp_mask)
133 {
134         struct bio_map_data *bmd;
135         struct page *page;
136         struct bio *bio;
137         int i = 0, ret;
138         int nr_pages;
139         unsigned int len = iter->count;
140         unsigned int offset = map_data ? offset_in_page(map_data->offset) : 0;
141
142         bmd = bio_alloc_map_data(iter, gfp_mask);
143         if (!bmd)
144                 return -ENOMEM;
145
146         /*
147          * We need to do a deep copy of the iov_iter including the iovecs.
148          * The caller provided iov might point to an on-stack or otherwise
149          * shortlived one.
150          */
151         bmd->is_our_pages = !map_data;
152         bmd->is_null_mapped = (map_data && map_data->null_mapped);
153
154         nr_pages = bio_max_segs(DIV_ROUND_UP(offset + len, PAGE_SIZE));
155
156         ret = -ENOMEM;
157         bio = bio_kmalloc(nr_pages, gfp_mask);
158         if (!bio)
159                 goto out_bmd;
160         bio_init(bio, NULL, bio->bi_inline_vecs, nr_pages, req_op(rq));
161
162         if (map_data) {
163                 nr_pages = 1U << map_data->page_order;
164                 i = map_data->offset / PAGE_SIZE;
165         }
166         while (len) {
167                 unsigned int bytes = PAGE_SIZE;
168
169                 bytes -= offset;
170
171                 if (bytes > len)
172                         bytes = len;
173
174                 if (map_data) {
175                         if (i == map_data->nr_entries * nr_pages) {
176                                 ret = -ENOMEM;
177                                 goto cleanup;
178                         }
179
180                         page = map_data->pages[i / nr_pages];
181                         page += (i % nr_pages);
182
183                         i++;
184                 } else {
185                         page = alloc_page(GFP_NOIO | gfp_mask);
186                         if (!page) {
187                                 ret = -ENOMEM;
188                                 goto cleanup;
189                         }
190                 }
191
192                 if (bio_add_pc_page(rq->q, bio, page, bytes, offset) < bytes) {
193                         if (!map_data)
194                                 __free_page(page);
195                         break;
196                 }
197
198                 len -= bytes;
199                 offset = 0;
200         }
201
202         if (map_data)
203                 map_data->offset += bio->bi_iter.bi_size;
204
205         /*
206          * success
207          */
208         if ((iov_iter_rw(iter) == WRITE &&
209              (!map_data || !map_data->null_mapped)) ||
210             (map_data && map_data->from_user)) {
211                 ret = bio_copy_from_iter(bio, iter);
212                 if (ret)
213                         goto cleanup;
214         } else {
215                 if (bmd->is_our_pages)
216                         zero_fill_bio(bio);
217                 iov_iter_advance(iter, bio->bi_iter.bi_size);
218         }
219
220         bio->bi_private = bmd;
221
222         ret = blk_rq_append_bio(rq, bio);
223         if (ret)
224                 goto cleanup;
225         return 0;
226 cleanup:
227         if (!map_data)
228                 bio_free_pages(bio);
229         bio_uninit(bio);
230         kfree(bio);
231 out_bmd:
232         kfree(bmd);
233         return ret;
234 }
235
236 static void blk_mq_map_bio_put(struct bio *bio)
237 {
238         if (bio->bi_opf & REQ_ALLOC_CACHE) {
239                 bio_put(bio);
240         } else {
241                 bio_uninit(bio);
242                 kfree(bio);
243         }
244 }
245
246 static struct bio *blk_rq_map_bio_alloc(struct request *rq,
247                 unsigned int nr_vecs, gfp_t gfp_mask)
248 {
249         struct bio *bio;
250
251         if (rq->cmd_flags & REQ_ALLOC_CACHE && (nr_vecs <= BIO_INLINE_VECS)) {
252                 bio = bio_alloc_bioset(NULL, nr_vecs, rq->cmd_flags, gfp_mask,
253                                         &fs_bio_set);
254                 if (!bio)
255                         return NULL;
256         } else {
257                 bio = bio_kmalloc(nr_vecs, gfp_mask);
258                 if (!bio)
259                         return NULL;
260                 bio_init(bio, NULL, bio->bi_inline_vecs, nr_vecs, req_op(rq));
261         }
262         return bio;
263 }
264
265 static int bio_map_user_iov(struct request *rq, struct iov_iter *iter,
266                 gfp_t gfp_mask)
267 {
268         iov_iter_extraction_t extraction_flags = 0;
269         unsigned int max_sectors = queue_max_hw_sectors(rq->q);
270         unsigned int nr_vecs = iov_iter_npages(iter, BIO_MAX_VECS);
271         struct bio *bio;
272         int ret;
273         int j;
274
275         if (!iov_iter_count(iter))
276                 return -EINVAL;
277
278         bio = blk_rq_map_bio_alloc(rq, nr_vecs, gfp_mask);
279         if (bio == NULL)
280                 return -ENOMEM;
281
282         if (blk_queue_pci_p2pdma(rq->q))
283                 extraction_flags |= ITER_ALLOW_P2PDMA;
284         if (iov_iter_extract_will_pin(iter))
285                 bio_set_flag(bio, BIO_PAGE_PINNED);
286
287         while (iov_iter_count(iter)) {
288                 struct page *stack_pages[UIO_FASTIOV];
289                 struct page **pages = stack_pages;
290                 ssize_t bytes;
291                 size_t offs;
292                 int npages;
293
294                 if (nr_vecs > ARRAY_SIZE(stack_pages))
295                         pages = NULL;
296
297                 bytes = iov_iter_extract_pages(iter, &pages, LONG_MAX,
298                                                nr_vecs, extraction_flags, &offs);
299                 if (unlikely(bytes <= 0)) {
300                         ret = bytes ? bytes : -EFAULT;
301                         goto out_unmap;
302                 }
303
304                 npages = DIV_ROUND_UP(offs + bytes, PAGE_SIZE);
305
306                 if (unlikely(offs & queue_dma_alignment(rq->q)))
307                         j = 0;
308                 else {
309                         for (j = 0; j < npages; j++) {
310                                 struct page *page = pages[j];
311                                 unsigned int n = PAGE_SIZE - offs;
312                                 bool same_page = false;
313
314                                 if (n > bytes)
315                                         n = bytes;
316
317                                 if (!bio_add_hw_page(rq->q, bio, page, n, offs,
318                                                      max_sectors, &same_page))
319                                         break;
320
321                                 if (same_page)
322                                         bio_release_page(bio, page);
323                                 bytes -= n;
324                                 offs = 0;
325                         }
326                 }
327                 /*
328                  * release the pages we didn't map into the bio, if any
329                  */
330                 while (j < npages)
331                         bio_release_page(bio, pages[j++]);
332                 if (pages != stack_pages)
333                         kvfree(pages);
334                 /* couldn't stuff something into bio? */
335                 if (bytes) {
336                         iov_iter_revert(iter, bytes);
337                         break;
338                 }
339         }
340
341         ret = blk_rq_append_bio(rq, bio);
342         if (ret)
343                 goto out_unmap;
344         return 0;
345
346  out_unmap:
347         bio_release_pages(bio, false);
348         blk_mq_map_bio_put(bio);
349         return ret;
350 }
351
352 static void bio_invalidate_vmalloc_pages(struct bio *bio)
353 {
354 #ifdef ARCH_IMPLEMENTS_FLUSH_KERNEL_VMAP_RANGE
355         if (bio->bi_private && !op_is_write(bio_op(bio))) {
356                 unsigned long i, len = 0;
357
358                 for (i = 0; i < bio->bi_vcnt; i++)
359                         len += bio->bi_io_vec[i].bv_len;
360                 invalidate_kernel_vmap_range(bio->bi_private, len);
361         }
362 #endif
363 }
364
365 static void bio_map_kern_endio(struct bio *bio)
366 {
367         bio_invalidate_vmalloc_pages(bio);
368         bio_uninit(bio);
369         kfree(bio);
370 }
371
372 /**
373  *      bio_map_kern    -       map kernel address into bio
374  *      @q: the struct request_queue for the bio
375  *      @data: pointer to buffer to map
376  *      @len: length in bytes
377  *      @gfp_mask: allocation flags for bio allocation
378  *
379  *      Map the kernel address into a bio suitable for io to a block
380  *      device. Returns an error pointer in case of error.
381  */
382 static struct bio *bio_map_kern(struct request_queue *q, void *data,
383                 unsigned int len, gfp_t gfp_mask)
384 {
385         unsigned long kaddr = (unsigned long)data;
386         unsigned long end = (kaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
387         unsigned long start = kaddr >> PAGE_SHIFT;
388         const int nr_pages = end - start;
389         bool is_vmalloc = is_vmalloc_addr(data);
390         struct page *page;
391         int offset, i;
392         struct bio *bio;
393
394         bio = bio_kmalloc(nr_pages, gfp_mask);
395         if (!bio)
396                 return ERR_PTR(-ENOMEM);
397         bio_init(bio, NULL, bio->bi_inline_vecs, nr_pages, 0);
398
399         if (is_vmalloc) {
400                 flush_kernel_vmap_range(data, len);
401                 bio->bi_private = data;
402         }
403
404         offset = offset_in_page(kaddr);
405         for (i = 0; i < nr_pages; i++) {
406                 unsigned int bytes = PAGE_SIZE - offset;
407
408                 if (len <= 0)
409                         break;
410
411                 if (bytes > len)
412                         bytes = len;
413
414                 if (!is_vmalloc)
415                         page = virt_to_page(data);
416                 else
417                         page = vmalloc_to_page(data);
418                 if (bio_add_pc_page(q, bio, page, bytes,
419                                     offset) < bytes) {
420                         /* we don't support partial mappings */
421                         bio_uninit(bio);
422                         kfree(bio);
423                         return ERR_PTR(-EINVAL);
424                 }
425
426                 data += bytes;
427                 len -= bytes;
428                 offset = 0;
429         }
430
431         bio->bi_end_io = bio_map_kern_endio;
432         return bio;
433 }
434
435 static void bio_copy_kern_endio(struct bio *bio)
436 {
437         bio_free_pages(bio);
438         bio_uninit(bio);
439         kfree(bio);
440 }
441
442 static void bio_copy_kern_endio_read(struct bio *bio)
443 {
444         char *p = bio->bi_private;
445         struct bio_vec *bvec;
446         struct bvec_iter_all iter_all;
447
448         bio_for_each_segment_all(bvec, bio, iter_all) {
449                 memcpy_from_bvec(p, bvec);
450                 p += bvec->bv_len;
451         }
452
453         bio_copy_kern_endio(bio);
454 }
455
456 /**
457  *      bio_copy_kern   -       copy kernel address into bio
458  *      @q: the struct request_queue for the bio
459  *      @data: pointer to buffer to copy
460  *      @len: length in bytes
461  *      @gfp_mask: allocation flags for bio and page allocation
462  *      @reading: data direction is READ
463  *
464  *      copy the kernel address into a bio suitable for io to a block
465  *      device. Returns an error pointer in case of error.
466  */
467 static struct bio *bio_copy_kern(struct request_queue *q, void *data,
468                 unsigned int len, gfp_t gfp_mask, int reading)
469 {
470         unsigned long kaddr = (unsigned long)data;
471         unsigned long end = (kaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
472         unsigned long start = kaddr >> PAGE_SHIFT;
473         struct bio *bio;
474         void *p = data;
475         int nr_pages = 0;
476
477         /*
478          * Overflow, abort
479          */
480         if (end < start)
481                 return ERR_PTR(-EINVAL);
482
483         nr_pages = end - start;
484         bio = bio_kmalloc(nr_pages, gfp_mask);
485         if (!bio)
486                 return ERR_PTR(-ENOMEM);
487         bio_init(bio, NULL, bio->bi_inline_vecs, nr_pages, 0);
488
489         while (len) {
490                 struct page *page;
491                 unsigned int bytes = PAGE_SIZE;
492
493                 if (bytes > len)
494                         bytes = len;
495
496                 page = alloc_page(GFP_NOIO | __GFP_ZERO | gfp_mask);
497                 if (!page)
498                         goto cleanup;
499
500                 if (!reading)
501                         memcpy(page_address(page), p, bytes);
502
503                 if (bio_add_pc_page(q, bio, page, bytes, 0) < bytes)
504                         break;
505
506                 len -= bytes;
507                 p += bytes;
508         }
509
510         if (reading) {
511                 bio->bi_end_io = bio_copy_kern_endio_read;
512                 bio->bi_private = data;
513         } else {
514                 bio->bi_end_io = bio_copy_kern_endio;
515         }
516
517         return bio;
518
519 cleanup:
520         bio_free_pages(bio);
521         bio_uninit(bio);
522         kfree(bio);
523         return ERR_PTR(-ENOMEM);
524 }
525
526 /*
527  * Append a bio to a passthrough request.  Only works if the bio can be merged
528  * into the request based on the driver constraints.
529  */
530 int blk_rq_append_bio(struct request *rq, struct bio *bio)
531 {
532         struct bvec_iter iter;
533         struct bio_vec bv;
534         unsigned int nr_segs = 0;
535
536         bio_for_each_bvec(bv, bio, iter)
537                 nr_segs++;
538
539         if (!rq->bio) {
540                 blk_rq_bio_prep(rq, bio, nr_segs);
541         } else {
542                 if (!ll_back_merge_fn(rq, bio, nr_segs))
543                         return -EINVAL;
544                 rq->biotail->bi_next = bio;
545                 rq->biotail = bio;
546                 rq->__data_len += (bio)->bi_iter.bi_size;
547                 bio_crypt_free_ctx(bio);
548         }
549
550         return 0;
551 }
552 EXPORT_SYMBOL(blk_rq_append_bio);
553
554 /* Prepare bio for passthrough IO given ITER_BVEC iter */
555 static int blk_rq_map_user_bvec(struct request *rq, const struct iov_iter *iter)
556 {
557         struct request_queue *q = rq->q;
558         size_t nr_iter = iov_iter_count(iter);
559         size_t nr_segs = iter->nr_segs;
560         struct bio_vec *bvecs, *bvprvp = NULL;
561         const struct queue_limits *lim = &q->limits;
562         unsigned int nsegs = 0, bytes = 0;
563         struct bio *bio;
564         size_t i;
565
566         if (!nr_iter || (nr_iter >> SECTOR_SHIFT) > queue_max_hw_sectors(q))
567                 return -EINVAL;
568         if (nr_segs > queue_max_segments(q))
569                 return -EINVAL;
570
571         /* no iovecs to alloc, as we already have a BVEC iterator */
572         bio = blk_rq_map_bio_alloc(rq, 0, GFP_KERNEL);
573         if (bio == NULL)
574                 return -ENOMEM;
575
576         bio_iov_bvec_set(bio, (struct iov_iter *)iter);
577         blk_rq_bio_prep(rq, bio, nr_segs);
578
579         /* loop to perform a bunch of sanity checks */
580         bvecs = (struct bio_vec *)iter->bvec;
581         for (i = 0; i < nr_segs; i++) {
582                 struct bio_vec *bv = &bvecs[i];
583
584                 /*
585                  * If the queue doesn't support SG gaps and adding this
586                  * offset would create a gap, fallback to copy.
587                  */
588                 if (bvprvp && bvec_gap_to_prev(lim, bvprvp, bv->bv_offset)) {
589                         blk_mq_map_bio_put(bio);
590                         return -EREMOTEIO;
591                 }
592                 /* check full condition */
593                 if (nsegs >= nr_segs || bytes > UINT_MAX - bv->bv_len)
594                         goto put_bio;
595                 if (bytes + bv->bv_len > nr_iter)
596                         goto put_bio;
597                 if (bv->bv_offset + bv->bv_len > PAGE_SIZE)
598                         goto put_bio;
599
600                 nsegs++;
601                 bytes += bv->bv_len;
602                 bvprvp = bv;
603         }
604         return 0;
605 put_bio:
606         blk_mq_map_bio_put(bio);
607         return -EINVAL;
608 }
609
610 /**
611  * blk_rq_map_user_iov - map user data to a request, for passthrough requests
612  * @q:          request queue where request should be inserted
613  * @rq:         request to map data to
614  * @map_data:   pointer to the rq_map_data holding pages (if necessary)
615  * @iter:       iovec iterator
616  * @gfp_mask:   memory allocation flags
617  *
618  * Description:
619  *    Data will be mapped directly for zero copy I/O, if possible. Otherwise
620  *    a kernel bounce buffer is used.
621  *
622  *    A matching blk_rq_unmap_user() must be issued at the end of I/O, while
623  *    still in process context.
624  */
625 int blk_rq_map_user_iov(struct request_queue *q, struct request *rq,
626                         struct rq_map_data *map_data,
627                         const struct iov_iter *iter, gfp_t gfp_mask)
628 {
629         bool copy = false, map_bvec = false;
630         unsigned long align = q->dma_pad_mask | queue_dma_alignment(q);
631         struct bio *bio = NULL;
632         struct iov_iter i;
633         int ret = -EINVAL;
634
635         if (map_data)
636                 copy = true;
637         else if (blk_queue_may_bounce(q))
638                 copy = true;
639         else if (iov_iter_alignment(iter) & align)
640                 copy = true;
641         else if (iov_iter_is_bvec(iter))
642                 map_bvec = true;
643         else if (!user_backed_iter(iter))
644                 copy = true;
645         else if (queue_virt_boundary(q))
646                 copy = queue_virt_boundary(q) & iov_iter_gap_alignment(iter);
647
648         if (map_bvec) {
649                 ret = blk_rq_map_user_bvec(rq, iter);
650                 if (!ret)
651                         return 0;
652                 if (ret != -EREMOTEIO)
653                         goto fail;
654                 /* fall back to copying the data on limits mismatches */
655                 copy = true;
656         }
657
658         i = *iter;
659         do {
660                 if (copy)
661                         ret = bio_copy_user_iov(rq, map_data, &i, gfp_mask);
662                 else
663                         ret = bio_map_user_iov(rq, &i, gfp_mask);
664                 if (ret)
665                         goto unmap_rq;
666                 if (!bio)
667                         bio = rq->bio;
668         } while (iov_iter_count(&i));
669
670         return 0;
671
672 unmap_rq:
673         blk_rq_unmap_user(bio);
674 fail:
675         rq->bio = NULL;
676         return ret;
677 }
678 EXPORT_SYMBOL(blk_rq_map_user_iov);
679
680 int blk_rq_map_user(struct request_queue *q, struct request *rq,
681                     struct rq_map_data *map_data, void __user *ubuf,
682                     unsigned long len, gfp_t gfp_mask)
683 {
684         struct iov_iter i;
685         int ret = import_ubuf(rq_data_dir(rq), ubuf, len, &i);
686
687         if (unlikely(ret < 0))
688                 return ret;
689
690         return blk_rq_map_user_iov(q, rq, map_data, &i, gfp_mask);
691 }
692 EXPORT_SYMBOL(blk_rq_map_user);
693
694 int blk_rq_map_user_io(struct request *req, struct rq_map_data *map_data,
695                 void __user *ubuf, unsigned long buf_len, gfp_t gfp_mask,
696                 bool vec, int iov_count, bool check_iter_count, int rw)
697 {
698         int ret = 0;
699
700         if (vec) {
701                 struct iovec fast_iov[UIO_FASTIOV];
702                 struct iovec *iov = fast_iov;
703                 struct iov_iter iter;
704
705                 ret = import_iovec(rw, ubuf, iov_count ? iov_count : buf_len,
706                                 UIO_FASTIOV, &iov, &iter);
707                 if (ret < 0)
708                         return ret;
709
710                 if (iov_count) {
711                         /* SG_IO howto says that the shorter of the two wins */
712                         iov_iter_truncate(&iter, buf_len);
713                         if (check_iter_count && !iov_iter_count(&iter)) {
714                                 kfree(iov);
715                                 return -EINVAL;
716                         }
717                 }
718
719                 ret = blk_rq_map_user_iov(req->q, req, map_data, &iter,
720                                 gfp_mask);
721                 kfree(iov);
722         } else if (buf_len) {
723                 ret = blk_rq_map_user(req->q, req, map_data, ubuf, buf_len,
724                                 gfp_mask);
725         }
726         return ret;
727 }
728 EXPORT_SYMBOL(blk_rq_map_user_io);
729
730 /**
731  * blk_rq_unmap_user - unmap a request with user data
732  * @bio:               start of bio list
733  *
734  * Description:
735  *    Unmap a rq previously mapped by blk_rq_map_user(). The caller must
736  *    supply the original rq->bio from the blk_rq_map_user() return, since
737  *    the I/O completion may have changed rq->bio.
738  */
739 int blk_rq_unmap_user(struct bio *bio)
740 {
741         struct bio *next_bio;
742         int ret = 0, ret2;
743
744         while (bio) {
745                 if (bio->bi_private) {
746                         ret2 = bio_uncopy_user(bio);
747                         if (ret2 && !ret)
748                                 ret = ret2;
749                 } else {
750                         bio_release_pages(bio, bio_data_dir(bio) == READ);
751                 }
752
753                 next_bio = bio;
754                 bio = bio->bi_next;
755                 blk_mq_map_bio_put(next_bio);
756         }
757
758         return ret;
759 }
760 EXPORT_SYMBOL(blk_rq_unmap_user);
761
762 /**
763  * blk_rq_map_kern - map kernel data to a request, for passthrough requests
764  * @q:          request queue where request should be inserted
765  * @rq:         request to fill
766  * @kbuf:       the kernel buffer
767  * @len:        length of user data
768  * @gfp_mask:   memory allocation flags
769  *
770  * Description:
771  *    Data will be mapped directly if possible. Otherwise a bounce
772  *    buffer is used. Can be called multiple times to append multiple
773  *    buffers.
774  */
775 int blk_rq_map_kern(struct request_queue *q, struct request *rq, void *kbuf,
776                     unsigned int len, gfp_t gfp_mask)
777 {
778         int reading = rq_data_dir(rq) == READ;
779         unsigned long addr = (unsigned long) kbuf;
780         struct bio *bio;
781         int ret;
782
783         if (len > (queue_max_hw_sectors(q) << 9))
784                 return -EINVAL;
785         if (!len || !kbuf)
786                 return -EINVAL;
787
788         if (!blk_rq_aligned(q, addr, len) || object_is_on_stack(kbuf) ||
789             blk_queue_may_bounce(q))
790                 bio = bio_copy_kern(q, kbuf, len, gfp_mask, reading);
791         else
792                 bio = bio_map_kern(q, kbuf, len, gfp_mask);
793
794         if (IS_ERR(bio))
795                 return PTR_ERR(bio);
796
797         bio->bi_opf &= ~REQ_OP_MASK;
798         bio->bi_opf |= req_op(rq);
799
800         ret = blk_rq_append_bio(rq, bio);
801         if (unlikely(ret)) {
802                 bio_uninit(bio);
803                 kfree(bio);
804         }
805         return ret;
806 }
807 EXPORT_SYMBOL(blk_rq_map_kern);