bio.h 20.3 KB
Newer Older
L
Linus Torvalds 已提交
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
 *
L
Linus Torvalds 已提交
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>
24
#include <linux/bug.h>
L
Linus Torvalds 已提交
25

26 27
#ifdef CONFIG_BLOCK

L
Linus Torvalds 已提交
28 29
#include <asm/io.h>

30 31 32
/* struct bio, bio_vec and BIO_* flags are defined in blk_types.h */
#include <linux/blk_types.h>

L
Linus Torvalds 已提交
33 34 35 36 37 38 39 40
#define BIO_DEBUG

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

41
#define BIO_MAX_PAGES		256
L
Linus Torvalds 已提交
42

43 44
#define bio_prio(bio)			(bio)->bi_ioprio
#define bio_set_prio(bio, prio)		((bio)->bi_ioprio = prio)
45

K
Kent Overstreet 已提交
46 47 48 49 50 51 52 53 54 55 56 57 58
#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)
59

60 61
#define bio_multiple_segments(bio)				\
	((bio)->bi_iter.bi_size != bio_iovec(bio).bv_len)
62 63
#define bio_sectors(bio)	((bio)->bi_iter.bi_size >> 9)
#define bio_end_sector(bio)	((bio)->bi_iter.bi_sector + bio_sectors((bio)))
64

65 66 67 68 69 70
/*
 * Return the data direction, READ or WRITE.
 */
#define bio_data_dir(bio) \
	(op_is_write(bio_op(bio)) ? WRITE : READ)

71 72 73 74 75 76 77
/*
 * 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 &&
A
Adrian Hunter 已提交
78
	    bio_op(bio) != REQ_OP_DISCARD &&
79 80
	    bio_op(bio) != REQ_OP_SECURE_ERASE &&
	    bio_op(bio) != REQ_OP_WRITE_ZEROES)
81 82 83 84 85
		return true;

	return false;
}

86 87
static inline bool bio_no_advance_iter(struct bio *bio)
{
A
Adrian Hunter 已提交
88 89
	return bio_op(bio) == REQ_OP_DISCARD ||
	       bio_op(bio) == REQ_OP_SECURE_ERASE ||
90 91
	       bio_op(bio) == REQ_OP_WRITE_SAME ||
	       bio_op(bio) == REQ_OP_WRITE_ZEROES;
92 93
}

94 95
static inline bool bio_mergeable(struct bio *bio)
{
J
Jens Axboe 已提交
96
	if (bio->bi_opf & REQ_NOMERGE_FLAGS)
97 98 99 100 101
		return false;

	return true;
}

102
static inline unsigned int bio_cur_bytes(struct bio *bio)
103
{
104
	if (bio_has_data(bio))
105
		return bio_iovec(bio).bv_len;
D
David Woodhouse 已提交
106
	else /* dataless requests such as discard */
107
		return bio->bi_iter.bi_size;
108 109 110 111
}

static inline void *bio_data(struct bio *bio)
{
112
	if (bio_has_data(bio))
113 114 115 116
		return page_address(bio_page(bio)) + bio_offset(bio);

	return NULL;
}
L
Linus Torvalds 已提交
117 118 119 120 121 122 123 124 125 126 127 128

/*
 * will die
 */
#define bvec_to_phys(bv)	(page_to_phys((bv)->bv_page) + (unsigned long) (bv)->bv_offset)

/*
 * queues that have highmem support enabled may still need to revert to
 * PIO transfers occasionally and thus map high pages temporarily. For
 * permanent PIO fall back, user is probably better off disabling highmem
 * I/O completely on that queue (see ide-dma for example)
 */
129 130 131
#define __bio_kmap_atomic(bio, iter)				\
	(kmap_atomic(bio_iter_iovec((bio), (iter)).bv_page) +	\
		bio_iter_iovec((bio), (iter)).bv_offset)
L
Linus Torvalds 已提交
132

133
#define __bio_kunmap_atomic(addr)	kunmap_atomic(addr)
L
Linus Torvalds 已提交
134 135 136 137 138

/*
 * merge helpers etc
 */

