bio.c 49.4 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 * Copyright (C) 2001 Jens Axboe <axboe@kernel.dk>
L
Linus Torvalds 已提交
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public Licens
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-
 *
 */
#include <linux/mm.h>
#include <linux/swap.h>
#include <linux/bio.h>
#include <linux/blkdev.h>
22
#include <linux/uio.h>
23
#include <linux/iocontext.h>
L
Linus Torvalds 已提交
24 25 26
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/kernel.h>
27
#include <linux/export.h>
L
Linus Torvalds 已提交
28 29
#include <linux/mempool.h>
#include <linux/workqueue.h>
30
#include <linux/cgroup.h>
L
Linus Torvalds 已提交
31

32
#include <trace/events/block.h>
33

34 35 36 37 38 39
/*
 * Test patch to inline a certain number of bi_io_vec's inside the bio
 * itself, to shrink a bio data allocation from two mempool calls to one
 */
#define BIO_INLINE_VECS		4

L
Linus Torvalds 已提交
40 41 42 43 44 45
/*
 * if you change this list, also change bvec_alloc or things will
 * break badly! cannot be bigger than what you can fit into an
 * unsigned short
 */
#define BV(x) { .nr_vecs = x, .name = "biovec-"__stringify(x) }
46
static struct biovec_slab bvec_slabs[BIOVEC_NR_POOLS] __read_mostly = {
L
Linus Torvalds 已提交
47 48 49 50 51 52 53 54
	BV(1), BV(4), BV(16), BV(64), BV(128), BV(BIO_MAX_PAGES),
};
#undef BV

/*
 * fs_bio_set is the bio_set containing bio and iovec memory pools used by
 * IO code that does not need private memory pools.
 */
55
struct bio_set *fs_bio_set;
56
EXPORT_SYMBOL(fs_bio_set);
L
Linus Torvalds 已提交
57

58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
/*
 * Our slab pool management
 */
struct bio_slab {
	struct kmem_cache *slab;
	unsigned int slab_ref;
	unsigned int slab_size;
	char name[8];
};
static DEFINE_MUTEX(bio_slab_lock);
static struct bio_slab *bio_slabs;
static unsigned int bio_slab_nr, bio_slab_max;

static struct kmem_cache *bio_find_or_create_slab(unsigned int extra_size)
{
	unsigned int sz = sizeof(struct bio) + extra_size;
	struct kmem_cache *slab = NULL;
75
	struct bio_slab *bslab, *new_bio_slabs;
76
	unsigned int new_bio_slab_max;
77 78 79 80 81 82
	unsigned int i, entry = -1;

	mutex_lock(&bio_slab_lock);

	i = 0;
	while (i < bio_slab_nr) {
83
		bslab = &bio_slabs[i];
84 85 86 87 88 89 90 91 92 93 94 95 96 97 98

		if (!bslab->slab && entry == -1)
			entry = i;
		else if (bslab->slab_size == sz) {
			slab = bslab->slab;
			bslab->slab_ref++;
			break;
		}
		i++;
	}

	if (slab)
		goto out_unlock;

	if (bio_slab_nr == bio_slab_max && entry == -1) {
99
		new_bio_slab_max = bio_slab_max << 1;
100
		new_bio_slabs = krealloc(bio_slabs,
101
					 new_bio_slab_max * sizeof(struct bio_slab),
102 103
					 GFP_KERNEL);
		if (!new_bio_slabs)
104
			goto out_unlock;
105
		bio_slab_max = new_bio_slab_max;
106
		bio_slabs = new_bio_slabs;
107 108 109 110 111 112 113
	}
	if (entry == -1)
		entry = bio_slab_nr++;

	bslab = &bio_slabs[entry];

	snprintf(bslab->name, sizeof(bslab->name), "bio-%d", entry);
114 115
	slab = kmem_cache_create(bslab->name, sz, ARCH_KMALLOC_MINALIGN,
				 SLAB_HWCACHE_ALIGN, NULL);
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155
	if (!slab)
		goto out_unlock;

	bslab->slab = slab;
	bslab->slab_ref = 1;
	bslab->slab_size = sz;
out_unlock:
	mutex_unlock(&bio_slab_lock);
	return slab;
}

static void bio_put_slab(struct bio_set *bs)
{
	struct bio_slab *bslab = NULL;
	unsigned int i;

	mutex_lock(&bio_slab_lock);

	for (i = 0; i < bio_slab_nr; i++) {
		if (bs->bio_slab == bio_slabs[i].slab) {
			bslab = &bio_slabs[i];
			break;
		}
	}

	if (WARN(!bslab, KERN_ERR "bio: unable to find slab!\n"))
		goto out;

	WARN_ON(!bslab->slab_ref);

	if (--bslab->slab_ref)
		goto out;

	kmem_cache_destroy(bslab->slab);
	bslab->slab = NULL;

out:
	mutex_unlock(&bio_slab_lock);
}

156 157 158 159 160
unsigned int bvec_nr_vecs(unsigned short idx)
{
	return bvec_slabs[idx].nr_vecs;
}

161
void bvec_free(mempool_t *pool, struct bio_vec *bv, unsigned int idx)
162 163 164 165
{
	BIO_BUG_ON(idx >= BIOVEC_NR_POOLS);

	if (idx == BIOVEC_MAX_IDX)
166
		mempool_free(bv, pool);
167 168 169 170 171 172 173
	else {
		struct biovec_slab *bvs = bvec_slabs + idx;

		kmem_cache_free(bvs->slab, bv);
	}
}

174 175
struct bio_vec *bvec_alloc(gfp_t gfp_mask, int nr, unsigned long *idx,
			   mempool_t *pool)
L
Linus Torvalds 已提交
176 177 178
{
	struct bio_vec *bvl;

179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
	/*
	 * see comment near bvec_array define!
	 */
	switch (nr) {
	case 1:
		*idx = 0;
		break;
	case 2 ... 4:
		*idx = 1;
		break;
	case 5 ... 16:
		*idx = 2;
		break;
	case 17 ... 64:
		*idx = 3;
		break;
	case 65 ... 128:
		*idx = 4;
		break;
	case 129 ... BIO_MAX_PAGES:
		*idx = 5;
		break;
	default:
		return NULL;
	}

	/*
	 * idx now points to the pool we want to allocate from. only the
	 * 1-vec entry pool is mempool backed.
	 */
	if (*idx == BIOVEC_MAX_IDX) {
fallback:
211
		bvl = mempool_alloc(pool, gfp_mask);
212 213 214 215
	} else {
		struct biovec_slab *bvs = bvec_slabs + *idx;
		gfp_t __gfp_mask = gfp_mask & ~(__GFP_WAIT | __GFP_IO);

J
Jens Axboe 已提交
216
		/*
217 218 219
		 * Make this allocation restricted and don't dump info on
		 * allocation failures, since we'll fallback to the mempool
		 * in case of failure.
J
Jens Axboe 已提交
220
		 */
221
		__gfp_mask |= __GFP_NOMEMALLOC | __GFP_NORETRY | __GFP_NOWARN;
L
Linus Torvalds 已提交
222

J
Jens Axboe 已提交
223
		/*
224 225
		 * Try a slab allocation. If this fails and __GFP_WAIT
		 * is set, retry with the 1-entry mempool
J
Jens Axboe 已提交
226
		 */
227 228 229 230 231 232 233
		bvl = kmem_cache_alloc(bvs->slab, __gfp_mask);
		if (unlikely(!bvl && (gfp_mask & __GFP_WAIT))) {
			*idx = BIOVEC_MAX_IDX;
			goto fallback;
		}
	}

L
Linus Torvalds 已提交
234 235 236
	return bvl;
}

K
Kent Overstreet 已提交
237
static void __bio_free(struct bio *bio)
L
Linus Torvalds 已提交
238
{
K
Kent Overstreet 已提交
239
	bio_disassociate_task(bio);
L
Linus Torvalds 已提交
240

241
	if (bio_integrity(bio))
242
		bio_integrity_free(bio);
K
Kent Overstreet 已提交
243
}
244

K
Kent Overstreet 已提交
245 246 247 248 249 250 251 252
static void bio_free(struct bio *bio)
{
	struct bio_set *bs = bio->bi_pool;
	void *p;

	__bio_free(bio);

	if (bs) {
253
		if (bio_flagged(bio, BIO_OWNS_VEC))
254
			bvec_free(bs->bvec_pool, bio->bi_io_vec, BIO_POOL_IDX(bio));
K
Kent Overstreet 已提交
255 256 257 258 259

		/*
		 * If we have front padding, adjust the bio pointer before freeing
		 */
		p = bio;
260 261
		p -= bs->front_pad;

K
Kent Overstreet 已提交
262 263 264 265 266
		mempool_free(p, bs->bio_pool);
	} else {
		/* Bio was allocated by bio_kmalloc() */
		kfree(bio);
	}
P
Peter Osterlund 已提交
267 268
}

269
void bio_init(struct bio *bio)
L
Linus Torvalds 已提交
270
{
J
Jens Axboe 已提交
271
	memset(bio, 0, sizeof(*bio));
L
Linus Torvalds 已提交
272
	bio->bi_flags = 1 << BIO_UPTODATE;
K
Kent Overstreet 已提交
273
	atomic_set(&bio->bi_remaining, 1);
L
Linus Torvalds 已提交
274 275
	atomic_set(&bio->bi_cnt, 1);
}
276
EXPORT_SYMBOL(bio_init);
L
Linus Torvalds 已提交
277

K
Kent Overstreet 已提交
278 279 280 281 282 283 284 285 286 287 288 289 290 291
/**
 * bio_reset - reinitialize a bio
 * @bio:	bio to reset
 *
 * Description:
 *   After calling bio_reset(), @bio will be in the same state as a freshly
 *   allocated bio returned bio bio_alloc_bioset() - the only fields that are
 *   preserved are the ones that are initialized by bio_alloc_bioset(). See
 *   comment in struct bio.
 */
