bio.h 20.3 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9
/*
 * Copyright (C) 2001 Jens Axboe <axboe@suse.de>
 *
 * 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
10
 *
Linus Torvalds's avatar
Linus Torvalds committed
11 12 13 14 15 16 17 18 19 20 21 22
 * 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-
 */
#ifndef __LINUX_BIO_H
#define __LINUX_BIO_H

#include <linux/highmem.h>
#include <linux/mempool.h>
23
#include <linux/ioprio.h>
Linus Torvalds's avatar
Linus Torvalds committed
24

25
#ifdef CONFIG_BLOCK
26 27 28
/* struct bio, bio_vec and BIO_* flags are defined in blk_types.h */
#include <linux/blk_types.h>

Linus Torvalds's avatar
Linus Torvalds committed
29 30 31 32 33 34 35 36
#define BIO_DEBUG

#ifdef BIO_DEBUG
#define BIO_BUG_ON	BUG_ON
#else
#define BIO_BUG_ON
#endif

37 38 39 40
#ifdef CONFIG_THP_SWAP
#if HPAGE_PMD_NR > 256
#define BIO_MAX_PAGES		HPAGE_PMD_NR
#else
41
#define BIO_MAX_PAGES		256
42 43 44 45
#endif
#else
#define BIO_MAX_PAGES		256
#endif
Linus Torvalds's avatar
Linus Torvalds committed
46

47 48
#define bio_prio(bio)			(bio)->bi_ioprio
#define bio_set_prio(bio, prio)		((bio)->bi_ioprio = prio)
49

50 51 52 53 54 55 56 57 58 59 60 61 62
#define bio_iter_iovec(bio, iter)				\
	bvec_iter_bvec((bio)->bi_io_vec, (iter))

#define bio_iter_page(bio, iter)				\
	bvec_iter_page((bio)->bi_io_vec, (iter))
#define bio_iter_len(bio, iter)					\
	bvec_iter_len((bio)->bi_io_vec, (iter))
#define bio_iter_offset(bio, iter)				\
	bvec_iter_offset((bio)->bi_io_vec, (iter))

#define bio_page(bio)		bio_iter_page((bio), (bio)->bi_iter)
#define bio_offset(bio)		bio_iter_offset((bio), (bio)->bi_iter)
#define bio_iovec(bio)		bio_iter_iovec((bio), (bio)->bi_iter)
63

64 65
#define bio_multiple_segments(bio)				\
	((bio)->bi_iter.bi_size != bio_iovec(bio).bv_len)
66 67 68 69 70 71

#define bvec_iter_sectors(iter)	((iter).bi_size >> 9)
#define bvec_iter_end_sector(iter) ((iter).bi_sector + bvec_iter_sectors((iter)))

#define bio_sectors(bio)	bvec_iter_sectors((bio)->bi_iter)
#define bio_end_sector(bio)	bvec_iter_end_sector((bio)->bi_iter)
72

73 74 75 76 77 78
/*
 * Return the data direction, READ or WRITE.
 */
#define bio_data_dir(bio) \
	(op_is_write(bio_op(bio)) ? WRITE : READ)

79 80 81 82 83 84 85
/*
 * Check whether this bio carries any data or not. A NULL bio is allowed.
 */
static inline bool bio_has_data(struct bio *bio)
{
	if (bio &&
	    bio->bi_iter.bi_size &&
Adrian Hunter's avatar
Adrian Hunter committed
86
	    bio_op(bio) != REQ_OP_DISCARD &&
87 88
	    bio_op(bio) != REQ_OP_SECURE_ERASE &&
	    bio_op(bio) != REQ_OP_WRITE_ZEROES)
89 90 91 92 93
		return true;

	return false;
}

94 95
static inline bool bio_no_advance_iter(struct bio *bio)
{
Adrian Hunter's avatar
Adrian Hunter committed
96 97
	return bio_op(bio) == REQ_OP_DISCARD ||
	       bio_op(bio) == REQ_OP_SECURE_ERASE ||
98 99
	       bio_op(bio) == REQ_OP_WRITE_SAME ||
	       bio_op(bio) == REQ_OP_WRITE_ZEROES;
100 101
}

102 103
static inline bool bio_mergeable(struct bio *bio)
{
104
	if (bio->bi_opf & REQ_NOMERGE_FLAGS)
105 106 107 108 109
		return false;

	return true;
}