139 140 141 142
/* Default implementation of BIOVEC_PHYS_MERGEABLE */
#define __BIOVEC_PHYS_MERGEABLE(vec1, vec2)	\
	((bvec_to_phys((vec1)) + (vec1)->bv_len) == bvec_to_phys((vec2)))

L
Linus Torvalds 已提交
143 144 145 146 147
/*
 * allow arch override, for eg virtualized architectures (put in asm/io.h)
 */
#ifndef BIOVEC_PHYS_MERGEABLE
#define BIOVEC_PHYS_MERGEABLE(vec1, vec2)	\
148
	__BIOVEC_PHYS_MERGEABLE(vec1, vec2)
L
Linus Torvalds 已提交
149 150 151 152 153
#endif

#define __BIO_SEG_BOUNDARY(addr1, addr2, mask) \
	(((addr1) | (mask)) == (((addr2) - 1) | (mask)))
#define BIOVEC_SEG_BOUNDARY(q, b1, b2) \
154
	__BIO_SEG_BOUNDARY(bvec_to_phys((b1)), bvec_to_phys((b2)) + (b2)->bv_len, queue_segment_boundary((q)))
L
Linus Torvalds 已提交
155

156 157 158 159 160
/*
 * 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)				\
161
	for (i = 0, bvl = (bio)->bi_io_vec; i < (bio)->bi_vcnt; i++, bvl++)
162

K
Kent Overstreet 已提交
163 164 165 166 167
static inline void bio_advance_iter(struct bio *bio, struct bvec_iter *iter,
				    unsigned bytes)
{
	iter->bi_sector += bytes >> 9;

D
Dmitry Monakhov 已提交
168
	if (bio_no_advance_iter(bio)) {
K
Kent Overstreet 已提交
169
		iter->bi_size -= bytes;
D
Dmitry Monakhov 已提交
170 171
		iter->bi_done += bytes;
	} else {
K
Kent Overstreet 已提交
172
		bvec_iter_advance(bio->bi_io_vec, iter, bytes);
173 174
		/* TODO: It is reasonable to complete bio with error here. */
	}
K
Kent Overstreet 已提交
175 176
}

D
Dmitry Monakhov 已提交
177 178 179 180 181 182 183 184 185 186 187 188 189 190
static inline bool bio_rewind_iter(struct bio *bio, struct bvec_iter *iter,
		unsigned int bytes)
{
	iter->bi_sector -= bytes >> 9;

	if (bio_no_advance_iter(bio)) {
		iter->bi_size += bytes;
		iter->bi_done -= bytes;
		return true;
	}

	return bvec_iter_rewind(bio->bi_io_vec, iter, bytes);
}

191 192
#define __bio_for_each_segment(bvl, bio, iter, start)			\
	for (iter = (start);						\
K
Kent Overstreet 已提交
193 194 195
	     (iter).bi_size &&						\
		((bvl = bio_iter_iovec((bio), (iter))), 1);		\
	     bio_advance_iter((bio), &(iter), (bvl).bv_len))
196 197 198 199

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

K
Kent Overstreet 已提交
200
#define bio_iter_last(bvec, iter) ((iter).bi_size == (bvec).bv_len)
L
Linus Torvalds 已提交
201

202
static inline unsigned bio_segments(struct bio *bio)
203 204 205 206 207
{
	unsigned segs = 0;
	struct bio_vec bv;
	struct bvec_iter iter;

208
	/*
209 210
	 * We special case discard/write same/write zeroes, because they
	 * interpret bi_size differently:
211 212
	 */

213 214 215 216
	switch (bio_op(bio)) {
	case REQ_OP_DISCARD:
	case REQ_OP_SECURE_ERASE:
	case REQ_OP_WRITE_ZEROES:
217 218
		return 0;
	case REQ_OP_WRITE_SAME:
219
		return 1;
220 221 222
	default:
		break;
	}
223

224
	bio_for_each_segment(bv, bio, iter)
225 226 227 228 229
		segs++;

	return segs;
}

L
Linus Torvalds 已提交
230 231 232 233 234 235 236 237 238 239 240 241 242 243
/*
 * 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
 */
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
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);
}
L
Linus Torvalds 已提交
259

