bio.h 21.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11
/*
 * 2.5 block I/O model
 *
 * 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
12
 *
L
Linus Torvalds 已提交
13 14 15 16 17 18 19 20 21 22 23 24
 * 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>
25
#include <linux/ioprio.h>
26
#include <linux/bug.h>
L
Linus Torvalds 已提交
27

28 29
#ifdef CONFIG_BLOCK

L
Linus Torvalds 已提交
30 31
#include <asm/io.h>

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

L
Linus Torvalds 已提交
35 36 37 38 39 40 41 42
#define BIO_DEBUG

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

43
#define BIO_MAX_PAGES		256
L
Linus Torvalds 已提交
44 45 46
#define BIO_MAX_SIZE		(BIO_MAX_PAGES << PAGE_CACHE_SHIFT)
#define BIO_MAX_SECTORS		(BIO_MAX_SIZE >> 9)

47 48 49 50 51 52 53 54 55 56 57 58 59
/*
 * upper 16 bits of bi_rw define the io priority of this bio
 */
#define BIO_PRIO_SHIFT	(8 * sizeof(unsigned long) - IOPRIO_BITS)
#define bio_prio(bio)	((bio)->bi_rw >> BIO_PRIO_SHIFT)
#define bio_prio_valid(bio)	ioprio_valid(bio_prio(bio))

#define bio_set_prio(bio, prio)		do {			\
	WARN_ON(prio >= (1 << IOPRIO_BITS));			\
	(bio)->bi_rw &= ((1UL << BIO_PRIO_SHIFT) - 1);		\
	(bio)->bi_rw |= ((unsigned long) (prio) << BIO_PRIO_SHIFT);	\
} while (0)

L
Linus Torvalds 已提交
60 61 62 63
/*
 * various member access, note that bio_data should of course not be used
 * on highmem page vectors
 */
K
Kent Overstreet 已提交
64
#define __bvec_iter_bvec(bvec, iter)	(&(bvec)[(iter).bi_idx])
65

K
Kent Overstreet 已提交
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
#define bvec_iter_page(bvec, iter)				\
	(__bvec_iter_bvec((bvec), (iter))->bv_page)

#define bvec_iter_len(bvec, iter)				\
	min((iter).bi_size,					\
	    __bvec_iter_bvec((bvec), (iter))->bv_len - (iter).bi_bvec_done)

#define bvec_iter_offset(bvec, iter)				\
	(__bvec_iter_bvec((bvec), (iter))->bv_offset + (iter).bi_bvec_done)

#define bvec_iter_bvec(bvec, iter)				\
((struct bio_vec) {						\
	.bv_page	= bvec_iter_page((bvec), (iter)),	\
	.bv_len		= bvec_iter_len((bvec), (iter)),	\
	.bv_offset	= bvec_iter_offset((bvec), (iter)),	\
})

#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)
96

97 98
#define bio_multiple_segments(bio)				\
	((bio)->bi_iter.bi_size != bio_iovec(bio).bv_len)
99 100
#define bio_sectors(bio)	((bio)->bi_iter.bi_size >> 9)
#define bio_end_sector(bio)	((bio)->bi_iter.bi_sector + bio_sectors((bio)))
101

102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
/*
 * 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 &&
	    !(bio->bi_rw & REQ_DISCARD))
		return true;

	return false;
}

static inline bool bio_is_rw(struct bio *bio)
{
	if (!bio_has_data(bio))
		return false;

	if (bio->bi_rw & BIO_NO_ADVANCE_ITER_MASK)
		return false;

	return true;
}

static inline bool bio_mergeable(struct bio *bio)
{
	if (bio->bi_rw & REQ_NOMERGE_FLAGS)
		return false;

	return true;
}

134
static inline unsigned int bio_cur_bytes(struct bio *bio)
135
{
136
	if (bio_has_data(bio))
137
		return bio_iovec(bio).bv_len;
D
David Woodhouse 已提交
138
	else /* dataless requests such as discard */
139
		return bio->bi_iter.bi_size;
140 141 142 143
}