110
static inline unsigned int bio_cur_bytes(struct bio *bio)
111
{
112
	if (bio_has_data(bio))
113
		return bio_iovec(bio).bv_len;
114
	else /* dataless requests such as discard */
115
		return bio->bi_iter.bi_size;
116 117 118 119
}

static inline void *bio_data(struct bio *bio)
{
120
	if (bio_has_data(bio))
121 122 123 124
		return page_address(bio_page(bio)) + bio_offset(bio);

	return NULL;
}
Linus Torvalds's avatar
Linus Torvalds committed
125

126 127 128 129 130
static inline bool bio_full(struct bio *bio)
{
	return bio->bi_vcnt >= bio->bi_max_vecs;
}

131 132 133 134 135
/*
 * drivers should _never_ use the all version - the bio may have been split
 * before it got to the driver and the driver won't own all of it
 */
#define bio_for_each_segment_all(bvl, bio, i)				\
136
	for (i = 0, bvl = (bio)->bi_io_vec; i < (bio)->bi_vcnt; i++, bvl++)
137

138 139 140 141 142
static inline void bio_advance_iter(struct bio *bio, struct bvec_iter *iter,
				    unsigned bytes)
{
	iter->bi_sector += bytes >> 9;

143
	if (bio_no_advance_iter(bio))
144
		iter->bi_size -= bytes;
145
	else
146
		bvec_iter_advance(bio->bi_io_vec, iter, bytes);
147
		/* TODO: It is reasonable to complete bio with error here. */
148 149
}

150 151
#define __bio_for_each_segment(bvl, bio, iter, start)			\
	for (iter = (start);						\
152 153 154
	     (iter).bi_size &&						\
		((bvl = bio_iter_iovec((bio), (iter))), 1);		\
	     bio_advance_iter((bio), &(iter), (bvl).bv_len))
155 156 157 158

#define bio_for_each_segment(bvl, bio, iter)				\
	__bio_for_each_segment(bvl, bio, iter, (bio)->bi_iter)

159
#define bio_iter_last(bvec, iter) ((iter).bi_size == (bvec).bv_len)
Linus Torvalds's avatar
Linus Torvalds committed
160

161
static inline unsigned bio_segments(struct bio *bio)
162 163 164 165 166
{
	unsigned segs = 0;
	struct bio_vec bv;
	struct bvec_iter iter;

167
	/*
168 169
	 * We special case discard/write same/write zeroes, because they
	 * interpret bi_size differently:
170 171
	 */

172 173 174 175
	switch (bio_op(bio)) {
	case REQ_OP_DISCARD:
	case REQ_OP_SECURE_ERASE:
	case REQ_OP_WRITE_ZEROES:
176 177
		return 0;
	case REQ_OP_WRITE_SAME:
178
		return 1;
179 180 181
	default:
		break;
	}
182

183
	bio_for_each_segment(bv, bio, iter)
184 185 186 187 188
		segs++;

	return segs;
}

Linus Torvalds's avatar
Linus Torvalds committed
189 190 191 192 193 194 195 196 197 198 199 200 201 202
/*
 * get a reference to a bio, so it won't disappear. the intended use is
 * something like:
 *
 * bio_get(bio);
 * submit_bio(rw, bio);
 * if (bio->bi_flags ...)
 *	do_something
 * bio_put(bio);
 *
 * without the bio_get(), it could potentially complete I/O before submit_bio
 * returns. and then bio would be freed memory when if (bio->bi_flags ...)
 * runs
 */
203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
static inline void bio_get(struct bio *bio)
{
	bio->bi_flags |= (1 << BIO_REFFED);
	smp_mb__before_atomic();
	atomic_inc(&bio->__bi_cnt);
}

static inline void bio_cnt_set(struct bio *bio, unsigned int count)
{
	if (count != 1) {
		bio->bi_flags |= (1 << BIO_REFFED);
		smp_mb__before_atomic();
	}
	atomic_set(&bio->__bi_cnt, count);
}
Linus Torvalds's avatar
Linus Torvalds committed
218

219 220
static inline bool bio_flagged(struct bio *bio, unsigned int bit)
{
221
	return (bio->bi_flags & (1U << bit)) != 0;
222 223 224 225
}

static inline void bio_set_flag(struct bio *bio, unsigned int bit)
{
226
	bio->bi_flags |= (1U << bit);
227 228 229 230
}

