blob: 33d79a4eb92d6e623aa90e2291af39b2b2689d83 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Jens Axboe0fe23472006-09-04 15:41:16 +02002 * Copyright (C) 2001 Jens Axboe <axboe@kernel.dk>
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public Licens
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-
16 *
17 */
18#include <linux/mm.h>
19#include <linux/swap.h>
20#include <linux/bio.h>
21#include <linux/blkdev.h>
Kent Overstreeta27bb332013-05-07 16:19:08 -070022#include <linux/uio.h>
Tejun Heo852c7882012-03-05 13:15:27 -080023#include <linux/iocontext.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/slab.h>
25#include <linux/init.h>
26#include <linux/kernel.h>
Paul Gortmaker630d9c42011-11-16 23:57:37 -050027#include <linux/export.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/mempool.h>
29#include <linux/workqueue.h>
Tejun Heo852c7882012-03-05 13:15:27 -080030#include <linux/cgroup.h>
James Bottomley f1970ba2005-06-20 14:06:52 +020031#include <scsi/sg.h> /* for struct sg_iovec */
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Li Zefan55782132009-06-09 13:43:05 +080033#include <trace/events/block.h>
Ingo Molnar0bfc2452008-11-26 11:59:56 +010034
Jens Axboe392ddc32008-12-23 12:42:54 +010035/*
36 * Test patch to inline a certain number of bi_io_vec's inside the bio
37 * itself, to shrink a bio data allocation from two mempool calls to one
38 */
39#define BIO_INLINE_VECS 4
40
Denis ChengRq6feef532008-10-09 08:57:05 +020041static mempool_t *bio_split_pool __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
Linus Torvalds1da177e2005-04-16 15:20:36 -070043/*
44 * if you change this list, also change bvec_alloc or things will
45 * break badly! cannot be bigger than what you can fit into an
46 * unsigned short
47 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#define BV(x) { .nr_vecs = x, .name = "biovec-"__stringify(x) }
Martin K. Petersendf677142011-03-08 08:28:01 +010049static struct biovec_slab bvec_slabs[BIOVEC_NR_POOLS] __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070050 BV(1), BV(4), BV(16), BV(64), BV(128), BV(BIO_MAX_PAGES),
51};
52#undef BV
53
54/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 * fs_bio_set is the bio_set containing bio and iovec memory pools used by
56 * IO code that does not need private memory pools.
57 */
Martin K. Petersen51d654e2008-06-17 18:59:56 +020058struct bio_set *fs_bio_set;
Kent Overstreet3f86a822012-09-06 15:35:01 -070059EXPORT_SYMBOL(fs_bio_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
Jens Axboebb799ca2008-12-10 15:35:05 +010061/*
62 * Our slab pool management
63 */
64struct bio_slab {
65 struct kmem_cache *slab;
66 unsigned int slab_ref;
67 unsigned int slab_size;
68 char name[8];
69};
70static DEFINE_MUTEX(bio_slab_lock);
71static struct bio_slab *bio_slabs;
72static unsigned int bio_slab_nr, bio_slab_max;
73
74static struct kmem_cache *bio_find_or_create_slab(unsigned int extra_size)
75{
76 unsigned int sz = sizeof(struct bio) + extra_size;
77 struct kmem_cache *slab = NULL;
Alexey Khoroshilov389d7b22012-08-09 15:19:25 +020078 struct bio_slab *bslab, *new_bio_slabs;
Anna Leuschner386bc352012-10-22 21:53:36 +020079 unsigned int new_bio_slab_max;
Jens Axboebb799ca2008-12-10 15:35:05 +010080 unsigned int i, entry = -1;
81
82 mutex_lock(&bio_slab_lock);
83
84 i = 0;
85 while (i < bio_slab_nr) {
Thiago Farinaf06f1352010-01-19 14:07:09 +010086 bslab = &bio_slabs[i];
Jens Axboebb799ca2008-12-10 15:35:05 +010087
88 if (!bslab->slab && entry == -1)
89 entry = i;
90 else if (bslab->slab_size == sz) {
91 slab = bslab->slab;
92 bslab->slab_ref++;
93 break;
94 }
95 i++;
96 }
97
98 if (slab)
99 goto out_unlock;
100
101 if (bio_slab_nr == bio_slab_max && entry == -1) {
Anna Leuschner386bc352012-10-22 21:53:36 +0200102 new_bio_slab_max = bio_slab_max << 1;
Alexey Khoroshilov389d7b22012-08-09 15:19:25 +0200103 new_bio_slabs = krealloc(bio_slabs,
Anna Leuschner386bc352012-10-22 21:53:36 +0200104 new_bio_slab_max * sizeof(struct bio_slab),
Alexey Khoroshilov389d7b22012-08-09 15:19:25 +0200105 GFP_KERNEL);
106 if (!new_bio_slabs)
Jens Axboebb799ca2008-12-10 15:35:05 +0100107 goto out_unlock;
Anna Leuschner386bc352012-10-22 21:53:36 +0200108 bio_slab_max = new_bio_slab_max;
Alexey Khoroshilov389d7b22012-08-09 15:19:25 +0200109 bio_slabs = new_bio_slabs;
Jens Axboebb799ca2008-12-10 15:35:05 +0100110 }
111 if (entry == -1)
112 entry = bio_slab_nr++;
113
114 bslab = &bio_slabs[entry];
115
116 snprintf(bslab->name, sizeof(bslab->name), "bio-%d", entry);
117 slab = kmem_cache_create(bslab->name, sz, 0, SLAB_HWCACHE_ALIGN, NULL);
118 if (!slab)
119 goto out_unlock;
120
Mandeep Singh Baines80cdc6d2011-03-22 16:33:54 -0700121 printk(KERN_INFO "bio: create slab <%s> at %d\n", bslab->name, entry);
Jens Axboebb799ca2008-12-10 15:35:05 +0100122 bslab->slab = slab;
123 bslab->slab_ref = 1;
124 bslab->slab_size = sz;
125out_unlock:
126 mutex_unlock(&bio_slab_lock);
127 return slab;
128}
129
130static void bio_put_slab(struct bio_set *bs)
131{
132 struct bio_slab *bslab = NULL;
133 unsigned int i;
134
135 mutex_lock(&bio_slab_lock);
136
137 for (i = 0; i < bio_slab_nr; i++) {
138 if (bs->bio_slab == bio_slabs[i].slab) {
139 bslab = &bio_slabs[i];
140 break;
141 }
142 }
143
144 if (WARN(!bslab, KERN_ERR "bio: unable to find slab!\n"))
145 goto out;
146
147 WARN_ON(!bslab->slab_ref);
148
149 if (--bslab->slab_ref)
150 goto out;
151
152 kmem_cache_destroy(bslab->slab);
153 bslab->slab = NULL;
154
155out:
156 mutex_unlock(&bio_slab_lock);
157}
158
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200159unsigned int bvec_nr_vecs(unsigned short idx)
160{
161 return bvec_slabs[idx].nr_vecs;
162}
163
Kent Overstreet9f060e22012-10-12 15:29:33 -0700164void bvec_free(mempool_t *pool, struct bio_vec *bv, unsigned int idx)
Jens Axboebb799ca2008-12-10 15:35:05 +0100165{
166 BIO_BUG_ON(idx >= BIOVEC_NR_POOLS);
167
168 if (idx == BIOVEC_MAX_IDX)
Kent Overstreet9f060e22012-10-12 15:29:33 -0700169 mempool_free(bv, pool);
Jens Axboebb799ca2008-12-10 15:35:05 +0100170 else {
171 struct biovec_slab *bvs = bvec_slabs + idx;
172
173 kmem_cache_free(bvs->slab, bv);
174 }
175}
176
Kent Overstreet9f060e22012-10-12 15:29:33 -0700177struct bio_vec *bvec_alloc(gfp_t gfp_mask, int nr, unsigned long *idx,
178 mempool_t *pool)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179{
180 struct bio_vec *bvl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181
182 /*
Jens Axboe7ff93452008-12-11 11:53:43 +0100183 * see comment near bvec_array define!
184 */
185 switch (nr) {
186 case 1:
187 *idx = 0;
188 break;
189 case 2 ... 4:
190 *idx = 1;
191 break;
192 case 5 ... 16:
193 *idx = 2;
194 break;
195 case 17 ... 64:
196 *idx = 3;
197 break;
198 case 65 ... 128:
199 *idx = 4;
200 break;
201 case 129 ... BIO_MAX_PAGES:
202 *idx = 5;
203 break;
204 default:
205 return NULL;
206 }
207
208 /*
209 * idx now points to the pool we want to allocate from. only the
210 * 1-vec entry pool is mempool backed.
211 */
212 if (*idx == BIOVEC_MAX_IDX) {
213fallback:
Kent Overstreet9f060e22012-10-12 15:29:33 -0700214 bvl = mempool_alloc(pool, gfp_mask);
Jens Axboe7ff93452008-12-11 11:53:43 +0100215 } else {
216 struct biovec_slab *bvs = bvec_slabs + *idx;
217 gfp_t __gfp_mask = gfp_mask & ~(__GFP_WAIT | __GFP_IO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218
Jens Axboe0a0d96b2008-09-11 13:17:37 +0200219 /*
Jens Axboe7ff93452008-12-11 11:53:43 +0100220 * Make this allocation restricted and don't dump info on
221 * allocation failures, since we'll fallback to the mempool
222 * in case of failure.
Jens Axboe0a0d96b2008-09-11 13:17:37 +0200223 */
Jens Axboe7ff93452008-12-11 11:53:43 +0100224 __gfp_mask |= __GFP_NOMEMALLOC | __GFP_NORETRY | __GFP_NOWARN;
225
226 /*
227 * Try a slab allocation. If this fails and __GFP_WAIT
228 * is set, retry with the 1-entry mempool
229 */
230 bvl = kmem_cache_alloc(bvs->slab, __gfp_mask);
231 if (unlikely(!bvl && (gfp_mask & __GFP_WAIT))) {
232 *idx = BIOVEC_MAX_IDX;
233 goto fallback;
234 }
235 }
236
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 return bvl;
238}
239
Kent Overstreet4254bba2012-09-06 15:35:00 -0700240static void __bio_free(struct bio *bio)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241{
Kent Overstreet4254bba2012-09-06 15:35:00 -0700242 bio_disassociate_task(bio);
Jens Axboe992c5dd2007-07-18 13:18:08 +0200243
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200244 if (bio_integrity(bio))
Kent Overstreet1e2a410f2012-09-06 15:34:56 -0700245 bio_integrity_free(bio);
Kent Overstreet4254bba2012-09-06 15:35:00 -0700246}
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200247
Kent Overstreet4254bba2012-09-06 15:35:00 -0700248static void bio_free(struct bio *bio)
249{
250 struct bio_set *bs = bio->bi_pool;
251 void *p;
252
253 __bio_free(bio);
254
255 if (bs) {
Kent Overstreeta38352e2012-05-25 13:03:11 -0700256 if (bio_flagged(bio, BIO_OWNS_VEC))
Kent Overstreet9f060e22012-10-12 15:29:33 -0700257 bvec_free(bs->bvec_pool, bio->bi_io_vec, BIO_POOL_IDX(bio));
Kent Overstreet4254bba2012-09-06 15:35:00 -0700258
259 /*
260 * If we have front padding, adjust the bio pointer before freeing
261 */
262 p = bio;
Jens Axboebb799ca2008-12-10 15:35:05 +0100263 p -= bs->front_pad;
264
Kent Overstreet4254bba2012-09-06 15:35:00 -0700265 mempool_free(p, bs->bio_pool);
266 } else {
267 /* Bio was allocated by bio_kmalloc() */
268 kfree(bio);
269 }
Peter Osterlund36763472005-09-06 15:16:42 -0700270}
271
Arjan van de Ven858119e2006-01-14 13:20:43 -0800272void bio_init(struct bio *bio)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273{
Jens Axboe2b94de52007-07-18 13:14:03 +0200274 memset(bio, 0, sizeof(*bio));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 bio->bi_flags = 1 << BIO_UPTODATE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 atomic_set(&bio->bi_cnt, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277}
H Hartley Sweetena112a712009-09-26 16:19:21 +0200278EXPORT_SYMBOL(bio_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279
280/**
Kent Overstreetf44b48c2012-09-06 15:34:58 -0700281 * bio_reset - reinitialize a bio
282 * @bio: bio to reset
283 *
284 * Description:
285 * After calling bio_reset(), @bio will be in the same state as a freshly
286 * allocated bio returned bio bio_alloc_bioset() - the only fields that are
287 * preserved are the ones that are initialized by bio_alloc_bioset(). See
288 * comment in struct bio.
289 */
290void bio_reset(struct bio *bio)
291{
292 unsigned long flags = bio->bi_flags & (~0UL << BIO_RESET_BITS);
293
Kent Overstreet4254bba2012-09-06 15:35:00 -0700294 __bio_free(bio);
Kent Overstreetf44b48c2012-09-06 15:34:58 -0700295
296 memset(bio, 0, BIO_RESET_BYTES);
297 bio->bi_flags = flags|(1 << BIO_UPTODATE);
298}
299EXPORT_SYMBOL(bio_reset);
300
Kent Overstreetdf2cb6d2012-09-10 14:33:46 -0700301static void bio_alloc_rescue(struct work_struct *work)
302{
303 struct bio_set *bs = container_of(work, struct bio_set, rescue_work);
304 struct bio *bio;
305
306 while (1) {
307 spin_lock(&bs->rescue_lock);
308 bio = bio_list_pop(&bs->rescue_list);
309 spin_unlock(&bs->rescue_lock);
310
311 if (!bio)
312 break;
313
314 generic_make_request(bio);
315 }
316}
317
318static void punt_bios_to_rescuer(struct bio_set *bs)
319{
320 struct bio_list punt, nopunt;
321 struct bio *bio;
322
323 /*
324 * In order to guarantee forward progress we must punt only bios that
325 * were allocated from this bio_set; otherwise, if there was a bio on
326 * there for a stacking driver higher up in the stack, processing it
327 * could require allocating bios from this bio_set, and doing that from
328 * our own rescuer would be bad.
329 *
330 * Since bio lists are singly linked, pop them all instead of trying to
331 * remove from the middle of the list:
332 */
333
334 bio_list_init(&punt);
335 bio_list_init(&nopunt);
336
337 while ((bio = bio_list_pop(current->bio_list)))
338 bio_list_add(bio->bi_pool == bs ? &punt : &nopunt, bio);
339
340 *current->bio_list = nopunt;
341
342 spin_lock(&bs->rescue_lock);
343 bio_list_merge(&bs->rescue_list, &punt);
344 spin_unlock(&bs->rescue_lock);
345
346 queue_work(bs->rescue_workqueue, &bs->rescue_work);
347}
348
Kent Overstreetf44b48c2012-09-06 15:34:58 -0700349/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 * bio_alloc_bioset - allocate a bio for I/O
351 * @gfp_mask: the GFP_ mask given to the slab allocator
352 * @nr_iovecs: number of iovecs to pre-allocate
Jaak Ristiojadb18efa2010-01-15 12:05:07 +0200353 * @bs: the bio_set to allocate from.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 *
355 * Description:
Kent Overstreet3f86a822012-09-06 15:35:01 -0700356 * If @bs is NULL, uses kmalloc() to allocate the bio; else the allocation is
357 * backed by the @bs's mempool.
358 *
359 * When @bs is not NULL, if %__GFP_WAIT is set then bio_alloc will always be
360 * able to allocate a bio. This is due to the mempool guarantees. To make this
361 * work, callers must never allocate more than 1 bio at a time from this pool.
362 * Callers that need to allocate more than 1 bio must always submit the
363 * previously allocated bio for IO before attempting to allocate a new one.
364 * Failure to do so can cause deadlocks under memory pressure.
365 *
Kent Overstreetdf2cb6d2012-09-10 14:33:46 -0700366 * Note that when running under generic_make_request() (i.e. any block
367 * driver), bios are not submitted until after you return - see the code in
368 * generic_make_request() that converts recursion into iteration, to prevent
369 * stack overflows.
370 *
371 * This would normally mean allocating multiple bios under
372 * generic_make_request() would be susceptible to deadlocks, but we have
373 * deadlock avoidance code that resubmits any blocked bios from a rescuer
374 * thread.
375 *
376 * However, we do not guarantee forward progress for allocations from other
377 * mempools. Doing multiple allocations from the same mempool under
378 * generic_make_request() should be avoided - instead, use bio_set's front_pad
379 * for per bio allocations.
380 *
Kent Overstreet3f86a822012-09-06 15:35:01 -0700381 * RETURNS:
382 * Pointer to new bio on success, NULL on failure.
383 */
Al Virodd0fc662005-10-07 07:46:04 +0100384struct bio *bio_alloc_bioset(gfp_t gfp_mask, int nr_iovecs, struct bio_set *bs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385{
Kent Overstreetdf2cb6d2012-09-10 14:33:46 -0700386 gfp_t saved_gfp = gfp_mask;
Kent Overstreet3f86a822012-09-06 15:35:01 -0700387 unsigned front_pad;
388 unsigned inline_vecs;
Tejun Heo451a9eb2009-04-15 19:50:51 +0200389 unsigned long idx = BIO_POOL_NONE;
Ingo Molnar34053972009-02-21 11:16:36 +0100390 struct bio_vec *bvl = NULL;
Tejun Heo451a9eb2009-04-15 19:50:51 +0200391 struct bio *bio;
392 void *p;
Jens Axboe0a0d96b2008-09-11 13:17:37 +0200393
Kent Overstreet3f86a822012-09-06 15:35:01 -0700394 if (!bs) {
395 if (nr_iovecs > UIO_MAXIOV)
396 return NULL;
397
398 p = kmalloc(sizeof(struct bio) +
399 nr_iovecs * sizeof(struct bio_vec),
400 gfp_mask);
401 front_pad = 0;
402 inline_vecs = nr_iovecs;
403 } else {
Kent Overstreetdf2cb6d2012-09-10 14:33:46 -0700404 /*
405 * generic_make_request() converts recursion to iteration; this
406 * means if we're running beneath it, any bios we allocate and
407 * submit will not be submitted (and thus freed) until after we
408 * return.
409 *
410 * This exposes us to a potential deadlock if we allocate
411 * multiple bios from the same bio_set() while running
412 * underneath generic_make_request(). If we were to allocate
413 * multiple bios (say a stacking block driver that was splitting
414 * bios), we would deadlock if we exhausted the mempool's
415 * reserve.
416 *
417 * We solve this, and guarantee forward progress, with a rescuer
418 * workqueue per bio_set. If we go to allocate and there are
419 * bios on current->bio_list, we first try the allocation
420 * without __GFP_WAIT; if that fails, we punt those bios we
421 * would be blocking to the rescuer workqueue before we retry
422 * with the original gfp_flags.
423 */
424
425 if (current->bio_list && !bio_list_empty(current->bio_list))
426 gfp_mask &= ~__GFP_WAIT;
427
Kent Overstreet3f86a822012-09-06 15:35:01 -0700428 p = mempool_alloc(bs->bio_pool, gfp_mask);
Kent Overstreetdf2cb6d2012-09-10 14:33:46 -0700429 if (!p && gfp_mask != saved_gfp) {
430 punt_bios_to_rescuer(bs);
431 gfp_mask = saved_gfp;
432 p = mempool_alloc(bs->bio_pool, gfp_mask);
433 }
434
Kent Overstreet3f86a822012-09-06 15:35:01 -0700435 front_pad = bs->front_pad;
436 inline_vecs = BIO_INLINE_VECS;
437 }
438
Tejun Heo451a9eb2009-04-15 19:50:51 +0200439 if (unlikely(!p))
440 return NULL;
Ingo Molnar34053972009-02-21 11:16:36 +0100441
Kent Overstreet3f86a822012-09-06 15:35:01 -0700442 bio = p + front_pad;
Ingo Molnar34053972009-02-21 11:16:36 +0100443 bio_init(bio);
444
Kent Overstreet3f86a822012-09-06 15:35:01 -0700445 if (nr_iovecs > inline_vecs) {
Kent Overstreet9f060e22012-10-12 15:29:33 -0700446 bvl = bvec_alloc(gfp_mask, nr_iovecs, &idx, bs->bvec_pool);
Kent Overstreetdf2cb6d2012-09-10 14:33:46 -0700447 if (!bvl && gfp_mask != saved_gfp) {
448 punt_bios_to_rescuer(bs);
449 gfp_mask = saved_gfp;
Kent Overstreet9f060e22012-10-12 15:29:33 -0700450 bvl = bvec_alloc(gfp_mask, nr_iovecs, &idx, bs->bvec_pool);
Kent Overstreetdf2cb6d2012-09-10 14:33:46 -0700451 }
452
Ingo Molnar34053972009-02-21 11:16:36 +0100453 if (unlikely(!bvl))
454 goto err_free;
Kent Overstreeta38352e2012-05-25 13:03:11 -0700455
456 bio->bi_flags |= 1 << BIO_OWNS_VEC;
Kent Overstreet3f86a822012-09-06 15:35:01 -0700457 } else if (nr_iovecs) {
458 bvl = bio->bi_inline_vecs;
Ingo Molnar34053972009-02-21 11:16:36 +0100459 }
Kent Overstreet3f86a822012-09-06 15:35:01 -0700460
461 bio->bi_pool = bs;
Ingo Molnar34053972009-02-21 11:16:36 +0100462 bio->bi_flags |= idx << BIO_POOL_OFFSET;
463 bio->bi_max_vecs = nr_iovecs;
Ingo Molnar34053972009-02-21 11:16:36 +0100464 bio->bi_io_vec = bvl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 return bio;
Ingo Molnar34053972009-02-21 11:16:36 +0100466
467err_free:
Tejun Heo451a9eb2009-04-15 19:50:51 +0200468 mempool_free(p, bs->bio_pool);
Ingo Molnar34053972009-02-21 11:16:36 +0100469 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470}
H Hartley Sweetena112a712009-09-26 16:19:21 +0200471EXPORT_SYMBOL(bio_alloc_bioset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473void zero_fill_bio(struct bio *bio)
474{
475 unsigned long flags;
476 struct bio_vec *bv;
477 int i;
478
479 bio_for_each_segment(bv, bio, i) {
480 char *data = bvec_kmap_irq(bv, &flags);
481 memset(data, 0, bv->bv_len);
482 flush_dcache_page(bv->bv_page);
483 bvec_kunmap_irq(data, &flags);
484 }
485}
486EXPORT_SYMBOL(zero_fill_bio);
487
488/**
489 * bio_put - release a reference to a bio
490 * @bio: bio to release reference to
491 *
492 * Description:
493 * Put a reference to a &struct bio, either one you have gotten with
Alberto Bertogliad0bf112009-11-02 11:39:22 +0100494 * bio_alloc, bio_get or bio_clone. The last put of a bio will free it.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 **/
496void bio_put(struct bio *bio)
497{
498 BIO_BUG_ON(!atomic_read(&bio->bi_cnt));
499
500 /*
501 * last put frees it
502 */
Kent Overstreet4254bba2012-09-06 15:35:00 -0700503 if (atomic_dec_and_test(&bio->bi_cnt))
504 bio_free(bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505}
H Hartley Sweetena112a712009-09-26 16:19:21 +0200506EXPORT_SYMBOL(bio_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
Jens Axboe165125e2007-07-24 09:28:11 +0200508inline int bio_phys_segments(struct request_queue *q, struct bio *bio)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509{
510 if (unlikely(!bio_flagged(bio, BIO_SEG_VALID)))
511 blk_recount_segments(q, bio);
512
513 return bio->bi_phys_segments;
514}
H Hartley Sweetena112a712009-09-26 16:19:21 +0200515EXPORT_SYMBOL(bio_phys_segments);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517/**
518 * __bio_clone - clone a bio
519 * @bio: destination bio
520 * @bio_src: bio to clone
521 *
522 * Clone a &bio. Caller will own the returned bio, but not
523 * the actual data it points to. Reference count of returned
524 * bio will be one.
525 */
Arjan van de Ven858119e2006-01-14 13:20:43 -0800526void __bio_clone(struct bio *bio, struct bio *bio_src)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527{
Andrew Mortone525e152005-08-07 09:42:12 -0700528 memcpy(bio->bi_io_vec, bio_src->bi_io_vec,
529 bio_src->bi_max_vecs * sizeof(struct bio_vec));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530
Jens Axboe5d840702008-01-25 12:44:44 +0100531 /*
532 * most users will be overriding ->bi_bdev with a new target,
533 * so we don't set nor calculate new physical/hw segment counts here
534 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 bio->bi_sector = bio_src->bi_sector;
536 bio->bi_bdev = bio_src->bi_bdev;
537 bio->bi_flags |= 1 << BIO_CLONED;
538 bio->bi_rw = bio_src->bi_rw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 bio->bi_vcnt = bio_src->bi_vcnt;
540 bio->bi_size = bio_src->bi_size;
Andrew Mortona5453be2005-07-28 01:07:18 -0700541 bio->bi_idx = bio_src->bi_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542}
H Hartley Sweetena112a712009-09-26 16:19:21 +0200543EXPORT_SYMBOL(__bio_clone);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
545/**
Kent Overstreetbf800ef2012-09-06 15:35:02 -0700546 * bio_clone_bioset - clone a bio
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 * @bio: bio to clone
548 * @gfp_mask: allocation priority
Kent Overstreetbf800ef2012-09-06 15:35:02 -0700549 * @bs: bio_set to allocate from
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 *
551 * Like __bio_clone, only also allocates the returned bio
552 */
Kent Overstreetbf800ef2012-09-06 15:35:02 -0700553struct bio *bio_clone_bioset(struct bio *bio, gfp_t gfp_mask,
554 struct bio_set *bs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555{
Kent Overstreetbf800ef2012-09-06 15:35:02 -0700556 struct bio *b;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557
Kent Overstreetbf800ef2012-09-06 15:35:02 -0700558 b = bio_alloc_bioset(gfp_mask, bio->bi_max_vecs, bs);
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200559 if (!b)
560 return NULL;
561
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200562 __bio_clone(b, bio);
563
564 if (bio_integrity(bio)) {
565 int ret;
566
Kent Overstreet1e2a410f2012-09-06 15:34:56 -0700567 ret = bio_integrity_clone(b, bio, gfp_mask);
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200568
Li Zefan059ea332009-03-09 10:42:45 +0100569 if (ret < 0) {
570 bio_put(b);
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200571 return NULL;
Li Zefan059ea332009-03-09 10:42:45 +0100572 }
Peter Osterlund36763472005-09-06 15:16:42 -0700573 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574
575 return b;
576}
Kent Overstreetbf800ef2012-09-06 15:35:02 -0700577EXPORT_SYMBOL(bio_clone_bioset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578
579/**
580 * bio_get_nr_vecs - return approx number of vecs
581 * @bdev: I/O target
582 *
583 * Return the approximate number of pages we can send to this target.
584 * There's no guarantee that you will be able to fit this number of pages
585 * into a bio, it does not account for dynamic restrictions that vary
586 * on offset.
587 */
588int bio_get_nr_vecs(struct block_device *bdev)
589{
Jens Axboe165125e2007-07-24 09:28:11 +0200590 struct request_queue *q = bdev_get_queue(bdev);
Bernd Schubertf908ee92012-05-11 16:36:44 +0200591 int nr_pages;
592
593 nr_pages = min_t(unsigned,
Kent Overstreet5abebfd2012-02-08 22:07:18 +0100594 queue_max_segments(q),
595 queue_max_sectors(q) / (PAGE_SIZE >> 9) + 1);
Bernd Schubertf908ee92012-05-11 16:36:44 +0200596
597 return min_t(unsigned, nr_pages, BIO_MAX_PAGES);
598
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599}
H Hartley Sweetena112a712009-09-26 16:19:21 +0200600EXPORT_SYMBOL(bio_get_nr_vecs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
Jens Axboe165125e2007-07-24 09:28:11 +0200602static int __bio_add_page(struct request_queue *q, struct bio *bio, struct page
Mike Christiedefd94b2005-12-05 02:37:06 -0600603 *page, unsigned int len, unsigned int offset,
Akinobu Mita34f2fd82013-11-18 22:11:42 +0900604 unsigned int max_sectors)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605{
606 int retried_segments = 0;
607 struct bio_vec *bvec;
608
609 /*
610 * cloned bio must not modify vec list
611 */
612 if (unlikely(bio_flagged(bio, BIO_CLONED)))
613 return 0;
614
Jens Axboe80cfd542006-01-06 09:43:28 +0100615 if (((bio->bi_size + len) >> 9) > max_sectors)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 return 0;
617
Jens Axboe80cfd542006-01-06 09:43:28 +0100618 /*
619 * For filesystems with a blocksize smaller than the pagesize
620 * we will often be called with the same page as last time and
621 * a consecutive offset. Optimize this special case.
622 */
623 if (bio->bi_vcnt > 0) {
624 struct bio_vec *prev = &bio->bi_io_vec[bio->bi_vcnt - 1];
625
626 if (page == prev->bv_page &&
627 offset == prev->bv_offset + prev->bv_len) {
Dmitry Monakhov1d616582010-01-27 22:44:36 +0300628 unsigned int prev_bv_len = prev->bv_len;
Jens Axboe80cfd542006-01-06 09:43:28 +0100629 prev->bv_len += len;
Alasdair G Kergoncc371e62008-07-03 09:53:43 +0200630
631 if (q->merge_bvec_fn) {
632 struct bvec_merge_data bvm = {
Dmitry Monakhov1d616582010-01-27 22:44:36 +0300633 /* prev_bvec is already charged in
634 bi_size, discharge it in order to
635 simulate merging updated prev_bvec
636 as new bvec. */
Alasdair G Kergoncc371e62008-07-03 09:53:43 +0200637 .bi_bdev = bio->bi_bdev,
638 .bi_sector = bio->bi_sector,
Dmitry Monakhov1d616582010-01-27 22:44:36 +0300639 .bi_size = bio->bi_size - prev_bv_len,
Alasdair G Kergoncc371e62008-07-03 09:53:43 +0200640 .bi_rw = bio->bi_rw,
641 };
642
Dmitry Monakhov8bf8c372010-03-03 06:28:06 +0300643 if (q->merge_bvec_fn(q, &bvm, prev) < prev->bv_len) {
Alasdair G Kergoncc371e62008-07-03 09:53:43 +0200644 prev->bv_len -= len;
645 return 0;
646 }
Jens Axboe80cfd542006-01-06 09:43:28 +0100647 }
648
649 goto done;
650 }
651 }
652
653 if (bio->bi_vcnt >= bio->bi_max_vecs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 return 0;
655
656 /*
657 * we might lose a segment or two here, but rather that than
658 * make this too complex.
659 */
660
Martin K. Petersen8a783622010-02-26 00:20:39 -0500661 while (bio->bi_phys_segments >= queue_max_segments(q)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662
663 if (retried_segments)
664 return 0;
665
666 retried_segments = 1;
667 blk_recount_segments(q, bio);
668 }
669
670 /*
671 * setup the new entry, we might clear it again later if we
672 * cannot add the page
673 */
674 bvec = &bio->bi_io_vec[bio->bi_vcnt];
675 bvec->bv_page = page;
676 bvec->bv_len = len;
677 bvec->bv_offset = offset;
678
679 /*
680 * if queue has other restrictions (eg varying max sector size
681 * depending on offset), it can specify a merge_bvec_fn in the
682 * queue to get further control
683 */
684 if (q->merge_bvec_fn) {
Alasdair G Kergoncc371e62008-07-03 09:53:43 +0200685 struct bvec_merge_data bvm = {
686 .bi_bdev = bio->bi_bdev,
687 .bi_sector = bio->bi_sector,
688 .bi_size = bio->bi_size,
689 .bi_rw = bio->bi_rw,
690 };
691
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 /*
693 * merge_bvec_fn() returns number of bytes it can accept
694 * at this offset
695 */
Dmitry Monakhov8bf8c372010-03-03 06:28:06 +0300696 if (q->merge_bvec_fn(q, &bvm, bvec) < bvec->bv_len) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 bvec->bv_page = NULL;
698 bvec->bv_len = 0;
699 bvec->bv_offset = 0;
700 return 0;
701 }
702 }
703
704 /* If we may be able to merge these biovecs, force a recount */
Mikulas Patockab8b3e162008-08-15 10:15:19 +0200705 if (bio->bi_vcnt && (BIOVEC_PHYS_MERGEABLE(bvec-1, bvec)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 bio->bi_flags &= ~(1 << BIO_SEG_VALID);
707
708 bio->bi_vcnt++;
709 bio->bi_phys_segments++;
Jens Axboe80cfd542006-01-06 09:43:28 +0100710 done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 bio->bi_size += len;
712 return len;
713}
714
715/**
Mike Christie6e68af62005-11-11 05:30:27 -0600716 * bio_add_pc_page - attempt to add page to bio
Jens Axboefddfdea2006-01-31 15:24:34 +0100717 * @q: the target queue
Mike Christie6e68af62005-11-11 05:30:27 -0600718 * @bio: destination bio
719 * @page: page to add
720 * @len: vec entry length
721 * @offset: vec entry offset
722 *
723 * Attempt to add a page to the bio_vec maplist. This can fail for a
Andreas Gruenbacherc6428082011-05-27 14:52:09 +0200724 * number of reasons, such as the bio being full or target block device
725 * limitations. The target block device must allow bio's up to PAGE_SIZE,
726 * so it is always possible to add a single page to an empty bio.
727 *
728 * This should only be used by REQ_PC bios.
Mike Christie6e68af62005-11-11 05:30:27 -0600729 */
Jens Axboe165125e2007-07-24 09:28:11 +0200730int bio_add_pc_page(struct request_queue *q, struct bio *bio, struct page *page,
Mike Christie6e68af62005-11-11 05:30:27 -0600731 unsigned int len, unsigned int offset)
732{
Martin K. Petersenae03bf62009-05-22 17:17:50 -0400733 return __bio_add_page(q, bio, page, len, offset,
734 queue_max_hw_sectors(q));
Mike Christie6e68af62005-11-11 05:30:27 -0600735}
H Hartley Sweetena112a712009-09-26 16:19:21 +0200736EXPORT_SYMBOL(bio_add_pc_page);
Mike Christie6e68af62005-11-11 05:30:27 -0600737
738/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 * bio_add_page - attempt to add page to bio
740 * @bio: destination bio
741 * @page: page to add
742 * @len: vec entry length
743 * @offset: vec entry offset
744 *
745 * Attempt to add a page to the bio_vec maplist. This can fail for a
Andreas Gruenbacherc6428082011-05-27 14:52:09 +0200746 * number of reasons, such as the bio being full or target block device
747 * limitations. The target block device must allow bio's up to PAGE_SIZE,
748 * so it is always possible to add a single page to an empty bio.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 */
750int bio_add_page(struct bio *bio, struct page *page, unsigned int len,
751 unsigned int offset)
752{
Mike Christiedefd94b2005-12-05 02:37:06 -0600753 struct request_queue *q = bdev_get_queue(bio->bi_bdev);
Martin K. Petersenae03bf62009-05-22 17:17:50 -0400754 return __bio_add_page(q, bio, page, len, offset, queue_max_sectors(q));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755}
H Hartley Sweetena112a712009-09-26 16:19:21 +0200756EXPORT_SYMBOL(bio_add_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757
Kent Overstreet9e882242012-09-10 14:41:12 -0700758struct submit_bio_ret {
759 struct completion event;
760 int error;
761};
762
763static void submit_bio_wait_endio(struct bio *bio, int error)
764{
765 struct submit_bio_ret *ret = bio->bi_private;
766
767 ret->error = error;
768 complete(&ret->event);
769}
770
771/**
772 * submit_bio_wait - submit a bio, and wait until it completes
773 * @rw: whether to %READ or %WRITE, or maybe to %READA (read ahead)
774 * @bio: The &struct bio which describes the I/O
775 *
776 * Simple wrapper around submit_bio(). Returns 0 on success, or the error from
777 * bio_endio() on failure.
778 */
779int submit_bio_wait(int rw, struct bio *bio)
780{
781 struct submit_bio_ret ret;
782
783 rw |= REQ_SYNC;
784 init_completion(&ret.event);
785 bio->bi_private = &ret;
786 bio->bi_end_io = submit_bio_wait_endio;
787 submit_bio(rw, bio);
788 wait_for_completion(&ret.event);
789
790 return ret.error;
791}
792EXPORT_SYMBOL(submit_bio_wait);
793
Kent Overstreet054bdf62012-09-28 13:17:55 -0700794/**
795 * bio_advance - increment/complete a bio by some number of bytes
796 * @bio: bio to advance
797 * @bytes: number of bytes to complete
798 *
799 * This updates bi_sector, bi_size and bi_idx; if the number of bytes to
800 * complete doesn't align with a bvec boundary, then bv_len and bv_offset will
801 * be updated on the last bvec as well.
802 *
803 * @bio will then represent the remaining, uncompleted portion of the io.
804 */
805void bio_advance(struct bio *bio, unsigned bytes)
806{
807 if (bio_integrity(bio))
808 bio_integrity_advance(bio, bytes);
809
810 bio->bi_sector += bytes >> 9;
811 bio->bi_size -= bytes;
812
813 if (bio->bi_rw & BIO_NO_ADVANCE_ITER_MASK)
814 return;
815
816 while (bytes) {
817 if (unlikely(bio->bi_idx >= bio->bi_vcnt)) {
818 WARN_ONCE(1, "bio idx %d >= vcnt %d\n",
819 bio->bi_idx, bio->bi_vcnt);
820 break;
821 }
822
823 if (bytes >= bio_iovec(bio)->bv_len) {
824 bytes -= bio_iovec(bio)->bv_len;
825 bio->bi_idx++;
826 } else {
827 bio_iovec(bio)->bv_len -= bytes;
828 bio_iovec(bio)->bv_offset += bytes;
829 bytes = 0;
830 }
831 }
832}
833EXPORT_SYMBOL(bio_advance);
834
Kent Overstreet16ac3d62012-09-10 13:57:51 -0700835/**
Kent Overstreeta0787602012-09-10 14:03:28 -0700836 * bio_alloc_pages - allocates a single page for each bvec in a bio
837 * @bio: bio to allocate pages for
838 * @gfp_mask: flags for allocation
839 *
840 * Allocates pages up to @bio->bi_vcnt.
841 *
842 * Returns 0 on success, -ENOMEM on failure. On failure, any allocated pages are
843 * freed.
844 */
845int bio_alloc_pages(struct bio *bio, gfp_t gfp_mask)
846{
847 int i;
848 struct bio_vec *bv;
849
850 bio_for_each_segment_all(bv, bio, i) {
851 bv->bv_page = alloc_page(gfp_mask);
852 if (!bv->bv_page) {
853 while (--bv >= bio->bi_io_vec)
854 __free_page(bv->bv_page);
855 return -ENOMEM;
856 }
857 }
858
859 return 0;
860}
861EXPORT_SYMBOL(bio_alloc_pages);
862
863/**
Kent Overstreet16ac3d62012-09-10 13:57:51 -0700864 * bio_copy_data - copy contents of data buffers from one chain of bios to
865 * another
866 * @src: source bio list
867 * @dst: destination bio list
868 *
869 * If @src and @dst are single bios, bi_next must be NULL - otherwise, treats
870 * @src and @dst as linked lists of bios.
871 *
872 * Stops when it reaches the end of either @src or @dst - that is, copies
873 * min(src->bi_size, dst->bi_size) bytes (or the equivalent for lists of bios).
874 */
875void bio_copy_data(struct bio *dst, struct bio *src)
876{
877 struct bio_vec *src_bv, *dst_bv;
878 unsigned src_offset, dst_offset, bytes;
879 void *src_p, *dst_p;
880
881 src_bv = bio_iovec(src);
882 dst_bv = bio_iovec(dst);
883
884 src_offset = src_bv->bv_offset;
885 dst_offset = dst_bv->bv_offset;
886
887 while (1) {
888 if (src_offset == src_bv->bv_offset + src_bv->bv_len) {
889 src_bv++;
890 if (src_bv == bio_iovec_idx(src, src->bi_vcnt)) {
891 src = src->bi_next;
892 if (!src)
893 break;
894
895 src_bv = bio_iovec(src);
896 }
897
898 src_offset = src_bv->bv_offset;
899 }
900
901 if (dst_offset == dst_bv->bv_offset + dst_bv->bv_len) {
902 dst_bv++;
903 if (dst_bv == bio_iovec_idx(dst, dst->bi_vcnt)) {
904 dst = dst->bi_next;
905 if (!dst)
906 break;
907
908 dst_bv = bio_iovec(dst);
909 }
910
911 dst_offset = dst_bv->bv_offset;
912 }
913
914 bytes = min(dst_bv->bv_offset + dst_bv->bv_len - dst_offset,
915 src_bv->bv_offset + src_bv->bv_len - src_offset);
916
917 src_p = kmap_atomic(src_bv->bv_page);
918 dst_p = kmap_atomic(dst_bv->bv_page);
919
Kent Overstreet2f6cf0d2013-09-23 23:17:26 -0700920 memcpy(dst_p + dst_offset,
921 src_p + src_offset,
Kent Overstreet16ac3d62012-09-10 13:57:51 -0700922 bytes);
923
924 kunmap_atomic(dst_p);
925 kunmap_atomic(src_p);
926
927 src_offset += bytes;
928 dst_offset += bytes;
929 }
930}
931EXPORT_SYMBOL(bio_copy_data);
932
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933struct bio_map_data {
934 struct bio_vec *iovecs;
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +0200935 struct sg_iovec *sgvecs;
FUJITA Tomonori152e2832008-08-28 16:17:06 +0900936 int nr_sgvecs;
937 int is_our_pages;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938};
939
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +0200940static void bio_set_map_data(struct bio_map_data *bmd, struct bio *bio,
FUJITA Tomonori152e2832008-08-28 16:17:06 +0900941 struct sg_iovec *iov, int iov_count,
942 int is_our_pages)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943{
944 memcpy(bmd->iovecs, bio->bi_io_vec, sizeof(struct bio_vec) * bio->bi_vcnt);
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +0200945 memcpy(bmd->sgvecs, iov, sizeof(struct sg_iovec) * iov_count);
946 bmd->nr_sgvecs = iov_count;
FUJITA Tomonori152e2832008-08-28 16:17:06 +0900947 bmd->is_our_pages = is_our_pages;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 bio->bi_private = bmd;
949}
950
951static void bio_free_map_data(struct bio_map_data *bmd)
952{
953 kfree(bmd->iovecs);
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +0200954 kfree(bmd->sgvecs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 kfree(bmd);
956}
957
Dan Carpenter121f0992011-11-16 09:21:50 +0100958static struct bio_map_data *bio_alloc_map_data(int nr_segs,
959 unsigned int iov_count,
FUJITA Tomonori76029ff2008-08-25 20:36:08 +0200960 gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961{
Jens Axboef3f63c12010-10-29 11:46:56 -0600962 struct bio_map_data *bmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963
Jens Axboef3f63c12010-10-29 11:46:56 -0600964 if (iov_count > UIO_MAXIOV)
965 return NULL;
966
967 bmd = kmalloc(sizeof(*bmd), gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 if (!bmd)
969 return NULL;
970
FUJITA Tomonori76029ff2008-08-25 20:36:08 +0200971 bmd->iovecs = kmalloc(sizeof(struct bio_vec) * nr_segs, gfp_mask);
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +0200972 if (!bmd->iovecs) {
973 kfree(bmd);
974 return NULL;
975 }
976
FUJITA Tomonori76029ff2008-08-25 20:36:08 +0200977 bmd->sgvecs = kmalloc(sizeof(struct sg_iovec) * iov_count, gfp_mask);
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +0200978 if (bmd->sgvecs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 return bmd;
980
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +0200981 kfree(bmd->iovecs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 kfree(bmd);
983 return NULL;
984}
985
FUJITA Tomonoriaefcc282008-08-25 20:36:08 +0200986static int __bio_copy_iov(struct bio *bio, struct bio_vec *iovecs,
FUJITA Tomonoriecb554a2009-07-09 14:46:53 +0200987 struct sg_iovec *iov, int iov_count,
988 int to_user, int from_user, int do_free_page)
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +0200989{
990 int ret = 0, i;
991 struct bio_vec *bvec;
992 int iov_idx = 0;
993 unsigned int iov_off = 0;
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +0200994
Kent Overstreetd74c6d52013-02-06 12:23:11 -0800995 bio_for_each_segment_all(bvec, bio, i) {
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +0200996 char *bv_addr = page_address(bvec->bv_page);
FUJITA Tomonoriaefcc282008-08-25 20:36:08 +0200997 unsigned int bv_len = iovecs[i].bv_len;
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +0200998
999 while (bv_len && iov_idx < iov_count) {
1000 unsigned int bytes;
Michal Simek0e0c6212009-06-10 12:57:07 -07001001 char __user *iov_addr;
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +02001002
1003 bytes = min_t(unsigned int,
1004 iov[iov_idx].iov_len - iov_off, bv_len);
1005 iov_addr = iov[iov_idx].iov_base + iov_off;
1006
1007 if (!ret) {
FUJITA Tomonoriecb554a2009-07-09 14:46:53 +02001008 if (to_user)
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +02001009 ret = copy_to_user(iov_addr, bv_addr,
1010 bytes);
1011
FUJITA Tomonoriecb554a2009-07-09 14:46:53 +02001012 if (from_user)
1013 ret = copy_from_user(bv_addr, iov_addr,
1014 bytes);
1015
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +02001016 if (ret)
1017 ret = -EFAULT;
1018 }
1019
1020 bv_len -= bytes;
1021 bv_addr += bytes;
1022 iov_addr += bytes;
1023 iov_off += bytes;
1024
1025 if (iov[iov_idx].iov_len == iov_off) {
1026 iov_idx++;
1027 iov_off = 0;
1028 }
1029 }
1030
FUJITA Tomonori152e2832008-08-28 16:17:06 +09001031 if (do_free_page)
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +02001032 __free_page(bvec->bv_page);
1033 }
1034
1035 return ret;
1036}
1037
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038/**
1039 * bio_uncopy_user - finish previously mapped bio
1040 * @bio: bio being terminated
1041 *
1042 * Free pages allocated from bio_copy_user() and write back data
1043 * to user space in case of a read.
1044 */
1045int bio_uncopy_user(struct bio *bio)
1046{
1047 struct bio_map_data *bmd = bio->bi_private;
Roland Dreier35dc2482013-08-05 17:55:01 -07001048 struct bio_vec *bvec;
1049 int ret = 0, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050
Roland Dreier35dc2482013-08-05 17:55:01 -07001051 if (!bio_flagged(bio, BIO_NULL_MAPPED)) {
1052 /*
1053 * if we're in a workqueue, the request is orphaned, so
1054 * don't copy into a random user address space, just free.
1055 */
1056 if (current->mm)
1057 ret = __bio_copy_iov(bio, bmd->iovecs, bmd->sgvecs,
1058 bmd->nr_sgvecs, bio_data_dir(bio) == READ,
1059 0, bmd->is_our_pages);
1060 else if (bmd->is_our_pages)
1061 bio_for_each_segment_all(bvec, bio, i)
1062 __free_page(bvec->bv_page);
1063 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 bio_free_map_data(bmd);
1065 bio_put(bio);
1066 return ret;
1067}
H Hartley Sweetena112a712009-09-26 16:19:21 +02001068EXPORT_SYMBOL(bio_uncopy_user);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069
1070/**
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +02001071 * bio_copy_user_iov - copy user data to bio
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 * @q: destination block queue
FUJITA Tomonori152e2832008-08-28 16:17:06 +09001073 * @map_data: pointer to the rq_map_data holding pages (if necessary)
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +02001074 * @iov: the iovec.
1075 * @iov_count: number of elements in the iovec
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 * @write_to_vm: bool indicating writing to pages or not
FUJITA Tomonoria3bce902008-08-28 16:17:05 +09001077 * @gfp_mask: memory allocation flags
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 *
1079 * Prepares and returns a bio for indirect user io, bouncing data
1080 * to/from kernel pages as necessary. Must be paired with
1081 * call bio_uncopy_user() on io completion.
1082 */
FUJITA Tomonori152e2832008-08-28 16:17:06 +09001083struct bio *bio_copy_user_iov(struct request_queue *q,
1084 struct rq_map_data *map_data,
1085 struct sg_iovec *iov, int iov_count,
1086 int write_to_vm, gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 struct bio_map_data *bmd;
1089 struct bio_vec *bvec;
1090 struct page *page;
1091 struct bio *bio;
1092 int i, ret;
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +02001093 int nr_pages = 0;
1094 unsigned int len = 0;
FUJITA Tomonori56c451f2008-12-18 14:49:37 +09001095 unsigned int offset = map_data ? map_data->offset & ~PAGE_MASK : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +02001097 for (i = 0; i < iov_count; i++) {
1098 unsigned long uaddr;
1099 unsigned long end;
1100 unsigned long start;
1101
1102 uaddr = (unsigned long)iov[i].iov_base;
1103 end = (uaddr + iov[i].iov_len + PAGE_SIZE - 1) >> PAGE_SHIFT;
1104 start = uaddr >> PAGE_SHIFT;
1105
Jens Axboecb4644c2010-11-10 14:36:25 +01001106 /*
1107 * Overflow, abort
1108 */
1109 if (end < start)
1110 return ERR_PTR(-EINVAL);
1111
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +02001112 nr_pages += end - start;
1113 len += iov[i].iov_len;
1114 }
1115
FUJITA Tomonori69838722009-04-28 20:24:29 +02001116 if (offset)
1117 nr_pages++;
1118
FUJITA Tomonoria3bce902008-08-28 16:17:05 +09001119 bmd = bio_alloc_map_data(nr_pages, iov_count, gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 if (!bmd)
1121 return ERR_PTR(-ENOMEM);
1122
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 ret = -ENOMEM;
Tejun Heoa9e9dc22009-04-15 22:10:27 +09001124 bio = bio_kmalloc(gfp_mask, nr_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 if (!bio)
1126 goto out_bmd;
1127
Christoph Hellwig7b6d91d2010-08-07 18:20:39 +02001128 if (!write_to_vm)
1129 bio->bi_rw |= REQ_WRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130
1131 ret = 0;
FUJITA Tomonori56c451f2008-12-18 14:49:37 +09001132
1133 if (map_data) {
FUJITA Tomonorie623ddb2008-12-18 14:49:36 +09001134 nr_pages = 1 << map_data->page_order;
FUJITA Tomonori56c451f2008-12-18 14:49:37 +09001135 i = map_data->offset / PAGE_SIZE;
1136 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 while (len) {
FUJITA Tomonorie623ddb2008-12-18 14:49:36 +09001138 unsigned int bytes = PAGE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139
FUJITA Tomonori56c451f2008-12-18 14:49:37 +09001140 bytes -= offset;
1141
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 if (bytes > len)
1143 bytes = len;
1144
FUJITA Tomonori152e2832008-08-28 16:17:06 +09001145 if (map_data) {
FUJITA Tomonorie623ddb2008-12-18 14:49:36 +09001146 if (i == map_data->nr_entries * nr_pages) {
FUJITA Tomonori152e2832008-08-28 16:17:06 +09001147 ret = -ENOMEM;
1148 break;
1149 }
FUJITA Tomonorie623ddb2008-12-18 14:49:36 +09001150
1151 page = map_data->pages[i / nr_pages];
1152 page += (i % nr_pages);
1153
1154 i++;
1155 } else {
FUJITA Tomonori152e2832008-08-28 16:17:06 +09001156 page = alloc_page(q->bounce_gfp | gfp_mask);
FUJITA Tomonorie623ddb2008-12-18 14:49:36 +09001157 if (!page) {
1158 ret = -ENOMEM;
1159 break;
1160 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 }
1162
FUJITA Tomonori56c451f2008-12-18 14:49:37 +09001163 if (bio_add_pc_page(q, bio, page, bytes, offset) < bytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165
1166 len -= bytes;
FUJITA Tomonori56c451f2008-12-18 14:49:37 +09001167 offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 }
1169
1170 if (ret)
1171 goto cleanup;
1172
1173 /*
1174 * success
1175 */
FUJITA Tomonoriecb554a2009-07-09 14:46:53 +02001176 if ((!write_to_vm && (!map_data || !map_data->null_mapped)) ||
1177 (map_data && map_data->from_user)) {
1178 ret = __bio_copy_iov(bio, bio->bi_io_vec, iov, iov_count, 0, 1, 0);
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +02001179 if (ret)
1180 goto cleanup;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 }
1182
FUJITA Tomonori152e2832008-08-28 16:17:06 +09001183 bio_set_map_data(bmd, bio, iov, iov_count, map_data ? 0 : 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 return bio;
1185cleanup:
FUJITA Tomonori152e2832008-08-28 16:17:06 +09001186 if (!map_data)
Kent Overstreetd74c6d52013-02-06 12:23:11 -08001187 bio_for_each_segment_all(bvec, bio, i)
FUJITA Tomonori152e2832008-08-28 16:17:06 +09001188 __free_page(bvec->bv_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189
1190 bio_put(bio);
1191out_bmd:
1192 bio_free_map_data(bmd);
1193 return ERR_PTR(ret);
1194}
1195
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +02001196/**
1197 * bio_copy_user - copy user data to bio
1198 * @q: destination block queue
FUJITA Tomonori152e2832008-08-28 16:17:06 +09001199 * @map_data: pointer to the rq_map_data holding pages (if necessary)
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +02001200 * @uaddr: start of user address
1201 * @len: length in bytes
1202 * @write_to_vm: bool indicating writing to pages or not
FUJITA Tomonoria3bce902008-08-28 16:17:05 +09001203 * @gfp_mask: memory allocation flags
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +02001204 *
1205 * Prepares and returns a bio for indirect user io, bouncing data
1206 * to/from kernel pages as necessary. Must be paired with
1207 * call bio_uncopy_user() on io completion.
1208 */
FUJITA Tomonori152e2832008-08-28 16:17:06 +09001209struct bio *bio_copy_user(struct request_queue *q, struct rq_map_data *map_data,
1210 unsigned long uaddr, unsigned int len,
1211 int write_to_vm, gfp_t gfp_mask)
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +02001212{
1213 struct sg_iovec iov;
1214
1215 iov.iov_base = (void __user *)uaddr;
1216 iov.iov_len = len;
1217
FUJITA Tomonori152e2832008-08-28 16:17:06 +09001218 return bio_copy_user_iov(q, map_data, &iov, 1, write_to_vm, gfp_mask);
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +02001219}
H Hartley Sweetena112a712009-09-26 16:19:21 +02001220EXPORT_SYMBOL(bio_copy_user);
FUJITA Tomonoric5dec1c2008-04-11 12:56:49 +02001221
Jens Axboe165125e2007-07-24 09:28:11 +02001222static struct bio *__bio_map_user_iov(struct request_queue *q,
James Bottomley f1970ba2005-06-20 14:06:52 +02001223 struct block_device *bdev,
1224 struct sg_iovec *iov, int iov_count,
FUJITA Tomonoria3bce902008-08-28 16:17:05 +09001225 int write_to_vm, gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226{
James Bottomley f1970ba2005-06-20 14:06:52 +02001227 int i, j;
1228 int nr_pages = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 struct page **pages;
1230 struct bio *bio;
James Bottomley f1970ba2005-06-20 14:06:52 +02001231 int cur_page = 0;
1232 int ret, offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233
James Bottomley f1970ba2005-06-20 14:06:52 +02001234 for (i = 0; i < iov_count; i++) {
1235 unsigned long uaddr = (unsigned long)iov[i].iov_base;
1236 unsigned long len = iov[i].iov_len;
1237 unsigned long end = (uaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
1238 unsigned long start = uaddr >> PAGE_SHIFT;
1239
Jens Axboecb4644c2010-11-10 14:36:25 +01001240 /*
1241 * Overflow, abort
1242 */
1243 if (end < start)
1244 return ERR_PTR(-EINVAL);
1245
James Bottomley f1970ba2005-06-20 14:06:52 +02001246 nr_pages += end - start;
1247 /*
Mike Christiead2d7222006-12-01 10:40:20 +01001248 * buffer must be aligned to at least hardsector size for now
James Bottomley f1970ba2005-06-20 14:06:52 +02001249 */
Mike Christiead2d7222006-12-01 10:40:20 +01001250 if (uaddr & queue_dma_alignment(q))
James Bottomley f1970ba2005-06-20 14:06:52 +02001251 return ERR_PTR(-EINVAL);
1252 }
1253
1254 if (!nr_pages)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 return ERR_PTR(-EINVAL);
1256
Tejun Heoa9e9dc22009-04-15 22:10:27 +09001257 bio = bio_kmalloc(gfp_mask, nr_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 if (!bio)
1259 return ERR_PTR(-ENOMEM);
1260
1261 ret = -ENOMEM;
FUJITA Tomonoria3bce902008-08-28 16:17:05 +09001262 pages = kcalloc(nr_pages, sizeof(struct page *), gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 if (!pages)
1264 goto out;
1265
James Bottomley f1970ba2005-06-20 14:06:52 +02001266 for (i = 0; i < iov_count; i++) {
1267 unsigned long uaddr = (unsigned long)iov[i].iov_base;
1268 unsigned long len = iov[i].iov_len;
1269 unsigned long end = (uaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
1270 unsigned long start = uaddr >> PAGE_SHIFT;
1271 const int local_nr_pages = end - start;
1272 const int page_limit = cur_page + local_nr_pages;
Jens Axboecb4644c2010-11-10 14:36:25 +01001273
Nick Pigginf5dd33c2008-07-25 19:45:25 -07001274 ret = get_user_pages_fast(uaddr, local_nr_pages,
1275 write_to_vm, &pages[cur_page]);
Jens Axboe99172152006-06-16 13:02:29 +02001276 if (ret < local_nr_pages) {
1277 ret = -EFAULT;
James Bottomley f1970ba2005-06-20 14:06:52 +02001278 goto out_unmap;
Jens Axboe99172152006-06-16 13:02:29 +02001279 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280
James Bottomley f1970ba2005-06-20 14:06:52 +02001281 offset = uaddr & ~PAGE_MASK;
1282 for (j = cur_page; j < page_limit; j++) {
1283 unsigned int bytes = PAGE_SIZE - offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284
James Bottomley f1970ba2005-06-20 14:06:52 +02001285 if (len <= 0)
1286 break;
1287
1288 if (bytes > len)
1289 bytes = len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290
James Bottomley f1970ba2005-06-20 14:06:52 +02001291 /*
1292 * sorry...
1293 */
Mike Christiedefd94b2005-12-05 02:37:06 -06001294 if (bio_add_pc_page(q, bio, pages[j], bytes, offset) <
1295 bytes)
James Bottomley f1970ba2005-06-20 14:06:52 +02001296 break;
1297
1298 len -= bytes;
1299 offset = 0;
1300 }
1301
1302 cur_page = j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 /*
James Bottomley f1970ba2005-06-20 14:06:52 +02001304 * release the pages we didn't map into the bio, if any
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 */
James Bottomley f1970ba2005-06-20 14:06:52 +02001306 while (j < page_limit)
1307 page_cache_release(pages[j++]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 }
1309
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 kfree(pages);
1311
1312 /*
1313 * set data direction, and check if mapped pages need bouncing
1314 */
1315 if (!write_to_vm)
Christoph Hellwig7b6d91d2010-08-07 18:20:39 +02001316 bio->bi_rw |= REQ_WRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317
James Bottomley f1970ba2005-06-20 14:06:52 +02001318 bio->bi_bdev = bdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 bio->bi_flags |= (1 << BIO_USER_MAPPED);
1320 return bio;
James Bottomley f1970ba2005-06-20 14:06:52 +02001321
1322 out_unmap:
1323 for (i = 0; i < nr_pages; i++) {
1324 if(!pages[i])
1325 break;
1326 page_cache_release(pages[i]);
1327 }
1328 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 kfree(pages);
1330 bio_put(bio);
1331 return ERR_PTR(ret);
1332}
1333
1334/**
1335 * bio_map_user - map user address into bio
Jens Axboe165125e2007-07-24 09:28:11 +02001336 * @q: the struct request_queue for the bio
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 * @bdev: destination block device
1338 * @uaddr: start of user address
1339 * @len: length in bytes
1340 * @write_to_vm: bool indicating writing to pages or not
FUJITA Tomonoria3bce902008-08-28 16:17:05 +09001341 * @gfp_mask: memory allocation flags
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 *
1343 * Map the user space address into a bio suitable for io to a block
1344 * device. Returns an error pointer in case of error.
1345 */
Jens Axboe165125e2007-07-24 09:28:11 +02001346struct bio *bio_map_user(struct request_queue *q, struct block_device *bdev,
FUJITA Tomonoria3bce902008-08-28 16:17:05 +09001347 unsigned long uaddr, unsigned int len, int write_to_vm,
1348 gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349{
James Bottomley f1970ba2005-06-20 14:06:52 +02001350 struct sg_iovec iov;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351
viro@ZenIV.linux.org.uk3f703532005-09-09 16:53:56 +01001352 iov.iov_base = (void __user *)uaddr;
James Bottomley f1970ba2005-06-20 14:06:52 +02001353 iov.iov_len = len;
1354
FUJITA Tomonoria3bce902008-08-28 16:17:05 +09001355 return bio_map_user_iov(q, bdev, &iov, 1, write_to_vm, gfp_mask);
James Bottomley f1970ba2005-06-20 14:06:52 +02001356}
H Hartley Sweetena112a712009-09-26 16:19:21 +02001357EXPORT_SYMBOL(bio_map_user);
James Bottomley f1970ba2005-06-20 14:06:52 +02001358
1359/**
1360 * bio_map_user_iov - map user sg_iovec table into bio
Jens Axboe165125e2007-07-24 09:28:11 +02001361 * @q: the struct request_queue for the bio
James Bottomley f1970ba2005-06-20 14:06:52 +02001362 * @bdev: destination block device
1363 * @iov: the iovec.
1364 * @iov_count: number of elements in the iovec
1365 * @write_to_vm: bool indicating writing to pages or not
FUJITA Tomonoria3bce902008-08-28 16:17:05 +09001366 * @gfp_mask: memory allocation flags
James Bottomley f1970ba2005-06-20 14:06:52 +02001367 *
1368 * Map the user space address into a bio suitable for io to a block
1369 * device. Returns an error pointer in case of error.
1370 */
Jens Axboe165125e2007-07-24 09:28:11 +02001371struct bio *bio_map_user_iov(struct request_queue *q, struct block_device *bdev,
James Bottomley f1970ba2005-06-20 14:06:52 +02001372 struct sg_iovec *iov, int iov_count,
FUJITA Tomonoria3bce902008-08-28 16:17:05 +09001373 int write_to_vm, gfp_t gfp_mask)
James Bottomley f1970ba2005-06-20 14:06:52 +02001374{
1375 struct bio *bio;
James Bottomley f1970ba2005-06-20 14:06:52 +02001376
FUJITA Tomonoria3bce902008-08-28 16:17:05 +09001377 bio = __bio_map_user_iov(q, bdev, iov, iov_count, write_to_vm,
1378 gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 if (IS_ERR(bio))
1380 return bio;
1381
1382 /*
1383 * subtle -- if __bio_map_user() ended up bouncing a bio,
1384 * it would normally disappear when its bi_end_io is run.
1385 * however, we need it for the unmap, so grab an extra
1386 * reference to it
1387 */
1388 bio_get(bio);
1389
Mike Christie0e75f902006-12-01 10:40:55 +01001390 return bio;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391}
1392
1393static void __bio_unmap_user(struct bio *bio)
1394{
1395 struct bio_vec *bvec;
1396 int i;
1397
1398 /*
1399 * make sure we dirty pages we wrote to
1400 */
Kent Overstreetd74c6d52013-02-06 12:23:11 -08001401 bio_for_each_segment_all(bvec, bio, i) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 if (bio_data_dir(bio) == READ)
1403 set_page_dirty_lock(bvec->bv_page);
1404
1405 page_cache_release(bvec->bv_page);
1406 }
1407
1408 bio_put(bio);
1409}
1410
1411/**
1412 * bio_unmap_user - unmap a bio
1413 * @bio: the bio being unmapped
1414 *
1415 * Unmap a bio previously mapped by bio_map_user(). Must be called with
1416 * a process context.
1417 *
1418 * bio_unmap_user() may sleep.
1419 */
1420void bio_unmap_user(struct bio *bio)
1421{
1422 __bio_unmap_user(bio);
1423 bio_put(bio);
1424}
H Hartley Sweetena112a712009-09-26 16:19:21 +02001425EXPORT_SYMBOL(bio_unmap_user);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426
NeilBrown6712ecf2007-09-27 12:47:43 +02001427static void bio_map_kern_endio(struct bio *bio, int err)
Jens Axboeb8238252005-06-20 14:05:27 +02001428{
Jens Axboeb8238252005-06-20 14:05:27 +02001429 bio_put(bio);
Jens Axboeb8238252005-06-20 14:05:27 +02001430}
1431
Jens Axboe165125e2007-07-24 09:28:11 +02001432static struct bio *__bio_map_kern(struct request_queue *q, void *data,
Al Viro27496a82005-10-21 03:20:48 -04001433 unsigned int len, gfp_t gfp_mask)
Mike Christie df46b9a2005-06-20 14:04:44 +02001434{
1435 unsigned long kaddr = (unsigned long)data;
1436 unsigned long end = (kaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
1437 unsigned long start = kaddr >> PAGE_SHIFT;
1438 const int nr_pages = end - start;
1439 int offset, i;
1440 struct bio *bio;
1441
Tejun Heoa9e9dc22009-04-15 22:10:27 +09001442 bio = bio_kmalloc(gfp_mask, nr_pages);
Mike Christie df46b9a2005-06-20 14:04:44 +02001443 if (!bio)
1444 return ERR_PTR(-ENOMEM);
1445
1446 offset = offset_in_page(kaddr);
1447 for (i = 0; i < nr_pages; i++) {
1448 unsigned int bytes = PAGE_SIZE - offset;
1449
1450 if (len <= 0)
1451 break;
1452
1453 if (bytes > len)
1454 bytes = len;
1455
Mike Christiedefd94b2005-12-05 02:37:06 -06001456 if (bio_add_pc_page(q, bio, virt_to_page(data), bytes,
1457 offset) < bytes)
Mike Christie df46b9a2005-06-20 14:04:44 +02001458 break;
1459
1460 data += bytes;
1461 len -= bytes;
1462 offset = 0;
1463 }
1464
Jens Axboeb8238252005-06-20 14:05:27 +02001465 bio->bi_end_io = bio_map_kern_endio;
Mike Christie df46b9a2005-06-20 14:04:44 +02001466 return bio;
1467}
1468
1469/**
1470 * bio_map_kern - map kernel address into bio
Jens Axboe165125e2007-07-24 09:28:11 +02001471 * @q: the struct request_queue for the bio
Mike Christie df46b9a2005-06-20 14:04:44 +02001472 * @data: pointer to buffer to map
1473 * @len: length in bytes
1474 * @gfp_mask: allocation flags for bio allocation
1475 *
1476 * Map the kernel address into a bio suitable for io to a block
1477 * device. Returns an error pointer in case of error.
1478 */
Jens Axboe165125e2007-07-24 09:28:11 +02001479struct bio *bio_map_kern(struct request_queue *q, void *data, unsigned int len,
Al Viro27496a82005-10-21 03:20:48 -04001480 gfp_t gfp_mask)
Mike Christie df46b9a2005-06-20 14:04:44 +02001481{
1482 struct bio *bio;
1483
1484 bio = __bio_map_kern(q, data, len, gfp_mask);
1485 if (IS_ERR(bio))
1486 return bio;
1487
1488 if (bio->bi_size == len)
1489 return bio;
1490
1491 /*
1492 * Don't support partial mappings.
1493 */
1494 bio_put(bio);
1495 return ERR_PTR(-EINVAL);
1496}
H Hartley Sweetena112a712009-09-26 16:19:21 +02001497EXPORT_SYMBOL(bio_map_kern);
Mike Christie df46b9a2005-06-20 14:04:44 +02001498
FUJITA Tomonori68154e92008-04-25 12:47:50 +02001499static void bio_copy_kern_endio(struct bio *bio, int err)
1500{
1501 struct bio_vec *bvec;
1502 const int read = bio_data_dir(bio) == READ;
FUJITA Tomonori76029ff2008-08-25 20:36:08 +02001503 struct bio_map_data *bmd = bio->bi_private;
FUJITA Tomonori68154e92008-04-25 12:47:50 +02001504 int i;
FUJITA Tomonori76029ff2008-08-25 20:36:08 +02001505 char *p = bmd->sgvecs[0].iov_base;
FUJITA Tomonori68154e92008-04-25 12:47:50 +02001506
Kent Overstreetd74c6d52013-02-06 12:23:11 -08001507 bio_for_each_segment_all(bvec, bio, i) {
FUJITA Tomonori68154e92008-04-25 12:47:50 +02001508 char *addr = page_address(bvec->bv_page);
FUJITA Tomonori76029ff2008-08-25 20:36:08 +02001509 int len = bmd->iovecs[i].bv_len;
FUJITA Tomonori68154e92008-04-25 12:47:50 +02001510
Tejun Heo4fc981e2009-05-19 18:33:06 +09001511 if (read)
FUJITA Tomonori76029ff2008-08-25 20:36:08 +02001512 memcpy(p, addr, len);
FUJITA Tomonori68154e92008-04-25 12:47:50 +02001513
1514 __free_page(bvec->bv_page);
FUJITA Tomonori76029ff2008-08-25 20:36:08 +02001515 p += len;
FUJITA Tomonori68154e92008-04-25 12:47:50 +02001516 }
1517
FUJITA Tomonori76029ff2008-08-25 20:36:08 +02001518 bio_free_map_data(bmd);
FUJITA Tomonori68154e92008-04-25 12:47:50 +02001519 bio_put(bio);
1520}
1521
1522/**
1523 * bio_copy_kern - copy kernel address into bio
1524 * @q: the struct request_queue for the bio
1525 * @data: pointer to buffer to copy
1526 * @len: length in bytes
1527 * @gfp_mask: allocation flags for bio and page allocation
Randy Dunlapffee0252008-04-30 09:08:54 +02001528 * @reading: data direction is READ
FUJITA Tomonori68154e92008-04-25 12:47:50 +02001529 *
1530 * copy the kernel address into a bio suitable for io to a block
1531 * device. Returns an error pointer in case of error.
1532 */
1533struct bio *bio_copy_kern(struct request_queue *q, void *data, unsigned int len,
1534 gfp_t gfp_mask, int reading)
1535{
FUJITA Tomonori68154e92008-04-25 12:47:50 +02001536 struct bio *bio;
1537 struct bio_vec *bvec;
FUJITA Tomonori4d8ab622008-08-28 15:05:57 +09001538 int i;
FUJITA Tomonori68154e92008-04-25 12:47:50 +02001539
FUJITA Tomonori4d8ab622008-08-28 15:05:57 +09001540 bio = bio_copy_user(q, NULL, (unsigned long)data, len, 1, gfp_mask);
1541 if (IS_ERR(bio))
1542 return bio;
FUJITA Tomonori68154e92008-04-25 12:47:50 +02001543
1544 if (!reading) {
1545 void *p = data;
1546
Kent Overstreetd74c6d52013-02-06 12:23:11 -08001547 bio_for_each_segment_all(bvec, bio, i) {
FUJITA Tomonori68154e92008-04-25 12:47:50 +02001548 char *addr = page_address(bvec->bv_page);
1549
1550 memcpy(addr, p, bvec->bv_len);
1551 p += bvec->bv_len;
1552 }
1553 }
1554
FUJITA Tomonori68154e92008-04-25 12:47:50 +02001555 bio->bi_end_io = bio_copy_kern_endio;
FUJITA Tomonori76029ff2008-08-25 20:36:08 +02001556
FUJITA Tomonori68154e92008-04-25 12:47:50 +02001557 return bio;
FUJITA Tomonori68154e92008-04-25 12:47:50 +02001558}
H Hartley Sweetena112a712009-09-26 16:19:21 +02001559EXPORT_SYMBOL(bio_copy_kern);
FUJITA Tomonori68154e92008-04-25 12:47:50 +02001560
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561/*
1562 * bio_set_pages_dirty() and bio_check_pages_dirty() are support functions
1563 * for performing direct-IO in BIOs.
1564 *
1565 * The problem is that we cannot run set_page_dirty() from interrupt context
1566 * because the required locks are not interrupt-safe. So what we can do is to
1567 * mark the pages dirty _before_ performing IO. And in interrupt context,
1568 * check that the pages are still dirty. If so, fine. If not, redirty them
1569 * in process context.
1570 *
1571 * We special-case compound pages here: normally this means reads into hugetlb
1572 * pages. The logic in here doesn't really work right for compound pages
1573 * because the VM does not uniformly chase down the head page in all cases.
1574 * But dirtiness of compound pages is pretty meaningless anyway: the VM doesn't
1575 * handle them at all. So we skip compound pages here at an early stage.
1576 *
1577 * Note that this code is very hard to test under normal circumstances because
1578 * direct-io pins the pages with get_user_pages(). This makes
1579 * is_page_cache_freeable return false, and the VM will not clean the pages.
Artem Bityutskiy0d5c3eb2012-07-25 18:12:08 +03001580 * But other code (eg, flusher threads) could clean the pages if they are mapped
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581 * pagecache.
1582 *
1583 * Simply disabling the call to bio_set_pages_dirty() is a good way to test the
1584 * deferred bio dirtying paths.
1585 */
1586
1587/*
1588 * bio_set_pages_dirty() will mark all the bio's pages as dirty.
1589 */
1590void bio_set_pages_dirty(struct bio *bio)
1591{
Kent Overstreetcb34e052012-09-05 15:22:02 -07001592 struct bio_vec *bvec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 int i;
1594
Kent Overstreetcb34e052012-09-05 15:22:02 -07001595 bio_for_each_segment_all(bvec, bio, i) {
1596 struct page *page = bvec->bv_page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597
1598 if (page && !PageCompound(page))
1599 set_page_dirty_lock(page);
1600 }
1601}
1602
Adrian Bunk86b6c7a2008-02-18 13:48:32 +01001603static void bio_release_pages(struct bio *bio)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604{
Kent Overstreetcb34e052012-09-05 15:22:02 -07001605 struct bio_vec *bvec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 int i;
1607
Kent Overstreetcb34e052012-09-05 15:22:02 -07001608 bio_for_each_segment_all(bvec, bio, i) {
1609 struct page *page = bvec->bv_page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610
1611 if (page)
1612 put_page(page);
1613 }
1614}
1615
1616/*
1617 * bio_check_pages_dirty() will check that all the BIO's pages are still dirty.
1618 * If they are, then fine. If, however, some pages are clean then they must
1619 * have been written out during the direct-IO read. So we take another ref on
1620 * the BIO and the offending pages and re-dirty the pages in process context.
1621 *
1622 * It is expected that bio_check_pages_dirty() will wholly own the BIO from
1623 * here on. It will run one page_cache_release() against each page and will
1624 * run one bio_put() against the BIO.
1625 */
1626
David Howells65f27f32006-11-22 14:55:48 +00001627static void bio_dirty_fn(struct work_struct *work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628
David Howells65f27f32006-11-22 14:55:48 +00001629static DECLARE_WORK(bio_dirty_work, bio_dirty_fn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630static DEFINE_SPINLOCK(bio_dirty_lock);
1631static struct bio *bio_dirty_list;
1632
1633/*
1634 * This runs in process context
1635 */
David Howells65f27f32006-11-22 14:55:48 +00001636static void bio_dirty_fn(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637{
1638 unsigned long flags;
1639 struct bio *bio;
1640
1641 spin_lock_irqsave(&bio_dirty_lock, flags);
1642 bio = bio_dirty_list;
1643 bio_dirty_list = NULL;
1644 spin_unlock_irqrestore(&bio_dirty_lock, flags);
1645
1646 while (bio) {
1647 struct bio *next = bio->bi_private;
1648
1649 bio_set_pages_dirty(bio);
1650 bio_release_pages(bio);
1651 bio_put(bio);
1652 bio = next;
1653 }
1654}
1655
1656void bio_check_pages_dirty(struct bio *bio)
1657{
Kent Overstreetcb34e052012-09-05 15:22:02 -07001658 struct bio_vec *bvec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 int nr_clean_pages = 0;
1660 int i;
1661
Kent Overstreetcb34e052012-09-05 15:22:02 -07001662 bio_for_each_segment_all(bvec, bio, i) {
1663 struct page *page = bvec->bv_page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664
1665 if (PageDirty(page) || PageCompound(page)) {
1666 page_cache_release(page);
Kent Overstreetcb34e052012-09-05 15:22:02 -07001667 bvec->bv_page = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 } else {
1669 nr_clean_pages++;
1670 }
1671 }
1672
1673 if (nr_clean_pages) {
1674 unsigned long flags;
1675
1676 spin_lock_irqsave(&bio_dirty_lock, flags);
1677 bio->bi_private = bio_dirty_list;
1678 bio_dirty_list = bio;
1679 spin_unlock_irqrestore(&bio_dirty_lock, flags);
1680 schedule_work(&bio_dirty_work);
1681 } else {
1682 bio_put(bio);
1683 }
1684}
1685
Ilya Loginov2d4dc892009-11-26 09:16:19 +01001686#if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
1687void bio_flush_dcache_pages(struct bio *bi)
1688{
1689 int i;
1690 struct bio_vec *bvec;
1691
1692 bio_for_each_segment(bvec, bi, i)
1693 flush_dcache_page(bvec->bv_page);
1694}
1695EXPORT_SYMBOL(bio_flush_dcache_pages);
1696#endif
1697
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698/**
1699 * bio_endio - end I/O on a bio
1700 * @bio: bio
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 * @error: error, if any
1702 *
1703 * Description:
NeilBrown6712ecf2007-09-27 12:47:43 +02001704 * bio_endio() will end I/O on the whole bio. bio_endio() is the
NeilBrown5bb23a62007-09-27 12:46:13 +02001705 * preferred way to end I/O on a bio, it takes care of clearing
1706 * BIO_UPTODATE on error. @error is 0 on success, and and one of the
1707 * established -Exxxx (-EIO, for instance) error values in case
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001708 * something went wrong. No one should call bi_end_io() directly on a
NeilBrown5bb23a62007-09-27 12:46:13 +02001709 * bio unless they own it and thus know that it has an end_io
1710 * function.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711 **/
NeilBrown6712ecf2007-09-27 12:47:43 +02001712void bio_endio(struct bio *bio, int error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713{
1714 if (error)
1715 clear_bit(BIO_UPTODATE, &bio->bi_flags);
NeilBrown9cc54d42007-09-27 12:46:12 +02001716 else if (!test_bit(BIO_UPTODATE, &bio->bi_flags))
1717 error = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718
NeilBrown5bb23a62007-09-27 12:46:13 +02001719 if (bio->bi_end_io)
NeilBrown6712ecf2007-09-27 12:47:43 +02001720 bio->bi_end_io(bio, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721}
H Hartley Sweetena112a712009-09-26 16:19:21 +02001722EXPORT_SYMBOL(bio_endio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723
1724void bio_pair_release(struct bio_pair *bp)
1725{
1726 if (atomic_dec_and_test(&bp->cnt)) {
1727 struct bio *master = bp->bio1.bi_private;
1728
NeilBrown6712ecf2007-09-27 12:47:43 +02001729 bio_endio(master, bp->error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 mempool_free(bp, bp->bio2.bi_private);
1731 }
1732}
H Hartley Sweetena112a712009-09-26 16:19:21 +02001733EXPORT_SYMBOL(bio_pair_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734
NeilBrown6712ecf2007-09-27 12:47:43 +02001735static void bio_pair_end_1(struct bio *bi, int err)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736{
1737 struct bio_pair *bp = container_of(bi, struct bio_pair, bio1);
1738
1739 if (err)
1740 bp->error = err;
1741
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742 bio_pair_release(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743}
1744
NeilBrown6712ecf2007-09-27 12:47:43 +02001745static void bio_pair_end_2(struct bio *bi, int err)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746{
1747 struct bio_pair *bp = container_of(bi, struct bio_pair, bio2);
1748
1749 if (err)
1750 bp->error = err;
1751
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 bio_pair_release(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753}
1754
1755/*
Alberto Bertoglic7eee1b2009-01-25 23:36:14 -02001756 * split a bio - only worry about a bio with a single page in its iovec
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 */
Denis ChengRq6feef532008-10-09 08:57:05 +02001758struct bio_pair *bio_split(struct bio *bi, int first_sectors)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759{
Denis ChengRq6feef532008-10-09 08:57:05 +02001760 struct bio_pair *bp = mempool_alloc(bio_split_pool, GFP_NOIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761
1762 if (!bp)
1763 return bp;
1764
Arnaldo Carvalho de Melo5f3ea372008-10-30 08:34:33 +01001765 trace_block_split(bdev_get_queue(bi->bi_bdev), bi,
Jens Axboe2056a782006-03-23 20:00:26 +01001766 bi->bi_sector + first_sectors);
1767
Kent Overstreet5b836362012-09-04 15:20:38 -07001768 BUG_ON(bio_segments(bi) > 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 atomic_set(&bp->cnt, 3);
1770 bp->error = 0;
1771 bp->bio1 = *bi;
1772 bp->bio2 = *bi;
1773 bp->bio2.bi_sector += first_sectors;
1774 bp->bio2.bi_size -= first_sectors << 9;
1775 bp->bio1.bi_size = first_sectors << 9;
1776
Shaohua Li02f39392012-09-28 10:38:48 +02001777 if (bi->bi_vcnt != 0) {
Kent Overstreet5b836362012-09-04 15:20:38 -07001778 bp->bv1 = *bio_iovec(bi);
1779 bp->bv2 = *bio_iovec(bi);
Martin K. Petersen4363ac72012-09-18 12:19:27 -04001780
Shaohua Li02f39392012-09-28 10:38:48 +02001781 if (bio_is_rw(bi)) {
1782 bp->bv2.bv_offset += first_sectors << 9;
1783 bp->bv2.bv_len -= first_sectors << 9;
1784 bp->bv1.bv_len = first_sectors << 9;
1785 }
1786
1787 bp->bio1.bi_io_vec = &bp->bv1;
1788 bp->bio2.bi_io_vec = &bp->bv2;
1789
1790 bp->bio1.bi_max_vecs = 1;
1791 bp->bio2.bi_max_vecs = 1;
Martin K. Petersen4363ac72012-09-18 12:19:27 -04001792 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 bp->bio1.bi_end_io = bio_pair_end_1;
1795 bp->bio2.bi_end_io = bio_pair_end_2;
1796
1797 bp->bio1.bi_private = bi;
Denis ChengRq6feef532008-10-09 08:57:05 +02001798 bp->bio2.bi_private = bio_split_pool;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +02001800 if (bio_integrity(bi))
1801 bio_integrity_split(bi, bp, first_sectors);
1802
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803 return bp;
1804}
H Hartley Sweetena112a712009-09-26 16:19:21 +02001805EXPORT_SYMBOL(bio_split);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806
Martin K. Petersenad3316b2008-10-01 22:42:53 -04001807/**
Kent Overstreet6678d832013-08-07 11:14:32 -07001808 * bio_trim - trim a bio
1809 * @bio: bio to trim
1810 * @offset: number of sectors to trim from the front of @bio
1811 * @size: size we want to trim @bio to, in sectors
1812 */
1813void bio_trim(struct bio *bio, int offset, int size)
1814{
1815 /* 'bio' is a cloned bio which we need to trim to match
1816 * the given offset and size.
1817 * This requires adjusting bi_sector, bi_size, and bi_io_vec
1818 */
1819 int i;
1820 struct bio_vec *bvec;
1821 int sofar = 0;
1822
1823 size <<= 9;
1824 if (offset == 0 && size == bio->bi_size)
1825 return;
1826
1827 clear_bit(BIO_SEG_VALID, &bio->bi_flags);
1828
1829 bio_advance(bio, offset << 9);
1830
1831 bio->bi_size = size;
1832
1833 /* avoid any complications with bi_idx being non-zero*/
1834 if (bio->bi_idx) {
1835 memmove(bio->bi_io_vec, bio->bi_io_vec+bio->bi_idx,
1836 (bio->bi_vcnt - bio->bi_idx) * sizeof(struct bio_vec));
1837 bio->bi_vcnt -= bio->bi_idx;
1838 bio->bi_idx = 0;
1839 }
1840 /* Make sure vcnt and last bv are not too big */
1841 bio_for_each_segment(bvec, bio, i) {
1842 if (sofar + bvec->bv_len > size)
1843 bvec->bv_len = size - sofar;
1844 if (bvec->bv_len == 0) {
1845 bio->bi_vcnt = i;
1846 break;
1847 }
1848 sofar += bvec->bv_len;
1849 }
1850}
1851EXPORT_SYMBOL_GPL(bio_trim);
1852
1853/**
Martin K. Petersenad3316b2008-10-01 22:42:53 -04001854 * bio_sector_offset - Find hardware sector offset in bio
1855 * @bio: bio to inspect
1856 * @index: bio_vec index
1857 * @offset: offset in bv_page
1858 *
1859 * Return the number of hardware sectors between beginning of bio
1860 * and an end point indicated by a bio_vec index and an offset
1861 * within that vector's page.
1862 */
1863sector_t bio_sector_offset(struct bio *bio, unsigned short index,
1864 unsigned int offset)
1865{
Martin K. Petersene1defc42009-05-22 17:17:49 -04001866 unsigned int sector_sz;
Martin K. Petersenad3316b2008-10-01 22:42:53 -04001867 struct bio_vec *bv;
1868 sector_t sectors;
1869 int i;
1870
Martin K. Petersene1defc42009-05-22 17:17:49 -04001871 sector_sz = queue_logical_block_size(bio->bi_bdev->bd_disk->queue);
Martin K. Petersenad3316b2008-10-01 22:42:53 -04001872 sectors = 0;
1873
1874 if (index >= bio->bi_idx)
1875 index = bio->bi_vcnt - 1;
1876
Kent Overstreetd74c6d52013-02-06 12:23:11 -08001877 bio_for_each_segment_all(bv, bio, i) {
Martin K. Petersenad3316b2008-10-01 22:42:53 -04001878 if (i == index) {
1879 if (offset > bv->bv_offset)
1880 sectors += (offset - bv->bv_offset) / sector_sz;
1881 break;
1882 }
1883
1884 sectors += bv->bv_len / sector_sz;
1885 }
1886
1887 return sectors;
1888}
1889EXPORT_SYMBOL(bio_sector_offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890
1891/*
1892 * create memory pools for biovec's in a bio_set.
1893 * use the global biovec slabs created for general use.
1894 */
Kent Overstreet9f060e22012-10-12 15:29:33 -07001895mempool_t *biovec_create_pool(struct bio_set *bs, int pool_entries)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896{
Jens Axboe7ff93452008-12-11 11:53:43 +01001897 struct biovec_slab *bp = bvec_slabs + BIOVEC_MAX_IDX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898
Kent Overstreet9f060e22012-10-12 15:29:33 -07001899 return mempool_create_slab_pool(pool_entries, bp->slab);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900}
1901
1902void bioset_free(struct bio_set *bs)
1903{
Kent Overstreetdf2cb6d2012-09-10 14:33:46 -07001904 if (bs->rescue_workqueue)
1905 destroy_workqueue(bs->rescue_workqueue);
1906
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907 if (bs->bio_pool)
1908 mempool_destroy(bs->bio_pool);
1909
Kent Overstreet9f060e22012-10-12 15:29:33 -07001910 if (bs->bvec_pool)
1911 mempool_destroy(bs->bvec_pool);
1912
Martin K. Petersen7878cba2009-06-26 15:37:49 +02001913 bioset_integrity_free(bs);
Jens Axboebb799ca2008-12-10 15:35:05 +01001914 bio_put_slab(bs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915
1916 kfree(bs);
1917}
H Hartley Sweetena112a712009-09-26 16:19:21 +02001918EXPORT_SYMBOL(bioset_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919
Jens Axboebb799ca2008-12-10 15:35:05 +01001920/**
1921 * bioset_create - Create a bio_set
1922 * @pool_size: Number of bio and bio_vecs to cache in the mempool
1923 * @front_pad: Number of bytes to allocate in front of the returned bio
1924 *
1925 * Description:
1926 * Set up a bio_set to be used with @bio_alloc_bioset. Allows the caller
1927 * to ask for a number of bytes to be allocated in front of the bio.
1928 * Front pad allocation is useful for embedding the bio inside
1929 * another structure, to avoid allocating extra data to go with the bio.
1930 * Note that the bio must be embedded at the END of that structure always,
1931 * or things will break badly.
1932 */
1933struct bio_set *bioset_create(unsigned int pool_size, unsigned int front_pad)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934{
Jens Axboe392ddc32008-12-23 12:42:54 +01001935 unsigned int back_pad = BIO_INLINE_VECS * sizeof(struct bio_vec);
Jens Axboe1b434492008-10-22 20:32:58 +02001936 struct bio_set *bs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937
Jens Axboe1b434492008-10-22 20:32:58 +02001938 bs = kzalloc(sizeof(*bs), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 if (!bs)
1940 return NULL;
1941
Jens Axboebb799ca2008-12-10 15:35:05 +01001942 bs->front_pad = front_pad;
Jens Axboe1b434492008-10-22 20:32:58 +02001943
Kent Overstreetdf2cb6d2012-09-10 14:33:46 -07001944 spin_lock_init(&bs->rescue_lock);
1945 bio_list_init(&bs->rescue_list);
1946 INIT_WORK(&bs->rescue_work, bio_alloc_rescue);
1947
Jens Axboe392ddc32008-12-23 12:42:54 +01001948 bs->bio_slab = bio_find_or_create_slab(front_pad + back_pad);
Jens Axboebb799ca2008-12-10 15:35:05 +01001949 if (!bs->bio_slab) {
1950 kfree(bs);
1951 return NULL;
1952 }
1953
1954 bs->bio_pool = mempool_create_slab_pool(pool_size, bs->bio_slab);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955 if (!bs->bio_pool)
1956 goto bad;
1957
Kent Overstreet9f060e22012-10-12 15:29:33 -07001958 bs->bvec_pool = biovec_create_pool(bs, pool_size);
1959 if (!bs->bvec_pool)
Kent Overstreetdf2cb6d2012-09-10 14:33:46 -07001960 goto bad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961
Kent Overstreetdf2cb6d2012-09-10 14:33:46 -07001962 bs->rescue_workqueue = alloc_workqueue("bioset", WQ_MEM_RECLAIM, 0);
1963 if (!bs->rescue_workqueue)
1964 goto bad;
1965
1966 return bs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967bad:
1968 bioset_free(bs);
1969 return NULL;
1970}
H Hartley Sweetena112a712009-09-26 16:19:21 +02001971EXPORT_SYMBOL(bioset_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972
Tejun Heo852c7882012-03-05 13:15:27 -08001973#ifdef CONFIG_BLK_CGROUP
1974/**
1975 * bio_associate_current - associate a bio with %current
1976 * @bio: target bio
1977 *
1978 * Associate @bio with %current if it hasn't been associated yet. Block
1979 * layer will treat @bio as if it were issued by %current no matter which
1980 * task actually issues it.
1981 *
1982 * This function takes an extra reference of @task's io_context and blkcg
1983 * which will be put when @bio is released. The caller must own @bio,
1984 * ensure %current->io_context exists, and is responsible for synchronizing
1985 * calls to this function.
1986 */
1987int bio_associate_current(struct bio *bio)
1988{
1989 struct io_context *ioc;
1990 struct cgroup_subsys_state *css;
1991
1992 if (bio->bi_ioc)
1993 return -EBUSY;
1994
1995 ioc = current->io_context;
1996 if (!ioc)
1997 return -ENOENT;
1998
1999 /* acquire active ref on @ioc and associate */
2000 get_io_context_active(ioc);
2001 bio->bi_ioc = ioc;
2002
2003 /* associate blkcg if exists */
2004 rcu_read_lock();
Tejun Heo8af01f52013-08-08 20:11:22 -04002005 css = task_css(current, blkio_subsys_id);
Tejun Heo852c7882012-03-05 13:15:27 -08002006 if (css && css_tryget(css))
2007 bio->bi_css = css;
2008 rcu_read_unlock();
2009
2010 return 0;
2011}
2012
2013/**
2014 * bio_disassociate_task - undo bio_associate_current()
2015 * @bio: target bio
2016 */
2017void bio_disassociate_task(struct bio *bio)
2018{
2019 if (bio->bi_ioc) {
2020 put_io_context(bio->bi_ioc);
2021 bio->bi_ioc = NULL;
2022 }
2023 if (bio->bi_css) {
2024 css_put(bio->bi_css);
2025 bio->bi_css = NULL;
2026 }
2027}
2028
2029#endif /* CONFIG_BLK_CGROUP */
2030
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031static void __init biovec_init_slabs(void)
2032{
2033 int i;
2034
2035 for (i = 0; i < BIOVEC_NR_POOLS; i++) {
2036 int size;
2037 struct biovec_slab *bvs = bvec_slabs + i;
2038
Jens Axboea7fcd372008-12-05 16:10:29 +01002039 if (bvs->nr_vecs <= BIO_INLINE_VECS) {
2040 bvs->slab = NULL;
2041 continue;
2042 }
Jens Axboea7fcd372008-12-05 16:10:29 +01002043
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044 size = bvs->nr_vecs * sizeof(struct bio_vec);
2045 bvs->slab = kmem_cache_create(bvs->name, size, 0,
Paul Mundt20c2df82007-07-20 10:11:58 +09002046 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047 }
2048}
2049
2050static int __init init_bio(void)
2051{
Jens Axboebb799ca2008-12-10 15:35:05 +01002052 bio_slab_max = 2;
2053 bio_slab_nr = 0;
2054 bio_slabs = kzalloc(bio_slab_max * sizeof(struct bio_slab), GFP_KERNEL);
2055 if (!bio_slabs)
2056 panic("bio: can't allocate bios\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057
Martin K. Petersen7878cba2009-06-26 15:37:49 +02002058 bio_integrity_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059 biovec_init_slabs();
2060
Jens Axboebb799ca2008-12-10 15:35:05 +01002061 fs_bio_set = bioset_create(BIO_POOL_SIZE, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062 if (!fs_bio_set)
2063 panic("bio: can't allocate bios\n");
2064
Martin K. Petersena91a2782011-03-17 11:11:05 +01002065 if (bioset_integrity_create(fs_bio_set, BIO_POOL_SIZE))
2066 panic("bio: can't create integrity pool\n");
2067
Matthew Dobson0eaae62a2006-03-26 01:37:47 -08002068 bio_split_pool = mempool_create_kmalloc_pool(BIO_SPLIT_ENTRIES,
2069 sizeof(struct bio_pair));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070 if (!bio_split_pool)
2071 panic("bio: can't create split pool\n");
2072
2073 return 0;
2074}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002075subsys_initcall(init_bio);