Merge branch 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/benh/powerpc
[firefly-linux-kernel-4.4.55.git] / include / linux / bio.h
1 /*
2  * 2.5 block I/O model
3  *
4  * Copyright (C) 2001 Jens Axboe <axboe@suse.de>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public Licens
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-
19  */
20 #ifndef __LINUX_BIO_H
21 #define __LINUX_BIO_H
22
23 #include <linux/highmem.h>
24 #include <linux/mempool.h>
25 #include <linux/ioprio.h>
26 #include <linux/bug.h>
27
28 #ifdef CONFIG_BLOCK
29
30 #include <asm/io.h>
31
32 /* struct bio, bio_vec and BIO_* flags are defined in blk_types.h */
33 #include <linux/blk_types.h>
34
35 #define BIO_DEBUG
36
37 #ifdef BIO_DEBUG
38 #define BIO_BUG_ON      BUG_ON
39 #else
40 #define BIO_BUG_ON
41 #endif
42
43 #define BIO_MAX_PAGES           256
44 #define BIO_MAX_SIZE            (BIO_MAX_PAGES << PAGE_CACHE_SHIFT)
45 #define BIO_MAX_SECTORS         (BIO_MAX_SIZE >> 9)
46
47 /*
48  * upper 16 bits of bi_rw define the io priority of this bio
49  */
50 #define BIO_PRIO_SHIFT  (8 * sizeof(unsigned long) - IOPRIO_BITS)
51 #define bio_prio(bio)   ((bio)->bi_rw >> BIO_PRIO_SHIFT)
52 #define bio_prio_valid(bio)     ioprio_valid(bio_prio(bio))
53
54 #define bio_set_prio(bio, prio)         do {                    \
55         WARN_ON(prio >= (1 << IOPRIO_BITS));                    \
56         (bio)->bi_rw &= ((1UL << BIO_PRIO_SHIFT) - 1);          \
57         (bio)->bi_rw |= ((unsigned long) (prio) << BIO_PRIO_SHIFT);     \
58 } while (0)
59
60 /*
61  * various member access, note that bio_data should of course not be used
62  * on highmem page vectors
63  */
64 #define __bvec_iter_bvec(bvec, iter)    (&(bvec)[(iter).bi_idx])
65
66 #define bvec_iter_page(bvec, iter)                              \
67         (__bvec_iter_bvec((bvec), (iter))->bv_page)
68
69 #define bvec_iter_len(bvec, iter)                               \
70         min((iter).bi_size,                                     \
71             __bvec_iter_bvec((bvec), (iter))->bv_len - (iter).bi_bvec_done)
72
73 #define bvec_iter_offset(bvec, iter)                            \
74         (__bvec_iter_bvec((bvec), (iter))->bv_offset + (iter).bi_bvec_done)
75
76 #define bvec_iter_bvec(bvec, iter)                              \
77 ((struct bio_vec) {                                             \
78         .bv_page        = bvec_iter_page((bvec), (iter)),       \
79         .bv_len         = bvec_iter_len((bvec), (iter)),        \
80         .bv_offset      = bvec_iter_offset((bvec), (iter)),     \
81 })
82
83 #define bio_iter_iovec(bio, iter)                               \
84         bvec_iter_bvec((bio)->bi_io_vec, (iter))
85
86 #define bio_iter_page(bio, iter)                                \
87         bvec_iter_page((bio)->bi_io_vec, (iter))
88 #define bio_iter_len(bio, iter)                                 \
89         bvec_iter_len((bio)->bi_io_vec, (iter))
90 #define bio_iter_offset(bio, iter)                              \
91         bvec_iter_offset((bio)->bi_io_vec, (iter))
92
93 #define bio_page(bio)           bio_iter_page((bio), (bio)->bi_iter)
94 #define bio_offset(bio)         bio_iter_offset((bio), (bio)->bi_iter)
95 #define bio_iovec(bio)          bio_iter_iovec((bio), (bio)->bi_iter)
96
97 #define bio_multiple_segments(bio)                              \
98         ((bio)->bi_iter.bi_size != bio_iovec(bio).bv_len)
99 #define bio_sectors(bio)        ((bio)->bi_iter.bi_size >> 9)
100 #define bio_end_sector(bio)     ((bio)->bi_iter.bi_sector + bio_sectors((bio)))
101
102 /*
103  * Check whether this bio carries any data or not. A NULL bio is allowed.
104  */
105 static inline bool bio_has_data(struct bio *bio)
106 {
107         if (bio &&
108             bio->bi_iter.bi_size &&
109             !(bio->bi_rw & REQ_DISCARD))
110                 return true;
111
112         return false;
113 }
114
115 static inline bool bio_is_rw(struct bio *bio)
116 {
117         if (!bio_has_data(bio))
118                 return false;
119
120         if (bio->bi_rw & BIO_NO_ADVANCE_ITER_MASK)
121                 return false;
122
123         return true;
124 }
125
126 static inline bool bio_mergeable(struct bio *bio)
127 {
128         if (bio->bi_rw & REQ_NOMERGE_FLAGS)
129                 return false;
130
131         return true;
132 }
133
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;
138         else /* dataless requests such as discard */
139                 return bio->bi_iter.bi_size;
140 }
141
142 static inline void *bio_data(struct bio *bio)
143 {
144         if (bio_has_data(bio))
145                 return page_address(bio_page(bio)) + bio_offset(bio);
146
147         return NULL;
148 }
149
150 /*
151  * will die
152  */
153 #define bio_to_phys(bio)        (page_to_phys(bio_page((bio))) + (unsigned long) bio_offset((bio)))
154 #define bvec_to_phys(bv)        (page_to_phys((bv)->bv_page) + (unsigned long) (bv)->bv_offset)
155
156 /*
157  * queues that have highmem support enabled may still need to revert to
158  * PIO transfers occasionally and thus map high pages temporarily. For
159  * permanent PIO fall back, user is probably better off disabling highmem
160  * I/O completely on that queue (see ide-dma for example)
161  */
162 #define __bio_kmap_atomic(bio, iter)                            \
163         (kmap_atomic(bio_iter_iovec((bio), (iter)).bv_page) +   \
164                 bio_iter_iovec((bio), (iter)).bv_offset)
165
166 #define __bio_kunmap_atomic(addr)       kunmap_atomic(addr)
167
168 /*
169  * merge helpers etc
170  */
171
172 /* Default implementation of BIOVEC_PHYS_MERGEABLE */
173 #define __BIOVEC_PHYS_MERGEABLE(vec1, vec2)     \
174         ((bvec_to_phys((vec1)) + (vec1)->bv_len) == bvec_to_phys((vec2)))
175
176 /*
177  * allow arch override, for eg virtualized architectures (put in asm/io.h)
178  */
179 #ifndef BIOVEC_PHYS_MERGEABLE
180 #define BIOVEC_PHYS_MERGEABLE(vec1, vec2)       \
181         __BIOVEC_PHYS_MERGEABLE(vec1, vec2)
182 #endif
183
184 #define __BIO_SEG_BOUNDARY(addr1, addr2, mask) \
185         (((addr1) | (mask)) == (((addr2) - 1) | (mask)))
186 #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)))
188
189 /*
190  * Check if adding a bio_vec after bprv with offset would create a gap in
191  * the SG list. Most drivers don't care about this, but some do.
192  */
193 static inline bool bvec_gap_to_prev(struct bio_vec *bprv, unsigned int offset)
194 {
195         return offset || ((bprv->bv_offset + bprv->bv_len) & (PAGE_SIZE - 1));
196 }
197
198 #define bio_io_error(bio) bio_endio((bio), -EIO)
199
200 /*
201  * drivers should _never_ use the all version - the bio may have been split
202  * before it got to the driver and the driver won't own all of it
203  */
204 #define bio_for_each_segment_all(bvl, bio, i)                           \
205         for (i = 0, bvl = (bio)->bi_io_vec; i < (bio)->bi_vcnt; i++, bvl++)
206
207 static inline void bvec_iter_advance(struct bio_vec *bv, struct bvec_iter *iter,
208                                      unsigned bytes)
209 {
210         WARN_ONCE(bytes > iter->bi_size,
211                   "Attempted to advance past end of bvec iter\n");
212
213         while (bytes) {
214                 unsigned len = min(bytes, bvec_iter_len(bv, *iter));
215
216                 bytes -= len;
217                 iter->bi_size -= len;
218                 iter->bi_bvec_done += len;
219
220                 if (iter->bi_bvec_done == __bvec_iter_bvec(bv, *iter)->bv_len) {
221                         iter->bi_bvec_done = 0;
222                         iter->bi_idx++;
223                 }
224         }
225 }
226
227 #define for_each_bvec(bvl, bio_vec, iter, start)                        \
228         for (iter = (start);                                            \
229              (iter).bi_size &&                                          \
230                 ((bvl = bvec_iter_bvec((bio_vec), (iter))), 1); \
231              bvec_iter_advance((bio_vec), &(iter), (bvl).bv_len))
232
233
234 static inline void bio_advance_iter(struct bio *bio, struct bvec_iter *iter,
235                                     unsigned bytes)
236 {
237         iter->bi_sector += bytes >> 9;
238
239         if (bio->bi_rw & BIO_NO_ADVANCE_ITER_MASK)
240                 iter->bi_size -= bytes;
241         else
242                 bvec_iter_advance(bio->bi_io_vec, iter, bytes);
243 }
244
245 #define __bio_for_each_segment(bvl, bio, iter, start)                   \
246         for (iter = (start);                                            \
247              (iter).bi_size &&                                          \
248                 ((bvl = bio_iter_iovec((bio), (iter))), 1);             \
249              bio_advance_iter((bio), &(iter), (bvl).bv_len))
250
251 #define bio_for_each_segment(bvl, bio, iter)                            \
252         __bio_for_each_segment(bvl, bio, iter, (bio)->bi_iter)
253
254 #define bio_iter_last(bvec, iter) ((iter).bi_size == (bvec).bv_len)
255
256 static inline unsigned bio_segments(struct bio *bio)
257 {
258         unsigned segs = 0;
259         struct bio_vec bv;
260         struct bvec_iter iter;
261
262         /*
263          * We special case discard/write same, because they interpret bi_size
264          * differently:
265          */
266
267         if (bio->bi_rw & REQ_DISCARD)
268                 return 1;
269
270         if (bio->bi_rw & REQ_WRITE_SAME)
271                 return 1;
272
273         bio_for_each_segment(bv, bio, iter)
274                 segs++;
275
276         return segs;
277 }
278
279 /*
280  * get a reference to a bio, so it won't disappear. the intended use is
281  * something like:
282  *
283  * bio_get(bio);
284  * submit_bio(rw, bio);
285  * if (bio->bi_flags ...)
286  *      do_something
287  * bio_put(bio);
288  *
289  * without the bio_get(), it could potentially complete I/O before submit_bio
290  * returns. and then bio would be freed memory when if (bio->bi_flags ...)
291  * runs
292  */
293 #define bio_get(bio)    atomic_inc(&(bio)->bi_cnt)
294
295 #if defined(CONFIG_BLK_DEV_INTEGRITY)
296 /*
297  * bio integrity payload
298  */
299 struct bio_integrity_payload {
300         struct bio              *bip_bio;       /* parent bio */
301
302         struct bvec_iter        bip_iter;
303
304         /* kill - should just use bip_vec */
305         void                    *bip_buf;       /* generated integrity data */
306
307         bio_end_io_t            *bip_end_io;    /* saved I/O completion fn */
308
309         unsigned short          bip_slab;       /* slab the bip came from */
310         unsigned short          bip_vcnt;       /* # of integrity bio_vecs */
311         unsigned                bip_owns_buf:1; /* should free bip_buf */
312
313         struct work_struct      bip_work;       /* I/O completion */
314
315         struct bio_vec          *bip_vec;
316         struct bio_vec          bip_inline_vecs[0];/* embedded bvec array */
317 };
318 #endif /* CONFIG_BLK_DEV_INTEGRITY */
319
320 extern void bio_trim(struct bio *bio, int offset, int size);
321 extern struct bio *bio_split(struct bio *bio, int sectors,
322                              gfp_t gfp, struct bio_set *bs);
323
324 /**
325  * bio_next_split - get next @sectors from a bio, splitting if necessary
326  * @bio:        bio to split
327  * @sectors:    number of sectors to split from the front of @bio
328  * @gfp:        gfp mask
329  * @bs:         bio set to allocate from
330  *
331  * Returns a bio representing the next @sectors of @bio - if the bio is smaller
332  * than @sectors, returns the original bio unchanged.
333  */
334 static inline struct bio *bio_next_split(struct bio *bio, int sectors,
335                                          gfp_t gfp, struct bio_set *bs)
336 {
337         if (sectors >= bio_sectors(bio))
338                 return bio;
339
340         return bio_split(bio, sectors, gfp, bs);
341 }
342
343 extern struct bio_set *bioset_create(unsigned int, unsigned int);
344 extern void bioset_free(struct bio_set *);
345 extern mempool_t *biovec_create_pool(int pool_entries);
346
347 extern struct bio *bio_alloc_bioset(gfp_t, int, struct bio_set *);
348 extern void bio_put(struct bio *);
349
350 extern void __bio_clone_fast(struct bio *, struct bio *);
351 extern struct bio *bio_clone_fast(struct bio *, gfp_t, struct bio_set *);
352 extern struct bio *bio_clone_bioset(struct bio *, gfp_t, struct bio_set *bs);
353
354 extern struct bio_set *fs_bio_set;
355 unsigned int bio_integrity_tag_size(struct bio *bio);
356
357 static inline struct bio *bio_alloc(gfp_t gfp_mask, unsigned int nr_iovecs)
358 {
359         return bio_alloc_bioset(gfp_mask, nr_iovecs, fs_bio_set);
360 }
361
362 static inline struct bio *bio_clone(struct bio *bio, gfp_t gfp_mask)
363 {
364         return bio_clone_bioset(bio, gfp_mask, fs_bio_set);
365 }
366
367 static inline struct bio *bio_kmalloc(gfp_t gfp_mask, unsigned int nr_iovecs)
368 {
369         return bio_alloc_bioset(gfp_mask, nr_iovecs, NULL);
370 }
371
372 static inline struct bio *bio_clone_kmalloc(struct bio *bio, gfp_t gfp_mask)
373 {
374         return bio_clone_bioset(bio, gfp_mask, NULL);
375
376 }
377
378 extern void bio_endio(struct bio *, int);
379 extern void bio_endio_nodec(struct bio *, int);
380 struct request_queue;
381 extern int bio_phys_segments(struct request_queue *, struct bio *);
382
383 extern int submit_bio_wait(int rw, struct bio *bio);
384 extern void bio_advance(struct bio *, unsigned);
385
386 extern void bio_init(struct bio *);
387 extern void bio_reset(struct bio *);
388 void bio_chain(struct bio *, struct bio *);
389
390 extern int bio_add_page(struct bio *, struct page *, unsigned int,unsigned int);
391 extern int bio_add_pc_page(struct request_queue *, struct bio *, struct page *,
392                            unsigned int, unsigned int);
393 extern int bio_get_nr_vecs(struct block_device *);
394 extern struct bio *bio_map_user(struct request_queue *, struct block_device *,
395                                 unsigned long, unsigned int, int, gfp_t);
396 struct sg_iovec;
397 struct rq_map_data;
398 extern struct bio *bio_map_user_iov(struct request_queue *,
399                                     struct block_device *,
400                                     const struct sg_iovec *, int, int, gfp_t);
401 extern void bio_unmap_user(struct bio *);
402 extern struct bio *bio_map_kern(struct request_queue *, void *, unsigned int,
403                                 gfp_t);
404 extern struct bio *bio_copy_kern(struct request_queue *, void *, unsigned int,
405                                  gfp_t, int);
406 extern void bio_set_pages_dirty(struct bio *bio);
407 extern void bio_check_pages_dirty(struct bio *bio);
408
409 #ifndef ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
410 # error "You should define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE for your platform"
411 #endif
412 #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
413 extern void bio_flush_dcache_pages(struct bio *bi);
414 #else
415 static inline void bio_flush_dcache_pages(struct bio *bi)
416 {
417 }
418 #endif
419
420 extern void bio_copy_data(struct bio *dst, struct bio *src);
421 extern int bio_alloc_pages(struct bio *bio, gfp_t gfp);
422
423 extern struct bio *bio_copy_user(struct request_queue *, struct rq_map_data *,
424                                  unsigned long, unsigned int, int, gfp_t);
425 extern struct bio *bio_copy_user_iov(struct request_queue *,
426                                      struct rq_map_data *,
427                                      const struct sg_iovec *,
428                                      int, int, gfp_t);
429 extern int bio_uncopy_user(struct bio *);
430 void zero_fill_bio(struct bio *bio);
431 extern struct bio_vec *bvec_alloc(gfp_t, int, unsigned long *, mempool_t *);
432 extern void bvec_free(mempool_t *, struct bio_vec *, unsigned int);
433 extern unsigned int bvec_nr_vecs(unsigned short idx);
434
435 #ifdef CONFIG_BLK_CGROUP
436 int bio_associate_current(struct bio *bio);
437 void bio_disassociate_task(struct bio *bio);
438 #else   /* CONFIG_BLK_CGROUP */
439 static inline int bio_associate_current(struct bio *bio) { return -ENOENT; }
440 static inline void bio_disassociate_task(struct bio *bio) { }
441 #endif  /* CONFIG_BLK_CGROUP */
442
443 #ifdef CONFIG_HIGHMEM
444 /*
445  * remember never ever reenable interrupts between a bvec_kmap_irq and
446  * bvec_kunmap_irq!
447  */
448 static inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
449 {
450         unsigned long addr;
451
452         /*
453          * might not be a highmem page, but the preempt/irq count
454          * balancing is a lot nicer this way
455          */
456         local_irq_save(*flags);
457         addr = (unsigned long) kmap_atomic(bvec->bv_page);
458
459         BUG_ON(addr & ~PAGE_MASK);
460
461         return (char *) addr + bvec->bv_offset;
462 }
463
464 static inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
465 {
466         unsigned long ptr = (unsigned long) buffer & PAGE_MASK;
467
468         kunmap_atomic((void *) ptr);
469         local_irq_restore(*flags);
470 }
471
472 #else
473 static inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
474 {
475         return page_address(bvec->bv_page) + bvec->bv_offset;
476 }
477
478 static inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
479 {
480         *flags = 0;
481 }
482 #endif
483
484 static inline char *__bio_kmap_irq(struct bio *bio, struct bvec_iter iter,
485                                    unsigned long *flags)
486 {
487         return bvec_kmap_irq(&bio_iter_iovec(bio, iter), flags);
488 }
489 #define __bio_kunmap_irq(buf, flags)    bvec_kunmap_irq(buf, flags)
490
491 #define bio_kmap_irq(bio, flags) \
492         __bio_kmap_irq((bio), (bio)->bi_iter, (flags))
493 #define bio_kunmap_irq(buf,flags)       __bio_kunmap_irq(buf, flags)
494
495 /*
496  * BIO list management for use by remapping drivers (e.g. DM or MD) and loop.
497  *
498  * A bio_list anchors a singly-linked list of bios chained through the bi_next
499  * member of the bio.  The bio_list also caches the last list member to allow
500  * fast access to the tail.
501  */
502 struct bio_list {
503         struct bio *head;
504         struct bio *tail;
505 };
506
507 static inline int bio_list_empty(const struct bio_list *bl)
508 {
509         return bl->head == NULL;
510 }
511
512 static inline void bio_list_init(struct bio_list *bl)
513 {
514         bl->head = bl->tail = NULL;
515 }
516
517 #define BIO_EMPTY_LIST  { NULL, NULL }
518
519 #define bio_list_for_each(bio, bl) \
520         for (bio = (bl)->head; bio; bio = bio->bi_next)
521
522 static inline unsigned bio_list_size(const struct bio_list *bl)
523 {
524         unsigned sz = 0;
525         struct bio *bio;
526
527         bio_list_for_each(bio, bl)
528                 sz++;
529
530         return sz;
531 }
532
533 static inline void bio_list_add(struct bio_list *bl, struct bio *bio)
534 {
535         bio->bi_next = NULL;
536
537         if (bl->tail)
538                 bl->tail->bi_next = bio;
539         else
540                 bl->head = bio;
541
542         bl->tail = bio;
543 }
544
545 static inline void bio_list_add_head(struct bio_list *bl, struct bio *bio)
546 {
547         bio->bi_next = bl->head;
548
549         bl->head = bio;
550
551         if (!bl->tail)
552                 bl->tail = bio;
553 }
554
555 static inline void bio_list_merge(struct bio_list *bl, struct bio_list *bl2)
556 {
557         if (!bl2->head)
558                 return;
559
560         if (bl->tail)
561                 bl->tail->bi_next = bl2->head;
562         else
563                 bl->head = bl2->head;
564
565         bl->tail = bl2->tail;
566 }
567
568 static inline void bio_list_merge_head(struct bio_list *bl,
569                                        struct bio_list *bl2)
570 {
571         if (!bl2->head)
572                 return;
573
574         if (bl->head)
575                 bl2->tail->bi_next = bl->head;
576         else
577                 bl->tail = bl2->tail;
578
579         bl->head = bl2->head;
580 }
581
582 static inline struct bio *bio_list_peek(struct bio_list *bl)
583 {
584         return bl->head;
585 }
586
587 static inline struct bio *bio_list_pop(struct bio_list *bl)
588 {
589         struct bio *bio = bl->head;
590
591         if (bio) {
592                 bl->head = bl->head->bi_next;
593                 if (!bl->head)
594                         bl->tail = NULL;
595
596                 bio->bi_next = NULL;
597         }
598
599         return bio;
600 }
601
602 static inline struct bio *bio_list_get(struct bio_list *bl)
603 {
604         struct bio *bio = bl->head;
605
606         bl->head = bl->tail = NULL;
607
608         return bio;
609 }
610
611 /*
612  * bio_set is used to allow other portions of the IO system to
613  * allocate their own private memory pools for bio and iovec structures.
614  * These memory pools in turn all allocate from the bio_slab
615  * and the bvec_slabs[].
616  */
617 #define BIO_POOL_SIZE 2
618 #define BIOVEC_NR_POOLS 6
619 #define BIOVEC_MAX_IDX  (BIOVEC_NR_POOLS - 1)
620
621 struct bio_set {
622         struct kmem_cache *bio_slab;
623         unsigned int front_pad;
624
625         mempool_t *bio_pool;
626         mempool_t *bvec_pool;
627 #if defined(CONFIG_BLK_DEV_INTEGRITY)
628         mempool_t *bio_integrity_pool;
629         mempool_t *bvec_integrity_pool;
630 #endif
631
632         /*
633          * Deadlock avoidance for stacking block drivers: see comments in
634          * bio_alloc_bioset() for details
635          */
636         spinlock_t              rescue_lock;
637         struct bio_list         rescue_list;
638         struct work_struct      rescue_work;
639         struct workqueue_struct *rescue_workqueue;
640 };
641
642 struct biovec_slab {
643         int nr_vecs;
644         char *name;
645         struct kmem_cache *slab;
646 };
647
648 /*
649  * a small number of entries is fine, not going to be performance critical.
650  * basically we just need to survive
651  */
652 #define BIO_SPLIT_ENTRIES 2
653
654 #if defined(CONFIG_BLK_DEV_INTEGRITY)
655
656 #define bip_for_each_vec(bvl, bip, iter)                                \
657         for_each_bvec(bvl, (bip)->bip_vec, iter, (bip)->bip_iter)
658
659 #define bio_for_each_integrity_vec(_bvl, _bio, _iter)                   \
660         for_each_bio(_bio)                                              \
661                 bip_for_each_vec(_bvl, _bio->bi_integrity, _iter)
662
663 #define bio_integrity(bio) (bio->bi_integrity != NULL)
664
665 extern struct bio_integrity_payload *bio_integrity_alloc(struct bio *, gfp_t, unsigned int);
666 extern void bio_integrity_free(struct bio *);
667 extern int bio_integrity_add_page(struct bio *, struct page *, unsigned int, unsigned int);
668 extern int bio_integrity_enabled(struct bio *bio);
669 extern int bio_integrity_set_tag(struct bio *, void *, unsigned int);
670 extern int bio_integrity_get_tag(struct bio *, void *, unsigned int);
671 extern int bio_integrity_prep(struct bio *);
672 extern void bio_integrity_endio(struct bio *, int);
673 extern void bio_integrity_advance(struct bio *, unsigned int);
674 extern void bio_integrity_trim(struct bio *, unsigned int, unsigned int);
675 extern int bio_integrity_clone(struct bio *, struct bio *, gfp_t);
676 extern int bioset_integrity_create(struct bio_set *, int);
677 extern void bioset_integrity_free(struct bio_set *);
678 extern void bio_integrity_init(void);
679
680 #else /* CONFIG_BLK_DEV_INTEGRITY */
681
682 static inline int bio_integrity(struct bio *bio)
683 {
684         return 0;
685 }
686
687 static inline int bio_integrity_enabled(struct bio *bio)
688 {
689         return 0;
690 }
691
692 static inline int bioset_integrity_create(struct bio_set *bs, int pool_size)
693 {
694         return 0;
695 }
696
697 static inline void bioset_integrity_free (struct bio_set *bs)
698 {
699         return;
700 }
701
702 static inline int bio_integrity_prep(struct bio *bio)
703 {
704         return 0;
705 }
706
707 static inline void bio_integrity_free(struct bio *bio)
708 {
709         return;
710 }
711
712 static inline int bio_integrity_clone(struct bio *bio, struct bio *bio_src,
713                                       gfp_t gfp_mask)
714 {
715         return 0;
716 }
717
718 static inline void bio_integrity_advance(struct bio *bio,
719                                          unsigned int bytes_done)
720 {
721         return;
722 }
723
724 static inline void bio_integrity_trim(struct bio *bio, unsigned int offset,
725                                       unsigned int sectors)
726 {
727         return;
728 }
729
730 static inline void bio_integrity_init(void)
731 {
732         return;
733 }
734
735 #endif /* CONFIG_BLK_DEV_INTEGRITY */
736
737 #endif /* CONFIG_BLOCK */
738 #endif /* __LINUX_BIO_H */