static inline void bio_clear_flag(struct bio *bio, unsigned int bit)
{
231
	bio->bi_flags &= ~(1U << bit);
232 233
}

234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
static inline void bio_get_first_bvec(struct bio *bio, struct bio_vec *bv)
{
	*bv = bio_iovec(bio);
}

static inline void bio_get_last_bvec(struct bio *bio, struct bio_vec *bv)
{
	struct bvec_iter iter = bio->bi_iter;
	int idx;

	if (unlikely(!bio_multiple_segments(bio))) {
		*bv = bio_iovec(bio);
		return;
	}

	bio_advance_iter(bio, &iter, iter.bi_size);

	if (!iter.bi_bvec_done)
		idx = iter.bi_idx - 1;
	else	/* in the middle of bvec */
		idx = iter.bi_idx;

	*bv = bio->bi_io_vec[idx];

	/*
	 * iter.bi_bvec_done records actual length of the last bvec
	 * if this bio ends in the middle of one io vector
	 */
	if (iter.bi_bvec_done)
		bv->bv_len = iter.bi_bvec_done;
}

266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
static inline unsigned bio_pages_all(struct bio *bio)
{
	WARN_ON_ONCE(bio_flagged(bio, BIO_CLONED));
	return bio->bi_vcnt;
}

static inline struct bio_vec *bio_first_bvec_all(struct bio *bio)
{
	WARN_ON_ONCE(bio_flagged(bio, BIO_CLONED));
	return bio->bi_io_vec;
}

static inline struct page *bio_first_page_all(struct bio *bio)
{
	return bio_first_bvec_all(bio)->bv_page;
}

static inline struct bio_vec *bio_last_bvec_all(struct bio *bio)
{
	WARN_ON_ONCE(bio_flagged(bio, BIO_CLONED));
	return &bio->bi_io_vec[bio->bi_vcnt - 1];
}

289 290 291 292 293 294 295 296
enum bip_flags {
	BIP_BLOCK_INTEGRITY	= 1 << 0, /* block layer owns integrity data */
	BIP_MAPPED_INTEGRITY	= 1 << 1, /* ref tag has been remapped */
	BIP_CTRL_NOCHECK	= 1 << 2, /* disable HBA integrity checking */
	BIP_DISK_NOCHECK	= 1 << 3, /* disable disk integrity checking */
	BIP_IP_CHECKSUM		= 1 << 4, /* IP checksum */
};

297 298 299 300 301 302
/*
 * bio integrity payload
 */
struct bio_integrity_payload {
	struct bio		*bip_bio;	/* parent bio */

303
	struct bvec_iter	bip_iter;
304

305
	unsigned short		bip_slab;	/* slab the bip came from */
306
	unsigned short		bip_vcnt;	/* # of integrity bio_vecs */
307
	unsigned short		bip_max_vcnt;	/* integrity bio_vec slots */
308
	unsigned short		bip_flags;	/* control flags */
309

310 311
	struct bvec_iter	bio_iter;	/* for rewinding parent bio */

312
	struct work_struct	bip_work;	/* I/O completion */
313 314 315

	struct bio_vec		*bip_vec;
	struct bio_vec		bip_inline_vecs[0];/* embedded bvec array */
316
};
317

318 319 320 321
#if defined(CONFIG_BLK_DEV_INTEGRITY)

static inline struct bio_integrity_payload *bio_integrity(struct bio *bio)
{
322
	if (bio->bi_opf & REQ_INTEGRITY)
323 324 325 326 327
		return bio->bi_integrity;

	return NULL;
}

328 329 330 331 332 333 334 335 336
static inline bool bio_integrity_flagged(struct bio *bio, enum bip_flags flag)
{
	struct bio_integrity_payload *bip = bio_integrity(bio);

	if (bip)
		return bip->bip_flags & flag;

	return false;
}
337

338 339 340 341 342 343 344 345 346 347 348
static inline sector_t bip_get_seed(struct bio_integrity_payload *bip)
{
	return bip->bip_iter.bi_sector;
}

static inline void bip_set_seed(struct bio_integrity_payload *bip,
				sector_t seed)
{
	bip->bip_iter.bi_sector = seed;
}

349
#endif /* CONFIG_BLK_DEV_INTEGRITY */
Linus Torvalds's avatar
Linus Torvalds committed
350