void bio_reset(struct bio *bio)
{
	unsigned long flags = bio->bi_flags & (~0UL << BIO_RESET_BITS);

K
Kent Overstreet 已提交
292
	__bio_free(bio);
K
Kent Overstreet 已提交
293 294 295

	memset(bio, 0, BIO_RESET_BYTES);
	bio->bi_flags = flags|(1 << BIO_UPTODATE);
K
Kent Overstreet 已提交
296
	atomic_set(&bio->bi_remaining, 1);
K
Kent Overstreet 已提交
297 298 299
}
EXPORT_SYMBOL(bio_reset);

K
Kent Overstreet 已提交
300 301 302 303 304 305 306 307
static void bio_chain_endio(struct bio *bio, int error)
{
	bio_endio(bio->bi_private, error);
	bio_put(bio);
}

/**
 * bio_chain - chain bio completions
308 309
 * @bio: the target bio
 * @parent: the @bio's parent bio
K
Kent Overstreet 已提交
310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
 *
 * The caller won't have a bi_end_io called when @bio completes - instead,
 * @parent's bi_end_io won't be called until both @parent and @bio have
 * completed; the chained bio will also be freed when it completes.
 *
 * The caller must not set bi_private or bi_end_io in @bio.
 */
void bio_chain(struct bio *bio, struct bio *parent)
{
	BUG_ON(bio->bi_private || bio->bi_end_io);

	bio->bi_private = parent;
	bio->bi_end_io	= bio_chain_endio;
	atomic_inc(&parent->bi_remaining);
}
EXPORT_SYMBOL(bio_chain);

327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
static void bio_alloc_rescue(struct work_struct *work)
{
	struct bio_set *bs = container_of(work, struct bio_set, rescue_work);
	struct bio *bio;

	while (1) {
		spin_lock(&bs->rescue_lock);
		bio = bio_list_pop(&bs->rescue_list);
		spin_unlock(&bs->rescue_lock);

		if (!bio)
			break;

		generic_make_request(bio);
	}
}

static void punt_bios_to_rescuer(struct bio_set *bs)
{
	struct bio_list punt, nopunt;
	struct bio *bio;

	/*
	 * In order to guarantee forward progress we must punt only bios that
	 * were allocated from this bio_set; otherwise, if there was a bio on
	 * there for a stacking driver higher up in the stack, processing it
	 * could require allocating bios from this bio_set, and doing that from
	 * our own rescuer would be bad.
	 *
	 * Since bio lists are singly linked, pop them all instead of trying to
	 * remove from the middle of the list:
	 */

	bio_list_init(&punt);
	bio_list_init(&nopunt);

	while ((bio = bio_list_pop(current->bio_list)))
		bio_list_add(bio->bi_pool == bs ? &punt : &nopunt, bio);

	*current->bio_list = nopunt;

	spin_lock(&bs->rescue_lock);
	bio_list_merge(&bs->rescue_list, &punt);
	spin_unlock(&bs->rescue_lock);

	queue_work(bs->rescue_workqueue, &bs->rescue_work);
}

L
Linus Torvalds 已提交
375 376 377 378
/**
 * bio_alloc_bioset - allocate a bio for I/O
 * @gfp_mask:   the GFP_ mask given to the slab allocator
 * @nr_iovecs:	number of iovecs to pre-allocate
379
 * @bs:		the bio_set to allocate from.
L
Linus Torvalds 已提交
380 381
 *
 * Description:
382 383 384 385 386 387 388 389 390 391
 *   If @bs is NULL, uses kmalloc() to allocate the bio; else the allocation is
 *   backed by the @bs's mempool.
 *
 *   When @bs is not NULL, if %__GFP_WAIT is set then bio_alloc will always be
 *   able to allocate a bio. This is due to the mempool guarantees. To make this
 *   work, callers must never allocate more than 1 bio at a time from this pool.
 *   Callers that need to allocate more than 1 bio must always submit the
 *   previously allocated bio for IO before attempting to allocate a new one.
 *   Failure to do so can cause deadlocks under memory pressure.
 *
392 393 394 395 396 397 398 399 400 401 402 403 404 405 406
 *   Note that when running under generic_make_request() (i.e. any block
 *   driver), bios are not submitted until after you return - see the code in
 *   generic_make_request() that converts recursion into iteration, to prevent
 *   stack overflows.
 *
 *   This would normally mean allocating multiple bios under
 *   generic_make_request() would be susceptible to deadlocks, but we have
 *   deadlock avoidance code that resubmits any blocked bios from a rescuer
 *   thread.
 *
 *   However, we do not guarantee forward progress for allocations from other
 *   mempools. Doing multiple allocations from the same mempool under
 *   generic_make_request() should be avoided - instead, use bio_set's front_pad
 *   for per bio allocations.
 *
407 408 409
 *   RETURNS:
 *   Pointer to new bio on success, NULL on failure.
 */
A
Al Viro 已提交
410
struct bio *bio_alloc_bioset(gfp_t gfp_mask, int nr_iovecs, struct bio_set *bs)
L
Linus Torvalds 已提交
411
{
412
	gfp_t saved_gfp = gfp_mask;
413 414
	unsigned front_pad;
	unsigned inline_vecs;
T
Tejun Heo 已提交
415
	unsigned long idx = BIO_POOL_NONE;
I
Ingo Molnar 已提交
416
	struct bio_vec *bvl = NULL;
T
Tejun Heo 已提交
417 418 419
	struct bio *bio;
	void *p;

420 421 422 423 424 425 426 427 428 429
	if (!bs) {
		if (nr_iovecs > UIO_MAXIOV)
			return NULL;

		p = kmalloc(sizeof(struct bio) +
			    nr_iovecs * sizeof(struct bio_vec),
			    gfp_mask);
		front_pad = 0;
		inline_vecs = nr_iovecs;
	} else {
J
Junichi Nomura 已提交
430 431 432
		/* should not use nobvec bioset for nr_iovecs > 0 */
		if (WARN_ON_ONCE(!bs->bvec_pool && nr_iovecs > 0))
			return NULL;
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456
		/*
		 * generic_make_request() converts recursion to iteration; this
		 * means if we're running beneath it, any bios we allocate and
		 * submit will not be submitted (and thus freed) until after we
		 * return.
		 *
		 * This exposes us to a potential deadlock if we allocate
		 * multiple bios from the same bio_set() while running
		 * underneath generic_make_request(). If we were to allocate
		 * multiple bios (say a stacking block driver that was splitting
		 * bios), we would deadlock if we exhausted the mempool's
		 * reserve.
		 *
		 * We solve this, and guarantee forward progress, with a rescuer
		 * workqueue per bio_set. If we go to allocate and there are
		 * bios on current->bio_list, we first try the allocation
		 * without __GFP_WAIT; if that fails, we punt those bios we
		 * would be blocking to the rescuer workqueue before we retry
		 * with the original gfp_flags.
		 */

		if (current->bio_list && !bio_list_empty(current->bio_list))
			gfp_mask &= ~__GFP_WAIT;

457
		p = mempool_alloc(bs->bio_pool, gfp_mask);
458 459 460 461 462 463
		if (!p && gfp_mask != saved_gfp) {
			punt_bios_to_rescuer(bs);
			gfp_mask = saved_gfp;
			p = mempool_alloc(bs->bio_pool, gfp_mask);
		}

464 465 466 467
		front_pad = bs->front_pad;
		inline_vecs = BIO_INLINE_VECS;
	}

T
Tejun Heo 已提交
468 469
	if (unlikely(!p))
		return NULL;
L
Linus Torvalds 已提交
470

471
	bio = p + front_pad;
I
Ingo Molnar 已提交
472 473
	bio_init(bio);

474
	if (nr_iovecs > inline_vecs) {
475
		bvl = bvec_alloc(gfp_mask, nr_iovecs, &idx, bs->bvec_pool);
476 477 478
		if (!bvl && gfp_mask != saved_gfp) {
			punt_bios_to_rescuer(bs);
			gfp_mask = saved_gfp;
479
			bvl = bvec_alloc(gfp_mask, nr_iovecs, &idx, bs->bvec_pool);
480 481
		}

I
Ingo Molnar 已提交
482 483
		if (unlikely(!bvl))
			goto err_free;
484 485

		bio->bi_flags |= 1 << BIO_OWNS_VEC;
486 487
	} else if (nr_iovecs) {
		bvl = bio->bi_inline_vecs;
L
Linus Torvalds 已提交
488
	}
489 490

	bio->bi_pool = bs;
I
Ingo Molnar 已提交
491 492 493
	bio->bi_flags |= idx << BIO_POOL_OFFSET;
	bio->bi_max_vecs = nr_iovecs;
	bio->bi_io_vec = bvl;
L
Linus Torvalds 已提交
494
	return bio;
I
Ingo Molnar 已提交
495 496

err_free:
T
Tejun Heo 已提交
497
	mempool_free(p, bs->bio_pool);
I
Ingo Molnar 已提交
498
	return NULL;
L
Linus Torvalds 已提交
499
}
500
EXPORT_SYMBOL(bio_alloc_bioset);
L
Linus Torvalds 已提交
501 502 503 504

void zero_fill_bio(struct bio *bio)
{
	unsigned long flags;
505 506
	struct bio_vec bv;
	struct bvec_iter iter;
L
Linus Torvalds 已提交
507

508 509 510 511
	bio_for_each_segment(bv, bio, iter) {
		char *data = bvec_kmap_irq(&bv, &flags);
		memset(data, 0, bv.bv_len);
		flush_dcache_page(bv.bv_page);
L
Linus Torvalds 已提交
512 513 514 515 516 517 518 519 520 521 522
		bvec_kunmap_irq(data, &flags);
	}
}
EXPORT_SYMBOL(zero_fill_bio);