static inline void *bio_data(struct bio *bio)
{
144
	if (bio_has_data(bio))
145 146 147 148
		return page_address(bio_page(bio)) + bio_offset(bio);

	return NULL;
}
L
Linus Torvalds 已提交
149 150 151 152 153 154 155 156 157 158 159 160 161

/*
 * will die
 */
#define bio_to_phys(bio)	(page_to_phys(bio_page((bio))) + (unsigned long) bio_offset((bio)))
#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)
 */
162 163 164
#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 已提交
165

166
#define __bio_kunmap_atomic(addr)	kunmap_atomic(addr)
L
Linus Torvalds 已提交
167 168 169 170 171

/*
 * merge helpers etc
 */

172 173 174 175
/* 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 已提交
176 177 178 179 180
/*
 * allow arch override, for eg virtualized architectures (put in asm/io.h)
 */
#ifndef BIOVEC_PHYS_MERGEABLE
#define BIOVEC_PHYS_MERGEABLE(vec1, vec2)	\
181
	__BIOVEC_PHYS_MERGEABLE(vec1, vec2)
L
Linus Torvalds 已提交
182 183 184 185 186
#endif

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

189 190 191 192 193
/*
 * 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)				\
194
	for (i = 0, bvl = (bio)->bi_io_vec; i < (bio)->bi_vcnt; i++, bvl++)
195

K
Kent Overstreet 已提交
196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
static inline void bvec_iter_advance(struct bio_vec *bv, struct bvec_iter *iter,
				     unsigned bytes)
{
	WARN_ONCE(bytes > iter->bi_size,
		  "Attempted to advance past end of bvec iter\n");

	while (bytes) {
		unsigned len = min(bytes, bvec_iter_len(bv, *iter));

		bytes -= len;
		iter->bi_size -= len;
		iter->bi_bvec_done += len;

		if (iter->bi_bvec_done == __bvec_iter_bvec(bv, *iter)->bv_len) {
			iter->bi_bvec_done = 0;
			iter->bi_idx++;
		}
	}
}

#define for_each_bvec(bvl, bio_vec, iter, start)			\
M
Martin K. Petersen 已提交
217 218 219
	for (iter = (start);						\
	     (iter).bi_size &&						\
		((bvl = bvec_iter_bvec((bio_vec), (iter))), 1);	\
K
Kent Overstreet 已提交
220 221 222 223 224 225 226 227 228 229 230 231 232 233
	     bvec_iter_advance((bio_vec), &(iter), (bvl).bv_len))


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

	if (bio->bi_rw & BIO_NO_ADVANCE_ITER_MASK)
		iter->bi_size -= bytes;
	else
		bvec_iter_advance(bio->bi_io_vec, iter, bytes);
}

234 235
#define __bio_for_each_segment(bvl, bio, iter, start)			\
	for (iter = (start);						\
K
Kent Overstreet 已提交
236 237 238
	     (iter).bi_size &&						\
		((bvl = bio_iter_iovec((bio), (iter))), 1);		\
	     bio_advance_iter((bio), &(iter), (bvl).bv_len))
239 240 241 242

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

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

245 246 247 248 249 250
static inline unsigned bio_segments(struct bio *bio)
{
	unsigned segs = 0;
	struct bio_vec bv;
	struct bvec_iter iter;

251 252 253 254 255 256 257 258 259 260 261
	/*
	 * We special case discard/write same, because they interpret bi_size
	 * differently:
	 */

	if (bio->bi_rw & REQ_DISCARD)
		return 1;

	if (bio->bi_rw & REQ_WRITE_SAME)
		return 1;

262 263 264 265 266 267
	bio_for_each_segment(bv, bio, iter)
		segs++;

	return segs;
}

L
Linus Torvalds 已提交
268 269 270 271 272 273 274 275 276 277 278 279 280 281
/*
 * 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
 */
282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
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 已提交
297

298 299
static inline bool bio_flagged(struct bio *bio, unsigned int bit)
{
300
	return (bio->bi_flags & (1U << bit)) != 0;
301 302 303 304
}