351
extern void bio_trim(struct bio *bio, int offset, int size);
352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
extern struct bio *bio_split(struct bio *bio, int sectors,
			     gfp_t gfp, struct bio_set *bs);

/**
 * bio_next_split - get next @sectors from a bio, splitting if necessary
 * @bio:	bio to split
 * @sectors:	number of sectors to split from the front of @bio
 * @gfp:	gfp mask
 * @bs:		bio set to allocate from
 *
 * Returns a bio representing the next @sectors of @bio - if the bio is smaller
 * than @sectors, returns the original bio unchanged.
 */
static inline struct bio *bio_next_split(struct bio *bio, int sectors,
					 gfp_t gfp, struct bio_set *bs)
{
	if (sectors >= bio_sectors(bio))
		return bio;

	return bio_split(bio, sectors, gfp, bs);
}

374 375
enum {
	BIOSET_NEED_BVECS = BIT(0),
376
	BIOSET_NEED_RESCUER = BIT(1),
377
};
378 379
extern int bioset_init(struct bio_set *, unsigned int, unsigned int, int flags);
extern void bioset_exit(struct bio_set *);
380
extern int biovec_init_pool(mempool_t *pool, int pool_entries);
381
extern int bioset_init_from_src(struct bio_set *bs, struct bio_set *src);
Linus Torvalds's avatar
Linus Torvalds committed
382

383
extern struct bio *bio_alloc_bioset(gfp_t, unsigned int, struct bio_set *);
Linus Torvalds's avatar
Linus Torvalds committed
384 385
extern void bio_put(struct bio *);

386 387
extern void __bio_clone_fast(struct bio *, struct bio *);
extern struct bio *bio_clone_fast(struct bio *, gfp_t, struct bio_set *);
388

389
extern struct bio_set fs_bio_set;
390 391 392

static inline struct bio *bio_alloc(gfp_t gfp_mask, unsigned int nr_iovecs)
{
393
	return bio_alloc_bioset(gfp_mask, nr_iovecs, &fs_bio_set);
394 395 396 397 398 399 400
}

static inline struct bio *bio_kmalloc(gfp_t gfp_mask, unsigned int nr_iovecs)
{
	return bio_alloc_bioset(gfp_mask, nr_iovecs, NULL);
}

401 402
extern blk_qc_t submit_bio(struct bio *);

403 404 405 406
extern void bio_endio(struct bio *);

static inline void bio_io_error(struct bio *bio)
{
407
	bio->bi_status = BLK_STS_IOERR;
408 409 410
	bio_endio(bio);
}

411 412 413
static inline void bio_wouldblock_error(struct bio *bio)
{
	bio->bi_status = BLK_STS_AGAIN;
414 415 416
	bio_endio(bio);
}

Linus Torvalds's avatar
Linus Torvalds committed
417 418 419
struct request_queue;
extern int bio_phys_segments(struct request_queue *, struct bio *);

420
extern int submit_bio_wait(struct bio *bio);
421 422
extern void bio_advance(struct bio *, unsigned);

423 424
extern void bio_init(struct bio *bio, struct bio_vec *table,
		     unsigned short max_vecs);
425
extern void bio_uninit(struct bio *);
Kent Overstreet's avatar
Kent Overstreet committed
426
extern void bio_reset(struct bio *);
427
void bio_chain(struct bio *, struct bio *);
Linus Torvalds's avatar
Linus Torvalds committed
428 429

extern int bio_add_page(struct bio *, struct page *, unsigned int,unsigned int);
430 431
extern int bio_add_pc_page(struct request_queue *, struct bio *, struct page *,
			   unsigned int, unsigned int);
432 433 434 435
bool __bio_try_merge_page(struct bio *bio, struct page *page,
		unsigned int len, unsigned int off);
void __bio_add_page(struct bio *bio, struct page *page,
		unsigned int len, unsigned int off);
436
int bio_iov_iter_get_pages(struct bio *bio, struct iov_iter *iter);
437
struct rq_map_data;
438
extern struct bio *bio_map_user_iov(struct request_queue *,
439
				    struct iov_iter *, gfp_t);
Linus Torvalds's avatar
Linus Torvalds committed
440
extern void bio_unmap_user(struct bio *);
441
extern struct bio *bio_map_kern(struct request_queue *, void *, unsigned int,
Al Viro's avatar
Al Viro committed
442
				gfp_t);
