| /* |
| * 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 |
| |
| * 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 |
| |
| /* Platforms may set this to teach the BIO layer about IOMMU hardware. */ |
| #include <asm/io.h> |
| #ifndef BIO_VMERGE_BOUNDARY |
| #define BIO_VMERGE_BOUNDARY 0 |
| #endif |
| |
| #define BIO_DEBUG |
| |
| #ifdef BIO_DEBUG |
| #define BIO_BUG_ON BUG_ON |
| #else |
| #define BIO_BUG_ON |
| #endif |
| |
| #define BIO_MAX_SECTORS 128 |
| |
| /* |
| * was unsigned short, but we might as well be ready for > 64kB I/O pages |
| */ |
| struct bio_vec { |
| struct page *bv_page; |
| unsigned int bv_len; |
| unsigned int bv_offset; |
| }; |
| |
| /* |
| * weee, c forward decl... |
| */ |
| struct bio; |
| typedef int (bio_end_io_t) (struct bio *, int); |
| typedef void (bio_destructor_t) (struct bio *); |
| |
| /* |
| * main unit of I/O for the block layer and lower layers (ie drivers and |
| * stacking drivers) |
| */ |
| struct bio { |
| sector_t bi_sector; |
| struct bio *bi_next; /* request queue link */ |
| kdev_t bi_dev; /* will be block device */ |
| unsigned long bi_flags; /* status, command, etc */ |
| unsigned long bi_rw; /* bottom bits READ/WRITE, |
| * top bits priority |
| */ |
| |
| unsigned short bi_vcnt; /* how many bio_vec's */ |
| unsigned short bi_idx; /* current index into bvl_vec */ |
| |
| /* Number of segments in this BIO after |
| * physical address coalescing is performed. |
| */ |
| unsigned short bi_phys_segments; |
| |
| /* Number of segments after physical and DMA remapping |
| * hardware coalescing is performed. |
| */ |
| unsigned short bi_hw_segments; |
| |
| unsigned int bi_size; /* residual I/O count */ |
| unsigned int bi_max; /* max bvl_vecs we can hold, |
| used as index into pool */ |
| |
| struct bio_vec *bi_io_vec; /* the actual vec list */ |
| |
| bio_end_io_t *bi_end_io; |
| atomic_t bi_cnt; /* pin count */ |
| |
| void *bi_private; |
| |
| bio_destructor_t *bi_destructor; /* destructor */ |
| }; |
| |
| /* |
| * bio flags |
| */ |
| #define BIO_UPTODATE 0 /* ok after I/O completion */ |
| #define BIO_RW_BLOCK 1 /* RW_AHEAD set, and read/write would block */ |
| #define BIO_EOF 2 /* out-out-bounds error */ |
| #define BIO_SEG_VALID 3 /* nr_hw_seg valid */ |
| #define BIO_CLONED 4 /* doesn't own data */ |
| |
| /* |
| * bio bi_rw flags |
| * |
| * bit 0 -- read (not set) or write (set) |
| * bit 1 -- rw-ahead when set |
| * bit 2 -- barrier |
| */ |
| #define BIO_RW 0 |
| #define BIO_RW_AHEAD 1 |
| #define BIO_RW_BARRIER 2 |
| |
| /* |
| * various member access, note that bio_data should of course not be used |
| * on highmem page vectors |
| */ |
| #define bio_iovec_idx(bio, idx) (&((bio)->bi_io_vec[(idx)])) |
| #define bio_iovec(bio) bio_iovec_idx((bio), (bio)->bi_idx) |
| #define bio_page(bio) bio_iovec((bio))->bv_page |
| #define bio_offset(bio) bio_iovec((bio))->bv_offset |
| #define bio_sectors(bio) ((bio)->bi_size >> 9) |
| #define bio_data(bio) (page_address(bio_page((bio))) + bio_offset((bio))) |
| #define bio_barrier(bio) ((bio)->bi_rw & (1 << BIO_BARRIER)) |
| |
| /* |
| * 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) |
| */ |
| #define __bio_kmap(bio, idx) (kmap(bio_iovec_idx((bio), (idx))->bv_page) + bio_iovec_idx((bio), (idx))->bv_offset) |
| #define bio_kmap(bio) __bio_kmap((bio), (bio)->bi_idx) |
| #define __bio_kunmap(bio, idx) kunmap(bio_iovec_idx((bio), (idx))->bv_page) |
| #define bio_kunmap(bio) __bio_kunmap((bio), (bio)->bi_idx) |
| |
| /* |
| * merge helpers etc |
| */ |
| |
| #define __BVEC_END(bio) bio_iovec_idx((bio), (bio)->bi_vcnt - 1) |
| #define __BVEC_START(bio) bio_iovec_idx((bio), 0) |
| #define BIOVEC_PHYS_MERGEABLE(vec1, vec2) \ |
| ((bvec_to_phys((vec1)) + (vec1)->bv_len) == bvec_to_phys((vec2))) |
| #define BIOVEC_VIRT_MERGEABLE(vec1, vec2) \ |
| ((((bvec_to_phys((vec1)) + (vec1)->bv_len) | bvec_to_phys((vec2))) & (BIO_VMERGE_BOUNDARY - 1)) == 0) |
| #define __BIO_SEG_BOUNDARY(addr1, addr2, mask) \ |
| (((addr1) | (mask)) == (((addr2) - 1) | (mask))) |
| #define BIOVEC_SEG_BOUNDARY(q, b1, b2) \ |
| __BIO_SEG_BOUNDARY(bvec_to_phys((b1)), bvec_to_phys((b2)) + (b2)->bv_len, (q)->seg_boundary_mask) |
| #define BIO_SEG_BOUNDARY(q, b1, b2) \ |
| BIOVEC_SEG_BOUNDARY((q), __BVEC_END((b1)), __BVEC_START((b2))) |
| |
| #define bio_io_error(bio) bio_endio((bio), 0, bio_sectors((bio))) |
| |
| /* |
| * drivers should not use the __ version unless they _really_ want to |
| * run through the entire bio and not just pending pieces |
| */ |
| #define __bio_for_each_segment(bvl, bio, i, start_idx) \ |
| for (bvl = bio_iovec_idx((bio), (start_idx)), i = (start_idx); \ |
| i < (bio)->bi_vcnt; \ |
| bvl++, i++) |
| |
| #define bio_for_each_segment(bvl, bio, i) \ |
| __bio_for_each_segment(bvl, bio, i, (bio)->bi_idx) |
| |
| /* |
| * 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 |
| */ |
| #define bio_get(bio) atomic_inc(&(bio)->bi_cnt) |
| |
| extern struct bio *bio_alloc(int, int); |
| extern void bio_put(struct bio *); |
| |
| extern int bio_endio(struct bio *, int, int); |
| struct request_queue; |
| extern inline int bio_phys_segments(struct request_queue *, struct bio *); |
| extern inline int bio_hw_segments(struct request_queue *, struct bio *); |
| |
| extern inline void __bio_clone(struct bio *, struct bio *); |
| extern struct bio *bio_clone(struct bio *, int); |
| extern struct bio *bio_copy(struct bio *, int, int); |
| |
| extern inline void bio_init(struct bio *); |
| |
| extern int bio_ioctl(kdev_t, unsigned int, unsigned long); |
| |
| #endif /* __LINUX_BIO_H */ |