static inline void bio_set_flag(struct bio *bio, unsigned int bit)
{
305
	bio->bi_flags |= (1U << bit);
306 307 308 309
}

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

313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
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;
}

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

353 354 355 356 357 358
/*
 * bio integrity payload
 */
struct bio_integrity_payload {
	struct bio		*bip_bio;	/* parent bio */

359
	struct bvec_iter	bip_iter;
360

361
	bio_end_io_t		*bip_end_io;	/* saved I/O completion fn */
362

363
	unsigned short		bip_slab;	/* slab the bip came from */
364
	unsigned short		bip_vcnt;	/* # of integrity bio_vecs */
365
	unsigned short		bip_max_vcnt;	/* integrity bio_vec slots */
366
	unsigned short		bip_flags;	/* control flags */
367 368

	struct work_struct	bip_work;	/* I/O completion */
369 370 371

	struct bio_vec		*bip_vec;
	struct bio_vec		bip_inline_vecs[0];/* embedded bvec array */
372
};
373

374 375 376 377 378 379 380 381 382 383
#if defined(CONFIG_BLK_DEV_INTEGRITY)

static inline struct bio_integrity_payload *bio_integrity(struct bio *bio)
{
	if (bio->bi_rw & REQ_INTEGRITY)
		return bio->bi_integrity;

	return NULL;
}

384 385 386 387 388 389 390 391 392
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;
}
393

394 395 396 397 398 399 400 401 402 403 404
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;
}

405
#endif /* CONFIG_BLK_DEV_INTEGRITY */
L
Linus Torvalds 已提交
406

407
extern void bio_trim(struct bio *bio, int offset, int size);
K
Kent Overstreet 已提交
408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429
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);
}

430
extern struct bio_set *bioset_create(unsigned int, unsigned int);
J
Junichi Nomura 已提交
431
extern struct bio_set *bioset_create_nobvec(unsigned int, unsigned int);
L
Linus Torvalds 已提交
432
extern void bioset_free(struct bio_set *);
433
extern mempool_t *biovec_create_pool(int pool_entries);
L
Linus Torvalds 已提交
434

A
Al Viro 已提交
435
extern struct bio *bio_alloc_bioset(gfp_t, int, struct bio_set *);
L
Linus Torvalds 已提交
436 437
extern void bio_put(struct bio *);

K
Kent Overstreet 已提交
438 439
extern void __bio_clone_fast(struct bio *, struct bio *);
extern struct bio *bio_clone_fast(struct bio *, gfp_t, struct bio_set *);
440 441
extern struct bio *bio_clone_bioset(struct bio *, gfp_t, struct bio_set *bs);

442 443 444 445 446 447 448
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);
}

449 450 451 452 453
static inline struct bio *bio_clone(struct bio *bio, gfp_t gfp_mask)
{
	return bio_clone_bioset(bio, gfp_mask, fs_bio_set);
}

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

459 460 461 462 463 464
static inline struct bio *bio_clone_kmalloc(struct bio *bio, gfp_t gfp_mask)
{
	return bio_clone_bioset(bio, gfp_mask, NULL);

}

465 466 467 468 469 470 471 472
extern void bio_endio(struct bio *);

static inline void bio_io_error(struct bio *bio)
{
	bio->bi_error = -EIO;
	bio_endio(bio);
}

L
Linus Torvalds 已提交
473 474 475
struct request_queue;
extern int bio_phys_segments(struct request_queue *, struct bio *);

476
extern int submit_bio_wait(int rw, struct bio *bio);
K
Kent Overstreet 已提交
477 478
extern void bio_advance(struct bio *, unsigned);

L
Linus Torvalds 已提交
479
extern void bio_init(struct bio *);
K
Kent Overstreet 已提交
480
extern void bio_reset(struct bio *);
K
Kent Overstreet 已提交
481
void bio_chain(struct bio *, struct bio *);
L
Linus Torvalds 已提交
482 483