443 444
extern struct bio *bio_copy_kern(struct request_queue *, void *, unsigned int,
				 gfp_t, int);
Linus Torvalds's avatar
Linus Torvalds committed
445 446
extern void bio_set_pages_dirty(struct bio *bio);
extern void bio_check_pages_dirty(struct bio *bio);
447

448
void generic_start_io_acct(struct request_queue *q, int op,
449
				unsigned long sectors, struct hd_struct *part);
450
void generic_end_io_acct(struct request_queue *q, int op,
451 452
				struct hd_struct *part,
				unsigned long start_time);
453

454 455 456 457 458 459 460 461 462 463 464
#ifndef ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
# error	"You should define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE for your platform"
#endif
#if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
extern void bio_flush_dcache_pages(struct bio *bi);
#else
static inline void bio_flush_dcache_pages(struct bio *bi)
{
}
#endif

465 466
extern void bio_copy_data_iter(struct bio *dst, struct bvec_iter *dst_iter,
			       struct bio *src, struct bvec_iter *src_iter);
467
extern void bio_copy_data(struct bio *dst, struct bio *src);
468
extern void bio_list_copy_data(struct bio *dst, struct bio *src);
469
extern void bio_free_pages(struct bio *bio);
470

471
extern struct bio *bio_copy_user_iov(struct request_queue *,
472
				     struct rq_map_data *,
473
				     struct iov_iter *,
474
				     gfp_t);
Linus Torvalds's avatar
Linus Torvalds committed
475
extern int bio_uncopy_user(struct bio *);
476 477 478 479 480 481 482
void zero_fill_bio_iter(struct bio *bio, struct bvec_iter iter);

static inline void zero_fill_bio(struct bio *bio)
{
	zero_fill_bio_iter(bio, bio->bi_iter);
}

483 484
extern struct bio_vec *bvec_alloc(gfp_t, int, unsigned long *, mempool_t *);
extern void bvec_free(mempool_t *, struct bio_vec *, unsigned int);
485
extern unsigned int bvec_nr_vecs(unsigned short idx);
486
extern const char *bio_devname(struct bio *bio, char *buffer);
487

488 489
#define bio_set_dev(bio, bdev) 			\
do {						\
490 491
	if ((bio)->bi_disk != (bdev)->bd_disk)	\
		bio_clear_flag(bio, BIO_THROTTLED);\
492 493 494 495 496 497 498 499 500 501 502 503 504
	(bio)->bi_disk = (bdev)->bd_disk;	\
	(bio)->bi_partno = (bdev)->bd_partno;	\
} while (0)

#define bio_copy_dev(dst, src)			\
do {						\
	(dst)->bi_disk = (src)->bi_disk;	\
	(dst)->bi_partno = (src)->bi_partno;	\
} while (0)

#define bio_dev(bio) \
	disk_devt((bio)->bi_disk)

505
#if defined(CONFIG_MEMCG) && defined(CONFIG_BLK_CGROUP)
506
int bio_associate_blkcg_from_page(struct bio *bio, struct page *page);
507
#else
508 509
static inline int bio_associate_blkcg_from_page(struct bio *bio,
						struct page *page) {  return 0; }
510 511
#endif

512
#ifdef CONFIG_BLK_CGROUP
513
int bio_associate_blkcg(struct bio *bio, struct cgroup_subsys_state *blkcg_css);
514
int bio_associate_blkg(struct bio *bio, struct blkcg_gq *blkg);
515
void bio_disassociate_task(struct bio *bio);
516
void bio_clone_blkcg_association(struct bio *dst, struct bio *src);
517
#else	/* CONFIG_BLK_CGROUP */
518 519
static inline int bio_associate_blkcg(struct bio *bio,
			struct cgroup_subsys_state *blkcg_css) { return 0; }
520
static inline void bio_disassociate_task(struct bio *bio) { }
521 522
static inline void bio_clone_blkcg_association(struct bio *dst,
			struct bio *src) { }
523 524
#endif	/* CONFIG_BLK_CGROUP */

Linus Torvalds's avatar
Linus Torvalds committed
525 526
#ifdef CONFIG_HIGHMEM
/*
527 528
 * remember never ever reenable interrupts between a bvec_kmap_irq and
 * bvec_kunmap_irq!
Linus Torvalds's avatar
Linus Torvalds committed
529
 */
