blob: b21f8e86f1207f9b76bf3e2083fcf72b5062f0b7 [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001// SPDX-License-Identifier: GPL-2.0
Jens Axboe86db1e22008-01-29 14:53:40 +01002/*
3 * Functions related to mapping data to requests
4 */
5#include <linux/kernel.h>
Ingo Molnar68db0cf2017-02-08 18:51:37 +01006#include <linux/sched/task_stack.h>
Jens Axboe86db1e22008-01-29 14:53:40 +01007#include <linux/module.h>
8#include <linux/bio.h>
9#include <linux/blkdev.h>
Kent Overstreet26e49cf2015-01-18 16:16:31 +010010#include <linux/uio.h>
Jens Axboe86db1e22008-01-29 14:53:40 +010011
12#include "blk.h"
13
Christoph Hellwig98d61d52016-07-19 11:31:51 +020014/*
15 * Append a bio to a passthrough request. Only works can be merged into
16 * the request based on the driver constraints.
17 */
18int blk_rq_append_bio(struct request *rq, struct bio *bio)
Jens Axboe86db1e22008-01-29 14:53:40 +010019{
Christoph Hellwigcaa4b0242017-06-27 12:13:21 -060020 blk_queue_bounce(rq->q, &bio);
21
Christoph Hellwig98d61d52016-07-19 11:31:51 +020022 if (!rq->bio) {
23 blk_rq_bio_prep(rq->q, rq, bio);
24 } else {
25 if (!ll_back_merge_fn(rq->q, rq, bio))
26 return -EINVAL;
27
Jens Axboe86db1e22008-01-29 14:53:40 +010028 rq->biotail->bi_next = bio;
29 rq->biotail = bio;
Kent Overstreet4f024f32013-10-11 15:44:27 -070030 rq->__data_len += bio->bi_iter.bi_size;
Jens Axboe86db1e22008-01-29 14:53:40 +010031 }
Christoph Hellwig98d61d52016-07-19 11:31:51 +020032
Jens Axboe86db1e22008-01-29 14:53:40 +010033 return 0;
34}
Christoph Hellwig98d61d52016-07-19 11:31:51 +020035EXPORT_SYMBOL(blk_rq_append_bio);
Jens Axboe86db1e22008-01-29 14:53:40 +010036
37static int __blk_rq_unmap_user(struct bio *bio)
38{
39 int ret = 0;
40
41 if (bio) {
42 if (bio_flagged(bio, BIO_USER_MAPPED))
43 bio_unmap_user(bio);
44 else
45 ret = bio_uncopy_user(bio);
46 }
47
48 return ret;
49}
50
Christoph Hellwig4d6af732016-03-02 18:07:14 +010051static int __blk_rq_map_user_iov(struct request *rq,
52 struct rq_map_data *map_data, struct iov_iter *iter,
53 gfp_t gfp_mask, bool copy)
54{
55 struct request_queue *q = rq->q;
56 struct bio *bio, *orig_bio;
57 int ret;
58
59 if (copy)
60 bio = bio_copy_user_iov(q, map_data, iter, gfp_mask);
61 else
62 bio = bio_map_user_iov(q, iter, gfp_mask);
63
64 if (IS_ERR(bio))
65 return PTR_ERR(bio);
66
Christoph Hellwigaebf5262017-01-31 16:57:31 +010067 bio->bi_opf &= ~REQ_OP_MASK;
68 bio->bi_opf |= req_op(rq);
69
Christoph Hellwig4d6af732016-03-02 18:07:14 +010070 orig_bio = bio;
Christoph Hellwig4d6af732016-03-02 18:07:14 +010071
72 /*
73 * We link the bounce buffer in and could have to traverse it
74 * later so we have to get a ref to prevent it from being freed
75 */
Christoph Hellwig98d61d52016-07-19 11:31:51 +020076 ret = blk_rq_append_bio(rq, bio);
Christoph Hellwigcaa4b0242017-06-27 12:13:21 -060077 bio_get(bio);
Christoph Hellwig4d6af732016-03-02 18:07:14 +010078 if (ret) {
79 bio_endio(bio);
80 __blk_rq_unmap_user(orig_bio);
81 bio_put(bio);
82 return ret;
83 }
84
85 return 0;
86}
87
Jens Axboe86db1e22008-01-29 14:53:40 +010088/**
Christoph Hellwigaebf5262017-01-31 16:57:31 +010089 * blk_rq_map_user_iov - map user data to a request, for passthrough requests
Jens Axboe86db1e22008-01-29 14:53:40 +010090 * @q: request queue where request should be inserted
91 * @rq: request to map data to
FUJITA Tomonori152e2832008-08-28 16:17:06 +090092 * @map_data: pointer to the rq_map_data holding pages (if necessary)
Kent Overstreet26e49cf2015-01-18 16:16:31 +010093 * @iter: iovec iterator
FUJITA Tomonoria3bce902008-08-28 16:17:05 +090094 * @gfp_mask: memory allocation flags
Jens Axboe86db1e22008-01-29 14:53:40 +010095 *
96 * Description:
Randy Dunlap710027a2008-08-19 20:13:11 +020097 * Data will be mapped directly for zero copy I/O, if possible. Otherwise
Jens Axboe86db1e22008-01-29 14:53:40 +010098 * a kernel bounce buffer is used.
99 *
Randy Dunlap710027a2008-08-19 20:13:11 +0200100 * A matching blk_rq_unmap_user() must be issued at the end of I/O, while
Jens Axboe86db1e22008-01-29 14:53:40 +0100101 * still in process context.
102 *
103 * Note: The mapped bio may need to be bounced through blk_queue_bounce()
104 * before being submitted to the device, as pages mapped may be out of
105 * reach. It's the callers responsibility to make sure this happens. The
106 * original bio must be passed back in to blk_rq_unmap_user() for proper
107 * unmapping.
108 */
109int blk_rq_map_user_iov(struct request_queue *q, struct request *rq,
Kent Overstreet26e49cf2015-01-18 16:16:31 +0100110 struct rq_map_data *map_data,
111 const struct iov_iter *iter, gfp_t gfp_mask)
Jens Axboe86db1e22008-01-29 14:53:40 +0100112{
Al Viro357f4352016-04-08 19:05:19 -0400113 bool copy = false;
114 unsigned long align = q->dma_pad_mask | queue_dma_alignment(q);
Christoph Hellwig4d6af732016-03-02 18:07:14 +0100115 struct bio *bio = NULL;
116 struct iov_iter i;
117 int ret;
Jens Axboe86db1e22008-01-29 14:53:40 +0100118
Linus Torvaldsa0ac4022016-12-06 16:18:14 -0800119 if (!iter_is_iovec(iter))
120 goto fail;
121
Al Viro357f4352016-04-08 19:05:19 -0400122 if (map_data)
123 copy = true;
124 else if (iov_iter_alignment(iter) & align)
125 copy = true;
126 else if (queue_virt_boundary(q))
127 copy = queue_virt_boundary(q) & iov_iter_gap_alignment(iter);
FUJITA Tomonoriafdc1a72008-04-11 12:56:51 +0200128
Christoph Hellwig4d6af732016-03-02 18:07:14 +0100129 i = *iter;
130 do {
131 ret =__blk_rq_map_user_iov(rq, map_data, &i, gfp_mask, copy);
132 if (ret)
133 goto unmap_rq;
134 if (!bio)
135 bio = rq->bio;
136 } while (iov_iter_count(&i));
Jens Axboe86db1e22008-01-29 14:53:40 +0100137
FUJITA Tomonorif18573a2008-04-11 12:56:52 +0200138 if (!bio_flagged(bio, BIO_USER_MAPPED))
Christoph Hellwige8064022016-10-20 15:12:13 +0200139 rq->rq_flags |= RQF_COPY_USER;
Jens Axboe86db1e22008-01-29 14:53:40 +0100140 return 0;
Christoph Hellwig4d6af732016-03-02 18:07:14 +0100141
142unmap_rq:
143 __blk_rq_unmap_user(bio);
Linus Torvaldsa0ac4022016-12-06 16:18:14 -0800144fail:
Christoph Hellwig4d6af732016-03-02 18:07:14 +0100145 rq->bio = NULL;
146 return -EINVAL;
Jens Axboe86db1e22008-01-29 14:53:40 +0100147}
FUJITA Tomonori152e2832008-08-28 16:17:06 +0900148EXPORT_SYMBOL(blk_rq_map_user_iov);
Jens Axboe86db1e22008-01-29 14:53:40 +0100149
Christoph Hellwigddad8dd2015-01-18 16:16:29 +0100150int blk_rq_map_user(struct request_queue *q, struct request *rq,
151 struct rq_map_data *map_data, void __user *ubuf,
152 unsigned long len, gfp_t gfp_mask)
153{
Kent Overstreet26e49cf2015-01-18 16:16:31 +0100154 struct iovec iov;
155 struct iov_iter i;
Al Viro8f7e8852015-03-21 20:06:04 -0400156 int ret = import_single_range(rq_data_dir(rq), ubuf, len, &iov, &i);
Christoph Hellwigddad8dd2015-01-18 16:16:29 +0100157
Al Viro8f7e8852015-03-21 20:06:04 -0400158 if (unlikely(ret < 0))
159 return ret;
Christoph Hellwigddad8dd2015-01-18 16:16:29 +0100160
Kent Overstreet26e49cf2015-01-18 16:16:31 +0100161 return blk_rq_map_user_iov(q, rq, map_data, &i, gfp_mask);
Christoph Hellwigddad8dd2015-01-18 16:16:29 +0100162}
163EXPORT_SYMBOL(blk_rq_map_user);
164
Jens Axboe86db1e22008-01-29 14:53:40 +0100165/**
166 * blk_rq_unmap_user - unmap a request with user data
167 * @bio: start of bio list
168 *
169 * Description:
170 * Unmap a rq previously mapped by blk_rq_map_user(). The caller must
171 * supply the original rq->bio from the blk_rq_map_user() return, since
Randy Dunlap710027a2008-08-19 20:13:11 +0200172 * the I/O completion may have changed rq->bio.
Jens Axboe86db1e22008-01-29 14:53:40 +0100173 */
174int blk_rq_unmap_user(struct bio *bio)
175{
176 struct bio *mapped_bio;
177 int ret = 0, ret2;
178
179 while (bio) {
180 mapped_bio = bio;
181 if (unlikely(bio_flagged(bio, BIO_BOUNCED)))
182 mapped_bio = bio->bi_private;
183
184 ret2 = __blk_rq_unmap_user(mapped_bio);
185 if (ret2 && !ret)
186 ret = ret2;
187
188 mapped_bio = bio;
189 bio = bio->bi_next;
190 bio_put(mapped_bio);
191 }
192
193 return ret;
194}
Jens Axboe86db1e22008-01-29 14:53:40 +0100195EXPORT_SYMBOL(blk_rq_unmap_user);
196
197/**
Christoph Hellwigaebf5262017-01-31 16:57:31 +0100198 * blk_rq_map_kern - map kernel data to a request, for passthrough requests
Jens Axboe86db1e22008-01-29 14:53:40 +0100199 * @q: request queue where request should be inserted
200 * @rq: request to fill
201 * @kbuf: the kernel buffer
202 * @len: length of user data
203 * @gfp_mask: memory allocation flags
FUJITA Tomonori68154e92008-04-25 12:47:50 +0200204 *
205 * Description:
206 * Data will be mapped directly if possible. Otherwise a bounce
Masanari Iidae2278672014-02-18 22:54:36 +0900207 * buffer is used. Can be called multiple times to append multiple
James Bottomley3a5a3922009-05-17 18:55:18 +0300208 * buffers.
Jens Axboe86db1e22008-01-29 14:53:40 +0100209 */
210int blk_rq_map_kern(struct request_queue *q, struct request *rq, void *kbuf,
211 unsigned int len, gfp_t gfp_mask)
212{
FUJITA Tomonori68154e92008-04-25 12:47:50 +0200213 int reading = rq_data_dir(rq) == READ;
Namhyung Kim14417792010-09-15 13:08:27 +0200214 unsigned long addr = (unsigned long) kbuf;
FUJITA Tomonori68154e92008-04-25 12:47:50 +0200215 int do_copy = 0;
Jens Axboe86db1e22008-01-29 14:53:40 +0100216 struct bio *bio;
James Bottomley3a5a3922009-05-17 18:55:18 +0300217 int ret;
Jens Axboe86db1e22008-01-29 14:53:40 +0100218
Martin K. Petersenae03bf62009-05-22 17:17:50 -0400219 if (len > (queue_max_hw_sectors(q) << 9))
Jens Axboe86db1e22008-01-29 14:53:40 +0100220 return -EINVAL;
221 if (!len || !kbuf)
222 return -EINVAL;
223
Namhyung Kim14417792010-09-15 13:08:27 +0200224 do_copy = !blk_rq_aligned(q, addr, len) || object_is_on_stack(kbuf);
FUJITA Tomonori68154e92008-04-25 12:47:50 +0200225 if (do_copy)
226 bio = bio_copy_kern(q, kbuf, len, gfp_mask, reading);
227 else
228 bio = bio_map_kern(q, kbuf, len, gfp_mask);
229
Jens Axboe86db1e22008-01-29 14:53:40 +0100230 if (IS_ERR(bio))
231 return PTR_ERR(bio);
232
Christoph Hellwigaebf5262017-01-31 16:57:31 +0100233 bio->bi_opf &= ~REQ_OP_MASK;
234 bio->bi_opf |= req_op(rq);
Jens Axboe86db1e22008-01-29 14:53:40 +0100235
FUJITA Tomonori68154e92008-04-25 12:47:50 +0200236 if (do_copy)
Christoph Hellwige8064022016-10-20 15:12:13 +0200237 rq->rq_flags |= RQF_COPY_USER;
FUJITA Tomonori68154e92008-04-25 12:47:50 +0200238
Christoph Hellwig98d61d52016-07-19 11:31:51 +0200239 ret = blk_rq_append_bio(rq, bio);
James Bottomley3a5a3922009-05-17 18:55:18 +0300240 if (unlikely(ret)) {
241 /* request is too big */
242 bio_put(bio);
243 return ret;
244 }
245
Jens Axboe86db1e22008-01-29 14:53:40 +0100246 return 0;
247}
Jens Axboe86db1e22008-01-29 14:53:40 +0100248EXPORT_SYMBOL(blk_rq_map_kern);