extern int bio_add_page(struct bio *, struct page *, unsigned int,unsigned int);
484 485
extern int bio_add_pc_page(struct request_queue *, struct bio *, struct page *,
			   unsigned int, unsigned int);
486
struct rq_map_data;
487
extern struct bio *bio_map_user_iov(struct request_queue *,
488
				    const struct iov_iter *, gfp_t);
L
Linus Torvalds 已提交
489
extern void bio_unmap_user(struct bio *);
M
Mike Christie 已提交
490
extern struct bio *bio_map_kern(struct request_queue *, void *, unsigned int,
A
Al Viro 已提交
491
				gfp_t);
492 493
extern struct bio *bio_copy_kern(struct request_queue *, void *, unsigned int,
				 gfp_t, int);
L
Linus Torvalds 已提交
494 495
extern void bio_set_pages_dirty(struct bio *bio);
extern void bio_check_pages_dirty(struct bio *bio);
496

497 498 499 500 501
void generic_start_io_acct(int rw, unsigned long sectors,
			   struct hd_struct *part);
void generic_end_io_acct(int rw, struct hd_struct *part,
			 unsigned long start_time);

502 503 504 505 506 507 508 509 510 511 512
#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 已提交
513
extern void bio_copy_data(struct bio *dst, struct bio *src);
K
Kent Overstreet 已提交
514
extern int bio_alloc_pages(struct bio *bio, gfp_t gfp);
K
Kent Overstreet 已提交
515

516
extern struct bio *bio_copy_user_iov(struct request_queue *,
517
				     struct rq_map_data *,
518 519
				     const struct iov_iter *,
				     gfp_t);
L
Linus Torvalds 已提交
520 521
extern int bio_uncopy_user(struct bio *);
void zero_fill_bio(struct bio *bio);
522 523
extern struct bio_vec *bvec_alloc(gfp_t, int, unsigned long *, mempool_t *);
extern void bvec_free(mempool_t *, struct bio_vec *, unsigned int);
524
extern unsigned int bvec_nr_vecs(unsigned short idx);
525

526
#ifdef CONFIG_BLK_CGROUP
527
int bio_associate_blkcg(struct bio *bio, struct cgroup_subsys_state *blkcg_css);
528 529 530
int bio_associate_current(struct bio *bio);
void bio_disassociate_task(struct bio *bio);
#else	/* CONFIG_BLK_CGROUP */
531 532
static inline int bio_associate_blkcg(struct bio *bio,
			struct cgroup_subsys_state *blkcg_css) { return 0; }
533 534 535 536
static inline int bio_associate_current(struct bio *bio) { return -ENOENT; }
static inline void bio_disassociate_task(struct bio *bio) { }
#endif	/* CONFIG_BLK_CGROUP */

L
Linus Torvalds 已提交
537 538
#ifdef CONFIG_HIGHMEM
/*
539 540
 * remember never ever reenable interrupts between a bvec_kmap_irq and
 * bvec_kunmap_irq!
L
Linus Torvalds 已提交
541
 */
542
static inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
L
Linus Torvalds 已提交
543 544 545 546 547 548 549 550
{
	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);
551
	addr = (unsigned long) kmap_atomic(bvec->bv_page);
L
Linus Torvalds 已提交
552 553 554 555 556 557

	BUG_ON(addr & ~PAGE_MASK);

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

558
static inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
L
Linus Torvalds 已提交
559 560 561
{
	unsigned long ptr = (unsigned long) buffer & PAGE_MASK;

562
	kunmap_atomic((void *) ptr);
L
Linus Torvalds 已提交
563 564 565 566
	local_irq_restore(*flags);
}

#else
567 568 569 570 571 572 573 574 575
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 已提交
576 577
#endif

578
static inline char *__bio_kmap_irq(struct bio *bio, struct bvec_iter iter,
L
Linus Torvalds 已提交
579 580
				   unsigned long *flags)
{
581
	return bvec_kmap_irq(&bio_iter_iovec(bio, iter), flags);
L
Linus Torvalds 已提交
582 583 584 585
}
#define __bio_kunmap_irq(buf, flags)	bvec_kunmap_irq(buf, flags)