530
static inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
Linus Torvalds's avatar
Linus Torvalds committed
531 532 533 534 535 536 537 538
{
	unsigned long addr;

	/*
	 * might not be a highmem page, but the preempt/irq count
	 * balancing is a lot nicer this way
	 */
	local_irq_save(*flags);
539
	addr = (unsigned long) kmap_atomic(bvec->bv_page);
Linus Torvalds's avatar
Linus Torvalds committed
540 541 542 543 544 545

	BUG_ON(addr & ~PAGE_MASK);

	return (char *) addr + bvec->bv_offset;
}

546
static inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
Linus Torvalds's avatar
Linus Torvalds committed
547 548 549
{
	unsigned long ptr = (unsigned long) buffer & PAGE_MASK;

550
	kunmap_atomic((void *) ptr);
Linus Torvalds's avatar
Linus Torvalds committed
551 552 553 554
	local_irq_restore(*flags);
}

#else
555 556 557 558 559 560 561 562 563
static inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
{
	return page_address(bvec->bv_page) + bvec->bv_offset;
}

static inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
{
	*flags = 0;
}
Linus Torvalds's avatar
Linus Torvalds committed
564 565
#endif

566
/*
567
 * BIO list management for use by remapping drivers (e.g. DM or MD) and loop.
568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587
 *
 * A bio_list anchors a singly-linked list of bios chained through the bi_next
 * member of the bio.  The bio_list also caches the last list member to allow
 * fast access to the tail.
 */
struct bio_list {
	struct bio *head;
	struct bio *tail;
};

static inline int bio_list_empty(const struct bio_list *bl)
{
	return bl->head == NULL;
}

static inline void bio_list_init(struct bio_list *bl)
{
	bl->head = bl->tail = NULL;
}

588 589
#define BIO_EMPTY_LIST	{ NULL, NULL }

590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652
#define bio_list_for_each(bio, bl) \
	for (bio = (bl)->head; bio; bio = bio->bi_next)

static inline unsigned bio_list_size(const struct bio_list *bl)
{
	unsigned sz = 0;
	struct bio *bio;

	bio_list_for_each(bio, bl)
		sz++;

	return sz;
}

static inline void bio_list_add(struct bio_list *bl, struct bio *bio)
{
	bio->bi_next = NULL;

	if (bl->tail)
		bl->tail->bi_next = bio;
	else
		bl->head = bio;

	bl->tail = bio;
}

static inline void bio_list_add_head(struct bio_list *bl, struct bio *bio)
{
	bio->bi_next = bl->head;

	bl->head = bio;

	if (!bl->tail)
		bl->tail = bio;
}

static inline void bio_list_merge(struct bio_list *bl, struct bio_list *bl2)
{
	if (!bl2->head)
		return;

	if (bl->tail)
		bl->tail->bi_next = bl2->head;
	else
		bl->head = bl2->head;

	bl->tail = bl2->tail;
}

static inline void bio_list_merge_head(struct bio_list *bl,
				       struct bio_list *bl2)
{
	if (!bl2->head)
		return;

	if (bl->head)
		bl2->tail->bi_next = bl->head;
	else
		bl->tail = bl2->tail;

	bl->head = bl2->head;
}

653 654 655 656 657
static inline struct bio *bio_list_peek(struct bio_list *bl)
{
	return bl->head;
}

658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
static inline struct bio *bio_list_pop(struct bio_list *bl)
{
	struct bio *bio = bl->head;

	if (bio) {
		bl->head = bl->head->bi_next;
		if (!bl->head)
			bl->tail = NULL;

		bio->bi_next = NULL;
	}

	return bio;
}

static inline struct bio *bio_list_get(struct bio_list *bl)
{
	struct bio *bio = bl->head;

	bl->head = bl->tail = NULL;

	return bio;
}

682 683 684 685 686 687 688 689 690 691 692
/*
 * Increment chain count for the bio. Make sure the CHAIN flag update
 * is visible before the raised count.
 */
static inline void bio_inc_remaining(struct bio *bio)
{
	bio_set_flag(bio, BIO_CHAIN);
	smp_mb__before_atomic();
	atomic_inc(&bio->__bi_remaining);
}