/**
 * bio_put - release a reference to a bio
 * @bio:   bio to release reference to
 *
 * Description:
 *   Put a reference to a &struct bio, either one you have gotten with
523
 *   bio_alloc, bio_get or bio_clone. The last put of a bio will free it.
L
Linus Torvalds 已提交
524 525 526 527 528 529 530 531
 **/
void bio_put(struct bio *bio)
{
	BIO_BUG_ON(!atomic_read(&bio->bi_cnt));

	/*
	 * last put frees it
	 */
K
Kent Overstreet 已提交
532 533
	if (atomic_dec_and_test(&bio->bi_cnt))
		bio_free(bio);
L
Linus Torvalds 已提交
534
}
535
EXPORT_SYMBOL(bio_put);
L
Linus Torvalds 已提交
536

537
inline int bio_phys_segments(struct request_queue *q, struct bio *bio)
L
Linus Torvalds 已提交
538 539 540 541 542 543
{
	if (unlikely(!bio_flagged(bio, BIO_SEG_VALID)))
		blk_recount_segments(q, bio);

	return bio->bi_phys_segments;
}
544
EXPORT_SYMBOL(bio_phys_segments);
L
Linus Torvalds 已提交
545

K
Kent Overstreet 已提交
546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605
/**
 * 	__bio_clone_fast - clone a bio that shares the original bio's biovec
 * 	@bio: destination bio
 * 	@bio_src: bio to clone
 *
 *	Clone a &bio. Caller will own the returned bio, but not
 *	the actual data it points to. Reference count of returned
 * 	bio will be one.
 *
 * 	Caller must ensure that @bio_src is not freed before @bio.
 */
void __bio_clone_fast(struct bio *bio, struct bio *bio_src)
{
	BUG_ON(bio->bi_pool && BIO_POOL_IDX(bio) != BIO_POOL_NONE);

	/*
	 * most users will be overriding ->bi_bdev with a new target,
	 * so we don't set nor calculate new physical/hw segment counts here
	 */
	bio->bi_bdev = bio_src->bi_bdev;
	bio->bi_flags |= 1 << BIO_CLONED;
	bio->bi_rw = bio_src->bi_rw;
	bio->bi_iter = bio_src->bi_iter;
	bio->bi_io_vec = bio_src->bi_io_vec;
}
EXPORT_SYMBOL(__bio_clone_fast);

/**
 *	bio_clone_fast - clone a bio that shares the original bio's biovec
 *	@bio: bio to clone
 *	@gfp_mask: allocation priority
 *	@bs: bio_set to allocate from
 *
 * 	Like __bio_clone_fast, only also allocates the returned bio
 */
struct bio *bio_clone_fast(struct bio *bio, gfp_t gfp_mask, struct bio_set *bs)
{
	struct bio *b;

	b = bio_alloc_bioset(gfp_mask, 0, bs);
	if (!b)
		return NULL;

	__bio_clone_fast(b, bio);

	if (bio_integrity(bio)) {
		int ret;

		ret = bio_integrity_clone(b, bio, gfp_mask);

		if (ret < 0) {
			bio_put(b);
			return NULL;
		}
	}

	return b;
}
EXPORT_SYMBOL(bio_clone_fast);

L
Linus Torvalds 已提交
606
/**
607 608
 * 	bio_clone_bioset - clone a bio
 * 	@bio_src: bio to clone
L
Linus Torvalds 已提交
609
 *	@gfp_mask: allocation priority
610
 *	@bs: bio_set to allocate from
L
Linus Torvalds 已提交
611
 *
612 613
 *	Clone bio. Caller will own the returned bio, but not the actual data it
 *	points to. Reference count of returned bio will be one.
L
Linus Torvalds 已提交
614
 */
615
struct bio *bio_clone_bioset(struct bio *bio_src, gfp_t gfp_mask,
616
			     struct bio_set *bs)
L
Linus Torvalds 已提交
617
{
618 619 620
	struct bvec_iter iter;
	struct bio_vec bv;
	struct bio *bio;
L
Linus Torvalds 已提交
621

622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643
	/*
	 * Pre immutable biovecs, __bio_clone() used to just do a memcpy from
	 * bio_src->bi_io_vec to bio->bi_io_vec.
	 *
	 * We can't do that anymore, because:
	 *
	 *  - The point of cloning the biovec is to produce a bio with a biovec
	 *    the caller can modify: bi_idx and bi_bvec_done should be 0.
	 *
	 *  - The original bio could've had more than BIO_MAX_PAGES biovecs; if
	 *    we tried to clone the whole thing bio_alloc_bioset() would fail.
	 *    But the clone should succeed as long as the number of biovecs we
	 *    actually need to allocate is fewer than BIO_MAX_PAGES.
	 *
	 *  - Lastly, bi_vcnt should not be looked at or relied upon by code
	 *    that does not own the bio - reason being drivers don't use it for
	 *    iterating over the biovec anymore, so expecting it to be kept up
	 *    to date (i.e. for clones that share the parent biovec) is just
	 *    asking for trouble and would force extra work on
	 *    __bio_clone_fast() anyways.
	 */

644
	bio = bio_alloc_bioset(gfp_mask, bio_segments(bio_src), bs);
645
	if (!bio)
646 647
		return NULL;

648 649 650 651
	bio->bi_bdev		= bio_src->bi_bdev;
	bio->bi_rw		= bio_src->bi_rw;
	bio->bi_iter.bi_sector	= bio_src->bi_iter.bi_sector;
	bio->bi_iter.bi_size	= bio_src->bi_iter.bi_size;
652

653 654 655 656 657 658 659 660
	if (bio->bi_rw & REQ_DISCARD)
		goto integrity_clone;

	if (bio->bi_rw & REQ_WRITE_SAME) {
		bio->bi_io_vec[bio->bi_vcnt++] = bio_src->bi_io_vec[0];
		goto integrity_clone;
	}

661 662
	bio_for_each_segment(bv, bio_src, iter)
		bio->bi_io_vec[bio->bi_vcnt++] = bv;
663

664
integrity_clone:
665 666
	if (bio_integrity(bio_src)) {
		int ret;
667

668
		ret = bio_integrity_clone(bio, bio_src, gfp_mask);
L
Li Zefan 已提交
669
		if (ret < 0) {
670
			bio_put(bio);
671
			return NULL;
L
Li Zefan 已提交
672
		}
P
Peter Osterlund 已提交
673
	}
L
Linus Torvalds 已提交
674

675
	return bio;
L
Linus Torvalds 已提交
676
}
677
EXPORT_SYMBOL(bio_clone_bioset);
L
Linus Torvalds 已提交
678 679 680 681 682 683 684 685 686 687 688 689

/**
 *	bio_get_nr_vecs		- return approx number of vecs
 *	@bdev:  I/O target
 *
 *	Return the approximate number of pages we can send to this target.
 *	There's no guarantee that you will be able to fit this number of pages
 *	into a bio, it does not account for dynamic restrictions that vary
 *	on offset.
 */
int bio_get_nr_vecs(struct block_device *bdev)
{
690
	struct request_queue *q = bdev_get_queue(bdev);
691 692 693
	int nr_pages;

	nr_pages = min_t(unsigned,
694 695
		     queue_max_segments(q),
		     queue_max_sectors(q) / (PAGE_SIZE >> 9) + 1);
696 697 698

	return min_t(unsigned, nr_pages, BIO_MAX_PAGES);

L
Linus Torvalds 已提交
699
}
700
EXPORT_SYMBOL(bio_get_nr_vecs);
L
Linus Torvalds 已提交
701

702
static int __bio_add_page(struct request_queue *q, struct bio *bio, struct page
703
			  *page, unsigned int len, unsigned int offset,
704
			  unsigned int max_sectors)