260 261
static inline bool bio_flagged(struct bio *bio, unsigned int bit)
{
262
	return (bio->bi_flags & (1U << bit)) != 0;
263 264 265 266
}

static inline void bio_set_flag(struct bio *bio, unsigned int bit)
{
267
	bio->bi_flags |= (1U << bit);
268 269 270 271
}

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

275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
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;
}

307 308 309 310 311 312 313 314
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 */
};

315 316 317 318 319 320
/*
 * bio integrity payload
 */
struct bio_integrity_payload {
	struct bio		*bip_bio;	/* parent bio */

321
	struct bvec_iter	bip_iter;
322

323
	unsigned short		bip_slab;	/* slab the bip came from */
324
	unsigned short		bip_vcnt;	/* # of integrity bio_vecs */
325
	unsigned short		bip_max_vcnt;	/* integrity bio_vec slots */
326
	unsigned short		bip_flags;	/* control flags */
327 328

	struct work_struct	bip_work;	/* I/O completion */
329 330 331

	struct bio_vec		*bip_vec;
	struct bio_vec		bip_inline_vecs[0];/* embedded bvec array */
332
};
333

334 335 336 337
#if defined(CONFIG_BLK_DEV_INTEGRITY)

static inline struct bio_integrity_payload *bio_integrity(struct bio *bio)
{
J
Jens Axboe 已提交
338
	if (bio->bi_opf & REQ_INTEGRITY)
339 340 341 342 343
		return bio->bi_integrity;

	return NULL;
}

344 345 346 347 348 349 350 351 352
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;
}
353

354 355 356 357 358 359 360 361 362 363 364
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;
}

365
#endif /* CONFIG_BLK_DEV_INTEGRITY */
L
Linus Torvalds 已提交
366

367
extern void bio_trim(struct bio *bio, int offset, int size);
K
Kent Overstreet 已提交
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389
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);
}

390 391 392
extern struct bio_set *bioset_create(unsigned int, unsigned int, int flags);
enum {
	BIOSET_NEED_BVECS = BIT(0),
393
	BIOSET_NEED_RESCUER = BIT(1),
394
};
L
Linus Torvalds 已提交
395
extern void bioset_free(struct bio_set *);
396
extern mempool_t *biovec_create_pool(int pool_entries);
L
Linus Torvalds 已提交
397

398
extern struct bio *bio_alloc_bioset(gfp_t, unsigned int, struct bio_set *);
L
Linus Torvalds 已提交
399 400
extern void bio_put(struct bio *);

K
Kent Overstreet 已提交
401 402
extern void __bio_clone_fast(struct bio *, struct bio *);
extern struct bio *bio_clone_fast(struct bio *, gfp_t, struct bio_set *);
403 404
extern struct bio *bio_clone_bioset(struct bio *, gfp_t, struct bio_set *bs);

405 406 407 408 409 410 411 412 413 414 415 416
extern struct bio_set *fs_bio_set;

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

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

417 418 419 420 421 422
static inline struct bio *bio_clone_kmalloc(struct bio *bio, gfp_t gfp_mask)
{
	return bio_clone_bioset(bio, gfp_mask, NULL);

}

423 424
extern blk_qc_t submit_bio(struct bio *);

425 426 427 428
extern void bio_endio(struct bio *);

static inline void bio_io_error(struct bio *bio)
{
429
	bio->bi_status = BLK_STS_IOERR;
430 431 432
	bio_endio(bio);
}

433 434 435
static inline void bio_wouldblock_error(struct bio *bio)
{
	bio->bi_status = BLK_STS_AGAIN;
436 437 438
	bio_endio(bio);
}

L
Linus Torvalds 已提交
439 440 441
struct request_queue;
extern int bio_phys_segments(struct request_queue *, struct bio *);

442
extern int submit_bio_wait(struct bio *bio);
K
Kent Overstreet 已提交
443 444
extern void bio_advance(struct bio *, unsigned);

445 446
extern void bio_init(struct bio *bio, struct bio_vec *table,
		     unsigned short max_vecs);