#define bio_kmap_irq(bio, flags) \
586
	__bio_kmap_irq((bio), (bio)->bi_iter, (flags))
L
Linus Torvalds 已提交
587 588
#define bio_kunmap_irq(buf,flags)	__bio_kunmap_irq(buf, flags)

589
/*
590
 * BIO list management for use by remapping drivers (e.g. DM or MD) and loop.
591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610
 *
 * 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;
}

611 612
#define BIO_EMPTY_LIST	{ NULL, NULL }

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 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675
#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 已提交
676 677 678 679 680
static inline struct bio *bio_list_peek(struct bio_list *bl)
{
	return bl->head;
}

681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704
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;
}

K
Kent Overstreet 已提交
705 706 707 708 709 710 711 712 713 714 715 716 717 718 719
/*
 * 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
#define BIOVEC_NR_POOLS 6
#define BIOVEC_MAX_IDX	(BIOVEC_NR_POOLS - 1)

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

	mempool_t *bio_pool;
720
	mempool_t *bvec_pool;
K
Kent Overstreet 已提交
721 722
#if defined(CONFIG_BLK_DEV_INTEGRITY)
	mempool_t *bio_integrity_pool;
723
	mempool_t *bvec_integrity_pool;
K
Kent Overstreet 已提交
724
#endif
725 726 727 728 729 730 731 732 733

	/*
	 * 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 已提交
734 735 736 737 738 739 740 741 742 743 744 745 746 747
};

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

748 749
#if defined(CONFIG_BLK_DEV_INTEGRITY)

750 751
#define bip_for_each_vec(bvl, bip, iter)				\
	for_each_bvec(bvl, (bip)->bip_vec, iter, (bip)->bip_iter)
752

753 754 755 756
#define bio_for_each_integrity_vec(_bvl, _bio, _iter)			\
	for_each_bio(_bio)						\
		bip_for_each_vec(_bvl, _bio->bi_integrity, _iter)

757
extern struct bio_integrity_payload *bio_integrity_alloc(struct bio *, gfp_t, unsigned int);
758
extern void bio_integrity_free(struct bio *);
759
extern int bio_integrity_add_page(struct bio *, struct page *, unsigned int, unsigned int);
760
extern bool bio_integrity_enabled(struct bio *bio);
761
extern int bio_integrity_prep(struct bio *);
762
extern void bio_integrity_endio(struct bio *);
763 764
extern void bio_integrity_advance(struct bio *, unsigned int);
extern void bio_integrity_trim(struct bio *, unsigned int, unsigned int);
765
extern int bio_integrity_clone(struct bio *, struct bio *, gfp_t);
766 767 768
extern int bioset_integrity_create(struct bio_set *, int);
extern void bioset_integrity_free(struct bio_set *);
extern void bio_integrity_init(void);
769 770 771

#else /* CONFIG_BLK_DEV_INTEGRITY */

772
static inline void *bio_integrity(struct bio *bio)
773
{
774
	return NULL;
775 776
}

777
static inline bool bio_integrity_enabled(struct bio *bio)
778
{
779
	return false;
780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796
}

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

static inline int bio_integrity_prep(struct bio *bio)
{
	return 0;
}

797
static inline void bio_integrity_free(struct bio *bio)
798 799 800 801
{
	return;
}

802
static inline int bio_integrity_clone(struct bio *bio, struct bio *bio_src,
803
				      gfp_t gfp_mask)
804 805 806
{
	return 0;
}
807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823

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

static inline void bio_integrity_trim(struct bio *bio, unsigned int offset,
				      unsigned int sectors)
{
	return;
}

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

825 826 827 828 829
static inline bool bio_integrity_flagged(struct bio *bio, enum bip_flags flag)
{
	return false;
}

830 831 832 833 834 835 836 837 838 839 840 841
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;
}

842 843
#endif /* CONFIG_BLK_DEV_INTEGRITY */

844
#endif /* CONFIG_BLOCK */
L
Linus Torvalds 已提交
845
#endif /* __LINUX_BIO_H */