L
Linus Torvalds 已提交
705 706 707 708 709 710 711 712 713 714
{
	int retried_segments = 0;
	struct bio_vec *bvec;

	/*
	 * cloned bio must not modify vec list
	 */
	if (unlikely(bio_flagged(bio, BIO_CLONED)))
		return 0;

715
	if (((bio->bi_iter.bi_size + len) >> 9) > max_sectors)
L
Linus Torvalds 已提交
716 717
		return 0;

718 719 720 721 722 723 724 725 726 727
	/*
	 * For filesystems with a blocksize smaller than the pagesize
	 * we will often be called with the same page as last time and
	 * a consecutive offset.  Optimize this special case.
	 */
	if (bio->bi_vcnt > 0) {
		struct bio_vec *prev = &bio->bi_io_vec[bio->bi_vcnt - 1];

		if (page == prev->bv_page &&
		    offset == prev->bv_offset + prev->bv_len) {
728
			unsigned int prev_bv_len = prev->bv_len;
729
			prev->bv_len += len;
730 731 732

			if (q->merge_bvec_fn) {
				struct bvec_merge_data bvm = {
733 734 735 736
					/* prev_bvec is already charged in
					   bi_size, discharge it in order to
					   simulate merging updated prev_bvec
					   as new bvec. */
737
					.bi_bdev = bio->bi_bdev,
738 739 740
					.bi_sector = bio->bi_iter.bi_sector,
					.bi_size = bio->bi_iter.bi_size -
						prev_bv_len,
741 742 743
					.bi_rw = bio->bi_rw,
				};

744
				if (q->merge_bvec_fn(q, &bvm, prev) < prev->bv_len) {
745 746 747
					prev->bv_len -= len;
					return 0;
				}
748 749
			}

750
			bio->bi_iter.bi_size += len;
751 752
			goto done;
		}
753 754 755 756 757 758 759 760

		/*
		 * If the queue doesn't support SG gaps and adding this
		 * offset would create a gap, disallow it.
		 */
		if (q->queue_flags & (1 << QUEUE_FLAG_SG_GAPS) &&
		    bvec_gap_to_prev(prev, offset))
			return 0;
761 762 763
	}

	if (bio->bi_vcnt >= bio->bi_max_vecs)
L
Linus Torvalds 已提交
764 765 766
		return 0;

	/*
767 768 769 770 771 772 773 774 775 776 777 778 779 780
	 * setup the new entry, we might clear it again later if we
	 * cannot add the page
	 */
	bvec = &bio->bi_io_vec[bio->bi_vcnt];
	bvec->bv_page = page;
	bvec->bv_len = len;
	bvec->bv_offset = offset;
	bio->bi_vcnt++;
	bio->bi_phys_segments++;
	bio->bi_iter.bi_size += len;

	/*
	 * Perform a recount if the number of segments is greater
	 * than queue_max_segments(q).
L
Linus Torvalds 已提交
781 782
	 */

783
	while (bio->bi_phys_segments > queue_max_segments(q)) {
L
Linus Torvalds 已提交
784 785

		if (retried_segments)
786
			goto failed;
L
Linus Torvalds 已提交
787 788 789 790 791 792 793 794 795 796 797

		retried_segments = 1;
		blk_recount_segments(q, bio);
	}

	/*
	 * if queue has other restrictions (eg varying max sector size
	 * depending on offset), it can specify a merge_bvec_fn in the
	 * queue to get further control
	 */
	if (q->merge_bvec_fn) {
798 799
		struct bvec_merge_data bvm = {
			.bi_bdev = bio->bi_bdev,
800
			.bi_sector = bio->bi_iter.bi_sector,
801
			.bi_size = bio->bi_iter.bi_size - len,
802 803 804
			.bi_rw = bio->bi_rw,
		};

L
Linus Torvalds 已提交
805 806 807 808
		/*
		 * merge_bvec_fn() returns number of bytes it can accept
		 * at this offset
		 */
809 810
		if (q->merge_bvec_fn(q, &bvm, bvec) < bvec->bv_len)
			goto failed;
L
Linus Torvalds 已提交
811 812 813
	}

	/* If we may be able to merge these biovecs, force a recount */
814
	if (bio->bi_vcnt > 1 && (BIOVEC_PHYS_MERGEABLE(bvec-1, bvec)))
L
Linus Torvalds 已提交
815 816
		bio->bi_flags &= ~(1 << BIO_SEG_VALID);

817
 done:
L
Linus Torvalds 已提交
818
	return len;
819 820 821 822 823 824 825 826 827

 failed:
	bvec->bv_page = NULL;
	bvec->bv_len = 0;
	bvec->bv_offset = 0;
	bio->bi_vcnt--;
	bio->bi_iter.bi_size -= len;
	blk_recount_segments(q, bio);
	return 0;
L
Linus Torvalds 已提交
828 829
}

830 831
/**
 *	bio_add_pc_page	-	attempt to add page to bio
J
Jens Axboe 已提交
832
 *	@q: the target queue
833 834 835 836 837 838
 *	@bio: destination bio
 *	@page: page to add
 *	@len: vec entry length
 *	@offset: vec entry offset
 *
 *	Attempt to add a page to the bio_vec maplist. This can fail for a
839 840 841 842 843
 *	number of reasons, such as the bio being full or target block device
 *	limitations. The target block device must allow bio's up to PAGE_SIZE,
 *	so it is always possible to add a single page to an empty bio.
 *
 *	This should only be used by REQ_PC bios.
844
 */
845
int bio_add_pc_page(struct request_queue *q, struct bio *bio, struct page *page,
846 847
		    unsigned int len, unsigned int offset)
{
848 849
	return __bio_add_page(q, bio, page, len, offset,
			      queue_max_hw_sectors(q));
850
}
851
EXPORT_SYMBOL(bio_add_pc_page);
852

L
Linus Torvalds 已提交
853 854 855 856 857 858 859 860
/**
 *	bio_add_page	-	attempt to add page to bio
 *	@bio: destination bio
 *	@page: page to add
 *	@len: vec entry length
 *	@offset: vec entry offset
 *
 *	Attempt to add a page to the bio_vec maplist. This can fail for a
861 862 863
 *	number of reasons, such as the bio being full or target block device
 *	limitations. The target block device must allow bio's up to PAGE_SIZE,
 *	so it is always possible to add a single page to an empty bio.
L
Linus Torvalds 已提交
864 865 866 867
 */
int bio_add_page(struct bio *bio, struct page *page, unsigned int len,
		 unsigned int offset)
{
868
	struct request_queue *q = bdev_get_queue(bio->bi_bdev);
869
	unsigned int max_sectors;
870

871 872 873 874 875
	max_sectors = blk_max_size_offset(q, bio->bi_iter.bi_sector);
	if ((max_sectors < (len >> 9)) && !bio->bi_iter.bi_size)
		max_sectors = len >> 9;

	return __bio_add_page(q, bio, page, len, offset, max_sectors);
L
Linus Torvalds 已提交
876
}
877
EXPORT_SYMBOL(bio_add_page);
L
Linus Torvalds 已提交
878

879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914
struct submit_bio_ret {
	struct completion event;
	int error;
};

static void submit_bio_wait_endio(struct bio *bio, int error)
{
	struct submit_bio_ret *ret = bio->bi_private;

	ret->error = error;
	complete(&ret->event);
}

/**
 * submit_bio_wait - submit a bio, and wait until it completes
 * @rw: whether to %READ or %WRITE, or maybe to %READA (read ahead)
 * @bio: The &struct bio which describes the I/O
 *
 * Simple wrapper around submit_bio(). Returns 0 on success, or the error from
 * bio_endio() on failure.
 */
int submit_bio_wait(int rw, struct bio *bio)
{
	struct submit_bio_ret ret;

	rw |= REQ_SYNC;
	init_completion(&ret.event);
	bio->bi_private = &ret;
	bio->bi_end_io = submit_bio_wait_endio;
	submit_bio(rw, bio);
	wait_for_completion(&ret.event);

	return ret.error;
}
EXPORT_SYMBOL(submit_bio_wait);

K
Kent Overstreet 已提交
915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930
/**
 * bio_advance - increment/complete a bio by some number of bytes
 * @bio:	bio to advance
 * @bytes:	number of bytes to complete
 *
 * This updates bi_sector, bi_size and bi_idx; if the number of bytes to
 * complete doesn't align with a bvec boundary, then bv_len and bv_offset will
 * be updated on the last bvec as well.
 *
 * @bio will then represent the remaining, uncompleted portion of the io.
 */
void bio_advance(struct bio *bio, unsigned bytes)
{
	if (bio_integrity(bio))
		bio_integrity_advance(bio, bytes);

K
Kent Overstreet 已提交
931
	bio_advance_iter(bio, &bio->bi_iter, bytes);
K
Kent Overstreet 已提交
932 933 934
}
EXPORT_SYMBOL(bio_advance);

K
Kent Overstreet 已提交
935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962
/**
 * bio_alloc_pages - allocates a single page for each bvec in a bio
 * @bio: bio to allocate pages for
 * @gfp_mask: flags for allocation
 *
 * Allocates pages up to @bio->bi_vcnt.
 *
 * Returns 0 on success, -ENOMEM on failure. On failure, any allocated pages are
 * freed.
 */
int bio_alloc_pages(struct bio *bio, gfp_t gfp_mask)
{
	int i;
	struct bio_vec *bv;

	bio_for_each_segment_all(bv, bio, i) {
		bv->bv_page = alloc_page(gfp_mask);
		if (!bv->bv_page) {
			while (--bv >= bio->bi_io_vec)
				__free_page(bv->bv_page);
			return -ENOMEM;
		}
	}

	return 0;
}
EXPORT_SYMBOL(bio_alloc_pages);

K
Kent Overstreet 已提交
963 964 965 966 967 968 969 970 971 972 973 974 975 976
/**
 * bio_copy_data - copy contents of data buffers from one chain of bios to
 * another
 * @src: source bio list
 * @dst: destination bio list
 *
 * If @src and @dst are single bios, bi_next must be NULL - otherwise, treats
 * @src and @dst as linked lists of bios.
 *
 * Stops when it reaches the end of either @src or @dst - that is, copies
 * min(src->bi_size, dst->bi_size) bytes (or the equivalent for lists of bios).
 */
void bio_copy_data(struct bio *dst, struct bio *src)
{
977 978
	struct bvec_iter src_iter, dst_iter;
	struct bio_vec src_bv, dst_bv;
K
Kent Overstreet 已提交
979
	void *src_p, *dst_p;
980
	unsigned bytes;
K
Kent Overstreet 已提交
981

982 983
	src_iter = src->bi_iter;
	dst_iter = dst->bi_iter;
K
Kent Overstreet 已提交
984 985

	while (1) {
986 987 988 989
		if (!src_iter.bi_size) {
			src = src->bi_next;
			if (!src)
				break;
K
Kent Overstreet 已提交
990

991
			src_iter = src->bi_iter;
K
Kent Overstreet 已提交
992 993
		}

994 995 996 997
		if (!dst_iter.bi_size) {
			dst = dst->bi_next;
			if (!dst)
				break;
K
Kent Overstreet 已提交
998

999
			dst_iter = dst->bi_iter;
K
Kent Overstreet 已提交
1000 1001
		}

1002 1003 1004 1005
		src_bv = bio_iter_iovec(src, src_iter);
		dst_bv = bio_iter_iovec(dst, dst_iter);

		bytes = min(src_bv.bv_len, dst_bv.bv_len);
K
Kent Overstreet 已提交
1006

1007 1008
		src_p = kmap_atomic(src_bv.bv_page);
		dst_p = kmap_atomic(dst_bv.bv_page);
K
Kent Overstreet 已提交
1009

1010 1011
		memcpy(dst_p + dst_bv.bv_offset,
		       src_p + src_bv.bv_offset,
K
Kent Overstreet 已提交
1012 1013 1014 1015 1016
		       bytes);

		kunmap_atomic(dst_p);
		kunmap_atomic(src_p);

1017 1018
		bio_advance_iter(src, &src_iter, bytes);
		bio_advance_iter(dst, &dst_iter, bytes);
K
Kent Overstreet 已提交
1019 1020 1021 1022
	}
}
EXPORT_SYMBOL(bio_copy_data);

