xref: /openbmc/linux/block/blk-map.c (revision 7ab89db9)
1b2441318SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0
286db1e29SJens Axboe /*
386db1e29SJens Axboe  * Functions related to mapping data to requests
486db1e29SJens Axboe  */
586db1e29SJens Axboe #include <linux/kernel.h>
668db0cf1SIngo Molnar #include <linux/sched/task_stack.h>
786db1e29SJens Axboe #include <linux/module.h>
886db1e29SJens Axboe #include <linux/bio.h>
986db1e29SJens Axboe #include <linux/blkdev.h>
1026e49cfcSKent Overstreet #include <linux/uio.h>
1186db1e29SJens Axboe 
1286db1e29SJens Axboe #include "blk.h"
1386db1e29SJens Axboe 
14130879f1SChristoph Hellwig struct bio_map_data {
15f3256075SChristoph Hellwig 	bool is_our_pages : 1;
16f3256075SChristoph Hellwig 	bool is_null_mapped : 1;
17130879f1SChristoph Hellwig 	struct iov_iter iter;
18130879f1SChristoph Hellwig 	struct iovec iov[];
19130879f1SChristoph Hellwig };
20130879f1SChristoph Hellwig 
21130879f1SChristoph Hellwig static struct bio_map_data *bio_alloc_map_data(struct iov_iter *data,
22130879f1SChristoph Hellwig 					       gfp_t gfp_mask)
23130879f1SChristoph Hellwig {
24130879f1SChristoph Hellwig 	struct bio_map_data *bmd;
25130879f1SChristoph Hellwig 
26130879f1SChristoph Hellwig 	if (data->nr_segs > UIO_MAXIOV)
27130879f1SChristoph Hellwig 		return NULL;
28130879f1SChristoph Hellwig 
29130879f1SChristoph Hellwig 	bmd = kmalloc(struct_size(bmd, iov, data->nr_segs), gfp_mask);
30130879f1SChristoph Hellwig 	if (!bmd)
31130879f1SChristoph Hellwig 		return NULL;
32130879f1SChristoph Hellwig 	memcpy(bmd->iov, data->iov, sizeof(struct iovec) * data->nr_segs);
33130879f1SChristoph Hellwig 	bmd->iter = *data;
34130879f1SChristoph Hellwig 	bmd->iter.iov = bmd->iov;
35130879f1SChristoph Hellwig 	return bmd;
36130879f1SChristoph Hellwig }
37130879f1SChristoph Hellwig 
38130879f1SChristoph Hellwig /**
39130879f1SChristoph Hellwig  * bio_copy_from_iter - copy all pages from iov_iter to bio
40130879f1SChristoph Hellwig  * @bio: The &struct bio which describes the I/O as destination
41130879f1SChristoph Hellwig  * @iter: iov_iter as source
42130879f1SChristoph Hellwig  *
43130879f1SChristoph Hellwig  * Copy all pages from iov_iter to bio.
44130879f1SChristoph Hellwig  * Returns 0 on success, or error on failure.
45130879f1SChristoph Hellwig  */
46130879f1SChristoph Hellwig static int bio_copy_from_iter(struct bio *bio, struct iov_iter *iter)
47130879f1SChristoph Hellwig {
48130879f1SChristoph Hellwig 	struct bio_vec *bvec;
49130879f1SChristoph Hellwig 	struct bvec_iter_all iter_all;
50130879f1SChristoph Hellwig 
51130879f1SChristoph Hellwig 	bio_for_each_segment_all(bvec, bio, iter_all) {
52130879f1SChristoph Hellwig 		ssize_t ret;
53130879f1SChristoph Hellwig 
54130879f1SChristoph Hellwig 		ret = copy_page_from_iter(bvec->bv_page,
55130879f1SChristoph Hellwig 					  bvec->bv_offset,
56130879f1SChristoph Hellwig 					  bvec->bv_len,
57130879f1SChristoph Hellwig 					  iter);
58130879f1SChristoph Hellwig 
59130879f1SChristoph Hellwig 		if (!iov_iter_count(iter))
60130879f1SChristoph Hellwig 			break;
61130879f1SChristoph Hellwig 
62130879f1SChristoph Hellwig 		if (ret < bvec->bv_len)
63130879f1SChristoph Hellwig 			return -EFAULT;
64130879f1SChristoph Hellwig 	}
65130879f1SChristoph Hellwig 
66130879f1SChristoph Hellwig 	return 0;
67130879f1SChristoph Hellwig }
68130879f1SChristoph Hellwig 
69130879f1SChristoph Hellwig /**
70130879f1SChristoph Hellwig  * bio_copy_to_iter - copy all pages from bio to iov_iter
71130879f1SChristoph Hellwig  * @bio: The &struct bio which describes the I/O as source
72130879f1SChristoph Hellwig  * @iter: iov_iter as destination
73130879f1SChristoph Hellwig  *
74130879f1SChristoph Hellwig  * Copy all pages from bio to iov_iter.
75130879f1SChristoph Hellwig  * Returns 0 on success, or error on failure.
76130879f1SChristoph Hellwig  */
77130879f1SChristoph Hellwig static int bio_copy_to_iter(struct bio *bio, struct iov_iter iter)
78130879f1SChristoph Hellwig {
79130879f1SChristoph Hellwig 	struct bio_vec *bvec;
80130879f1SChristoph Hellwig 	struct bvec_iter_all iter_all;
81130879f1SChristoph Hellwig 
82130879f1SChristoph Hellwig 	bio_for_each_segment_all(bvec, bio, iter_all) {
83130879f1SChristoph Hellwig 		ssize_t ret;
84130879f1SChristoph Hellwig 
85130879f1SChristoph Hellwig 		ret = copy_page_to_iter(bvec->bv_page,
86130879f1SChristoph Hellwig 					bvec->bv_offset,
87130879f1SChristoph Hellwig 					bvec->bv_len,
88130879f1SChristoph Hellwig 					&iter);
89130879f1SChristoph Hellwig 
90130879f1SChristoph Hellwig 		if (!iov_iter_count(&iter))
91130879f1SChristoph Hellwig 			break;
92130879f1SChristoph Hellwig 
93130879f1SChristoph Hellwig 		if (ret < bvec->bv_len)
94130879f1SChristoph Hellwig 			return -EFAULT;
95130879f1SChristoph Hellwig 	}
96130879f1SChristoph Hellwig 
97130879f1SChristoph Hellwig 	return 0;
98130879f1SChristoph Hellwig }
99130879f1SChristoph Hellwig 
100130879f1SChristoph Hellwig /**
101130879f1SChristoph Hellwig  *	bio_uncopy_user	-	finish previously mapped bio
102130879f1SChristoph Hellwig  *	@bio: bio being terminated
103130879f1SChristoph Hellwig  *
104130879f1SChristoph Hellwig  *	Free pages allocated from bio_copy_user_iov() and write back data
105130879f1SChristoph Hellwig  *	to user space in case of a read.
106130879f1SChristoph Hellwig  */
107130879f1SChristoph Hellwig static int bio_uncopy_user(struct bio *bio)
108130879f1SChristoph Hellwig {
109130879f1SChristoph Hellwig 	struct bio_map_data *bmd = bio->bi_private;
110130879f1SChristoph Hellwig 	int ret = 0;
111130879f1SChristoph Hellwig 
1123310eebaSChristoph Hellwig 	if (!bmd->is_null_mapped) {
113130879f1SChristoph Hellwig 		/*
114130879f1SChristoph Hellwig 		 * if we're in a workqueue, the request is orphaned, so
115130879f1SChristoph Hellwig 		 * don't copy into a random user address space, just free
116130879f1SChristoph Hellwig 		 * and return -EINTR so user space doesn't expect any data.
117130879f1SChristoph Hellwig 		 */
118130879f1SChristoph Hellwig 		if (!current->mm)
119130879f1SChristoph Hellwig 			ret = -EINTR;
120130879f1SChristoph Hellwig 		else if (bio_data_dir(bio) == READ)
121130879f1SChristoph Hellwig 			ret = bio_copy_to_iter(bio, bmd->iter);
122130879f1SChristoph Hellwig 		if (bmd->is_our_pages)
123130879f1SChristoph Hellwig 			bio_free_pages(bio);
124130879f1SChristoph Hellwig 	}
125130879f1SChristoph Hellwig 	kfree(bmd);
126130879f1SChristoph Hellwig 	return ret;
127130879f1SChristoph Hellwig }
128130879f1SChristoph Hellwig 
1297589ad67SChristoph Hellwig static int bio_copy_user_iov(struct request *rq, struct rq_map_data *map_data,
1307589ad67SChristoph Hellwig 		struct iov_iter *iter, gfp_t gfp_mask)
131130879f1SChristoph Hellwig {
132130879f1SChristoph Hellwig 	struct bio_map_data *bmd;
133130879f1SChristoph Hellwig 	struct page *page;
134393bb12eSChristoph Hellwig 	struct bio *bio;
135130879f1SChristoph Hellwig 	int i = 0, ret;
136130879f1SChristoph Hellwig 	int nr_pages;
137130879f1SChristoph Hellwig 	unsigned int len = iter->count;
138130879f1SChristoph Hellwig 	unsigned int offset = map_data ? offset_in_page(map_data->offset) : 0;
139130879f1SChristoph Hellwig 
140130879f1SChristoph Hellwig 	bmd = bio_alloc_map_data(iter, gfp_mask);
141130879f1SChristoph Hellwig 	if (!bmd)
1427589ad67SChristoph Hellwig 		return -ENOMEM;
143130879f1SChristoph Hellwig 
144130879f1SChristoph Hellwig 	/*
145130879f1SChristoph Hellwig 	 * We need to do a deep copy of the iov_iter including the iovecs.
146130879f1SChristoph Hellwig 	 * The caller provided iov might point to an on-stack or otherwise
147130879f1SChristoph Hellwig 	 * shortlived one.
148130879f1SChristoph Hellwig 	 */
149f3256075SChristoph Hellwig 	bmd->is_our_pages = !map_data;
15003859717SChristoph Hellwig 	bmd->is_null_mapped = (map_data && map_data->null_mapped);
151130879f1SChristoph Hellwig 
1525f7136dbSMatthew Wilcox (Oracle) 	nr_pages = bio_max_segs(DIV_ROUND_UP(offset + len, PAGE_SIZE));
153130879f1SChristoph Hellwig 
154130879f1SChristoph Hellwig 	ret = -ENOMEM;
155066ff571SChristoph Hellwig 	bio = bio_kmalloc(nr_pages, gfp_mask);
156130879f1SChristoph Hellwig 	if (!bio)
157130879f1SChristoph Hellwig 		goto out_bmd;
158066ff571SChristoph Hellwig 	bio_init(bio, NULL, bio->bi_inline_vecs, nr_pages, req_op(rq));
159130879f1SChristoph Hellwig 
160130879f1SChristoph Hellwig 	if (map_data) {
161130879f1SChristoph Hellwig 		nr_pages = 1 << map_data->page_order;
162130879f1SChristoph Hellwig 		i = map_data->offset / PAGE_SIZE;
163130879f1SChristoph Hellwig 	}
164130879f1SChristoph Hellwig 	while (len) {
165130879f1SChristoph Hellwig 		unsigned int bytes = PAGE_SIZE;
166130879f1SChristoph Hellwig 
167130879f1SChristoph Hellwig 		bytes -= offset;
168130879f1SChristoph Hellwig 
169130879f1SChristoph Hellwig 		if (bytes > len)
170130879f1SChristoph Hellwig 			bytes = len;
171130879f1SChristoph Hellwig 
172130879f1SChristoph Hellwig 		if (map_data) {
173130879f1SChristoph Hellwig 			if (i == map_data->nr_entries * nr_pages) {
174130879f1SChristoph Hellwig 				ret = -ENOMEM;
1757589ad67SChristoph Hellwig 				goto cleanup;
176130879f1SChristoph Hellwig 			}
177130879f1SChristoph Hellwig 
178130879f1SChristoph Hellwig 			page = map_data->pages[i / nr_pages];
179130879f1SChristoph Hellwig 			page += (i % nr_pages);
180130879f1SChristoph Hellwig 
181130879f1SChristoph Hellwig 			i++;
182130879f1SChristoph Hellwig 		} else {
183ce288e05SChristoph Hellwig 			page = alloc_page(GFP_NOIO | gfp_mask);
184130879f1SChristoph Hellwig 			if (!page) {
185130879f1SChristoph Hellwig 				ret = -ENOMEM;
1867589ad67SChristoph Hellwig 				goto cleanup;
187130879f1SChristoph Hellwig 			}
188130879f1SChristoph Hellwig 		}
189130879f1SChristoph Hellwig 
1907589ad67SChristoph Hellwig 		if (bio_add_pc_page(rq->q, bio, page, bytes, offset) < bytes) {
191130879f1SChristoph Hellwig 			if (!map_data)
192130879f1SChristoph Hellwig 				__free_page(page);
193130879f1SChristoph Hellwig 			break;
194130879f1SChristoph Hellwig 		}
195130879f1SChristoph Hellwig 
196130879f1SChristoph Hellwig 		len -= bytes;
197130879f1SChristoph Hellwig 		offset = 0;
198130879f1SChristoph Hellwig 	}
199130879f1SChristoph Hellwig 
200130879f1SChristoph Hellwig 	if (map_data)
201130879f1SChristoph Hellwig 		map_data->offset += bio->bi_iter.bi_size;
202130879f1SChristoph Hellwig 
203130879f1SChristoph Hellwig 	/*
204130879f1SChristoph Hellwig 	 * success
205130879f1SChristoph Hellwig 	 */
206130879f1SChristoph Hellwig 	if ((iov_iter_rw(iter) == WRITE &&
207130879f1SChristoph Hellwig 	     (!map_data || !map_data->null_mapped)) ||
208130879f1SChristoph Hellwig 	    (map_data && map_data->from_user)) {
209130879f1SChristoph Hellwig 		ret = bio_copy_from_iter(bio, iter);
210130879f1SChristoph Hellwig 		if (ret)
211130879f1SChristoph Hellwig 			goto cleanup;
212130879f1SChristoph Hellwig 	} else {
213130879f1SChristoph Hellwig 		if (bmd->is_our_pages)
214130879f1SChristoph Hellwig 			zero_fill_bio(bio);
215130879f1SChristoph Hellwig 		iov_iter_advance(iter, bio->bi_iter.bi_size);
216130879f1SChristoph Hellwig 	}
217130879f1SChristoph Hellwig 
218130879f1SChristoph Hellwig 	bio->bi_private = bmd;
2197589ad67SChristoph Hellwig 
220393bb12eSChristoph Hellwig 	ret = blk_rq_append_bio(rq, bio);
2217589ad67SChristoph Hellwig 	if (ret)
2227589ad67SChristoph Hellwig 		goto cleanup;
2237589ad67SChristoph Hellwig 	return 0;
224130879f1SChristoph Hellwig cleanup:
225130879f1SChristoph Hellwig 	if (!map_data)
226130879f1SChristoph Hellwig 		bio_free_pages(bio);
227066ff571SChristoph Hellwig 	bio_uninit(bio);
228066ff571SChristoph Hellwig 	kfree(bio);
229130879f1SChristoph Hellwig out_bmd:
230130879f1SChristoph Hellwig 	kfree(bmd);
2317589ad67SChristoph Hellwig 	return ret;
232130879f1SChristoph Hellwig }
233130879f1SChristoph Hellwig 
2347589ad67SChristoph Hellwig static int bio_map_user_iov(struct request *rq, struct iov_iter *iter,
2357589ad67SChristoph Hellwig 		gfp_t gfp_mask)
236130879f1SChristoph Hellwig {
2377589ad67SChristoph Hellwig 	unsigned int max_sectors = queue_max_hw_sectors(rq->q);
238066ff571SChristoph Hellwig 	unsigned int nr_vecs = iov_iter_npages(iter, BIO_MAX_VECS);
239393bb12eSChristoph Hellwig 	struct bio *bio;
240130879f1SChristoph Hellwig 	int ret;
2417589ad67SChristoph Hellwig 	int j;
242130879f1SChristoph Hellwig 
243130879f1SChristoph Hellwig 	if (!iov_iter_count(iter))
2447589ad67SChristoph Hellwig 		return -EINVAL;
245130879f1SChristoph Hellwig 
246066ff571SChristoph Hellwig 	bio = bio_kmalloc(nr_vecs, gfp_mask);
247130879f1SChristoph Hellwig 	if (!bio)
2487589ad67SChristoph Hellwig 		return -ENOMEM;
249066ff571SChristoph Hellwig 	bio_init(bio, NULL, bio->bi_inline_vecs, nr_vecs, req_op(rq));
250130879f1SChristoph Hellwig 
251130879f1SChristoph Hellwig 	while (iov_iter_count(iter)) {
252130879f1SChristoph Hellwig 		struct page **pages;
253130879f1SChristoph Hellwig 		ssize_t bytes;
254130879f1SChristoph Hellwig 		size_t offs, added = 0;
255130879f1SChristoph Hellwig 		int npages;
256130879f1SChristoph Hellwig 
257130879f1SChristoph Hellwig 		bytes = iov_iter_get_pages_alloc(iter, &pages, LONG_MAX, &offs);
258130879f1SChristoph Hellwig 		if (unlikely(bytes <= 0)) {
259130879f1SChristoph Hellwig 			ret = bytes ? bytes : -EFAULT;
260130879f1SChristoph Hellwig 			goto out_unmap;
261130879f1SChristoph Hellwig 		}
262130879f1SChristoph Hellwig 
263130879f1SChristoph Hellwig 		npages = DIV_ROUND_UP(offs + bytes, PAGE_SIZE);
264130879f1SChristoph Hellwig 
265*7ab89db9SMichal Orzel 		if (unlikely(offs & queue_dma_alignment(rq->q)))
266130879f1SChristoph Hellwig 			j = 0;
267*7ab89db9SMichal Orzel 		else {
268130879f1SChristoph Hellwig 			for (j = 0; j < npages; j++) {
269130879f1SChristoph Hellwig 				struct page *page = pages[j];
270130879f1SChristoph Hellwig 				unsigned int n = PAGE_SIZE - offs;
271130879f1SChristoph Hellwig 				bool same_page = false;
272130879f1SChristoph Hellwig 
273130879f1SChristoph Hellwig 				if (n > bytes)
274130879f1SChristoph Hellwig 					n = bytes;
275130879f1SChristoph Hellwig 
2767589ad67SChristoph Hellwig 				if (!bio_add_hw_page(rq->q, bio, page, n, offs,
277e4581105SChristoph Hellwig 						     max_sectors, &same_page)) {
278130879f1SChristoph Hellwig 					if (same_page)
279130879f1SChristoph Hellwig 						put_page(page);
280130879f1SChristoph Hellwig 					break;
281130879f1SChristoph Hellwig 				}
282130879f1SChristoph Hellwig 
283130879f1SChristoph Hellwig 				added += n;
284130879f1SChristoph Hellwig 				bytes -= n;
285130879f1SChristoph Hellwig 				offs = 0;
286130879f1SChristoph Hellwig 			}
287130879f1SChristoph Hellwig 			iov_iter_advance(iter, added);
288130879f1SChristoph Hellwig 		}
289130879f1SChristoph Hellwig 		/*
290130879f1SChristoph Hellwig 		 * release the pages we didn't map into the bio, if any
291130879f1SChristoph Hellwig 		 */
292130879f1SChristoph Hellwig 		while (j < npages)
293130879f1SChristoph Hellwig 			put_page(pages[j++]);
294130879f1SChristoph Hellwig 		kvfree(pages);
295130879f1SChristoph Hellwig 		/* couldn't stuff something into bio? */
296130879f1SChristoph Hellwig 		if (bytes)
297130879f1SChristoph Hellwig 			break;
298130879f1SChristoph Hellwig 	}
299130879f1SChristoph Hellwig 
300393bb12eSChristoph Hellwig 	ret = blk_rq_append_bio(rq, bio);
3017589ad67SChristoph Hellwig 	if (ret)
302393bb12eSChristoph Hellwig 		goto out_unmap;
3037589ad67SChristoph Hellwig 	return 0;
3047589ad67SChristoph Hellwig 
305130879f1SChristoph Hellwig  out_unmap:
306130879f1SChristoph Hellwig 	bio_release_pages(bio, false);
307066ff571SChristoph Hellwig 	bio_uninit(bio);
308066ff571SChristoph Hellwig 	kfree(bio);
3097589ad67SChristoph Hellwig 	return ret;
310130879f1SChristoph Hellwig }
311130879f1SChristoph Hellwig 
312130879f1SChristoph Hellwig static void bio_invalidate_vmalloc_pages(struct bio *bio)
313130879f1SChristoph Hellwig {
314f358afc5SChristoph Hellwig #ifdef ARCH_IMPLEMENTS_FLUSH_KERNEL_VMAP_RANGE
315130879f1SChristoph Hellwig 	if (bio->bi_private && !op_is_write(bio_op(bio))) {
316130879f1SChristoph Hellwig 		unsigned long i, len = 0;
317130879f1SChristoph Hellwig 
318130879f1SChristoph Hellwig 		for (i = 0; i < bio->bi_vcnt; i++)
319130879f1SChristoph Hellwig 			len += bio->bi_io_vec[i].bv_len;
320130879f1SChristoph Hellwig 		invalidate_kernel_vmap_range(bio->bi_private, len);
321130879f1SChristoph Hellwig 	}
322130879f1SChristoph Hellwig #endif
323130879f1SChristoph Hellwig }
324130879f1SChristoph Hellwig 
325130879f1SChristoph Hellwig static void bio_map_kern_endio(struct bio *bio)
326130879f1SChristoph Hellwig {
327130879f1SChristoph Hellwig 	bio_invalidate_vmalloc_pages(bio);
328066ff571SChristoph Hellwig 	bio_uninit(bio);
329066ff571SChristoph Hellwig 	kfree(bio);
330130879f1SChristoph Hellwig }
331130879f1SChristoph Hellwig 
332130879f1SChristoph Hellwig /**
333130879f1SChristoph Hellwig  *	bio_map_kern	-	map kernel address into bio
334130879f1SChristoph Hellwig  *	@q: the struct request_queue for the bio
335130879f1SChristoph Hellwig  *	@data: pointer to buffer to map
336130879f1SChristoph Hellwig  *	@len: length in bytes
337130879f1SChristoph Hellwig  *	@gfp_mask: allocation flags for bio allocation
338130879f1SChristoph Hellwig  *
339130879f1SChristoph Hellwig  *	Map the kernel address into a bio suitable for io to a block
340130879f1SChristoph Hellwig  *	device. Returns an error pointer in case of error.
341130879f1SChristoph Hellwig  */
342130879f1SChristoph Hellwig static struct bio *bio_map_kern(struct request_queue *q, void *data,
343130879f1SChristoph Hellwig 		unsigned int len, gfp_t gfp_mask)
344130879f1SChristoph Hellwig {
345130879f1SChristoph Hellwig 	unsigned long kaddr = (unsigned long)data;
346130879f1SChristoph Hellwig 	unsigned long end = (kaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
347130879f1SChristoph Hellwig 	unsigned long start = kaddr >> PAGE_SHIFT;
348130879f1SChristoph Hellwig 	const int nr_pages = end - start;
349130879f1SChristoph Hellwig 	bool is_vmalloc = is_vmalloc_addr(data);
350130879f1SChristoph Hellwig 	struct page *page;
351130879f1SChristoph Hellwig 	int offset, i;
352130879f1SChristoph Hellwig 	struct bio *bio;
353130879f1SChristoph Hellwig 
354066ff571SChristoph Hellwig 	bio = bio_kmalloc(nr_pages, gfp_mask);
355130879f1SChristoph Hellwig 	if (!bio)
356130879f1SChristoph Hellwig 		return ERR_PTR(-ENOMEM);
357066ff571SChristoph Hellwig 	bio_init(bio, NULL, bio->bi_inline_vecs, nr_pages, 0);
358130879f1SChristoph Hellwig 
359130879f1SChristoph Hellwig 	if (is_vmalloc) {
360130879f1SChristoph Hellwig 		flush_kernel_vmap_range(data, len);
361130879f1SChristoph Hellwig 		bio->bi_private = data;
362130879f1SChristoph Hellwig 	}
363130879f1SChristoph Hellwig 
364130879f1SChristoph Hellwig 	offset = offset_in_page(kaddr);
365130879f1SChristoph Hellwig 	for (i = 0; i < nr_pages; i++) {
366130879f1SChristoph Hellwig 		unsigned int bytes = PAGE_SIZE - offset;
367130879f1SChristoph Hellwig 
368130879f1SChristoph Hellwig 		if (len <= 0)
369130879f1SChristoph Hellwig 			break;
370130879f1SChristoph Hellwig 
371130879f1SChristoph Hellwig 		if (bytes > len)
372130879f1SChristoph Hellwig 			bytes = len;
373130879f1SChristoph Hellwig 
374130879f1SChristoph Hellwig 		if (!is_vmalloc)
375130879f1SChristoph Hellwig 			page = virt_to_page(data);
376130879f1SChristoph Hellwig 		else
377130879f1SChristoph Hellwig 			page = vmalloc_to_page(data);
378130879f1SChristoph Hellwig 		if (bio_add_pc_page(q, bio, page, bytes,
379130879f1SChristoph Hellwig 				    offset) < bytes) {
380130879f1SChristoph Hellwig 			/* we don't support partial mappings */
381066ff571SChristoph Hellwig 			bio_uninit(bio);
382066ff571SChristoph Hellwig 			kfree(bio);
383130879f1SChristoph Hellwig 			return ERR_PTR(-EINVAL);
384130879f1SChristoph Hellwig 		}
385130879f1SChristoph Hellwig 
386130879f1SChristoph Hellwig 		data += bytes;
387130879f1SChristoph Hellwig 		len -= bytes;
388130879f1SChristoph Hellwig 		offset = 0;
389130879f1SChristoph Hellwig 	}
390130879f1SChristoph Hellwig 
391130879f1SChristoph Hellwig 	bio->bi_end_io = bio_map_kern_endio;
392130879f1SChristoph Hellwig 	return bio;
393130879f1SChristoph Hellwig }
394130879f1SChristoph Hellwig 
395130879f1SChristoph Hellwig static void bio_copy_kern_endio(struct bio *bio)
396130879f1SChristoph Hellwig {
397130879f1SChristoph Hellwig 	bio_free_pages(bio);
398066ff571SChristoph Hellwig 	bio_uninit(bio);
399066ff571SChristoph Hellwig 	kfree(bio);
400130879f1SChristoph Hellwig }
401130879f1SChristoph Hellwig 
402130879f1SChristoph Hellwig static void bio_copy_kern_endio_read(struct bio *bio)
403130879f1SChristoph Hellwig {
404130879f1SChristoph Hellwig 	char *p = bio->bi_private;
405130879f1SChristoph Hellwig 	struct bio_vec *bvec;
406130879f1SChristoph Hellwig 	struct bvec_iter_all iter_all;
407130879f1SChristoph Hellwig 
408130879f1SChristoph Hellwig 	bio_for_each_segment_all(bvec, bio, iter_all) {
409d24920e2SChristoph Hellwig 		memcpy_from_bvec(p, bvec);
410130879f1SChristoph Hellwig 		p += bvec->bv_len;
411130879f1SChristoph Hellwig 	}
412130879f1SChristoph Hellwig 
413130879f1SChristoph Hellwig 	bio_copy_kern_endio(bio);
414130879f1SChristoph Hellwig }
415130879f1SChristoph Hellwig 
416130879f1SChristoph Hellwig /**
417130879f1SChristoph Hellwig  *	bio_copy_kern	-	copy kernel address into bio
418130879f1SChristoph Hellwig  *	@q: the struct request_queue for the bio
419130879f1SChristoph Hellwig  *	@data: pointer to buffer to copy
420130879f1SChristoph Hellwig  *	@len: length in bytes
421130879f1SChristoph Hellwig  *	@gfp_mask: allocation flags for bio and page allocation
422130879f1SChristoph Hellwig  *	@reading: data direction is READ
423130879f1SChristoph Hellwig  *
424130879f1SChristoph Hellwig  *	copy the kernel address into a bio suitable for io to a block
425130879f1SChristoph Hellwig  *	device. Returns an error pointer in case of error.
426130879f1SChristoph Hellwig  */
427130879f1SChristoph Hellwig static struct bio *bio_copy_kern(struct request_queue *q, void *data,
428130879f1SChristoph Hellwig 		unsigned int len, gfp_t gfp_mask, int reading)
429130879f1SChristoph Hellwig {
430130879f1SChristoph Hellwig 	unsigned long kaddr = (unsigned long)data;
431130879f1SChristoph Hellwig 	unsigned long end = (kaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
432130879f1SChristoph Hellwig 	unsigned long start = kaddr >> PAGE_SHIFT;
433130879f1SChristoph Hellwig 	struct bio *bio;
434130879f1SChristoph Hellwig 	void *p = data;
435130879f1SChristoph Hellwig 	int nr_pages = 0;
436130879f1SChristoph Hellwig 
437130879f1SChristoph Hellwig 	/*
438130879f1SChristoph Hellwig 	 * Overflow, abort
439130879f1SChristoph Hellwig 	 */
440130879f1SChristoph Hellwig 	if (end < start)
441130879f1SChristoph Hellwig 		return ERR_PTR(-EINVAL);
442130879f1SChristoph Hellwig 
443130879f1SChristoph Hellwig 	nr_pages = end - start;
444066ff571SChristoph Hellwig 	bio = bio_kmalloc(nr_pages, gfp_mask);
445130879f1SChristoph Hellwig 	if (!bio)
446130879f1SChristoph Hellwig 		return ERR_PTR(-ENOMEM);
447066ff571SChristoph Hellwig 	bio_init(bio, NULL, bio->bi_inline_vecs, nr_pages, 0);
448130879f1SChristoph Hellwig 
449130879f1SChristoph Hellwig 	while (len) {
450130879f1SChristoph Hellwig 		struct page *page;
451130879f1SChristoph Hellwig 		unsigned int bytes = PAGE_SIZE;
452130879f1SChristoph Hellwig 
453130879f1SChristoph Hellwig 		if (bytes > len)
454130879f1SChristoph Hellwig 			bytes = len;
455130879f1SChristoph Hellwig 
456cc8f7fe1SHaimin Zhang 		page = alloc_page(GFP_NOIO | __GFP_ZERO | gfp_mask);
457130879f1SChristoph Hellwig 		if (!page)
458130879f1SChristoph Hellwig 			goto cleanup;
459130879f1SChristoph Hellwig 
460130879f1SChristoph Hellwig 		if (!reading)
461130879f1SChristoph Hellwig 			memcpy(page_address(page), p, bytes);
462130879f1SChristoph Hellwig 
463130879f1SChristoph Hellwig 		if (bio_add_pc_page(q, bio, page, bytes, 0) < bytes)
464130879f1SChristoph Hellwig 			break;
465130879f1SChristoph Hellwig 
466130879f1SChristoph Hellwig 		len -= bytes;
467130879f1SChristoph Hellwig 		p += bytes;
468130879f1SChristoph Hellwig 	}
469130879f1SChristoph Hellwig 
470130879f1SChristoph Hellwig 	if (reading) {
471130879f1SChristoph Hellwig 		bio->bi_end_io = bio_copy_kern_endio_read;
472130879f1SChristoph Hellwig 		bio->bi_private = data;
473130879f1SChristoph Hellwig 	} else {
474130879f1SChristoph Hellwig 		bio->bi_end_io = bio_copy_kern_endio;
475130879f1SChristoph Hellwig 	}
476130879f1SChristoph Hellwig 
477130879f1SChristoph Hellwig 	return bio;
478130879f1SChristoph Hellwig 
479130879f1SChristoph Hellwig cleanup:
480130879f1SChristoph Hellwig 	bio_free_pages(bio);
481066ff571SChristoph Hellwig 	bio_uninit(bio);
482066ff571SChristoph Hellwig 	kfree(bio);
483130879f1SChristoph Hellwig 	return ERR_PTR(-ENOMEM);
484130879f1SChristoph Hellwig }
485130879f1SChristoph Hellwig 
48698d61d5bSChristoph Hellwig /*
4870abc2a10SJens Axboe  * Append a bio to a passthrough request.  Only works if the bio can be merged
4880abc2a10SJens Axboe  * into the request based on the driver constraints.
48998d61d5bSChristoph Hellwig  */
490393bb12eSChristoph Hellwig int blk_rq_append_bio(struct request *rq, struct bio *bio)
49186db1e29SJens Axboe {
49214ccb66bSChristoph Hellwig 	struct bvec_iter iter;
49314ccb66bSChristoph Hellwig 	struct bio_vec bv;
49414ccb66bSChristoph Hellwig 	unsigned int nr_segs = 0;
4950abc2a10SJens Axboe 
496393bb12eSChristoph Hellwig 	bio_for_each_bvec(bv, bio, iter)
49714ccb66bSChristoph Hellwig 		nr_segs++;
49814ccb66bSChristoph Hellwig 
49998d61d5bSChristoph Hellwig 	if (!rq->bio) {
500393bb12eSChristoph Hellwig 		blk_rq_bio_prep(rq, bio, nr_segs);
50198d61d5bSChristoph Hellwig 	} else {
502393bb12eSChristoph Hellwig 		if (!ll_back_merge_fn(rq, bio, nr_segs))
50386db1e29SJens Axboe 			return -EINVAL;
504393bb12eSChristoph Hellwig 		rq->biotail->bi_next = bio;
505393bb12eSChristoph Hellwig 		rq->biotail = bio;
506393bb12eSChristoph Hellwig 		rq->__data_len += (bio)->bi_iter.bi_size;
507393bb12eSChristoph Hellwig 		bio_crypt_free_ctx(bio);
50886db1e29SJens Axboe 	}
50998d61d5bSChristoph Hellwig 
51086db1e29SJens Axboe 	return 0;
51186db1e29SJens Axboe }
51298d61d5bSChristoph Hellwig EXPORT_SYMBOL(blk_rq_append_bio);
51386db1e29SJens Axboe 
51486db1e29SJens Axboe /**
515aebf526bSChristoph Hellwig  * blk_rq_map_user_iov - map user data to a request, for passthrough requests
51686db1e29SJens Axboe  * @q:		request queue where request should be inserted
51786db1e29SJens Axboe  * @rq:		request to map data to
518152e283fSFUJITA Tomonori  * @map_data:   pointer to the rq_map_data holding pages (if necessary)
51926e49cfcSKent Overstreet  * @iter:	iovec iterator
520a3bce90eSFUJITA Tomonori  * @gfp_mask:	memory allocation flags
52186db1e29SJens Axboe  *
52286db1e29SJens Axboe  * Description:
523710027a4SRandy Dunlap  *    Data will be mapped directly for zero copy I/O, if possible. Otherwise
52486db1e29SJens Axboe  *    a kernel bounce buffer is used.
52586db1e29SJens Axboe  *
526710027a4SRandy Dunlap  *    A matching blk_rq_unmap_user() must be issued at the end of I/O, while
52786db1e29SJens Axboe  *    still in process context.
52886db1e29SJens Axboe  */
52986db1e29SJens Axboe int blk_rq_map_user_iov(struct request_queue *q, struct request *rq,
53026e49cfcSKent Overstreet 			struct rq_map_data *map_data,
53126e49cfcSKent Overstreet 			const struct iov_iter *iter, gfp_t gfp_mask)
53286db1e29SJens Axboe {
533357f435dSAl Viro 	bool copy = false;
534357f435dSAl Viro 	unsigned long align = q->dma_pad_mask | queue_dma_alignment(q);
5354d6af73dSChristoph Hellwig 	struct bio *bio = NULL;
5364d6af73dSChristoph Hellwig 	struct iov_iter i;
53769e0927bSDouglas Gilbert 	int ret = -EINVAL;
53886db1e29SJens Axboe 
539a0ac402cSLinus Torvalds 	if (!iter_is_iovec(iter))
540a0ac402cSLinus Torvalds 		goto fail;
541a0ac402cSLinus Torvalds 
542357f435dSAl Viro 	if (map_data)
5434d6af73dSChristoph Hellwig 		copy = true;
544393bb12eSChristoph Hellwig 	else if (blk_queue_may_bounce(q))
545393bb12eSChristoph Hellwig 		copy = true;
546357f435dSAl Viro 	else if (iov_iter_alignment(iter) & align)
547357f435dSAl Viro 		copy = true;
548357f435dSAl Viro 	else if (queue_virt_boundary(q))
549357f435dSAl Viro 		copy = queue_virt_boundary(q) & iov_iter_gap_alignment(iter);
550afdc1a78SFUJITA Tomonori 
5514d6af73dSChristoph Hellwig 	i = *iter;
5524d6af73dSChristoph Hellwig 	do {
5537589ad67SChristoph Hellwig 		if (copy)
5547589ad67SChristoph Hellwig 			ret = bio_copy_user_iov(rq, map_data, &i, gfp_mask);
5557589ad67SChristoph Hellwig 		else
5567589ad67SChristoph Hellwig 			ret = bio_map_user_iov(rq, &i, gfp_mask);
5574d6af73dSChristoph Hellwig 		if (ret)
5584d6af73dSChristoph Hellwig 			goto unmap_rq;
5594d6af73dSChristoph Hellwig 		if (!bio)
5604d6af73dSChristoph Hellwig 			bio = rq->bio;
5614d6af73dSChristoph Hellwig 	} while (iov_iter_count(&i));
56286db1e29SJens Axboe 
56386db1e29SJens Axboe 	return 0;
5644d6af73dSChristoph Hellwig 
5654d6af73dSChristoph Hellwig unmap_rq:
5663b7995a9SYang Yingliang 	blk_rq_unmap_user(bio);
567a0ac402cSLinus Torvalds fail:
5684d6af73dSChristoph Hellwig 	rq->bio = NULL;
56969e0927bSDouglas Gilbert 	return ret;
57086db1e29SJens Axboe }
571152e283fSFUJITA Tomonori EXPORT_SYMBOL(blk_rq_map_user_iov);
57286db1e29SJens Axboe 
573ddad8dd0SChristoph Hellwig int blk_rq_map_user(struct request_queue *q, struct request *rq,
574ddad8dd0SChristoph Hellwig 		    struct rq_map_data *map_data, void __user *ubuf,
575ddad8dd0SChristoph Hellwig 		    unsigned long len, gfp_t gfp_mask)
576ddad8dd0SChristoph Hellwig {
57726e49cfcSKent Overstreet 	struct iovec iov;
57826e49cfcSKent Overstreet 	struct iov_iter i;
5798f7e885aSAl Viro 	int ret = import_single_range(rq_data_dir(rq), ubuf, len, &iov, &i);
580ddad8dd0SChristoph Hellwig 
5818f7e885aSAl Viro 	if (unlikely(ret < 0))
5828f7e885aSAl Viro 		return ret;
583ddad8dd0SChristoph Hellwig 
58426e49cfcSKent Overstreet 	return blk_rq_map_user_iov(q, rq, map_data, &i, gfp_mask);
585ddad8dd0SChristoph Hellwig }
586ddad8dd0SChristoph Hellwig EXPORT_SYMBOL(blk_rq_map_user);
587ddad8dd0SChristoph Hellwig 
58886db1e29SJens Axboe /**
58986db1e29SJens Axboe  * blk_rq_unmap_user - unmap a request with user data
59086db1e29SJens Axboe  * @bio:	       start of bio list
59186db1e29SJens Axboe  *
59286db1e29SJens Axboe  * Description:
59386db1e29SJens Axboe  *    Unmap a rq previously mapped by blk_rq_map_user(). The caller must
59486db1e29SJens Axboe  *    supply the original rq->bio from the blk_rq_map_user() return, since
595710027a4SRandy Dunlap  *    the I/O completion may have changed rq->bio.
59686db1e29SJens Axboe  */
59786db1e29SJens Axboe int blk_rq_unmap_user(struct bio *bio)
59886db1e29SJens Axboe {
599393bb12eSChristoph Hellwig 	struct bio *next_bio;
60086db1e29SJens Axboe 	int ret = 0, ret2;
60186db1e29SJens Axboe 
60286db1e29SJens Axboe 	while (bio) {
6033310eebaSChristoph Hellwig 		if (bio->bi_private) {
604393bb12eSChristoph Hellwig 			ret2 = bio_uncopy_user(bio);
60586db1e29SJens Axboe 			if (ret2 && !ret)
60686db1e29SJens Axboe 				ret = ret2;
6073310eebaSChristoph Hellwig 		} else {
608393bb12eSChristoph Hellwig 			bio_release_pages(bio, bio_data_dir(bio) == READ);
6097b63c052SChristoph Hellwig 		}
61086db1e29SJens Axboe 
611393bb12eSChristoph Hellwig 		next_bio = bio;
61286db1e29SJens Axboe 		bio = bio->bi_next;
613066ff571SChristoph Hellwig 		bio_uninit(next_bio);
614066ff571SChristoph Hellwig 		kfree(next_bio);
61586db1e29SJens Axboe 	}
61686db1e29SJens Axboe 
61786db1e29SJens Axboe 	return ret;
61886db1e29SJens Axboe }
61986db1e29SJens Axboe EXPORT_SYMBOL(blk_rq_unmap_user);
62086db1e29SJens Axboe 
62186db1e29SJens Axboe /**
622aebf526bSChristoph Hellwig  * blk_rq_map_kern - map kernel data to a request, for passthrough requests
62386db1e29SJens Axboe  * @q:		request queue where request should be inserted
62486db1e29SJens Axboe  * @rq:		request to fill
62586db1e29SJens Axboe  * @kbuf:	the kernel buffer
62686db1e29SJens Axboe  * @len:	length of user data
62786db1e29SJens Axboe  * @gfp_mask:	memory allocation flags
62868154e90SFUJITA Tomonori  *
62968154e90SFUJITA Tomonori  * Description:
63068154e90SFUJITA Tomonori  *    Data will be mapped directly if possible. Otherwise a bounce
631e227867fSMasanari Iida  *    buffer is used. Can be called multiple times to append multiple
6323a5a3927SJames Bottomley  *    buffers.
63386db1e29SJens Axboe  */
63486db1e29SJens Axboe int blk_rq_map_kern(struct request_queue *q, struct request *rq, void *kbuf,
63586db1e29SJens Axboe 		    unsigned int len, gfp_t gfp_mask)
63686db1e29SJens Axboe {
63768154e90SFUJITA Tomonori 	int reading = rq_data_dir(rq) == READ;
63814417799SNamhyung Kim 	unsigned long addr = (unsigned long) kbuf;
639393bb12eSChristoph Hellwig 	struct bio *bio;
6403a5a3927SJames Bottomley 	int ret;
64186db1e29SJens Axboe 
642ae03bf63SMartin K. Petersen 	if (len > (queue_max_hw_sectors(q) << 9))
64386db1e29SJens Axboe 		return -EINVAL;
64486db1e29SJens Axboe 	if (!len || !kbuf)
64586db1e29SJens Axboe 		return -EINVAL;
64686db1e29SJens Axboe 
647393bb12eSChristoph Hellwig 	if (!blk_rq_aligned(q, addr, len) || object_is_on_stack(kbuf) ||
648393bb12eSChristoph Hellwig 	    blk_queue_may_bounce(q))
64968154e90SFUJITA Tomonori 		bio = bio_copy_kern(q, kbuf, len, gfp_mask, reading);
65068154e90SFUJITA Tomonori 	else
65186db1e29SJens Axboe 		bio = bio_map_kern(q, kbuf, len, gfp_mask);
65268154e90SFUJITA Tomonori 
65386db1e29SJens Axboe 	if (IS_ERR(bio))
65486db1e29SJens Axboe 		return PTR_ERR(bio);
65586db1e29SJens Axboe 
656aebf526bSChristoph Hellwig 	bio->bi_opf &= ~REQ_OP_MASK;
657aebf526bSChristoph Hellwig 	bio->bi_opf |= req_op(rq);
65886db1e29SJens Axboe 
659393bb12eSChristoph Hellwig 	ret = blk_rq_append_bio(rq, bio);
660066ff571SChristoph Hellwig 	if (unlikely(ret)) {
661066ff571SChristoph Hellwig 		bio_uninit(bio);
662066ff571SChristoph Hellwig 		kfree(bio);
663066ff571SChristoph Hellwig 	}
6643a5a3927SJames Bottomley 	return ret;
6653a5a3927SJames Bottomley }
66686db1e29SJens Axboe EXPORT_SYMBOL(blk_rq_map_kern);
667