447
extern void bio_uninit(struct bio *);
K
Kent Overstreet 已提交
448
extern void bio_reset(struct bio *);
K
Kent Overstreet 已提交
449
void bio_chain(struct bio *, struct bio *);
L
Linus Torvalds 已提交
450 451

extern int bio_add_page(struct bio *, struct page *, unsigned int,unsigned int);
452 453
extern int bio_add_pc_page(struct request_queue *, struct bio *, struct page *,
			   unsigned int, unsigned int);
454
int bio_iov_iter_get_pages(struct bio *bio, struct iov_iter *iter);
455
struct rq_map_data;
456
extern struct bio *bio_map_user_iov(struct request_queue *,
457
				    const struct iov_iter *, gfp_t);
L
Linus Torvalds 已提交
458
extern void bio_unmap_user(struct bio *);
M
Mike Christie 已提交
459
extern struct bio *bio_map_kern(struct request_queue *, void *, unsigned int,
A
Al Viro 已提交
460
				gfp_t);
461 462
extern struct bio *bio_copy_kern(struct request_queue *, void *, unsigned int,
				 gfp_t, int);
L
Linus Torvalds 已提交
463 464
extern void bio_set_pages_dirty(struct bio *bio);
extern void bio_check_pages_dirty(struct bio *bio);
465

466 467 468 469 470
void generic_start_io_acct(struct request_queue *q, int rw,
				unsigned long sectors, struct hd_struct *part);
void generic_end_io_acct(struct request_queue *q, int rw,
				struct hd_struct *part,
				unsigned long start_time);
471

472 473 474 475 476 477 478 479 480 481 482
#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

K
Kent Overstreet 已提交
483
extern void bio_copy_data(struct bio *dst, struct bio *src);
K
Kent Overstreet 已提交
484
extern int bio_alloc_pages(struct bio *bio, gfp_t gfp);
485
extern void bio_free_pages(struct bio *bio);
K
Kent Overstreet 已提交
486

487
extern struct bio *bio_copy_user_iov(struct request_queue *,
488
				     struct rq_map_data *,
489 490
				     const struct iov_iter *,
				     gfp_t);
L
Linus Torvalds 已提交
491 492
extern int bio_uncopy_user(struct bio *);
void zero_fill_bio(struct bio *bio);
493 494
extern struct bio_vec *bvec_alloc(gfp_t, int, unsigned long *, mempool_t *);
extern void bvec_free(mempool_t *, struct bio_vec *, unsigned int);
495
extern unsigned int bvec_nr_vecs(unsigned short idx);
496

497
#ifdef CONFIG_BLK_CGROUP
498
int bio_associate_blkcg(struct bio *bio, struct cgroup_subsys_state *blkcg_css);
499 500
int bio_associate_current(struct bio *bio);
void bio_disassociate_task(struct bio *bio);
501
void bio_clone_blkcg_association(struct bio *dst, struct bio *src);
502
#else	/* CONFIG_BLK_CGROUP */
503 504
static inline int bio_associate_blkcg(struct bio *bio,
			struct cgroup_subsys_state *blkcg_css) { return 0; }
505 506
static inline int bio_associate_current(struct bio *bio) { return -ENOENT; }
static inline void bio_disassociate_task(struct bio *bio) { }
507 508
static inline void bio_clone_blkcg_association(struct bio *dst,
			struct bio *src) { }
509 510
#endif	/* CONFIG_BLK_CGROUP */

L
Linus Torvalds 已提交
511 512
#ifdef CONFIG_HIGHMEM
/*
513 514
 * remember never ever reenable interrupts between a bvec_kmap_irq and
 * bvec_kunmap_irq!
L
Linus Torvalds 已提交
515
 */
516
static inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
L
Linus Torvalds 已提交
517 518 519 520 521 522 523 524
{
	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);
525
	addr = (unsigned long) kmap_atomic(bvec->bv_page);
L
Linus Torvalds 已提交
526 527 528 529 530 531

	BUG_ON(addr & ~PAGE_MASK);

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

532
static inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
L
Linus Torvalds 已提交
533 534 535
{
	unsigned long ptr = (unsigned long) buffer & PAGE_MASK;

536
	kunmap_atomic((void *) ptr);
L
Linus Torvalds 已提交
537 538 539 540
	local_irq_restore(*flags);
}