L
Linus Torvalds 已提交
1023
struct bio_map_data {
1024
	int is_our_pages;
1025 1026
	struct iov_iter iter;
	struct iovec iov[];
L
Linus Torvalds 已提交
1027 1028
};

1029
static struct bio_map_data *bio_alloc_map_data(unsigned int iov_count,
1030
					       gfp_t gfp_mask)
L
Linus Torvalds 已提交
1031
{
1032 1033
	if (iov_count > UIO_MAXIOV)
		return NULL;
L
Linus Torvalds 已提交
1034

1035
	return kmalloc(sizeof(struct bio_map_data) +
1036
		       sizeof(struct iovec) * iov_count, gfp_mask);
L
Linus Torvalds 已提交
1037 1038
}

1039 1040 1041 1042 1043 1044 1045 1046 1047
/**
 * bio_copy_from_iter - copy all pages from iov_iter to bio
 * @bio: The &struct bio which describes the I/O as destination
 * @iter: iov_iter as source
 *
 * Copy all pages from iov_iter to bio.
 * Returns 0 on success, or error on failure.
 */
static int bio_copy_from_iter(struct bio *bio, struct iov_iter iter)
1048
{
1049
	int i;
1050 1051
	struct bio_vec *bvec;

1052
	bio_for_each_segment_all(bvec, bio, i) {
1053
		ssize_t ret;
1054

1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
		ret = copy_page_from_iter(bvec->bv_page,
					  bvec->bv_offset,
					  bvec->bv_len,
					  &iter);

		if (!iov_iter_count(&iter))
			break;

		if (ret < bvec->bv_len)
			return -EFAULT;
1065 1066
	}

1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098
	return 0;
}

/**
 * bio_copy_to_iter - copy all pages from bio to iov_iter
 * @bio: The &struct bio which describes the I/O as source
 * @iter: iov_iter as destination
 *
 * Copy all pages from bio to iov_iter.
 * Returns 0 on success, or error on failure.
 */
static int bio_copy_to_iter(struct bio *bio, struct iov_iter iter)
{
	int i;
	struct bio_vec *bvec;

	bio_for_each_segment_all(bvec, bio, i) {
		ssize_t ret;

		ret = copy_page_to_iter(bvec->bv_page,
					bvec->bv_offset,
					bvec->bv_len,
					&iter);

		if (!iov_iter_count(&iter))
			break;

		if (ret < bvec->bv_len)
			return -EFAULT;
	}

	return 0;
1099 1100
}

1101 1102 1103 1104 1105 1106 1107 1108 1109
static void bio_free_pages(struct bio *bio)
{
	struct bio_vec *bvec;
	int i;

	bio_for_each_segment_all(bvec, bio, i)
		__free_page(bvec->bv_page);
}

L
Linus Torvalds 已提交
1110 1111 1112 1113
/**
 *	bio_uncopy_user	-	finish previously mapped bio
 *	@bio: bio being terminated
 *
1114
 *	Free pages allocated from bio_copy_user_iov() and write back data
L
Linus Torvalds 已提交
1115 1116 1117 1118 1119
 *	to user space in case of a read.
 */
int bio_uncopy_user(struct bio *bio)
{
	struct bio_map_data *bmd = bio->bi_private;
1120
	int ret = 0;
L
Linus Torvalds 已提交
1121

1122 1123 1124 1125 1126
	if (!bio_flagged(bio, BIO_NULL_MAPPED)) {
		/*
		 * if we're in a workqueue, the request is orphaned, so
		 * don't copy into a random user address space, just free.
		 */
1127 1128
		if (current->mm && bio_data_dir(bio) == READ)
			ret = bio_copy_to_iter(bio, bmd->iter);
1129 1130
		if (bmd->is_our_pages)
			bio_free_pages(bio);
1131
	}
1132
	kfree(bmd);
L
Linus Torvalds 已提交
1133 1134 1135
	bio_put(bio);
	return ret;
}
1136
EXPORT_SYMBOL(bio_uncopy_user);
L
Linus Torvalds 已提交
1137 1138

/**
1139
 *	bio_copy_user_iov	-	copy user data to bio
1140 1141 1142 1143
 *	@q:		destination block queue
 *	@map_data:	pointer to the rq_map_data holding pages (if necessary)
 *	@iter:		iovec iterator
 *	@gfp_mask:	memory allocation flags
L
Linus Torvalds 已提交
1144 1145 1146 1147 1148
 *
 *	Prepares and returns a bio for indirect user io, bouncing data
 *	to/from kernel pages as necessary. Must be paired with
 *	call bio_uncopy_user() on io completion.
 */
1149 1150
struct bio *bio_copy_user_iov(struct request_queue *q,
			      struct rq_map_data *map_data,
1151 1152
			      const struct iov_iter *iter,
			      gfp_t gfp_mask)
L
Linus Torvalds 已提交
1153 1154 1155 1156 1157
{
	struct bio_map_data *bmd;
	struct page *page;
	struct bio *bio;
	int i, ret;
1158
	int nr_pages = 0;
1159
	unsigned int len = iter->count;
1160
	unsigned int offset = map_data ? map_data->offset & ~PAGE_MASK : 0;
L
Linus Torvalds 已提交
1161

1162
	for (i = 0; i < iter->nr_segs; i++) {
1163 1164 1165 1166
		unsigned long uaddr;
		unsigned long end;
		unsigned long start;

1167 1168 1169
		uaddr = (unsigned long) iter->iov[i].iov_base;
		end = (uaddr + iter->iov[i].iov_len + PAGE_SIZE - 1)
			>> PAGE_SHIFT;
1170 1171
		start = uaddr >> PAGE_SHIFT;

1172 1173 1174 1175 1176 1177
		/*
		 * Overflow, abort
		 */
		if (end < start)
			return ERR_PTR(-EINVAL);

1178 1179 1180
		nr_pages += end - start;
	}

1181 1182 1183
	if (offset)
		nr_pages++;

1184
	bmd = bio_alloc_map_data(iter->nr_segs, gfp_mask);
L
Linus Torvalds 已提交
1185 1186 1187
	if (!bmd)
		return ERR_PTR(-ENOMEM);

1188 1189 1190 1191 1192 1193 1194 1195 1196 1197
	/*
	 * We need to do a deep copy of the iov_iter including the iovecs.
	 * The caller provided iov might point to an on-stack or otherwise
	 * shortlived one.
	 */
	bmd->is_our_pages = map_data ? 0 : 1;
	memcpy(bmd->iov, iter->iov, sizeof(struct iovec) * iter->nr_segs);
	iov_iter_init(&bmd->iter, iter->type, bmd->iov,
			iter->nr_segs, iter->count);

L
Linus Torvalds 已提交
1198
	ret = -ENOMEM;
1199
	bio = bio_kmalloc(gfp_mask, nr_pages);
L
Linus Torvalds 已提交
1200 1201 1202
	if (!bio)
		goto out_bmd;

1203
	if (iter->type & WRITE)
1204
		bio->bi_rw |= REQ_WRITE;
L
Linus Torvalds 已提交
1205 1206

	ret = 0;
1207 1208

	if (map_data) {
1209
		nr_pages = 1 << map_data->page_order;
1210 1211
		i = map_data->offset / PAGE_SIZE;
	}
L
Linus Torvalds 已提交
1212
	while (len) {
1213
		unsigned int bytes = PAGE_SIZE;
L
Linus Torvalds 已提交
1214

1215 1216
		bytes -= offset;

L
Linus Torvalds 已提交
1217 1218 1219
		if (bytes > len)
			bytes = len;

1220
		if (map_data) {
1221
			if (i == map_data->nr_entries * nr_pages) {
1222 1223 1224
				ret = -ENOMEM;
				break;
			}
1225 1226 1227 1228 1229 1230

			page = map_data->pages[i / nr_pages];
			page += (i % nr_pages);

			i++;
		} else {
1231
			page = alloc_page(q->bounce_gfp | gfp_mask);
1232 1233 1234 1235
			if (!page) {
				ret = -ENOMEM;
				break;
			}
L
Linus Torvalds 已提交
1236 1237
		}

1238
		if (bio_add_pc_page(q, bio, page, bytes, offset) < bytes)
L
Linus Torvalds 已提交
1239 1240 1241
			break;

		len -= bytes;
1242
		offset = 0;
L
Linus Torvalds 已提交
1243 1244 1245 1246 1247 1248 1249 1250
	}

	if (ret)
		goto cleanup;

	/*
	 * success
	 */
1251
	if (((iter->type & WRITE) && (!map_data || !map_data->null_mapped)) ||
1252
	    (map_data && map_data->from_user)) {
1253
		ret = bio_copy_from_iter(bio, *iter);
1254 1255
		if (ret)
			goto cleanup;
L
Linus Torvalds 已提交
1256 1257
	}

1258
	bio->bi_private = bmd;
L
Linus Torvalds 已提交
1259 1260
	return bio;
cleanup:
1261
	if (!map_data)
1262
		bio_free_pages(bio);
L
Linus Torvalds 已提交
1263 1264
	bio_put(bio);
out_bmd:
1265
	kfree(bmd);
L
Linus Torvalds 已提交
1266 1267 1268
	return ERR_PTR(ret);
}

1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280
/**
 *	bio_map_user_iov - map user iovec into bio
 *	@q:		the struct request_queue for the bio
 *	@iter:		iovec iterator
 *	@gfp_mask:	memory allocation flags
 *
 *	Map the user space address into a bio suitable for io to a block
 *	device. Returns an error pointer in case of error.
 */
