Merge tag 'bug-for-3.4' of git://git.kernel.org/pub/scm/linux/kernel/git/paulg/linux
[linux-2.6.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 bio_iovec_idx(bio, idx) (&((bio)->bi_io_vec[(idx)]))
65 #define bio_iovec(bio)          bio_iovec_idx((bio), (bio)->bi_idx)
66 #define bio_page(bio)           bio_iovec((bio))->bv_page
67 #define bio_offset(bio)         bio_iovec((bio))->bv_offset
68 #define bio_segments(bio)       ((bio)->bi_vcnt - (bio)->bi_idx)
69 #define bio_sectors(bio)        ((bio)->bi_size >> 9)
70
71 static inline unsigned int bio_cur_bytes(struct bio *bio)
72 {
73         if (bio->bi_vcnt)
74                 return bio_iovec(bio)->bv_len;
75         else /* dataless requests such as discard */
76                 return bio->bi_size;
77 }
78
79 static inline void *bio_data(struct bio *bio)
80 {
81         if (bio->bi_vcnt)
82                 return page_address(bio_page(bio)) + bio_offset(bio);
83
84         return NULL;
85 }
86
87 static inline int bio_has_allocated_vec(struct bio *bio)
88 {
89         return bio->bi_io_vec && bio->bi_io_vec != bio->bi_inline_vecs;
90 }
91
92 /*
93  * will die
94  */
95 #define bio_to_phys(bio)        (page_to_phys(bio_page((bio))) + (unsigned long) bio_offset((bio)))
96 #define bvec_to_phys(bv)        (page_to_phys((bv)->bv_page) + (unsigned long) (bv)->bv_offset)
97
98 /*
99  * queues that have highmem support enabled may still need to revert to
100  * PIO transfers occasionally and thus map high pages temporarily. For
101  * permanent PIO fall back, user is probably better off disabling highmem
102  * I/O completely on that queue (see ide-dma for example)
103  */
104 #define __bio_kmap_atomic(bio, idx, kmtype)                             \
105         (kmap_atomic(bio_iovec_idx((bio), (idx))->bv_page) +    \
106                 bio_iovec_idx((bio), (idx))->bv_offset)
107
108 #define __bio_kunmap_atomic(addr, kmtype) kunmap_atomic(addr)
109
110 /*
111  * merge helpers etc
112  */
113
114 #define __BVEC_END(bio)         bio_iovec_idx((bio), (bio)->bi_vcnt - 1)
115 #define __BVEC_START(bio)       bio_iovec_idx((bio), (bio)->bi_idx)
116
117 /* Default implementation of BIOVEC_PHYS_MERGEABLE */
118 #define __BIOVEC_PHYS_MERGEABLE(vec1, vec2)     \
119         ((bvec_to_phys((vec1)) + (vec1)->bv_len) == bvec_to_phys((vec2)))
120
121 /*
122  * allow arch override, for eg virtualized architectures (put in asm/io.h)
123  */
124 #ifndef BIOVEC_PHYS_MERGEABLE
125 #define BIOVEC_PHYS_MERGEABLE(vec1, vec2)       \
126         __BIOVEC_PHYS_MERGEABLE(vec1, vec2)
127 #endif
128
129 #define __BIO_SEG_BOUNDARY(addr1, addr2, mask) \
130         (((addr1) | (mask)) == (((addr2) - 1) | (mask)))
131 #define BIOVEC_SEG_BOUNDARY(q, b1, b2) \
132         __BIO_SEG_BOUNDARY(bvec_to_phys((b1)), bvec_to_phys((b2)) + (b2)->bv_len, queue_segment_boundary((q)))
133 #define BIO_SEG_BOUNDARY(q, b1, b2) \
134         BIOVEC_SEG_BOUNDARY((q), __BVEC_END((b1)), __BVEC_START((b2)))
135
136 #define bio_io_error(bio) bio_endio((bio), -EIO)
137
138 /*
139  * drivers should not use the __ version unless they _really_ want to
140  * run through the entire bio and not just pending pieces
141  */
142 #define __bio_for_each_segment(bvl, bio, i, start_idx)                  \
143         for (bvl = bio_iovec_idx((bio), (start_idx)), i = (start_idx);  \
144              i < (bio)->bi_vcnt;                                        \
145              bvl++, i++)
146
147 #define bio_for_each_segment(bvl, bio, i)                               \
148         __bio_for_each_segment(bvl, bio, i, (bio)->bi_idx)
149
150 /*
151  * get a reference to a bio, so it won't disappear. the intended use is
152  * something like:
153  *
154  * bio_get(bio);
155  * submit_bio(rw, bio);
156  * if (bio->bi_flags ...)
157  *      do_something
158  * bio_put(bio);
159  *
160  * without the bio_get(), it could potentially complete I/O before submit_bio
161  * returns. and then bio would be freed memory when if (bio->bi_flags ...)
162  * runs
163  */
164 #define bio_get(bio)    atomic_inc(&(bio)->bi_cnt)
165
166 #if defined(CONFIG_BLK_DEV_INTEGRITY)
167 /*
168  * bio integrity payload
169  */
170 struct bio_integrity_payload {
171         struct bio              *bip_bio;       /* parent bio */
172
173         sector_t                bip_sector;     /* virtual start sector */
174
175         void                    *bip_buf;       /* generated integrity data */
176         bio_end_io_t            *bip_end_io;    /* saved I/O completion fn */
177
178         unsigned int            bip_size;
179
180         unsigned short          bip_slab;       /* slab the bip came from */
181         unsigned short          bip_vcnt;       /* # of integrity bio_vecs */
182         unsigned short          bip_idx;        /* current bip_vec index */
183
184         struct work_struct      bip_work;       /* I/O completion */
185         struct bio_vec          bip_vec[0];     /* embedded bvec array */
186 };
187 #endif /* CONFIG_BLK_DEV_INTEGRITY */
188
189 /*
190  * A bio_pair is used when we need to split a bio.
191  * This can only happen for a bio that refers to just one
192  * page of data, and in the unusual situation when the
193  * page crosses a chunk/device boundary
194  *
195  * The address of the master bio is stored in bio1.bi_private
196  * The address of the pool the pair was allocated from is stored
197  *   in bio2.bi_private
198  */
199 struct bio_pair {
200         struct bio                      bio1, bio2;
201         struct bio_vec                  bv1, bv2;
202 #if defined(CONFIG_BLK_DEV_INTEGRITY)
203         struct bio_integrity_payload    bip1, bip2;
204         struct bio_vec                  iv1, iv2;
205 #endif
206         atomic_t                        cnt;
207         int                             error;
208 };
209 extern struct bio_pair *bio_split(struct bio *bi, int first_sectors);
210 extern void bio_pair_release(struct bio_pair *dbio);
211
212 extern struct bio_set *bioset_create(unsigned int, unsigned int);
213 extern void bioset_free(struct bio_set *);
214
215 extern struct bio *bio_alloc(gfp_t, unsigned int);
216 extern struct bio *bio_kmalloc(gfp_t, unsigned int);
217 extern struct bio *bio_alloc_bioset(gfp_t, int, struct bio_set *);
218 extern void bio_put(struct bio *);
219 extern void bio_free(struct bio *, struct bio_set *);
220
221 extern void bio_endio(struct bio *, int);
222 struct request_queue;
223 extern int bio_phys_segments(struct request_queue *, struct bio *);
224
225 extern void __bio_clone(struct bio *, struct bio *);
226 extern struct bio *bio_clone(struct bio *, gfp_t);
227
228 extern void bio_init(struct bio *);
229
230 extern int bio_add_page(struct bio *, struct page *, unsigned int,unsigned int);
231 extern int bio_add_pc_page(struct request_queue *, struct bio *, struct page *,
232                            unsigned int, unsigned int);
233 extern int bio_get_nr_vecs(struct block_device *);
234 extern sector_t bio_sector_offset(struct bio *, unsigned short, unsigned int);
235 extern struct bio *bio_map_user(struct request_queue *, struct block_device *,
236                                 unsigned long, unsigned int, int, gfp_t);
237 struct sg_iovec;
238 struct rq_map_data;
239 extern struct bio *bio_map_user_iov(struct request_queue *,
240                                     struct block_device *,
241                                     struct sg_iovec *, int, int, gfp_t);
242 extern void bio_unmap_user(struct bio *);
243 extern struct bio *bio_map_kern(struct request_queue *, void *, unsigned int,
244                                 gfp_t);
245 extern struct bio *bio_copy_kern(struct request_queue *, void *, unsigned int,
246                                  gfp_t, int);
247 extern void bio_set_pages_dirty(struct bio *bio);
248 extern void bio_check_pages_dirty(struct bio *bio);
249
250 #ifndef ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
251 # error "You should define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE for your platform"
252 #endif
253 #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
254 extern void bio_flush_dcache_pages(struct bio *bi);
255 #else
256 static inline void bio_flush_dcache_pages(struct bio *bi)
257 {
258 }
259 #endif
260
261 extern struct bio *bio_copy_user(struct request_queue *, struct rq_map_data *,
262                                  unsigned long, unsigned int, int, gfp_t);
263 extern struct bio *bio_copy_user_iov(struct request_queue *,
264                                      struct rq_map_data *, struct sg_iovec *,
265                                      int, int, gfp_t);
266 extern int bio_uncopy_user(struct bio *);
267 void zero_fill_bio(struct bio *bio);
268 extern struct bio_vec *bvec_alloc_bs(gfp_t, int, unsigned long *, struct bio_set *);
269 extern void bvec_free_bs(struct bio_set *, struct bio_vec *, unsigned int);
270 extern unsigned int bvec_nr_vecs(unsigned short idx);
271
272 /*
273  * bio_set is used to allow other portions of the IO system to
274  * allocate their own private memory pools for bio and iovec structures.
275  * These memory pools in turn all allocate from the bio_slab
276  * and the bvec_slabs[].
277  */
278 #define BIO_POOL_SIZE 2
279 #define BIOVEC_NR_POOLS 6
280 #define BIOVEC_MAX_IDX  (BIOVEC_NR_POOLS - 1)
281
282 struct bio_set {
283         struct kmem_cache *bio_slab;
284         unsigned int front_pad;
285
286         mempool_t *bio_pool;
287 #if defined(CONFIG_BLK_DEV_INTEGRITY)
288         mempool_t *bio_integrity_pool;
289 #endif
290         mempool_t *bvec_pool;
291 };
292
293 struct biovec_slab {
294         int nr_vecs;
295         char *name;
296         struct kmem_cache *slab;
297 };
298
299 extern struct bio_set *fs_bio_set;
300
301 /*
302  * a small number of entries is fine, not going to be performance critical.
303  * basically we just need to survive
304  */
305 #define BIO_SPLIT_ENTRIES 2
306
307 #ifdef CONFIG_HIGHMEM
308 /*
309  * remember never ever reenable interrupts between a bvec_kmap_irq and
310  * bvec_kunmap_irq!
311  */
312 static inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
313 {
314         unsigned long addr;
315
316         /*
317          * might not be a highmem page, but the preempt/irq count
318          * balancing is a lot nicer this way
319          */
320         local_irq_save(*flags);
321         addr = (unsigned long) kmap_atomic(bvec->bv_page);
322
323         BUG_ON(addr & ~PAGE_MASK);
324
325         return (char *) addr + bvec->bv_offset;
326 }
327
328 static inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
329 {
330         unsigned long ptr = (unsigned long) buffer & PAGE_MASK;
331
332         kunmap_atomic((void *) ptr);
333         local_irq_restore(*flags);
334 }
335
336 #else
337 static inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
338 {
339         return page_address(bvec->bv_page) + bvec->bv_offset;
340 }
341
342 static inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
343 {
344         *flags = 0;
345 }
346 #endif
347
348 static inline char *__bio_kmap_irq(struct bio *bio, unsigned short idx,
349                                    unsigned long *flags)
350 {
351         return bvec_kmap_irq(bio_iovec_idx(bio, idx), flags);
352 }
353 #define __bio_kunmap_irq(buf, flags)    bvec_kunmap_irq(buf, flags)
354
355 #define bio_kmap_irq(bio, flags) \
356         __bio_kmap_irq((bio), (bio)->bi_idx, (flags))
357 #define bio_kunmap_irq(buf,flags)       __bio_kunmap_irq(buf, flags)
358
359 /*
360  * Check whether this bio carries any data or not. A NULL bio is allowed.
361  */
362 static inline int bio_has_data(struct bio *bio)
363 {
364         return bio && bio->bi_io_vec != NULL;
365 }
366
367 /*
368  * BIO list management for use by remapping drivers (e.g. DM or MD) and loop.
369  *
370  * A bio_list anchors a singly-linked list of bios chained through the bi_next
371  * member of the bio.  The bio_list also caches the last list member to allow
372  * fast access to the tail.
373  */
374 struct bio_list {
375         struct bio *head;
376         struct bio *tail;
377 };
378
379 static inline int bio_list_empty(const struct bio_list *bl)
380 {
381         return bl->head == NULL;
382 }
383
384 static inline void bio_list_init(struct bio_list *bl)
385 {
386         bl->head = bl->tail = NULL;
387 }
388
389 #define bio_list_for_each(bio, bl) \
390         for (bio = (bl)->head; bio; bio = bio->bi_next)
391
392 static inline unsigned bio_list_size(const struct bio_list *bl)
393 {
394         unsigned sz = 0;
395         struct bio *bio;
396
397         bio_list_for_each(bio, bl)
398                 sz++;
399
400         return sz;
401 }
402
403 static inline void bio_list_add(struct bio_list *bl, struct bio *bio)
404 {
405         bio->bi_next = NULL;
406
407         if (bl->tail)
408                 bl->tail->bi_next = bio;
409         else
410                 bl->head = bio;
411
412         bl->tail = bio;
413 }
414
415 static inline void bio_list_add_head(struct bio_list *bl, struct bio *bio)
416 {
417         bio->bi_next = bl->head;
418
419         bl->head = bio;
420
421         if (!bl->tail)
422                 bl->tail = bio;
423 }
424
425 static inline void bio_list_merge(struct bio_list *bl, struct bio_list *bl2)
426 {
427         if (!bl2->head)
428                 return;
429
430         if (bl->tail)
431                 bl->tail->bi_next = bl2->head;
432         else
433                 bl->head = bl2->head;
434
435         bl->tail = bl2->tail;
436 }
437
438 static inline void bio_list_merge_head(struct bio_list *bl,
439                                        struct bio_list *bl2)
440 {
441         if (!bl2->head)
442                 return;
443
444         if (bl->head)
445                 bl2->tail->bi_next = bl->head;
446         else
447                 bl->tail = bl2->tail;
448
449         bl->head = bl2->head;
450 }
451
452 static inline struct bio *bio_list_peek(struct bio_list *bl)
453 {
454         return bl->head;
455 }
456
457 static inline struct bio *bio_list_pop(struct bio_list *bl)
458 {
459         struct bio *bio = bl->head;
460
461         if (bio) {
462                 bl->head = bl->head->bi_next;
463                 if (!bl->head)
464                         bl->tail = NULL;
465
466                 bio->bi_next = NULL;
467         }
468
469         return bio;
470 }
471
472 static inline struct bio *bio_list_get(struct bio_list *bl)
473 {
474         struct bio *bio = bl->head;
475
476         bl->head = bl->tail = NULL;
477
478         return bio;
479 }
480
481 #if defined(CONFIG_BLK_DEV_INTEGRITY)
482
483 #define bip_vec_idx(bip, idx)   (&(bip->bip_vec[(idx)]))
484 #define bip_vec(bip)            bip_vec_idx(bip, 0)
485
486 #define __bip_for_each_vec(bvl, bip, i, start_idx)                      \
487         for (bvl = bip_vec_idx((bip), (start_idx)), i = (start_idx);    \
488              i < (bip)->bip_vcnt;                                       \
489              bvl++, i++)
490
491 #define bip_for_each_vec(bvl, bip, i)                                   \
492         __bip_for_each_vec(bvl, bip, i, (bip)->bip_idx)
493
494 #define bio_for_each_integrity_vec(_bvl, _bio, _iter)                   \
495         for_each_bio(_bio)                                              \
496                 bip_for_each_vec(_bvl, _bio->bi_integrity, _iter)
497
498 #define bio_integrity(bio) (bio->bi_integrity != NULL)
499
500 extern struct bio_integrity_payload *bio_integrity_alloc_bioset(struct bio *, gfp_t, unsigned int, struct bio_set *);
501 extern struct bio_integrity_payload *bio_integrity_alloc(struct bio *, gfp_t, unsigned int);
502 extern void bio_integrity_free(struct bio *, struct bio_set *);
503 extern int bio_integrity_add_page(struct bio *, struct page *, unsigned int, unsigned int);
504 extern int bio_integrity_enabled(struct bio *bio);
505 extern int bio_integrity_set_tag(struct bio *, void *, unsigned int);
506 extern int bio_integrity_get_tag(struct bio *, void *, unsigned int);
507 extern int bio_integrity_prep(struct bio *);
508 extern void bio_integrity_endio(struct bio *, int);
509 extern void bio_integrity_advance(struct bio *, unsigned int);
510 extern void bio_integrity_trim(struct bio *, unsigned int, unsigned int);
511 extern void bio_integrity_split(struct bio *, struct bio_pair *, int);
512 extern int bio_integrity_clone(struct bio *, struct bio *, gfp_t, struct bio_set *);
513 extern int bioset_integrity_create(struct bio_set *, int);
514 extern void bioset_integrity_free(struct bio_set *);
515 extern void bio_integrity_init(void);
516
517 #else /* CONFIG_BLK_DEV_INTEGRITY */
518
519 static inline int bio_integrity(struct bio *bio)
520 {
521         return 0;
522 }
523
524 static inline int bio_integrity_enabled(struct bio *bio)
525 {
526         return 0;
527 }
528
529 static inline int bioset_integrity_create(struct bio_set *bs, int pool_size)
530 {
531         return 0;
532 }
533
534 static inline void bioset_integrity_free (struct bio_set *bs)
535 {
536         return;
537 }
538
539 static inline int bio_integrity_prep(struct bio *bio)
540 {
541         return 0;
542 }
543
544 static inline void bio_integrity_free(struct bio *bio, struct bio_set *bs)
545 {
546         return;
547 }
548
549 static inline int bio_integrity_clone(struct bio *bio, struct bio *bio_src,
550                                       gfp_t gfp_mask, struct bio_set *bs)
551 {
552         return 0;
553 }
554
555 static inline void bio_integrity_split(struct bio *bio, struct bio_pair *bp,
556                                        int sectors)
557 {
558         return;
559 }
560
561 static inline void bio_integrity_advance(struct bio *bio,
562                                          unsigned int bytes_done)
563 {
564         return;
565 }
566
567 static inline void bio_integrity_trim(struct bio *bio, unsigned int offset,
568                                       unsigned int sectors)
569 {
570         return;
571 }
572
573 static inline void bio_integrity_init(void)
574 {
575         return;
576 }
577
578 #endif /* CONFIG_BLK_DEV_INTEGRITY */
579
580 #endif /* CONFIG_BLOCK */
581 #endif /* __LINUX_BIO_H */