693 694 695 696 697 698 699 700 701 702 703 704
/*
 * bio_set is used to allow other portions of the IO system to
 * allocate their own private memory pools for bio and iovec structures.
 * These memory pools in turn all allocate from the bio_slab
 * and the bvec_slabs[].
 */
#define BIO_POOL_SIZE 2

struct bio_set {
	struct kmem_cache *bio_slab;
	unsigned int front_pad;

705 706
	mempool_t bio_pool;
	mempool_t bvec_pool;
707
#if defined(CONFIG_BLK_DEV_INTEGRITY)
708 709
	mempool_t bio_integrity_pool;
	mempool_t bvec_integrity_pool;
710
#endif
711 712 713 714 715 716 717 718 719

	/*
	 * Deadlock avoidance for stacking block drivers: see comments in
	 * bio_alloc_bioset() for details
	 */
	spinlock_t		rescue_lock;
	struct bio_list		rescue_list;
	struct work_struct	rescue_work;
	struct workqueue_struct	*rescue_workqueue;
720 721 722 723 724 725 726 727
};

struct biovec_slab {
	int nr_vecs;
	char *name;
	struct kmem_cache *slab;
};

728 729 730 731 732
static inline bool bioset_initialized(struct bio_set *bs)
{
	return bs->bio_slab != NULL;
}

733 734 735 736 737 738
/*
 * a small number of entries is fine, not going to be performance critical.
 * basically we just need to survive
 */
#define BIO_SPLIT_ENTRIES 2

739 740
#if defined(CONFIG_BLK_DEV_INTEGRITY)

741 742
#define bip_for_each_vec(bvl, bip, iter)				\
	for_each_bvec(bvl, (bip)->bip_vec, iter, (bip)->bip_iter)
743

744 745 746 747
#define bio_for_each_integrity_vec(_bvl, _bio, _iter)			\
	for_each_bio(_bio)						\
		bip_for_each_vec(_bvl, _bio->bi_integrity, _iter)

748 749
extern struct bio_integrity_payload *bio_integrity_alloc(struct bio *, gfp_t, unsigned int);
extern int bio_integrity_add_page(struct bio *, struct page *, unsigned int, unsigned int);
750
extern bool bio_integrity_prep(struct bio *);
751
extern void bio_integrity_advance(struct bio *, unsigned int);
752
extern void bio_integrity_trim(struct bio *);
753
extern int bio_integrity_clone(struct bio *, struct bio *, gfp_t);
754 755 756
extern int bioset_integrity_create(struct bio_set *, int);
extern void bioset_integrity_free(struct bio_set *);
extern void bio_integrity_init(void);
757 758 759

#else /* CONFIG_BLK_DEV_INTEGRITY */

760
static inline void *bio_integrity(struct bio *bio)
761
{
762
	return NULL;
763 764 765 766 767 768 769 770 771 772 773 774
}

static inline int bioset_integrity_create(struct bio_set *bs, int pool_size)
{
	return 0;
}

static inline void bioset_integrity_free (struct bio_set *bs)
{
	return;
}

775
static inline bool bio_integrity_prep(struct bio *bio)
776
{
777
	return true;
778 779
}

780
static inline int bio_integrity_clone(struct bio *bio, struct bio *bio_src,
781
				      gfp_t gfp_mask)
782 783 784
{
	return 0;
}
785 786 787 788 789 790 791

static inline void bio_integrity_advance(struct bio *bio,
					 unsigned int bytes_done)
{
	return;
}

792
static inline void bio_integrity_trim(struct bio *bio)
793 794 795 796 797 798 799 800
{
	return;
}

static inline void bio_integrity_init(void)
{
	return;
}
801

802 803 804 805 806
static inline bool bio_integrity_flagged(struct bio *bio, enum bip_flags flag)
{
	return false;
}

807 808 809 810 811 812 813 814 815 816 817 818
static inline void *bio_integrity_alloc(struct bio * bio, gfp_t gfp,
								unsigned int nr)
{
	return ERR_PTR(-EINVAL);
}

static inline int bio_integrity_add_page(struct bio *bio, struct page *page,
					unsigned int len, unsigned int offset)
{
	return 0;
}

819 820
#endif /* CONFIG_BLK_DEV_INTEGRITY */

821
#endif /* CONFIG_BLOCK */
Linus Torvalds's avatar
Linus Torvalds committed
822
#endif /* __LINUX_BIO_H */