Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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> |
Jens Axboe | 22e2c50 | 2005-06-27 10:55:12 +0200 | [diff] [blame] | 25 | #include <linux/ioprio.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | |
David Howells | 02a5e0a | 2007-08-11 22:34:32 +0200 | [diff] [blame] | 27 | #ifdef CONFIG_BLOCK |
| 28 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | #include <asm/io.h> |
| 30 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | #define BIO_DEBUG |
| 32 | |
| 33 | #ifdef BIO_DEBUG |
| 34 | #define BIO_BUG_ON BUG_ON |
| 35 | #else |
| 36 | #define BIO_BUG_ON |
| 37 | #endif |
| 38 | |
Alexey Dobriyan | d84a847 | 2006-06-25 05:49:32 -0700 | [diff] [blame] | 39 | #define BIO_MAX_PAGES 256 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 40 | #define BIO_MAX_SIZE (BIO_MAX_PAGES << PAGE_CACHE_SHIFT) |
| 41 | #define BIO_MAX_SECTORS (BIO_MAX_SIZE >> 9) |
| 42 | |
| 43 | /* |
| 44 | * was unsigned short, but we might as well be ready for > 64kB I/O pages |
| 45 | */ |
| 46 | struct bio_vec { |
| 47 | struct page *bv_page; |
| 48 | unsigned int bv_len; |
| 49 | unsigned int bv_offset; |
| 50 | }; |
| 51 | |
| 52 | struct bio_set; |
| 53 | struct bio; |
Martin K. Petersen | 7ba1ba1 | 2008-06-30 20:04:41 +0200 | [diff] [blame] | 54 | struct bio_integrity_payload; |
NeilBrown | 6712ecf | 2007-09-27 12:47:43 +0200 | [diff] [blame] | 55 | typedef void (bio_end_io_t) (struct bio *, int); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 56 | typedef void (bio_destructor_t) (struct bio *); |
| 57 | |
| 58 | /* |
| 59 | * main unit of I/O for the block layer and lower layers (ie drivers and |
| 60 | * stacking drivers) |
| 61 | */ |
| 62 | struct bio { |
Roger Gammans | 2c2345c | 2006-10-04 13:37:45 +0200 | [diff] [blame] | 63 | sector_t bi_sector; /* device address in 512 byte |
| 64 | sectors */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 65 | struct bio *bi_next; /* request queue link */ |
| 66 | struct block_device *bi_bdev; |
| 67 | unsigned long bi_flags; /* status, command, etc */ |
| 68 | unsigned long bi_rw; /* bottom bits READ/WRITE, |
| 69 | * top bits priority |
| 70 | */ |
| 71 | |
| 72 | unsigned short bi_vcnt; /* how many bio_vec's */ |
| 73 | unsigned short bi_idx; /* current index into bvl_vec */ |
| 74 | |
| 75 | /* Number of segments in this BIO after |
| 76 | * physical address coalescing is performed. |
| 77 | */ |
Jens Axboe | 5b99c2f | 2008-08-15 10:56:11 +0200 | [diff] [blame] | 78 | unsigned int bi_phys_segments; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | unsigned int bi_size; /* residual I/O count */ |
| 81 | |
FUJITA Tomonori | 8677142 | 2008-10-13 14:19:05 +0200 | [diff] [blame] | 82 | /* |
| 83 | * To keep track of the max segment size, we account for the |
| 84 | * sizes of the first and last mergeable segments in this bio. |
| 85 | */ |
| 86 | unsigned int bi_seg_front_size; |
| 87 | unsigned int bi_seg_back_size; |
| 88 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | unsigned int bi_max_vecs; /* max bvl_vecs we can hold */ |
| 90 | |
Jens Axboe | c7c22e4 | 2008-09-13 20:26:01 +0200 | [diff] [blame] | 91 | unsigned int bi_comp_cpu; /* completion CPU */ |
| 92 | |
Richard Kennedy | ba744d5 | 2008-12-03 12:41:40 +0100 | [diff] [blame] | 93 | atomic_t bi_cnt; /* pin count */ |
| 94 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | struct bio_vec *bi_io_vec; /* the actual vec list */ |
| 96 | |
| 97 | bio_end_io_t *bi_end_io; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | |
| 99 | void *bi_private; |
Martin K. Petersen | 7ba1ba1 | 2008-06-30 20:04:41 +0200 | [diff] [blame] | 100 | #if defined(CONFIG_BLK_DEV_INTEGRITY) |
| 101 | struct bio_integrity_payload *bi_integrity; /* data integrity */ |
| 102 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 103 | |
| 104 | bio_destructor_t *bi_destructor; /* destructor */ |
Jens Axboe | 392ddc3 | 2008-12-23 12:42:54 +0100 | [diff] [blame] | 105 | |
| 106 | /* |
| 107 | * We can inline a number of vecs at the end of the bio, to avoid |
| 108 | * double allocations for a small number of bio_vecs. This member |
| 109 | * MUST obviously be kept at the very end of the bio. |
| 110 | */ |
| 111 | struct bio_vec bi_inline_vecs[0]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | }; |
| 113 | |
| 114 | /* |
| 115 | * bio flags |
| 116 | */ |
| 117 | #define BIO_UPTODATE 0 /* ok after I/O completion */ |
| 118 | #define BIO_RW_BLOCK 1 /* RW_AHEAD set, and read/write would block */ |
| 119 | #define BIO_EOF 2 /* out-out-bounds error */ |
Mikulas Patocka | 5df97b9 | 2008-08-15 10:20:02 +0200 | [diff] [blame] | 120 | #define BIO_SEG_VALID 3 /* bi_phys_segments valid */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 121 | #define BIO_CLONED 4 /* doesn't own data */ |
| 122 | #define BIO_BOUNCED 5 /* bio is a bounce bio */ |
| 123 | #define BIO_USER_MAPPED 6 /* contains user pages */ |
| 124 | #define BIO_EOPNOTSUPP 7 /* not supported */ |
Jens Axboe | c7c22e4 | 2008-09-13 20:26:01 +0200 | [diff] [blame] | 125 | #define BIO_CPU_AFFINE 8 /* complete bio on same CPU as submitted */ |
FUJITA Tomonori | 8188276 | 2008-09-02 16:20:19 +0900 | [diff] [blame] | 126 | #define BIO_NULL_MAPPED 9 /* contains invalid user pages */ |
Martin K. Petersen | 74aa8c2 | 2008-10-01 03:38:37 -0400 | [diff] [blame] | 127 | #define BIO_FS_INTEGRITY 10 /* fs owns integrity data, not block layer */ |
Keith Mannthey | 08bafc0 | 2008-11-25 10:24:35 +0100 | [diff] [blame] | 128 | #define BIO_QUIET 11 /* Make BIO Quiet */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 129 | #define bio_flagged(bio, flag) ((bio)->bi_flags & (1 << (flag))) |
| 130 | |
| 131 | /* |
| 132 | * top 4 bits of bio flags indicate the pool this bio came from |
| 133 | */ |
| 134 | #define BIO_POOL_BITS (4) |
Tejun Heo | 451a9eb | 2009-04-15 19:50:51 +0200 | [diff] [blame] | 135 | #define BIO_POOL_NONE ((1UL << BIO_POOL_BITS) - 1) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 136 | #define BIO_POOL_OFFSET (BITS_PER_LONG - BIO_POOL_BITS) |
| 137 | #define BIO_POOL_MASK (1UL << BIO_POOL_OFFSET) |
| 138 | #define BIO_POOL_IDX(bio) ((bio)->bi_flags >> BIO_POOL_OFFSET) |
| 139 | |
| 140 | /* |
Christoph Hellwig | 7b6d91d | 2010-08-07 18:20:39 +0200 | [diff] [blame^] | 141 | * Request flags. For use in the cmd_flags field of struct request, and in |
| 142 | * bi_rw of struct bio. Note that some flags are only valid in either one. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 143 | */ |
Christoph Hellwig | 7b6d91d | 2010-08-07 18:20:39 +0200 | [diff] [blame^] | 144 | enum rq_flag_bits { |
| 145 | /* common flags */ |
| 146 | __REQ_WRITE, /* not set, read. set, write */ |
| 147 | __REQ_FAILFAST_DEV, /* no driver retries of device errors */ |
| 148 | __REQ_FAILFAST_TRANSPORT, /* no driver retries of transport errors */ |
| 149 | __REQ_FAILFAST_DRIVER, /* no driver retries of driver errors */ |
| 150 | |
| 151 | __REQ_HARDBARRIER, /* may not be passed by drive either */ |
| 152 | __REQ_SYNC, /* request is sync (sync write or read) */ |
| 153 | __REQ_META, /* metadata io request */ |
| 154 | __REQ_DISCARD, /* request to discard sectors */ |
| 155 | __REQ_NOIDLE, /* don't anticipate more IO after this one */ |
| 156 | |
| 157 | /* bio only flags */ |
| 158 | __REQ_UNPLUG, /* unplug the immediately after submission */ |
| 159 | __REQ_RAHEAD, /* read ahead, can fail anytime */ |
| 160 | |
| 161 | /* request only flags */ |
| 162 | __REQ_SORTED, /* elevator knows about this request */ |
| 163 | __REQ_SOFTBARRIER, /* may not be passed by ioscheduler */ |
| 164 | __REQ_FUA, /* forced unit access */ |
| 165 | __REQ_NOMERGE, /* don't touch this for merging */ |
| 166 | __REQ_STARTED, /* drive already may have started this one */ |
| 167 | __REQ_DONTPREP, /* don't call prep for this one */ |
| 168 | __REQ_QUEUED, /* uses queueing */ |
| 169 | __REQ_ELVPRIV, /* elevator private data attached */ |
| 170 | __REQ_FAILED, /* set if the request failed */ |
| 171 | __REQ_QUIET, /* don't worry about errors */ |
| 172 | __REQ_PREEMPT, /* set for "ide_preempt" requests */ |
| 173 | __REQ_ORDERED_COLOR, /* is before or after barrier */ |
| 174 | __REQ_ALLOCED, /* request came from our alloc pool */ |
| 175 | __REQ_COPY_USER, /* contains copies of user pages */ |
| 176 | __REQ_INTEGRITY, /* integrity metadata has been remapped */ |
| 177 | __REQ_IO_STAT, /* account I/O stat */ |
| 178 | __REQ_MIXED_MERGE, /* merge of different types, fail separately */ |
| 179 | __REQ_NR_BITS, /* stops here */ |
Tejun Heo | a82afdf | 2009-07-03 17:48:16 +0900 | [diff] [blame] | 180 | }; |
Jens Axboe | 213d941 | 2009-01-06 09:16:05 +0100 | [diff] [blame] | 181 | |
Christoph Hellwig | 7b6d91d | 2010-08-07 18:20:39 +0200 | [diff] [blame^] | 182 | #define REQ_WRITE (1 << __REQ_WRITE) |
| 183 | #define REQ_FAILFAST_DEV (1 << __REQ_FAILFAST_DEV) |
| 184 | #define REQ_FAILFAST_TRANSPORT (1 << __REQ_FAILFAST_TRANSPORT) |
| 185 | #define REQ_FAILFAST_DRIVER (1 << __REQ_FAILFAST_DRIVER) |
| 186 | #define REQ_HARDBARRIER (1 << __REQ_HARDBARRIER) |
| 187 | #define REQ_SYNC (1 << __REQ_SYNC) |
| 188 | #define REQ_META (1 << __REQ_META) |
| 189 | #define REQ_DISCARD (1 << __REQ_DISCARD) |
| 190 | #define REQ_NOIDLE (1 << __REQ_NOIDLE) |
Jens Axboe | 1f98a13 | 2009-09-11 14:32:04 +0200 | [diff] [blame] | 191 | |
Christoph Hellwig | 7b6d91d | 2010-08-07 18:20:39 +0200 | [diff] [blame^] | 192 | #define REQ_FAILFAST_MASK \ |
| 193 | (REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER) |
| 194 | #define REQ_COMMON_MASK \ |
| 195 | (REQ_WRITE | REQ_FAILFAST_MASK | REQ_HARDBARRIER | REQ_SYNC | \ |
| 196 | REQ_META| REQ_DISCARD | REQ_NOIDLE) |
| 197 | |
| 198 | #define REQ_UNPLUG (1 << __REQ_UNPLUG) |
| 199 | #define REQ_RAHEAD (1 << __REQ_RAHEAD) |
| 200 | |
| 201 | #define REQ_SORTED (1 << __REQ_SORTED) |
| 202 | #define REQ_SOFTBARRIER (1 << __REQ_SOFTBARRIER) |
| 203 | #define REQ_FUA (1 << __REQ_FUA) |
| 204 | #define REQ_NOMERGE (1 << __REQ_NOMERGE) |
| 205 | #define REQ_STARTED (1 << __REQ_STARTED) |
| 206 | #define REQ_DONTPREP (1 << __REQ_DONTPREP) |
| 207 | #define REQ_QUEUED (1 << __REQ_QUEUED) |
| 208 | #define REQ_ELVPRIV (1 << __REQ_ELVPRIV) |
| 209 | #define REQ_FAILED (1 << __REQ_FAILED) |
| 210 | #define REQ_QUIET (1 << __REQ_QUIET) |
| 211 | #define REQ_PREEMPT (1 << __REQ_PREEMPT) |
| 212 | #define REQ_ORDERED_COLOR (1 << __REQ_ORDERED_COLOR) |
| 213 | #define REQ_ALLOCED (1 << __REQ_ALLOCED) |
| 214 | #define REQ_COPY_USER (1 << __REQ_COPY_USER) |
| 215 | #define REQ_INTEGRITY (1 << __REQ_INTEGRITY) |
| 216 | #define REQ_IO_STAT (1 << __REQ_IO_STAT) |
| 217 | #define REQ_MIXED_MERGE (1 << __REQ_MIXED_MERGE) |
Jens Axboe | 1dfa17f | 2009-01-06 09:21:49 +0100 | [diff] [blame] | 218 | |
| 219 | /* |
Jens Axboe | 22e2c50 | 2005-06-27 10:55:12 +0200 | [diff] [blame] | 220 | * upper 16 bits of bi_rw define the io priority of this bio |
| 221 | */ |
| 222 | #define BIO_PRIO_SHIFT (8 * sizeof(unsigned long) - IOPRIO_BITS) |
| 223 | #define bio_prio(bio) ((bio)->bi_rw >> BIO_PRIO_SHIFT) |
| 224 | #define bio_prio_valid(bio) ioprio_valid(bio_prio(bio)) |
| 225 | |
| 226 | #define bio_set_prio(bio, prio) do { \ |
| 227 | WARN_ON(prio >= (1 << IOPRIO_BITS)); \ |
| 228 | (bio)->bi_rw &= ((1UL << BIO_PRIO_SHIFT) - 1); \ |
| 229 | (bio)->bi_rw |= ((unsigned long) (prio) << BIO_PRIO_SHIFT); \ |
| 230 | } while (0) |
| 231 | |
| 232 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 233 | * various member access, note that bio_data should of course not be used |
| 234 | * on highmem page vectors |
| 235 | */ |
| 236 | #define bio_iovec_idx(bio, idx) (&((bio)->bi_io_vec[(idx)])) |
| 237 | #define bio_iovec(bio) bio_iovec_idx((bio), (bio)->bi_idx) |
| 238 | #define bio_page(bio) bio_iovec((bio))->bv_page |
| 239 | #define bio_offset(bio) bio_iovec((bio))->bv_offset |
| 240 | #define bio_segments(bio) ((bio)->bi_vcnt - (bio)->bi_idx) |
| 241 | #define bio_sectors(bio) ((bio)->bi_size >> 9) |
Christoph Hellwig | 7b6d91d | 2010-08-07 18:20:39 +0200 | [diff] [blame^] | 242 | #define bio_empty_barrier(bio) \ |
| 243 | ((bio->bi_rw & REQ_HARDBARRIER) && \ |
| 244 | !bio_has_data(bio) && \ |
| 245 | !(bio->bi_rw & REQ_DISCARD)) |
Jens Axboe | bf2de6f | 2007-09-27 13:01:25 +0200 | [diff] [blame] | 246 | |
Tejun Heo | 2e46e8b | 2009-05-07 22:24:41 +0900 | [diff] [blame] | 247 | static inline unsigned int bio_cur_bytes(struct bio *bio) |
Jens Axboe | bf2de6f | 2007-09-27 13:01:25 +0200 | [diff] [blame] | 248 | { |
| 249 | if (bio->bi_vcnt) |
Tejun Heo | 2e46e8b | 2009-05-07 22:24:41 +0900 | [diff] [blame] | 250 | return bio_iovec(bio)->bv_len; |
David Woodhouse | fb2dce8 | 2008-08-05 18:01:53 +0100 | [diff] [blame] | 251 | else /* dataless requests such as discard */ |
Tejun Heo | 2e46e8b | 2009-05-07 22:24:41 +0900 | [diff] [blame] | 252 | return bio->bi_size; |
Jens Axboe | bf2de6f | 2007-09-27 13:01:25 +0200 | [diff] [blame] | 253 | } |
| 254 | |
| 255 | static inline void *bio_data(struct bio *bio) |
| 256 | { |
| 257 | if (bio->bi_vcnt) |
| 258 | return page_address(bio_page(bio)) + bio_offset(bio); |
| 259 | |
| 260 | return NULL; |
| 261 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 262 | |
Jens Axboe | 392ddc3 | 2008-12-23 12:42:54 +0100 | [diff] [blame] | 263 | static inline int bio_has_allocated_vec(struct bio *bio) |
| 264 | { |
| 265 | return bio->bi_io_vec && bio->bi_io_vec != bio->bi_inline_vecs; |
| 266 | } |
| 267 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 268 | /* |
| 269 | * will die |
| 270 | */ |
| 271 | #define bio_to_phys(bio) (page_to_phys(bio_page((bio))) + (unsigned long) bio_offset((bio))) |
| 272 | #define bvec_to_phys(bv) (page_to_phys((bv)->bv_page) + (unsigned long) (bv)->bv_offset) |
| 273 | |
| 274 | /* |
| 275 | * queues that have highmem support enabled may still need to revert to |
| 276 | * PIO transfers occasionally and thus map high pages temporarily. For |
| 277 | * permanent PIO fall back, user is probably better off disabling highmem |
| 278 | * I/O completely on that queue (see ide-dma for example) |
| 279 | */ |
| 280 | #define __bio_kmap_atomic(bio, idx, kmtype) \ |
| 281 | (kmap_atomic(bio_iovec_idx((bio), (idx))->bv_page, kmtype) + \ |
| 282 | bio_iovec_idx((bio), (idx))->bv_offset) |
| 283 | |
| 284 | #define __bio_kunmap_atomic(addr, kmtype) kunmap_atomic(addr, kmtype) |
| 285 | |
| 286 | /* |
| 287 | * merge helpers etc |
| 288 | */ |
| 289 | |
| 290 | #define __BVEC_END(bio) bio_iovec_idx((bio), (bio)->bi_vcnt - 1) |
| 291 | #define __BVEC_START(bio) bio_iovec_idx((bio), (bio)->bi_idx) |
| 292 | |
Jeremy Fitzhardinge | f92131c | 2008-10-29 14:10:51 +0100 | [diff] [blame] | 293 | /* Default implementation of BIOVEC_PHYS_MERGEABLE */ |
| 294 | #define __BIOVEC_PHYS_MERGEABLE(vec1, vec2) \ |
| 295 | ((bvec_to_phys((vec1)) + (vec1)->bv_len) == bvec_to_phys((vec2))) |
| 296 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 297 | /* |
| 298 | * allow arch override, for eg virtualized architectures (put in asm/io.h) |
| 299 | */ |
| 300 | #ifndef BIOVEC_PHYS_MERGEABLE |
| 301 | #define BIOVEC_PHYS_MERGEABLE(vec1, vec2) \ |
Jeremy Fitzhardinge | f92131c | 2008-10-29 14:10:51 +0100 | [diff] [blame] | 302 | __BIOVEC_PHYS_MERGEABLE(vec1, vec2) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 303 | #endif |
| 304 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 305 | #define __BIO_SEG_BOUNDARY(addr1, addr2, mask) \ |
| 306 | (((addr1) | (mask)) == (((addr2) - 1) | (mask))) |
| 307 | #define BIOVEC_SEG_BOUNDARY(q, b1, b2) \ |
Martin K. Petersen | ae03bf6 | 2009-05-22 17:17:50 -0400 | [diff] [blame] | 308 | __BIO_SEG_BOUNDARY(bvec_to_phys((b1)), bvec_to_phys((b2)) + (b2)->bv_len, queue_segment_boundary((q))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 309 | #define BIO_SEG_BOUNDARY(q, b1, b2) \ |
| 310 | BIOVEC_SEG_BOUNDARY((q), __BVEC_END((b1)), __BVEC_START((b2))) |
| 311 | |
NeilBrown | 6712ecf | 2007-09-27 12:47:43 +0200 | [diff] [blame] | 312 | #define bio_io_error(bio) bio_endio((bio), -EIO) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 313 | |
| 314 | /* |
| 315 | * drivers should not use the __ version unless they _really_ want to |
| 316 | * run through the entire bio and not just pending pieces |
| 317 | */ |
| 318 | #define __bio_for_each_segment(bvl, bio, i, start_idx) \ |
| 319 | for (bvl = bio_iovec_idx((bio), (start_idx)), i = (start_idx); \ |
| 320 | i < (bio)->bi_vcnt; \ |
| 321 | bvl++, i++) |
| 322 | |
| 323 | #define bio_for_each_segment(bvl, bio, i) \ |
| 324 | __bio_for_each_segment(bvl, bio, i, (bio)->bi_idx) |
| 325 | |
| 326 | /* |
| 327 | * get a reference to a bio, so it won't disappear. the intended use is |
| 328 | * something like: |
| 329 | * |
| 330 | * bio_get(bio); |
| 331 | * submit_bio(rw, bio); |
| 332 | * if (bio->bi_flags ...) |
| 333 | * do_something |
| 334 | * bio_put(bio); |
| 335 | * |
| 336 | * without the bio_get(), it could potentially complete I/O before submit_bio |
| 337 | * returns. and then bio would be freed memory when if (bio->bi_flags ...) |
| 338 | * runs |
| 339 | */ |
| 340 | #define bio_get(bio) atomic_inc(&(bio)->bi_cnt) |
| 341 | |
Martin K. Petersen | 7ba1ba1 | 2008-06-30 20:04:41 +0200 | [diff] [blame] | 342 | #if defined(CONFIG_BLK_DEV_INTEGRITY) |
| 343 | /* |
| 344 | * bio integrity payload |
| 345 | */ |
| 346 | struct bio_integrity_payload { |
| 347 | struct bio *bip_bio; /* parent bio */ |
Martin K. Petersen | 7ba1ba1 | 2008-06-30 20:04:41 +0200 | [diff] [blame] | 348 | |
| 349 | sector_t bip_sector; /* virtual start sector */ |
| 350 | |
| 351 | void *bip_buf; /* generated integrity data */ |
| 352 | bio_end_io_t *bip_end_io; /* saved I/O completion fn */ |
| 353 | |
Martin K. Petersen | 7ba1ba1 | 2008-06-30 20:04:41 +0200 | [diff] [blame] | 354 | unsigned int bip_size; |
| 355 | |
Martin K. Petersen | 7878cba | 2009-06-26 15:37:49 +0200 | [diff] [blame] | 356 | unsigned short bip_slab; /* slab the bip came from */ |
Martin K. Petersen | 7ba1ba1 | 2008-06-30 20:04:41 +0200 | [diff] [blame] | 357 | unsigned short bip_vcnt; /* # of integrity bio_vecs */ |
| 358 | unsigned short bip_idx; /* current bip_vec index */ |
| 359 | |
| 360 | struct work_struct bip_work; /* I/O completion */ |
Martin K. Petersen | 7878cba | 2009-06-26 15:37:49 +0200 | [diff] [blame] | 361 | struct bio_vec bip_vec[0]; /* embedded bvec array */ |
Martin K. Petersen | 7ba1ba1 | 2008-06-30 20:04:41 +0200 | [diff] [blame] | 362 | }; |
| 363 | #endif /* CONFIG_BLK_DEV_INTEGRITY */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 364 | |
| 365 | /* |
| 366 | * A bio_pair is used when we need to split a bio. |
| 367 | * This can only happen for a bio that refers to just one |
| 368 | * page of data, and in the unusual situation when the |
| 369 | * page crosses a chunk/device boundary |
| 370 | * |
| 371 | * The address of the master bio is stored in bio1.bi_private |
| 372 | * The address of the pool the pair was allocated from is stored |
| 373 | * in bio2.bi_private |
| 374 | */ |
| 375 | struct bio_pair { |
Martin K. Petersen | 7ba1ba1 | 2008-06-30 20:04:41 +0200 | [diff] [blame] | 376 | struct bio bio1, bio2; |
| 377 | struct bio_vec bv1, bv2; |
| 378 | #if defined(CONFIG_BLK_DEV_INTEGRITY) |
| 379 | struct bio_integrity_payload bip1, bip2; |
| 380 | struct bio_vec iv1, iv2; |
| 381 | #endif |
| 382 | atomic_t cnt; |
| 383 | int error; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 384 | }; |
Denis ChengRq | 6feef53 | 2008-10-09 08:57:05 +0200 | [diff] [blame] | 385 | extern struct bio_pair *bio_split(struct bio *bi, int first_sectors); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 386 | extern void bio_pair_release(struct bio_pair *dbio); |
| 387 | |
Jens Axboe | bb799ca | 2008-12-10 15:35:05 +0100 | [diff] [blame] | 388 | extern struct bio_set *bioset_create(unsigned int, unsigned int); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 389 | extern void bioset_free(struct bio_set *); |
| 390 | |
Al Viro | dd0fc66 | 2005-10-07 07:46:04 +0100 | [diff] [blame] | 391 | extern struct bio *bio_alloc(gfp_t, int); |
Jens Axboe | 0a0d96b | 2008-09-11 13:17:37 +0200 | [diff] [blame] | 392 | extern struct bio *bio_kmalloc(gfp_t, int); |
Al Viro | dd0fc66 | 2005-10-07 07:46:04 +0100 | [diff] [blame] | 393 | extern struct bio *bio_alloc_bioset(gfp_t, int, struct bio_set *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 394 | extern void bio_put(struct bio *); |
Peter Osterlund | 3676347 | 2005-09-06 15:16:42 -0700 | [diff] [blame] | 395 | extern void bio_free(struct bio *, struct bio_set *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 396 | |
NeilBrown | 6712ecf | 2007-09-27 12:47:43 +0200 | [diff] [blame] | 397 | extern void bio_endio(struct bio *, int); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 398 | struct request_queue; |
| 399 | extern int bio_phys_segments(struct request_queue *, struct bio *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 400 | |
| 401 | extern void __bio_clone(struct bio *, struct bio *); |
Al Viro | dd0fc66 | 2005-10-07 07:46:04 +0100 | [diff] [blame] | 402 | extern struct bio *bio_clone(struct bio *, gfp_t); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 403 | |
| 404 | extern void bio_init(struct bio *); |
| 405 | |
| 406 | extern int bio_add_page(struct bio *, struct page *, unsigned int,unsigned int); |
Mike Christie | 6e68af6 | 2005-11-11 05:30:27 -0600 | [diff] [blame] | 407 | extern int bio_add_pc_page(struct request_queue *, struct bio *, struct page *, |
| 408 | unsigned int, unsigned int); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 409 | extern int bio_get_nr_vecs(struct block_device *); |
Martin K. Petersen | ad3316b | 2008-10-01 22:42:53 -0400 | [diff] [blame] | 410 | extern sector_t bio_sector_offset(struct bio *, unsigned short, unsigned int); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 411 | extern struct bio *bio_map_user(struct request_queue *, struct block_device *, |
FUJITA Tomonori | a3bce90 | 2008-08-28 16:17:05 +0900 | [diff] [blame] | 412 | unsigned long, unsigned int, int, gfp_t); |
James Bottomley | f1970ba | 2005-06-20 14:06:52 +0200 | [diff] [blame] | 413 | struct sg_iovec; |
FUJITA Tomonori | 152e283 | 2008-08-28 16:17:06 +0900 | [diff] [blame] | 414 | struct rq_map_data; |
James Bottomley | f1970ba | 2005-06-20 14:06:52 +0200 | [diff] [blame] | 415 | extern struct bio *bio_map_user_iov(struct request_queue *, |
| 416 | struct block_device *, |
FUJITA Tomonori | a3bce90 | 2008-08-28 16:17:05 +0900 | [diff] [blame] | 417 | struct sg_iovec *, int, int, gfp_t); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 418 | extern void bio_unmap_user(struct bio *); |
Mike Christie | df46b9a | 2005-06-20 14:04:44 +0200 | [diff] [blame] | 419 | extern struct bio *bio_map_kern(struct request_queue *, void *, unsigned int, |
Al Viro | 27496a8 | 2005-10-21 03:20:48 -0400 | [diff] [blame] | 420 | gfp_t); |
FUJITA Tomonori | 68154e9 | 2008-04-25 12:47:50 +0200 | [diff] [blame] | 421 | extern struct bio *bio_copy_kern(struct request_queue *, void *, unsigned int, |
| 422 | gfp_t, int); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 423 | extern void bio_set_pages_dirty(struct bio *bio); |
| 424 | extern void bio_check_pages_dirty(struct bio *bio); |
Ilya Loginov | 2d4dc89 | 2009-11-26 09:16:19 +0100 | [diff] [blame] | 425 | |
| 426 | #ifndef ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE |
| 427 | # error "You should define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE for your platform" |
| 428 | #endif |
| 429 | #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE |
| 430 | extern void bio_flush_dcache_pages(struct bio *bi); |
| 431 | #else |
| 432 | static inline void bio_flush_dcache_pages(struct bio *bi) |
| 433 | { |
| 434 | } |
| 435 | #endif |
| 436 | |
FUJITA Tomonori | 152e283 | 2008-08-28 16:17:06 +0900 | [diff] [blame] | 437 | extern struct bio *bio_copy_user(struct request_queue *, struct rq_map_data *, |
| 438 | unsigned long, unsigned int, int, gfp_t); |
| 439 | extern struct bio *bio_copy_user_iov(struct request_queue *, |
| 440 | struct rq_map_data *, struct sg_iovec *, |
FUJITA Tomonori | a3bce90 | 2008-08-28 16:17:05 +0900 | [diff] [blame] | 441 | int, int, gfp_t); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 442 | extern int bio_uncopy_user(struct bio *); |
| 443 | void zero_fill_bio(struct bio *bio); |
Martin K. Petersen | 51d654e | 2008-06-17 18:59:56 +0200 | [diff] [blame] | 444 | extern struct bio_vec *bvec_alloc_bs(gfp_t, int, unsigned long *, struct bio_set *); |
Jens Axboe | bb799ca | 2008-12-10 15:35:05 +0100 | [diff] [blame] | 445 | extern void bvec_free_bs(struct bio_set *, struct bio_vec *, unsigned int); |
Martin K. Petersen | 7ba1ba1 | 2008-06-30 20:04:41 +0200 | [diff] [blame] | 446 | extern unsigned int bvec_nr_vecs(unsigned short idx); |
Martin K. Petersen | 51d654e | 2008-06-17 18:59:56 +0200 | [diff] [blame] | 447 | |
| 448 | /* |
Jens Axboe | c7c22e4 | 2008-09-13 20:26:01 +0200 | [diff] [blame] | 449 | * Allow queuer to specify a completion CPU for this bio |
| 450 | */ |
| 451 | static inline void bio_set_completion_cpu(struct bio *bio, unsigned int cpu) |
| 452 | { |
| 453 | bio->bi_comp_cpu = cpu; |
| 454 | } |
| 455 | |
| 456 | /* |
Martin K. Petersen | 51d654e | 2008-06-17 18:59:56 +0200 | [diff] [blame] | 457 | * bio_set is used to allow other portions of the IO system to |
| 458 | * allocate their own private memory pools for bio and iovec structures. |
| 459 | * These memory pools in turn all allocate from the bio_slab |
| 460 | * and the bvec_slabs[]. |
| 461 | */ |
| 462 | #define BIO_POOL_SIZE 2 |
| 463 | #define BIOVEC_NR_POOLS 6 |
Jens Axboe | 7ff9345 | 2008-12-11 11:53:43 +0100 | [diff] [blame] | 464 | #define BIOVEC_MAX_IDX (BIOVEC_NR_POOLS - 1) |
Martin K. Petersen | 51d654e | 2008-06-17 18:59:56 +0200 | [diff] [blame] | 465 | |
| 466 | struct bio_set { |
Jens Axboe | 1b43449 | 2008-10-22 20:32:58 +0200 | [diff] [blame] | 467 | struct kmem_cache *bio_slab; |
Jens Axboe | bb799ca | 2008-12-10 15:35:05 +0100 | [diff] [blame] | 468 | unsigned int front_pad; |
| 469 | |
Martin K. Petersen | 51d654e | 2008-06-17 18:59:56 +0200 | [diff] [blame] | 470 | mempool_t *bio_pool; |
Martin K. Petersen | 7878cba | 2009-06-26 15:37:49 +0200 | [diff] [blame] | 471 | #if defined(CONFIG_BLK_DEV_INTEGRITY) |
| 472 | mempool_t *bio_integrity_pool; |
| 473 | #endif |
Jens Axboe | 7ff9345 | 2008-12-11 11:53:43 +0100 | [diff] [blame] | 474 | mempool_t *bvec_pool; |
Martin K. Petersen | 51d654e | 2008-06-17 18:59:56 +0200 | [diff] [blame] | 475 | }; |
| 476 | |
| 477 | struct biovec_slab { |
| 478 | int nr_vecs; |
| 479 | char *name; |
| 480 | struct kmem_cache *slab; |
| 481 | }; |
| 482 | |
| 483 | extern struct bio_set *fs_bio_set; |
Jens Axboe | bb799ca | 2008-12-10 15:35:05 +0100 | [diff] [blame] | 484 | extern struct biovec_slab bvec_slabs[BIOVEC_NR_POOLS] __read_mostly; |
Martin K. Petersen | 51d654e | 2008-06-17 18:59:56 +0200 | [diff] [blame] | 485 | |
| 486 | /* |
| 487 | * a small number of entries is fine, not going to be performance critical. |
| 488 | * basically we just need to survive |
| 489 | */ |
| 490 | #define BIO_SPLIT_ENTRIES 2 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 491 | |
| 492 | #ifdef CONFIG_HIGHMEM |
| 493 | /* |
Alberto Bertogli | 20b636b | 2009-02-02 12:41:07 +0100 | [diff] [blame] | 494 | * remember never ever reenable interrupts between a bvec_kmap_irq and |
| 495 | * bvec_kunmap_irq! |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 496 | */ |
Alberto Bertogli | 4f570f9 | 2009-11-02 11:40:16 +0100 | [diff] [blame] | 497 | static inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 498 | { |
| 499 | unsigned long addr; |
| 500 | |
| 501 | /* |
| 502 | * might not be a highmem page, but the preempt/irq count |
| 503 | * balancing is a lot nicer this way |
| 504 | */ |
| 505 | local_irq_save(*flags); |
| 506 | addr = (unsigned long) kmap_atomic(bvec->bv_page, KM_BIO_SRC_IRQ); |
| 507 | |
| 508 | BUG_ON(addr & ~PAGE_MASK); |
| 509 | |
| 510 | return (char *) addr + bvec->bv_offset; |
| 511 | } |
| 512 | |
Alberto Bertogli | 4f570f9 | 2009-11-02 11:40:16 +0100 | [diff] [blame] | 513 | static inline void bvec_kunmap_irq(char *buffer, unsigned long *flags) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 514 | { |
| 515 | unsigned long ptr = (unsigned long) buffer & PAGE_MASK; |
| 516 | |
| 517 | kunmap_atomic((void *) ptr, KM_BIO_SRC_IRQ); |
| 518 | local_irq_restore(*flags); |
| 519 | } |
| 520 | |
| 521 | #else |
| 522 | #define bvec_kmap_irq(bvec, flags) (page_address((bvec)->bv_page) + (bvec)->bv_offset) |
| 523 | #define bvec_kunmap_irq(buf, flags) do { *(flags) = 0; } while (0) |
| 524 | #endif |
| 525 | |
Adrian Bunk | c2d08da | 2005-09-10 00:27:18 -0700 | [diff] [blame] | 526 | static inline char *__bio_kmap_irq(struct bio *bio, unsigned short idx, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 527 | unsigned long *flags) |
| 528 | { |
| 529 | return bvec_kmap_irq(bio_iovec_idx(bio, idx), flags); |
| 530 | } |
| 531 | #define __bio_kunmap_irq(buf, flags) bvec_kunmap_irq(buf, flags) |
| 532 | |
| 533 | #define bio_kmap_irq(bio, flags) \ |
| 534 | __bio_kmap_irq((bio), (bio)->bi_idx, (flags)) |
| 535 | #define bio_kunmap_irq(buf,flags) __bio_kunmap_irq(buf, flags) |
| 536 | |
Jens Axboe | 7a67f63 | 2008-08-08 11:17:12 +0200 | [diff] [blame] | 537 | /* |
| 538 | * Check whether this bio carries any data or not. A NULL bio is allowed. |
| 539 | */ |
| 540 | static inline int bio_has_data(struct bio *bio) |
| 541 | { |
| 542 | return bio && bio->bi_io_vec != NULL; |
| 543 | } |
| 544 | |
Christoph Hellwig | 8f3d8ba | 2009-04-07 19:55:13 +0200 | [diff] [blame] | 545 | /* |
Akinobu Mita | e686307 | 2009-04-17 08:41:21 +0200 | [diff] [blame] | 546 | * BIO list management for use by remapping drivers (e.g. DM or MD) and loop. |
Christoph Hellwig | 8f3d8ba | 2009-04-07 19:55:13 +0200 | [diff] [blame] | 547 | * |
| 548 | * A bio_list anchors a singly-linked list of bios chained through the bi_next |
| 549 | * member of the bio. The bio_list also caches the last list member to allow |
| 550 | * fast access to the tail. |
| 551 | */ |
| 552 | struct bio_list { |
| 553 | struct bio *head; |
| 554 | struct bio *tail; |
| 555 | }; |
| 556 | |
| 557 | static inline int bio_list_empty(const struct bio_list *bl) |
| 558 | { |
| 559 | return bl->head == NULL; |
| 560 | } |
| 561 | |
| 562 | static inline void bio_list_init(struct bio_list *bl) |
| 563 | { |
| 564 | bl->head = bl->tail = NULL; |
| 565 | } |
| 566 | |
| 567 | #define bio_list_for_each(bio, bl) \ |
| 568 | for (bio = (bl)->head; bio; bio = bio->bi_next) |
| 569 | |
| 570 | static inline unsigned bio_list_size(const struct bio_list *bl) |
| 571 | { |
| 572 | unsigned sz = 0; |
| 573 | struct bio *bio; |
| 574 | |
| 575 | bio_list_for_each(bio, bl) |
| 576 | sz++; |
| 577 | |
| 578 | return sz; |
| 579 | } |
| 580 | |
| 581 | static inline void bio_list_add(struct bio_list *bl, struct bio *bio) |
| 582 | { |
| 583 | bio->bi_next = NULL; |
| 584 | |
| 585 | if (bl->tail) |
| 586 | bl->tail->bi_next = bio; |
| 587 | else |
| 588 | bl->head = bio; |
| 589 | |
| 590 | bl->tail = bio; |
| 591 | } |
| 592 | |
| 593 | static inline void bio_list_add_head(struct bio_list *bl, struct bio *bio) |
| 594 | { |
| 595 | bio->bi_next = bl->head; |
| 596 | |
| 597 | bl->head = bio; |
| 598 | |
| 599 | if (!bl->tail) |
| 600 | bl->tail = bio; |
| 601 | } |
| 602 | |
| 603 | static inline void bio_list_merge(struct bio_list *bl, struct bio_list *bl2) |
| 604 | { |
| 605 | if (!bl2->head) |
| 606 | return; |
| 607 | |
| 608 | if (bl->tail) |
| 609 | bl->tail->bi_next = bl2->head; |
| 610 | else |
| 611 | bl->head = bl2->head; |
| 612 | |
| 613 | bl->tail = bl2->tail; |
| 614 | } |
| 615 | |
| 616 | static inline void bio_list_merge_head(struct bio_list *bl, |
| 617 | struct bio_list *bl2) |
| 618 | { |
| 619 | if (!bl2->head) |
| 620 | return; |
| 621 | |
| 622 | if (bl->head) |
| 623 | bl2->tail->bi_next = bl->head; |
| 624 | else |
| 625 | bl->tail = bl2->tail; |
| 626 | |
| 627 | bl->head = bl2->head; |
| 628 | } |
| 629 | |
Geert Uytterhoeven | 13685a1 | 2009-06-10 04:38:40 +0000 | [diff] [blame] | 630 | static inline struct bio *bio_list_peek(struct bio_list *bl) |
| 631 | { |
| 632 | return bl->head; |
| 633 | } |
| 634 | |
Christoph Hellwig | 8f3d8ba | 2009-04-07 19:55:13 +0200 | [diff] [blame] | 635 | static inline struct bio *bio_list_pop(struct bio_list *bl) |
| 636 | { |
| 637 | struct bio *bio = bl->head; |
| 638 | |
| 639 | if (bio) { |
| 640 | bl->head = bl->head->bi_next; |
| 641 | if (!bl->head) |
| 642 | bl->tail = NULL; |
| 643 | |
| 644 | bio->bi_next = NULL; |
| 645 | } |
| 646 | |
| 647 | return bio; |
| 648 | } |
| 649 | |
| 650 | static inline struct bio *bio_list_get(struct bio_list *bl) |
| 651 | { |
| 652 | struct bio *bio = bl->head; |
| 653 | |
| 654 | bl->head = bl->tail = NULL; |
| 655 | |
| 656 | return bio; |
| 657 | } |
| 658 | |
Martin K. Petersen | 7ba1ba1 | 2008-06-30 20:04:41 +0200 | [diff] [blame] | 659 | #if defined(CONFIG_BLK_DEV_INTEGRITY) |
| 660 | |
| 661 | #define bip_vec_idx(bip, idx) (&(bip->bip_vec[(idx)])) |
| 662 | #define bip_vec(bip) bip_vec_idx(bip, 0) |
| 663 | |
| 664 | #define __bip_for_each_vec(bvl, bip, i, start_idx) \ |
| 665 | for (bvl = bip_vec_idx((bip), (start_idx)), i = (start_idx); \ |
| 666 | i < (bip)->bip_vcnt; \ |
| 667 | bvl++, i++) |
| 668 | |
| 669 | #define bip_for_each_vec(bvl, bip, i) \ |
| 670 | __bip_for_each_vec(bvl, bip, i, (bip)->bip_idx) |
| 671 | |
Alberto Bertogli | 8deaf72 | 2008-10-02 12:46:53 +0200 | [diff] [blame] | 672 | #define bio_integrity(bio) (bio->bi_integrity != NULL) |
Martin K. Petersen | 7ba1ba1 | 2008-06-30 20:04:41 +0200 | [diff] [blame] | 673 | |
Martin K. Petersen | 7878cba | 2009-06-26 15:37:49 +0200 | [diff] [blame] | 674 | extern struct bio_integrity_payload *bio_integrity_alloc_bioset(struct bio *, gfp_t, unsigned int, struct bio_set *); |
Martin K. Petersen | 7ba1ba1 | 2008-06-30 20:04:41 +0200 | [diff] [blame] | 675 | extern struct bio_integrity_payload *bio_integrity_alloc(struct bio *, gfp_t, unsigned int); |
Martin K. Petersen | 7878cba | 2009-06-26 15:37:49 +0200 | [diff] [blame] | 676 | extern void bio_integrity_free(struct bio *, struct bio_set *); |
Martin K. Petersen | 7ba1ba1 | 2008-06-30 20:04:41 +0200 | [diff] [blame] | 677 | extern int bio_integrity_add_page(struct bio *, struct page *, unsigned int, unsigned int); |
| 678 | extern int bio_integrity_enabled(struct bio *bio); |
| 679 | extern int bio_integrity_set_tag(struct bio *, void *, unsigned int); |
| 680 | extern int bio_integrity_get_tag(struct bio *, void *, unsigned int); |
| 681 | extern int bio_integrity_prep(struct bio *); |
| 682 | extern void bio_integrity_endio(struct bio *, int); |
| 683 | extern void bio_integrity_advance(struct bio *, unsigned int); |
| 684 | extern void bio_integrity_trim(struct bio *, unsigned int, unsigned int); |
| 685 | extern void bio_integrity_split(struct bio *, struct bio_pair *, int); |
Martin K. Petersen | 7878cba | 2009-06-26 15:37:49 +0200 | [diff] [blame] | 686 | extern int bio_integrity_clone(struct bio *, struct bio *, gfp_t, struct bio_set *); |
| 687 | extern int bioset_integrity_create(struct bio_set *, int); |
| 688 | extern void bioset_integrity_free(struct bio_set *); |
| 689 | extern void bio_integrity_init(void); |
Martin K. Petersen | 7ba1ba1 | 2008-06-30 20:04:41 +0200 | [diff] [blame] | 690 | |
| 691 | #else /* CONFIG_BLK_DEV_INTEGRITY */ |
| 692 | |
| 693 | #define bio_integrity(a) (0) |
Martin K. Petersen | 7878cba | 2009-06-26 15:37:49 +0200 | [diff] [blame] | 694 | #define bioset_integrity_create(a, b) (0) |
Martin K. Petersen | 7ba1ba1 | 2008-06-30 20:04:41 +0200 | [diff] [blame] | 695 | #define bio_integrity_prep(a) (0) |
| 696 | #define bio_integrity_enabled(a) (0) |
Martin K. Petersen | 7878cba | 2009-06-26 15:37:49 +0200 | [diff] [blame] | 697 | #define bio_integrity_clone(a, b, c, d) (0) |
| 698 | #define bioset_integrity_free(a) do { } while (0) |
| 699 | #define bio_integrity_free(a, b) do { } while (0) |
Martin K. Petersen | 7ba1ba1 | 2008-06-30 20:04:41 +0200 | [diff] [blame] | 700 | #define bio_integrity_endio(a, b) do { } while (0) |
| 701 | #define bio_integrity_advance(a, b) do { } while (0) |
| 702 | #define bio_integrity_trim(a, b, c) do { } while (0) |
| 703 | #define bio_integrity_split(a, b, c) do { } while (0) |
| 704 | #define bio_integrity_set_tag(a, b, c) do { } while (0) |
| 705 | #define bio_integrity_get_tag(a, b, c) do { } while (0) |
Martin K. Petersen | 7878cba | 2009-06-26 15:37:49 +0200 | [diff] [blame] | 706 | #define bio_integrity_init(a) do { } while (0) |
Martin K. Petersen | 7ba1ba1 | 2008-06-30 20:04:41 +0200 | [diff] [blame] | 707 | |
| 708 | #endif /* CONFIG_BLK_DEV_INTEGRITY */ |
| 709 | |
David Howells | 02a5e0a | 2007-08-11 22:34:32 +0200 | [diff] [blame] | 710 | #endif /* CONFIG_BLOCK */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 711 | #endif /* __LINUX_BIO_H */ |