#else
541 542 543 544 545 546 547 548 549
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;
}
L
Linus Torvalds 已提交
550 551
#endif

552
static inline char *__bio_kmap_irq(struct bio *bio, struct bvec_iter iter,
L
Linus Torvalds 已提交
553 554
				   unsigned long *flags)
{
555
	return bvec_kmap_irq(&bio_iter_iovec(bio, iter), flags);
L
Linus Torvalds 已提交
556 557 558 559
}
#define __bio_kunmap_irq(buf, flags)	bvec_kunmap_irq(buf, flags)

#define bio_kmap_irq(bio, flags) \
560
	__bio_kmap_irq((bio), (bio)->bi_iter, (flags))
L
Linus Torvalds 已提交
561 562
#define bio_kunmap_irq(buf,flags)	__bio_kunmap_irq(buf, flags)

563
/*
564
 * BIO list management for use by remapping drivers (e.g. DM or MD) and loop.
565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
 *
 * 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;
}

585 586
#define BIO_EMPTY_LIST	{ NULL, NULL }

587 588 589 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
#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;
}

G
Geert Uytterhoeven 已提交
650 651 652 653 654
static inline struct bio *bio_list_peek(struct bio_list *bl)
{
	return bl->head;
}

655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678
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;
}

679 680 681 682 683 684 685 686 687 688 689
/*
 * 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);
}

K
Kent Overstreet 已提交
690 691 692 693 694 695 696 697 698 699 700 701 702
/*
 * 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;

	mempool_t *bio_pool;
703
	mempool_t *bvec_pool;
K
Kent Overstreet 已提交
704 705
#if defined(CONFIG_BLK_DEV_INTEGRITY)
	mempool_t *bio_integrity_pool;
706
	mempool_t *bvec_integrity_pool;
K
Kent Overstreet 已提交
707
#endif
708 709 710 711 712 713 714 715 716

	/*
	 * 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;
K
Kent Overstreet 已提交
717 718 719 720 721 722 723 724 725 726 727 728 729 730
};

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

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

731 732
#if defined(CONFIG_BLK_DEV_INTEGRITY)

733 734
#define bip_for_each_vec(bvl, bip, iter)				\
	for_each_bvec(bvl, (bip)->bip_vec, iter, (bip)->bip_iter)
735

736 737 738 739
#define bio_for_each_integrity_vec(_bvl, _bio, _iter)			\
	for_each_bio(_bio)						\
		bip_for_each_vec(_bvl, _bio->bi_integrity, _iter)

740 741
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);
742
extern bool bio_integrity_prep(struct bio *);
743
extern void bio_integrity_advance(struct bio *, unsigned int);
744
extern void bio_integrity_trim(struct bio *);
745
extern int bio_integrity_clone(struct bio *, struct bio *, gfp_t);
746 747 748
extern int bioset_integrity_create(struct bio_set *, int);
extern void bioset_integrity_free(struct bio_set *);
extern void bio_integrity_init(void);
749 750 751

#else /* CONFIG_BLK_DEV_INTEGRITY */

752
static inline void *bio_integrity(struct bio *bio)
753
{
754
	return NULL;
755 756 757 758 759 760 761 762 763 764 765 766
}

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;
}

767
static inline bool bio_integrity_prep(struct bio *bio)
768
{
769
	return true;
770 771
}

772
static inline int bio_integrity_clone(struct bio *bio, struct bio *bio_src,
773
				      gfp_t gfp_mask)
774 775 776
{
	return 0;
}
777 778 779 780 781 782 783

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

784
static inline void bio_integrity_trim(struct bio *bio)
785 786 787 788 789 790 791 792
{
	return;
}

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

794 795 796 797 798
static inline bool bio_integrity_flagged(struct bio *bio, enum bip_flags flag)
{
	return false;
}

799 800 801 802 803 804 805 806 807 808 809 810
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;
}

811 812
#endif /* CONFIG_BLK_DEV_INTEGRITY */

813
#endif /* CONFIG_BLOCK */
L
Linus Torvalds 已提交
814
#endif /* __LINUX_BIO_H */