struct bio *bio_map_user_iov(struct request_queue *q,
			     const struct iov_iter *iter,
			     gfp_t gfp_mask)
L
Linus Torvalds 已提交
1281
{
1282
	int j;
1283
	int nr_pages = 0;
L
Linus Torvalds 已提交
1284 1285
	struct page **pages;
	struct bio *bio;
1286 1287
	int cur_page = 0;
	int ret, offset;
1288 1289
	struct iov_iter i;
	struct iovec iov;
L
Linus Torvalds 已提交
1290

1291 1292 1293
	iov_for_each(iov, i, *iter) {
		unsigned long uaddr = (unsigned long) iov.iov_base;
		unsigned long len = iov.iov_len;
1294 1295 1296
		unsigned long end = (uaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
		unsigned long start = uaddr >> PAGE_SHIFT;

1297 1298 1299 1300 1301 1302
		/*
		 * Overflow, abort
		 */
		if (end < start)
			return ERR_PTR(-EINVAL);

1303 1304
		nr_pages += end - start;
		/*
1305
		 * buffer must be aligned to at least hardsector size for now
1306
		 */
1307
		if (uaddr & queue_dma_alignment(q))
1308 1309 1310 1311
			return ERR_PTR(-EINVAL);
	}

	if (!nr_pages)
L
Linus Torvalds 已提交
1312 1313
		return ERR_PTR(-EINVAL);

1314
	bio = bio_kmalloc(gfp_mask, nr_pages);
L
Linus Torvalds 已提交
1315 1316 1317 1318
	if (!bio)
		return ERR_PTR(-ENOMEM);

	ret = -ENOMEM;
1319
	pages = kcalloc(nr_pages, sizeof(struct page *), gfp_mask);
L
Linus Torvalds 已提交
1320 1321 1322
	if (!pages)
		goto out;

1323 1324 1325
	iov_for_each(iov, i, *iter) {
		unsigned long uaddr = (unsigned long) iov.iov_base;
		unsigned long len = iov.iov_len;
1326 1327 1328 1329
		unsigned long end = (uaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
		unsigned long start = uaddr >> PAGE_SHIFT;
		const int local_nr_pages = end - start;
		const int page_limit = cur_page + local_nr_pages;
1330

N
Nick Piggin 已提交
1331
		ret = get_user_pages_fast(uaddr, local_nr_pages,
1332 1333
				(iter->type & WRITE) != WRITE,
				&pages[cur_page]);
1334 1335
		if (ret < local_nr_pages) {
			ret = -EFAULT;
1336
			goto out_unmap;
1337
		}
1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351

		offset = uaddr & ~PAGE_MASK;
		for (j = cur_page; j < page_limit; j++) {
			unsigned int bytes = PAGE_SIZE - offset;

			if (len <= 0)
				break;
			
			if (bytes > len)
				bytes = len;

			/*
			 * sorry...
			 */
1352 1353
			if (bio_add_pc_page(q, bio, pages[j], bytes, offset) <
					    bytes)
1354 1355 1356 1357 1358
				break;

			len -= bytes;
			offset = 0;
		}
L
Linus Torvalds 已提交
1359

1360
		cur_page = j;
L
Linus Torvalds 已提交
1361
		/*
1362
		 * release the pages we didn't map into the bio, if any
L
Linus Torvalds 已提交
1363
		 */
1364 1365
		while (j < page_limit)
			page_cache_release(pages[j++]);
L
Linus Torvalds 已提交
1366 1367 1368 1369 1370 1371 1372
	}

	kfree(pages);

	/*
	 * set data direction, and check if mapped pages need bouncing
	 */
1373
	if (iter->type & WRITE)
1374
		bio->bi_rw |= REQ_WRITE;
L
Linus Torvalds 已提交
1375 1376

	bio->bi_flags |= (1 << BIO_USER_MAPPED);
1377 1378 1379 1380 1381 1382 1383 1384

	/*
	 * subtle -- if __bio_map_user() ended up bouncing a bio,
	 * it would normally disappear when its bi_end_io is run.
	 * however, we need it for the unmap, so grab an extra
	 * reference to it
	 */
	bio_get(bio);
L
Linus Torvalds 已提交
1385
	return bio;
1386 1387

 out_unmap:
1388 1389
	for (j = 0; j < nr_pages; j++) {
		if (!pages[j])
1390
			break;
1391
		page_cache_release(pages[j]);
1392 1393
	}
 out:
L
Linus Torvalds 已提交
1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406
	kfree(pages);
	bio_put(bio);
	return ERR_PTR(ret);
}

static void __bio_unmap_user(struct bio *bio)
{
	struct bio_vec *bvec;
	int i;

	/*
	 * make sure we dirty pages we wrote to
	 */
1407
	bio_for_each_segment_all(bvec, bio, i) {
L
Linus Torvalds 已提交
1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430
		if (bio_data_dir(bio) == READ)
			set_page_dirty_lock(bvec->bv_page);

		page_cache_release(bvec->bv_page);
	}

	bio_put(bio);
}

/**
 *	bio_unmap_user	-	unmap a bio
 *	@bio:		the bio being unmapped
 *
 *	Unmap a bio previously mapped by bio_map_user(). Must be called with
 *	a process context.
 *
 *	bio_unmap_user() may sleep.
 */
void bio_unmap_user(struct bio *bio)
{
	__bio_unmap_user(bio);
	bio_put(bio);
}
1431
EXPORT_SYMBOL(bio_unmap_user);
L
Linus Torvalds 已提交
1432

1433
static void bio_map_kern_endio(struct bio *bio, int err)
1434 1435 1436 1437
{
	bio_put(bio);
}

1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449
/**
 *	bio_map_kern	-	map kernel address into bio
 *	@q: the struct request_queue for the bio
 *	@data: pointer to buffer to map
 *	@len: length in bytes
 *	@gfp_mask: allocation flags for bio allocation
 *
 *	Map the kernel address into a bio suitable for io to a block
 *	device. Returns an error pointer in case of error.
 */
struct bio *bio_map_kern(struct request_queue *q, void *data, unsigned int len,
			 gfp_t gfp_mask)
M
Mike Christie 已提交
1450 1451 1452 1453 1454 1455 1456 1457
{
	unsigned long kaddr = (unsigned long)data;
	unsigned long end = (kaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
	unsigned long start = kaddr >> PAGE_SHIFT;
	const int nr_pages = end - start;
	int offset, i;
	struct bio *bio;

1458
	bio = bio_kmalloc(gfp_mask, nr_pages);
M
Mike Christie 已提交
1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471
	if (!bio)
		return ERR_PTR(-ENOMEM);

	offset = offset_in_page(kaddr);
	for (i = 0; i < nr_pages; i++) {
		unsigned int bytes = PAGE_SIZE - offset;

		if (len <= 0)
			break;

		if (bytes > len)
			bytes = len;

1472
		if (bio_add_pc_page(q, bio, virt_to_page(data), bytes,
1473 1474 1475 1476 1477
				    offset) < bytes) {
			/* we don't support partial mappings */
			bio_put(bio);
			return ERR_PTR(-EINVAL);
		}
M
Mike Christie 已提交
1478 1479 1480 1481 1482 1483

		data += bytes;
		len -= bytes;
		offset = 0;
	}

1484
	bio->bi_end_io = bio_map_kern_endio;
M
Mike Christie 已提交
1485 1486
	return bio;
}
1487
EXPORT_SYMBOL(bio_map_kern);
M
Mike Christie 已提交
1488

1489 1490
static void bio_copy_kern_endio(struct bio *bio, int err)
{
1491 1492 1493 1494 1495 1496
	bio_free_pages(bio);
	bio_put(bio);
}

static void bio_copy_kern_endio_read(struct bio *bio, int err)
{
C
Christoph Hellwig 已提交
1497
	char *p = bio->bi_private;
1498
	struct bio_vec *bvec;
1499 1500
	int i;

1501
	bio_for_each_segment_all(bvec, bio, i) {
1502
		memcpy(p, page_address(bvec->bv_page), bvec->bv_len);
1503
		p += bvec->bv_len;
1504 1505
	}

1506
	bio_copy_kern_endio(bio, err);
1507 1508 1509 1510 1511 1512 1513 1514
}

/**
 *	bio_copy_kern	-	copy kernel address into bio
 *	@q: the struct request_queue for the bio
 *	@data: pointer to buffer to copy
 *	@len: length in bytes
 *	@gfp_mask: allocation flags for bio and page allocation
1515
 *	@reading: data direction is READ
1516 1517 1518 1519 1520 1521 1522
 *
 *	copy the kernel address into a bio suitable for io to a block
 *	device. Returns an error pointer in case of error.
 */
struct bio *bio_copy_kern(struct request_queue *q, void *data, unsigned int len,
			  gfp_t gfp_mask, int reading)
{
C
Christoph Hellwig 已提交
1523 1524 1525 1526 1527
	unsigned long kaddr = (unsigned long)data;
	unsigned long end = (kaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
	unsigned long start = kaddr >> PAGE_SHIFT;
	struct bio *bio;
	void *p = data;
1528
	int nr_pages = 0;
1529

C
Christoph Hellwig 已提交
1530 1531 1532 1533 1534
	/*
	 * Overflow, abort
	 */
	if (end < start)
		return ERR_PTR(-EINVAL);
1535

C
Christoph Hellwig 已提交
1536 1537 1538 1539
	nr_pages = end - start;
	bio = bio_kmalloc(gfp_mask, nr_pages);
	if (!bio)
		return ERR_PTR(-ENOMEM);
1540

C
Christoph Hellwig 已提交
1541 1542 1543
	while (len) {
		struct page *page;
		unsigned int bytes = PAGE_SIZE;
1544

C
Christoph Hellwig 已提交
1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559
		if (bytes > len)
			bytes = len;

		page = alloc_page(q->bounce_gfp | gfp_mask);
		if (!page)
			goto cleanup;

		if (!reading)
			memcpy(page_address(page), p, bytes);

		if (bio_add_pc_page(q, bio, page, bytes, 0) < bytes)
			break;

		len -= bytes;
		p += bytes;
1560 1561
	}

1562 1563 1564 1565 1566
	if (reading) {
		bio->bi_end_io = bio_copy_kern_endio_read;
		bio->bi_private = data;
	} else {
		bio->bi_end_io = bio_copy_kern_endio;
C
Christoph Hellwig 已提交
1567
		bio->bi_rw |= REQ_WRITE;
1568
	}
1569

1570
	return bio;
C
Christoph Hellwig 已提交
1571 1572

cleanup:
1573
	bio_free_pages(bio);
C
Christoph Hellwig 已提交
1574 1575
	bio_put(bio);
	return ERR_PTR(-ENOMEM);
1576
}
1577
EXPORT_SYMBOL(bio_copy_kern);
1578

L
Linus Torvalds 已提交
1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597
/*
 * bio_set_pages_dirty() and bio_check_pages_dirty() are support functions
 * for performing direct-IO in BIOs.
 *
 * The problem is that we cannot run set_page_dirty() from interrupt context
 * because the required locks are not interrupt-safe.  So what we can do is to
 * mark the pages dirty _before_ performing IO.  And in interrupt context,
 * check that the pages are still dirty.   If so, fine.  If not, redirty them
 * in process context.
 *
 * We special-case compound pages here: normally this means reads into hugetlb
 * pages.  The logic in here doesn't really work right for compound pages
 * because the VM does not uniformly chase down the head page in all cases.
 * But dirtiness of compound pages is pretty meaningless anyway: the VM doesn't
 * handle them at all.  So we skip compound pages here at an early stage.
 *
 * Note that this code is very hard to test under normal circumstances because
 * direct-io pins the pages with get_user_pages().  This makes
 * is_page_cache_freeable return false, and the VM will not clean the pages.
1598
 * But other code (eg, flusher threads) could clean the pages if they are mapped
L
Linus Torvalds 已提交
1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609
 * pagecache.
 *
 * Simply disabling the call to bio_set_pages_dirty() is a good way to test the
 * deferred bio dirtying paths.
 */

/*
 * bio_set_pages_dirty() will mark all the bio's pages as dirty.
 */
void bio_set_pages_dirty(struct bio *bio)
{
1610
	struct bio_vec *bvec;
L
Linus Torvalds 已提交
1611 1612
	int i;

1613 1614
	bio_for_each_segment_all(bvec, bio, i) {
		struct page *page = bvec->bv_page;
L
Linus Torvalds 已提交
1615 1616 1617 1618 1619 1620

		if (page && !PageCompound(page))
			set_page_dirty_lock(page);
	}
}

1621
static void bio_release_pages(struct bio *bio)
L
Linus Torvalds 已提交
1622
{
1623
	struct bio_vec *bvec;
L
Linus Torvalds 已提交
1624 1625
	int i;

1626 1627
	bio_for_each_segment_all(bvec, bio, i) {
		struct page *page = bvec->bv_page;
L
Linus Torvalds 已提交
1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644

		if (page)
			put_page(page);
	}
}

/*
 * bio_check_pages_dirty() will check that all the BIO's pages are still dirty.
 * If they are, then fine.  If, however, some pages are clean then they must
 * have been written out during the direct-IO read.  So we take another ref on
 * the BIO and the offending pages and re-dirty the pages in process context.
 *
 * It is expected that bio_check_pages_dirty() will wholly own the BIO from
 * here on.  It will run one page_cache_release() against each page and will
 * run one bio_put() against the BIO.
 */

1645
static void bio_dirty_fn(struct work_struct *work);
L
Linus Torvalds 已提交
1646

1647
static DECLARE_WORK(bio_dirty_work, bio_dirty_fn);
L
Linus Torvalds 已提交
1648 1649 1650 1651 1652 1653
static DEFINE_SPINLOCK(bio_dirty_lock);
static struct bio *bio_dirty_list;

/*
 * This runs in process context
 */
1654
static void bio_dirty_fn(struct work_struct *work)
L
Linus Torvalds 已提交
1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675
{
	unsigned long flags;
	struct bio *bio;

	spin_lock_irqsave(&bio_dirty_lock, flags);
	bio = bio_dirty_list;
	bio_dirty_list = NULL;
	spin_unlock_irqrestore(&bio_dirty_lock, flags);

	while (bio) {
		struct bio *next = bio->bi_private;

		bio_set_pages_dirty(bio);
		bio_release_pages(bio);
		bio_put(bio);
		bio = next;
	}
}

void bio_check_pages_dirty(struct bio *bio)
{
1676
	struct bio_vec *bvec;
L
Linus Torvalds 已提交
1677 1678 1679
	int nr_clean_pages = 0;
	int i;

1680 1681
	bio_for_each_segment_all(bvec, bio, i) {
		struct page *page = bvec->bv_page;
L
Linus Torvalds 已提交
1682 1683 1684

		if (PageDirty(page) || PageCompound(page)) {
			page_cache_release(page);
1685
			bvec->bv_page = NULL;
L
Linus Torvalds 已提交
1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703
		} else {
			nr_clean_pages++;
		}
	}

	if (nr_clean_pages) {
		unsigned long flags;

		spin_lock_irqsave(&bio_dirty_lock, flags);
		bio->bi_private = bio_dirty_list;
		bio_dirty_list = bio;
		spin_unlock_irqrestore(&bio_dirty_lock, flags);
		schedule_work(&bio_dirty_work);
	} else {
		bio_put(bio);
	}
}

1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731
void generic_start_io_acct(int rw, unsigned long sectors,
			   struct hd_struct *part)
{
	int cpu = part_stat_lock();

	part_round_stats(cpu, part);
	part_stat_inc(cpu, part, ios[rw]);
	part_stat_add(cpu, part, sectors[rw], sectors);
	part_inc_in_flight(part, rw);

	part_stat_unlock();
}
EXPORT_SYMBOL(generic_start_io_acct);

void generic_end_io_acct(int rw, struct hd_struct *part,
			 unsigned long start_time)
{
	unsigned long duration = jiffies - start_time;
	int cpu = part_stat_lock();

	part_stat_add(cpu, part, ticks[rw], duration);
	part_round_stats(cpu, part);
	part_dec_in_flight(part, rw);

	part_stat_unlock();
}
EXPORT_SYMBOL(generic_end_io_acct);

1732 1733 1734
#if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
void bio_flush_dcache_pages(struct bio *bi)
{
1735 1736
	struct bio_vec bvec;
	struct bvec_iter iter;
1737

1738 1739
	bio_for_each_segment(bvec, bi, iter)
		flush_dcache_page(bvec.bv_page);
1740 1741 1742 1743
}
EXPORT_SYMBOL(bio_flush_dcache_pages);
#endif

L
Linus Torvalds 已提交
1744 1745 1746 1747 1748 1749
/**
 * bio_endio - end I/O on a bio
 * @bio:	bio
 * @error:	error, if any
 *
 * Description:
1750
 *   bio_endio() will end I/O on the whole bio. bio_endio() is the
N
NeilBrown 已提交
1751 1752 1753
 *   preferred way to end I/O on a bio, it takes care of clearing
 *   BIO_UPTODATE on error. @error is 0 on success, and and one of the
 *   established -Exxxx (-EIO, for instance) error values in case
L
Lucas De Marchi 已提交
1754
 *   something went wrong. No one should call bi_end_io() directly on a
N
NeilBrown 已提交
1755 1756
 *   bio unless they own it and thus know that it has an end_io
 *   function.
L
Linus Torvalds 已提交
1757
 **/
1758
void bio_endio(struct bio *bio, int error)
L
Linus Torvalds 已提交
1759
{
K
Kent Overstreet 已提交
1760 1761 1762 1763 1764 1765 1766 1767 1768 1769
	while (bio) {
		BUG_ON(atomic_read(&bio->bi_remaining) <= 0);

		if (error)
			clear_bit(BIO_UPTODATE, &bio->bi_flags);
		else if (!test_bit(BIO_UPTODATE, &bio->bi_flags))
			error = -EIO;

		if (!atomic_dec_and_test(&bio->bi_remaining))
			return;
L
Linus Torvalds 已提交
1770

K
Kent Overstreet 已提交
1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788
		/*
		 * Need to have a real endio function for chained bios,
		 * otherwise various corner cases will break (like stacking
		 * block devices that save/restore bi_end_io) - however, we want
		 * to avoid unbounded recursion and blowing the stack. Tail call
		 * optimization would handle this, but compiling with frame
		 * pointers also disables gcc's sibling call optimization.
		 */
		if (bio->bi_end_io == bio_chain_endio) {
			struct bio *parent = bio->bi_private;
			bio_put(bio);
			bio = parent;
		} else {
			if (bio->bi_end_io)
				bio->bi_end_io(bio, error);
			bio = NULL;
		}
	}
L
Linus Torvalds 已提交
1789
}
1790
EXPORT_SYMBOL(bio_endio);
L
Linus Torvalds 已提交
1791

K
Kent Overstreet 已提交
1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806
/**
 * bio_endio_nodec - end I/O on a bio, without decrementing bi_remaining
 * @bio:	bio
 * @error:	error, if any
 *
 * For code that has saved and restored bi_end_io; thing hard before using this
 * function, probably you should've cloned the entire bio.
 **/
void bio_endio_nodec(struct bio *bio, int error)
{
	atomic_inc(&bio->bi_remaining);
	bio_endio(bio, error);
}
EXPORT_SYMBOL(bio_endio_nodec);

K
Kent Overstreet 已提交
1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842
/**
 * bio_split - split a bio
 * @bio:	bio to split
 * @sectors:	number of sectors to split from the front of @bio
 * @gfp:	gfp mask
 * @bs:		bio set to allocate from
 *
 * Allocates and returns a new bio which represents @sectors from the start of
 * @bio, and updates @bio to represent the remaining sectors.
 *
 * The newly allocated bio will point to @bio's bi_io_vec; it is the caller's
 * responsibility to ensure that @bio is not freed before the split.
 */
struct bio *bio_split(struct bio *bio, int sectors,
		      gfp_t gfp, struct bio_set *bs)
{
	struct bio *split = NULL;

	BUG_ON(sectors <= 0);
	BUG_ON(sectors >= bio_sectors(bio));

	split = bio_clone_fast(bio, gfp, bs);
	if (!split)
		return NULL;

	split->bi_iter.bi_size = sectors << 9;

	if (bio_integrity(split))
		bio_integrity_trim(split, 0, sectors);

	bio_advance(bio, split->bi_iter.bi_size);

	return split;
}
EXPORT_SYMBOL(bio_split);

1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855
/**
 * bio_trim - trim a bio
 * @bio:	bio to trim
 * @offset:	number of sectors to trim from the front of @bio
 * @size:	size we want to trim @bio to, in sectors
 */
void bio_trim(struct bio *bio, int offset, int size)
{
	/* 'bio' is a cloned bio which we need to trim to match
	 * the given offset and size.
	 */

	size <<= 9;
1856
	if (offset == 0 && size == bio->bi_iter.bi_size)
1857 1858 1859 1860 1861 1862
		return;

	clear_bit(BIO_SEG_VALID, &bio->bi_flags);

	bio_advance(bio, offset << 9);

1863
	bio->bi_iter.bi_size = size;
1864 1865 1866
}
EXPORT_SYMBOL_GPL(bio_trim);

L
Linus Torvalds 已提交
1867 1868 1869 1870
/*
 * create memory pools for biovec's in a bio_set.
 * use the global biovec slabs created for general use.
 */
1871
mempool_t *biovec_create_pool(int pool_entries)
L
Linus Torvalds 已提交
1872
{
1873
	struct biovec_slab *bp = bvec_slabs + BIOVEC_MAX_IDX;
L
Linus Torvalds 已提交
1874

1875
	return mempool_create_slab_pool(pool_entries, bp->slab);
L
Linus Torvalds 已提交
1876 1877 1878 1879
}

void bioset_free(struct bio_set *bs)
{
1880 1881 1882
	if (bs->rescue_workqueue)
		destroy_workqueue(bs->rescue_workqueue);

L
Linus Torvalds 已提交
1883 1884 1885
	if (bs->bio_pool)
		mempool_destroy(bs->bio_pool);

1886 1887 1888
	if (bs->bvec_pool)
		mempool_destroy(bs->bvec_pool);

1889
	bioset_integrity_free(bs);
1890
	bio_put_slab(bs);
L
Linus Torvalds 已提交
1891 1892 1893

	kfree(bs);
}
1894
EXPORT_SYMBOL(bioset_free);
L
Linus Torvalds 已提交
1895

J
Junichi Nomura 已提交
1896 1897 1898
static struct bio_set *__bioset_create(unsigned int pool_size,
				       unsigned int front_pad,
				       bool create_bvec_pool)
L
Linus Torvalds 已提交
1899
{
1900
	unsigned int back_pad = BIO_INLINE_VECS * sizeof(struct bio_vec);
1901
	struct bio_set *bs;
L
Linus Torvalds 已提交
1902

1903
	bs = kzalloc(sizeof(*bs), GFP_KERNEL);
L
Linus Torvalds 已提交
1904 1905 1906
	if (!bs)
		return NULL;

1907
	bs->front_pad = front_pad;
1908

1909 1910 1911 1912
	spin_lock_init(&bs->rescue_lock);
	bio_list_init(&bs->rescue_list);
	INIT_WORK(&bs->rescue_work, bio_alloc_rescue);

1913
	bs->bio_slab = bio_find_or_create_slab(front_pad + back_pad);
1914 1915 1916 1917 1918 1919
	if (!bs->bio_slab) {
		kfree(bs);
		return NULL;
	}

	bs->bio_pool = mempool_create_slab_pool(pool_size, bs->bio_slab);
L
Linus Torvalds 已提交
1920 1921 1922
	if (!bs->bio_pool)
		goto bad;

J
Junichi Nomura 已提交
1923 1924 1925 1926 1927
	if (create_bvec_pool) {
		bs->bvec_pool = biovec_create_pool(pool_size);
		if (!bs->bvec_pool)
			goto bad;
	}
1928 1929 1930 1931

	bs->rescue_workqueue = alloc_workqueue("bioset", WQ_MEM_RECLAIM, 0);
	if (!bs->rescue_workqueue)
		goto bad;
L
Linus Torvalds 已提交
1932

1933
	return bs;
L
Linus Torvalds 已提交
1934 1935 1936 1937
bad:
	bioset_free(bs);
	return NULL;
}
J
Junichi Nomura 已提交
1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955

/**
 * bioset_create  - Create a bio_set
 * @pool_size:	Number of bio and bio_vecs to cache in the mempool
 * @front_pad:	Number of bytes to allocate in front of the returned bio
 *
 * Description:
 *    Set up a bio_set to be used with @bio_alloc_bioset. Allows the caller
 *    to ask for a number of bytes to be allocated in front of the bio.
 *    Front pad allocation is useful for embedding the bio inside
 *    another structure, to avoid allocating extra data to go with the bio.
 *    Note that the bio must be embedded at the END of that structure always,
 *    or things will break badly.
 */
struct bio_set *bioset_create(unsigned int pool_size, unsigned int front_pad)
{
	return __bioset_create(pool_size, front_pad, true);
}
1956
EXPORT_SYMBOL(bioset_create);
L
Linus Torvalds 已提交
1957

J
Junichi Nomura 已提交
1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972
/**
 * bioset_create_nobvec  - Create a bio_set without bio_vec mempool
 * @pool_size:	Number of bio to cache in the mempool
 * @front_pad:	Number of bytes to allocate in front of the returned bio
 *
 * Description:
 *    Same functionality as bioset_create() except that mempool is not
 *    created for bio_vecs. Saving some memory for bio_clone_fast() users.
 */
struct bio_set *bioset_create_nobvec(unsigned int pool_size, unsigned int front_pad)
{
	return __bioset_create(pool_size, front_pad, false);
}
EXPORT_SYMBOL(bioset_create_nobvec);

1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004
#ifdef CONFIG_BLK_CGROUP
/**
 * bio_associate_current - associate a bio with %current
 * @bio: target bio
 *
 * Associate @bio with %current if it hasn't been associated yet.  Block
 * layer will treat @bio as if it were issued by %current no matter which
 * task actually issues it.
 *
 * This function takes an extra reference of @task's io_context and blkcg
 * which will be put when @bio is released.  The caller must own @bio,
 * ensure %current->io_context exists, and is responsible for synchronizing
 * calls to this function.
 */
int bio_associate_current(struct bio *bio)
{
	struct io_context *ioc;
	struct cgroup_subsys_state *css;

	if (bio->bi_ioc)
		return -EBUSY;

	ioc = current->io_context;
	if (!ioc)
		return -ENOENT;

	/* acquire active ref on @ioc and associate */
	get_io_context_active(ioc);
	bio->bi_ioc = ioc;

	/* associate blkcg if exists */
	rcu_read_lock();
2005
	css = task_css(current, blkio_cgrp_id);
2006
	if (css && css_tryget_online(css))
2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030
		bio->bi_css = css;
	rcu_read_unlock();

	return 0;
}

/**
 * bio_disassociate_task - undo bio_associate_current()
 * @bio: target bio
 */
void bio_disassociate_task(struct bio *bio)
{
	if (bio->bi_ioc) {
		put_io_context(bio->bi_ioc);
		bio->bi_ioc = NULL;
	}
	if (bio->bi_css) {
		css_put(bio->bi_css);
		bio->bi_css = NULL;
	}
}

#endif /* CONFIG_BLK_CGROUP */

L
Linus Torvalds 已提交
2031 2032 2033 2034 2035 2036 2037 2038
static void __init biovec_init_slabs(void)
{
	int i;

	for (i = 0; i < BIOVEC_NR_POOLS; i++) {
		int size;
		struct biovec_slab *bvs = bvec_slabs + i;

2039 2040 2041 2042 2043
		if (bvs->nr_vecs <= BIO_INLINE_VECS) {
			bvs->slab = NULL;
			continue;
		}

L
Linus Torvalds 已提交
2044 2045
		size = bvs->nr_vecs * sizeof(struct bio_vec);
		bvs->slab = kmem_cache_create(bvs->name, size, 0,
2046
                                SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
L
Linus Torvalds 已提交
2047 2048 2049 2050 2051
	}
}

static int __init init_bio(void)
{
2052 2053 2054 2055 2056
	bio_slab_max = 2;
	bio_slab_nr = 0;
	bio_slabs = kzalloc(bio_slab_max * sizeof(struct bio_slab), GFP_KERNEL);
	if (!bio_slabs)
		panic("bio: can't allocate bios\n");
L
Linus Torvalds 已提交
2057

2058
	bio_integrity_init();
L
Linus Torvalds 已提交
2059 2060
	biovec_init_slabs();

2061
	fs_bio_set = bioset_create(BIO_POOL_SIZE, 0);
L
Linus Torvalds 已提交
2062 2063 2064
	if (!fs_bio_set)
		panic("bio: can't allocate bios\n");

2065 2066 2067
	if (bioset_integrity_create(fs_bio_set, BIO_POOL_SIZE))
		panic("bio: can't create integrity pool\n");

L
Linus Torvalds 已提交
2068 2069 2070
	return 0;
}
subsys_initcall(init_bio);