2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
|
|
|
|
#include <linux/highmem.h>
|
|
|
|
#include <linux/mempool.h>
|
2005-06-27 08:55:12 +00:00
|
|
|
#include <linux/ioprio.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-08-11 20:34:32 +00:00
|
|
|
#ifdef CONFIG_BLOCK
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/io.h>
|
|
|
|
|
|
|
|
#define BIO_DEBUG
|
|
|
|
|
|
|
|
#ifdef BIO_DEBUG
|
|
|
|
#define BIO_BUG_ON BUG_ON
|
|
|
|
#else
|
|
|
|
#define BIO_BUG_ON
|
|
|
|
#endif
|
|
|
|
|
2006-06-25 12:49:32 +00:00
|
|
|
#define BIO_MAX_PAGES 256
|
2005-04-16 22:20:36 +00:00
|
|
|
#define BIO_MAX_SIZE (BIO_MAX_PAGES << PAGE_CACHE_SHIFT)
|
|
|
|
#define BIO_MAX_SECTORS (BIO_MAX_SIZE >> 9)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct bio_set;
|
|
|
|
struct bio;
|
2008-06-30 18:04:41 +00:00
|
|
|
struct bio_integrity_payload;
|
2007-09-27 10:47:43 +00:00
|
|
|
typedef void (bio_end_io_t) (struct bio *, int);
|
2005-04-16 22:20:36 +00:00
|
|
|
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 {
|
2006-10-04 11:37:45 +00:00
|
|
|
sector_t bi_sector; /* device address in 512 byte
|
|
|
|
sectors */
|
2005-04-16 22:20:36 +00:00
|
|
|
struct bio *bi_next; /* request queue link */
|
|
|
|
struct block_device *bi_bdev;
|
|
|
|
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.
|
|
|
|
*/
|
2008-08-15 08:56:11 +00:00
|
|
|
unsigned int bi_phys_segments;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
unsigned int bi_size; /* residual I/O count */
|
|
|
|
|
2008-10-13 12:19:05 +00:00
|
|
|
/*
|
|
|
|
* To keep track of the max segment size, we account for the
|
|
|
|
* sizes of the first and last mergeable segments in this bio.
|
|
|
|
*/
|
|
|
|
unsigned int bi_seg_front_size;
|
|
|
|
unsigned int bi_seg_back_size;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int bi_max_vecs; /* max bvl_vecs we can hold */
|
|
|
|
|
2008-09-13 18:26:01 +00:00
|
|
|
unsigned int bi_comp_cpu; /* completion CPU */
|
|
|
|
|
2008-12-03 11:41:40 +00:00
|
|
|
atomic_t bi_cnt; /* pin count */
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct bio_vec *bi_io_vec; /* the actual vec list */
|
|
|
|
|
|
|
|
bio_end_io_t *bi_end_io;
|
|
|
|
|
|
|
|
void *bi_private;
|
2008-06-30 18:04:41 +00:00
|
|
|
#if defined(CONFIG_BLK_DEV_INTEGRITY)
|
|
|
|
struct bio_integrity_payload *bi_integrity; /* data integrity */
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
bio_destructor_t *bi_destructor; /* destructor */
|
2008-12-23 11:42:54 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We can inline a number of vecs at the end of the bio, to avoid
|
|
|
|
* double allocations for a small number of bio_vecs. This member
|
|
|
|
* MUST obviously be kept at the very end of the bio.
|
|
|
|
*/
|
|
|
|
struct bio_vec bi_inline_vecs[0];
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 */
|
2008-08-15 08:20:02 +00:00
|
|
|
#define BIO_SEG_VALID 3 /* bi_phys_segments valid */
|
2005-04-16 22:20:36 +00:00
|
|
|
#define BIO_CLONED 4 /* doesn't own data */
|
|
|
|
#define BIO_BOUNCED 5 /* bio is a bounce bio */
|
|
|
|
#define BIO_USER_MAPPED 6 /* contains user pages */
|
|
|
|
#define BIO_EOPNOTSUPP 7 /* not supported */
|
2008-09-13 18:26:01 +00:00
|
|
|
#define BIO_CPU_AFFINE 8 /* complete bio on same CPU as submitted */
|
2008-09-02 07:20:19 +00:00
|
|
|
#define BIO_NULL_MAPPED 9 /* contains invalid user pages */
|
2008-10-01 07:38:37 +00:00
|
|
|
#define BIO_FS_INTEGRITY 10 /* fs owns integrity data, not block layer */
|
block: Supress Buffer I/O errors when SCSI REQ_QUIET flag set
Allow the scsi request REQ_QUIET flag to be propagated to the buffer
file system layer. The basic ideas is to pass the flag from the scsi
request to the bio (block IO) and then to the buffer layer. The buffer
layer can then suppress needless printks.
This patch declutters the kernel log by removed the 40-50 (per lun)
buffer io error messages seen during a boot in my multipath setup . It
is a good chance any real errors will be missed in the "noise" it the
logs without this patch.
During boot I see blocks of messages like
"
__ratelimit: 211 callbacks suppressed
Buffer I/O error on device sdm, logical block 5242879
Buffer I/O error on device sdm, logical block 5242879
Buffer I/O error on device sdm, logical block 5242847
Buffer I/O error on device sdm, logical block 1
Buffer I/O error on device sdm, logical block 5242878
Buffer I/O error on device sdm, logical block 5242879
Buffer I/O error on device sdm, logical block 5242879
Buffer I/O error on device sdm, logical block 5242879
Buffer I/O error on device sdm, logical block 5242879
Buffer I/O error on device sdm, logical block 5242872
"
in my logs.
My disk environment is multipath fiber channel using the SCSI_DH_RDAC
code and multipathd. This topology includes an "active" and "ghost"
path for each lun. IO's to the "ghost" path will never complete and the
SCSI layer, via the scsi device handler rdac code, quick returns the IOs
to theses paths and sets the REQ_QUIET scsi flag to suppress the scsi
layer messages.
I am wanting to extend the QUIET behavior to include the buffer file
system layer to deal with these errors as well. I have been running this
patch for a while now on several boxes without issue. A few runs of
bonnie++ show no noticeable difference in performance in my setup.
Thanks for John Stultz for the quiet_error finalization.
Submitted-by: Keith Mannthey <kmannth@us.ibm.com>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
2008-11-25 09:24:35 +00:00
|
|
|
#define BIO_QUIET 11 /* Make BIO Quiet */
|
2005-04-16 22:20:36 +00:00
|
|
|
#define bio_flagged(bio, flag) ((bio)->bi_flags & (1 << (flag)))
|
|
|
|
|
|
|
|
/*
|
|
|
|
* top 4 bits of bio flags indicate the pool this bio came from
|
|
|
|
*/
|
|
|
|
#define BIO_POOL_BITS (4)
|
|
|
|
#define BIO_POOL_OFFSET (BITS_PER_LONG - BIO_POOL_BITS)
|
|
|
|
#define BIO_POOL_MASK (1UL << BIO_POOL_OFFSET)
|
|
|
|
#define BIO_POOL_IDX(bio) ((bio)->bi_flags >> BIO_POOL_OFFSET)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* bio bi_rw flags
|
|
|
|
*
|
2008-10-09 07:01:10 +00:00
|
|
|
* bit 0 -- data direction
|
|
|
|
* If not set, bio is a read from device. If set, it's a write to device.
|
2005-04-16 22:20:36 +00:00
|
|
|
* bit 1 -- rw-ahead when set
|
|
|
|
* bit 2 -- barrier
|
2008-10-09 07:01:10 +00:00
|
|
|
* Insert a serialization point in the IO queue, forcing previously
|
2009-01-05 09:18:53 +00:00
|
|
|
* submitted IO to be completed before this one is issued.
|
2008-08-19 23:45:30 +00:00
|
|
|
* bit 3 -- synchronous I/O hint: the block layer will unplug immediately
|
2008-10-09 07:01:10 +00:00
|
|
|
* Note that this does NOT indicate that the IO itself is sync, just
|
|
|
|
* that the block layer will not postpone issue of this IO by plugging.
|
2008-08-19 23:45:30 +00:00
|
|
|
* bit 4 -- metadata request
|
2008-10-09 07:01:10 +00:00
|
|
|
* Used for tracing to differentiate metadata and data IO. May also
|
|
|
|
* get some preferential treatment in the IO scheduler
|
2008-08-19 23:45:30 +00:00
|
|
|
* bit 5 -- discard sectors
|
2008-10-09 07:01:10 +00:00
|
|
|
* Informs the lower level device that this range of sectors is no longer
|
|
|
|
* used by the file system and may thus be freed by the device. Used
|
|
|
|
* for flash based storage.
|
2008-08-19 23:45:30 +00:00
|
|
|
* bit 6 -- fail fast device errors
|
|
|
|
* bit 7 -- fail fast transport errors
|
|
|
|
* bit 8 -- fail fast driver errors
|
|
|
|
* Don't want driver retries for any fast fail whatever the reason.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-08-09 15:22:17 +00:00
|
|
|
#define BIO_RW 0 /* Must match RW in req flags (blkdev.h) */
|
|
|
|
#define BIO_RW_AHEAD 1 /* Must match FAILFAST in req flags */
|
2005-04-16 22:20:36 +00:00
|
|
|
#define BIO_RW_BARRIER 2
|
2009-01-06 08:16:05 +00:00
|
|
|
#define BIO_RW_SYNCIO 3
|
|
|
|
#define BIO_RW_UNPLUG 4
|
|
|
|
#define BIO_RW_META 5
|
|
|
|
#define BIO_RW_DISCARD 6
|
|
|
|
#define BIO_RW_FAILFAST_DEV 7
|
|
|
|
#define BIO_RW_FAILFAST_TRANSPORT 8
|
|
|
|
#define BIO_RW_FAILFAST_DRIVER 9
|
|
|
|
|
|
|
|
#define BIO_RW_SYNC (BIO_RW_SYNCIO | BIO_RW_UNPLUG)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-01-06 08:21:49 +00:00
|
|
|
#define bio_rw_flagged(bio, flag) ((bio)->bi_rw & (1 << (flag)))
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Old defines, these should eventually be replaced by direct usage of
|
|
|
|
* bio_rw_flagged()
|
|
|
|
*/
|
|
|
|
#define bio_barrier(bio) bio_rw_flagged(bio, BIO_RW_BARRIER)
|
|
|
|
#define bio_sync(bio) bio_rw_flagged(bio, BIO_RW_SYNCIO)
|
|
|
|
#define bio_unplug(bio) bio_rw_flagged(bio, BIO_RW_UNPLUG)
|
|
|
|
#define bio_failfast_dev(bio) bio_rw_flagged(bio, BIO_RW_FAILFAST_DEV)
|
|
|
|
#define bio_failfast_transport(bio) \
|
|
|
|
bio_rw_flagged(bio, BIO_RW_FAILFAST_TRANSPORT)
|
|
|
|
#define bio_failfast_driver(bio) \
|
|
|
|
bio_rw_flagged(bio, BIO_RW_FAILFAST_DRIVER)
|
|
|
|
#define bio_rw_ahead(bio) bio_rw_flagged(bio, BIO_RW_AHEAD)
|
|
|
|
#define bio_rw_meta(bio) bio_rw_flagged(bio, BIO_RW_META)
|
|
|
|
#define bio_discard(bio) bio_rw_flagged(bio, BIO_RW_DISCARD)
|
|
|
|
|
2005-06-27 08:55:12 +00:00
|
|
|
/*
|
|
|
|
* upper 16 bits of bi_rw define the io priority of this bio
|
|
|
|
*/
|
|
|
|
#define BIO_PRIO_SHIFT (8 * sizeof(unsigned long) - IOPRIO_BITS)
|
|
|
|
#define bio_prio(bio) ((bio)->bi_rw >> BIO_PRIO_SHIFT)
|
|
|
|
#define bio_prio_valid(bio) ioprio_valid(bio_prio(bio))
|
|
|
|
|
|
|
|
#define bio_set_prio(bio, prio) do { \
|
|
|
|
WARN_ON(prio >= (1 << IOPRIO_BITS)); \
|
|
|
|
(bio)->bi_rw &= ((1UL << BIO_PRIO_SHIFT) - 1); \
|
|
|
|
(bio)->bi_rw |= ((unsigned long) (prio) << BIO_PRIO_SHIFT); \
|
|
|
|
} while (0)
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* 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_segments(bio) ((bio)->bi_vcnt - (bio)->bi_idx)
|
|
|
|
#define bio_sectors(bio) ((bio)->bi_size >> 9)
|
2008-08-09 15:42:20 +00:00
|
|
|
#define bio_empty_barrier(bio) (bio_barrier(bio) && !bio_has_data(bio) && !bio_discard(bio))
|
2007-09-27 11:01:25 +00:00
|
|
|
|
|
|
|
static inline unsigned int bio_cur_sectors(struct bio *bio)
|
|
|
|
{
|
|
|
|
if (bio->bi_vcnt)
|
|
|
|
return bio_iovec(bio)->bv_len >> 9;
|
2008-08-05 17:01:53 +00:00
|
|
|
else /* dataless requests such as discard */
|
|
|
|
return bio->bi_size >> 9;
|
2007-09-27 11:01:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void *bio_data(struct bio *bio)
|
|
|
|
{
|
|
|
|
if (bio->bi_vcnt)
|
|
|
|
return page_address(bio_page(bio)) + bio_offset(bio);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-23 11:42:54 +00:00
|
|
|
static inline int bio_has_allocated_vec(struct bio *bio)
|
|
|
|
{
|
|
|
|
return bio->bi_io_vec && bio->bi_io_vec != bio->bi_inline_vecs;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* 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_atomic(bio, idx, kmtype) \
|
|
|
|
(kmap_atomic(bio_iovec_idx((bio), (idx))->bv_page, kmtype) + \
|
|
|
|
bio_iovec_idx((bio), (idx))->bv_offset)
|
|
|
|
|
|
|
|
#define __bio_kunmap_atomic(addr, kmtype) kunmap_atomic(addr, kmtype)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* merge helpers etc
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define __BVEC_END(bio) bio_iovec_idx((bio), (bio)->bi_vcnt - 1)
|
|
|
|
#define __BVEC_START(bio) bio_iovec_idx((bio), (bio)->bi_idx)
|
|
|
|
|
2008-10-29 13:10:51 +00:00
|
|
|
/* Default implementation of BIOVEC_PHYS_MERGEABLE */
|
|
|
|
#define __BIOVEC_PHYS_MERGEABLE(vec1, vec2) \
|
|
|
|
((bvec_to_phys((vec1)) + (vec1)->bv_len) == bvec_to_phys((vec2)))
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* allow arch override, for eg virtualized architectures (put in asm/io.h)
|
|
|
|
*/
|
|
|
|
#ifndef BIOVEC_PHYS_MERGEABLE
|
|
|
|
#define BIOVEC_PHYS_MERGEABLE(vec1, vec2) \
|
2008-10-29 13:10:51 +00:00
|
|
|
__BIOVEC_PHYS_MERGEABLE(vec1, vec2)
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#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)))
|
|
|
|
|
2007-09-27 10:47:43 +00:00
|
|
|
#define bio_io_error(bio) bio_endio((bio), -EIO)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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)
|
|
|
|
|
2008-06-30 18:04:41 +00:00
|
|
|
#if defined(CONFIG_BLK_DEV_INTEGRITY)
|
|
|
|
/*
|
|
|
|
* bio integrity payload
|
|
|
|
*/
|
|
|
|
struct bio_integrity_payload {
|
|
|
|
struct bio *bip_bio; /* parent bio */
|
|
|
|
struct bio_vec *bip_vec; /* integrity data vector */
|
|
|
|
|
|
|
|
sector_t bip_sector; /* virtual start sector */
|
|
|
|
|
|
|
|
void *bip_buf; /* generated integrity data */
|
|
|
|
bio_end_io_t *bip_end_io; /* saved I/O completion fn */
|
|
|
|
|
|
|
|
unsigned int bip_size;
|
|
|
|
|
|
|
|
unsigned short bip_pool; /* pool the ivec came from */
|
|
|
|
unsigned short bip_vcnt; /* # of integrity bio_vecs */
|
|
|
|
unsigned short bip_idx; /* current bip_vec index */
|
|
|
|
|
|
|
|
struct work_struct bip_work; /* I/O completion */
|
|
|
|
};
|
|
|
|
#endif /* CONFIG_BLK_DEV_INTEGRITY */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* A bio_pair is used when we need to split a bio.
|
|
|
|
* This can only happen for a bio that refers to just one
|
|
|
|
* page of data, and in the unusual situation when the
|
|
|
|
* page crosses a chunk/device boundary
|
|
|
|
*
|
|
|
|
* The address of the master bio is stored in bio1.bi_private
|
|
|
|
* The address of the pool the pair was allocated from is stored
|
|
|
|
* in bio2.bi_private
|
|
|
|
*/
|
|
|
|
struct bio_pair {
|
2008-06-30 18:04:41 +00:00
|
|
|
struct bio bio1, bio2;
|
|
|
|
struct bio_vec bv1, bv2;
|
|
|
|
#if defined(CONFIG_BLK_DEV_INTEGRITY)
|
|
|
|
struct bio_integrity_payload bip1, bip2;
|
|
|
|
struct bio_vec iv1, iv2;
|
|
|
|
#endif
|
|
|
|
atomic_t cnt;
|
|
|
|
int error;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
2008-10-09 06:57:05 +00:00
|
|
|
extern struct bio_pair *bio_split(struct bio *bi, int first_sectors);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void bio_pair_release(struct bio_pair *dbio);
|
|
|
|
|
2008-12-10 14:35:05 +00:00
|
|
|
extern struct bio_set *bioset_create(unsigned int, unsigned int);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void bioset_free(struct bio_set *);
|
|
|
|
|
2005-10-07 06:46:04 +00:00
|
|
|
extern struct bio *bio_alloc(gfp_t, int);
|
2008-09-11 11:17:37 +00:00
|
|
|
extern struct bio *bio_kmalloc(gfp_t, int);
|
2005-10-07 06:46:04 +00:00
|
|
|
extern struct bio *bio_alloc_bioset(gfp_t, int, struct bio_set *);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void bio_put(struct bio *);
|
2005-09-06 22:16:42 +00:00
|
|
|
extern void bio_free(struct bio *, struct bio_set *);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-09-27 10:47:43 +00:00
|
|
|
extern void bio_endio(struct bio *, int);
|
2005-04-16 22:20:36 +00:00
|
|
|
struct request_queue;
|
|
|
|
extern int bio_phys_segments(struct request_queue *, struct bio *);
|
|
|
|
|
|
|
|
extern void __bio_clone(struct bio *, struct bio *);
|
2005-10-07 06:46:04 +00:00
|
|
|
extern struct bio *bio_clone(struct bio *, gfp_t);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
extern void bio_init(struct bio *);
|
|
|
|
|
|
|
|
extern int bio_add_page(struct bio *, struct page *, unsigned int,unsigned int);
|
2005-11-11 11:30:27 +00:00
|
|
|
extern int bio_add_pc_page(struct request_queue *, struct bio *, struct page *,
|
|
|
|
unsigned int, unsigned int);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern int bio_get_nr_vecs(struct block_device *);
|
2008-10-02 02:42:53 +00:00
|
|
|
extern sector_t bio_sector_offset(struct bio *, unsigned short, unsigned int);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern struct bio *bio_map_user(struct request_queue *, struct block_device *,
|
2008-08-28 07:17:05 +00:00
|
|
|
unsigned long, unsigned int, int, gfp_t);
|
2005-06-20 12:06:52 +00:00
|
|
|
struct sg_iovec;
|
2008-08-28 07:17:06 +00:00
|
|
|
struct rq_map_data;
|
2005-06-20 12:06:52 +00:00
|
|
|
extern struct bio *bio_map_user_iov(struct request_queue *,
|
|
|
|
struct block_device *,
|
2008-08-28 07:17:05 +00:00
|
|
|
struct sg_iovec *, int, int, gfp_t);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void bio_unmap_user(struct bio *);
|
2005-06-20 12:04:44 +00:00
|
|
|
extern struct bio *bio_map_kern(struct request_queue *, void *, unsigned int,
|
2005-10-21 07:20:48 +00:00
|
|
|
gfp_t);
|
2008-04-25 10:47:50 +00:00
|
|
|
extern struct bio *bio_copy_kern(struct request_queue *, void *, unsigned int,
|
|
|
|
gfp_t, int);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void bio_set_pages_dirty(struct bio *bio);
|
|
|
|
extern void bio_check_pages_dirty(struct bio *bio);
|
2008-08-28 07:17:06 +00:00
|
|
|
extern struct bio *bio_copy_user(struct request_queue *, struct rq_map_data *,
|
|
|
|
unsigned long, unsigned int, int, gfp_t);
|
|
|
|
extern struct bio *bio_copy_user_iov(struct request_queue *,
|
|
|
|
struct rq_map_data *, struct sg_iovec *,
|
2008-08-28 07:17:05 +00:00
|
|
|
int, int, gfp_t);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern int bio_uncopy_user(struct bio *);
|
|
|
|
void zero_fill_bio(struct bio *bio);
|
2008-06-17 16:59:56 +00:00
|
|
|
extern struct bio_vec *bvec_alloc_bs(gfp_t, int, unsigned long *, struct bio_set *);
|
2008-12-10 14:35:05 +00:00
|
|
|
extern void bvec_free_bs(struct bio_set *, struct bio_vec *, unsigned int);
|
2008-06-30 18:04:41 +00:00
|
|
|
extern unsigned int bvec_nr_vecs(unsigned short idx);
|
2008-06-17 16:59:56 +00:00
|
|
|
|
2008-09-13 18:26:01 +00:00
|
|
|
/*
|
|
|
|
* Allow queuer to specify a completion CPU for this bio
|
|
|
|
*/
|
|
|
|
static inline void bio_set_completion_cpu(struct bio *bio, unsigned int cpu)
|
|
|
|
{
|
|
|
|
bio->bi_comp_cpu = cpu;
|
|
|
|
}
|
|
|
|
|
2008-06-17 16:59:56 +00:00
|
|
|
/*
|
|
|
|
* bio_set is used to allow other portions of the IO system to
|
|
|
|
* allocate their own private memory pools for bio and iovec structures.
|
|
|
|
* These memory pools in turn all allocate from the bio_slab
|
|
|
|
* and the bvec_slabs[].
|
|
|
|
*/
|
|
|
|
#define BIO_POOL_SIZE 2
|
|
|
|
#define BIOVEC_NR_POOLS 6
|
2008-12-11 10:53:43 +00:00
|
|
|
#define BIOVEC_MAX_IDX (BIOVEC_NR_POOLS - 1)
|
2008-06-17 16:59:56 +00:00
|
|
|
|
|
|
|
struct bio_set {
|
2008-10-22 18:32:58 +00:00
|
|
|
struct kmem_cache *bio_slab;
|
2008-12-10 14:35:05 +00:00
|
|
|
unsigned int front_pad;
|
|
|
|
|
2008-06-17 16:59:56 +00:00
|
|
|
mempool_t *bio_pool;
|
2008-06-30 18:04:41 +00:00
|
|
|
#if defined(CONFIG_BLK_DEV_INTEGRITY)
|
|
|
|
mempool_t *bio_integrity_pool;
|
|
|
|
#endif
|
2008-12-11 10:53:43 +00:00
|
|
|
mempool_t *bvec_pool;
|
2008-06-17 16:59:56 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct biovec_slab {
|
|
|
|
int nr_vecs;
|
|
|
|
char *name;
|
|
|
|
struct kmem_cache *slab;
|
|
|
|
};
|
|
|
|
|
|
|
|
extern struct bio_set *fs_bio_set;
|
2008-12-10 14:35:05 +00:00
|
|
|
extern struct biovec_slab bvec_slabs[BIOVEC_NR_POOLS] __read_mostly;
|
2008-06-17 16:59:56 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* a small number of entries is fine, not going to be performance critical.
|
|
|
|
* basically we just need to survive
|
|
|
|
*/
|
|
|
|
#define BIO_SPLIT_ENTRIES 2
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_HIGHMEM
|
|
|
|
/*
|
2009-02-02 11:41:07 +00:00
|
|
|
* remember never ever reenable interrupts between a bvec_kmap_irq and
|
|
|
|
* bvec_kunmap_irq!
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* This function MUST be inlined - it plays with the CPU interrupt flags.
|
|
|
|
*/
|
2009-02-02 11:41:07 +00:00
|
|
|
static __always_inline char *bvec_kmap_irq(struct bio_vec *bvec,
|
|
|
|
unsigned long *flags)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
unsigned long addr;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* might not be a highmem page, but the preempt/irq count
|
|
|
|
* balancing is a lot nicer this way
|
|
|
|
*/
|
|
|
|
local_irq_save(*flags);
|
|
|
|
addr = (unsigned long) kmap_atomic(bvec->bv_page, KM_BIO_SRC_IRQ);
|
|
|
|
|
|
|
|
BUG_ON(addr & ~PAGE_MASK);
|
|
|
|
|
|
|
|
return (char *) addr + bvec->bv_offset;
|
|
|
|
}
|
|
|
|
|
2009-02-02 11:41:07 +00:00
|
|
|
static __always_inline void bvec_kunmap_irq(char *buffer,
|
|
|
|
unsigned long *flags)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
unsigned long ptr = (unsigned long) buffer & PAGE_MASK;
|
|
|
|
|
|
|
|
kunmap_atomic((void *) ptr, KM_BIO_SRC_IRQ);
|
|
|
|
local_irq_restore(*flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
#define bvec_kmap_irq(bvec, flags) (page_address((bvec)->bv_page) + (bvec)->bv_offset)
|
|
|
|
#define bvec_kunmap_irq(buf, flags) do { *(flags) = 0; } while (0)
|
|
|
|
#endif
|
|
|
|
|
2005-09-10 07:27:18 +00:00
|
|
|
static inline char *__bio_kmap_irq(struct bio *bio, unsigned short idx,
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long *flags)
|
|
|
|
{
|
|
|
|
return bvec_kmap_irq(bio_iovec_idx(bio, idx), flags);
|
|
|
|
}
|
|
|
|
#define __bio_kunmap_irq(buf, flags) bvec_kunmap_irq(buf, flags)
|
|
|
|
|
|
|
|
#define bio_kmap_irq(bio, flags) \
|
|
|
|
__bio_kmap_irq((bio), (bio)->bi_idx, (flags))
|
|
|
|
#define bio_kunmap_irq(buf,flags) __bio_kunmap_irq(buf, flags)
|
|
|
|
|
2008-08-08 09:17:12 +00:00
|
|
|
/*
|
|
|
|
* Check whether this bio carries any data or not. A NULL bio is allowed.
|
|
|
|
*/
|
|
|
|
static inline int bio_has_data(struct bio *bio)
|
|
|
|
{
|
|
|
|
return bio && bio->bi_io_vec != NULL;
|
|
|
|
}
|
|
|
|
|
2008-06-30 18:04:41 +00:00
|
|
|
#if defined(CONFIG_BLK_DEV_INTEGRITY)
|
|
|
|
|
|
|
|
#define bip_vec_idx(bip, idx) (&(bip->bip_vec[(idx)]))
|
|
|
|
#define bip_vec(bip) bip_vec_idx(bip, 0)
|
|
|
|
|
|
|
|
#define __bip_for_each_vec(bvl, bip, i, start_idx) \
|
|
|
|
for (bvl = bip_vec_idx((bip), (start_idx)), i = (start_idx); \
|
|
|
|
i < (bip)->bip_vcnt; \
|
|
|
|
bvl++, i++)
|
|
|
|
|
|
|
|
#define bip_for_each_vec(bvl, bip, i) \
|
|
|
|
__bip_for_each_vec(bvl, bip, i, (bip)->bip_idx)
|
|
|
|
|
2008-10-02 10:46:53 +00:00
|
|
|
#define bio_integrity(bio) (bio->bi_integrity != NULL)
|
2008-06-30 18:04:41 +00:00
|
|
|
|
|
|
|
extern struct bio_integrity_payload *bio_integrity_alloc_bioset(struct bio *, gfp_t, unsigned int, struct bio_set *);
|
|
|
|
extern struct bio_integrity_payload *bio_integrity_alloc(struct bio *, gfp_t, unsigned int);
|
|
|
|
extern void bio_integrity_free(struct bio *, struct bio_set *);
|
|
|
|
extern int bio_integrity_add_page(struct bio *, struct page *, unsigned int, unsigned int);
|
|
|
|
extern int bio_integrity_enabled(struct bio *bio);
|
|
|
|
extern int bio_integrity_set_tag(struct bio *, void *, unsigned int);
|
|
|
|
extern int bio_integrity_get_tag(struct bio *, void *, unsigned int);
|
|
|
|
extern int bio_integrity_prep(struct bio *);
|
|
|
|
extern void bio_integrity_endio(struct bio *, int);
|
|
|
|
extern void bio_integrity_advance(struct bio *, unsigned int);
|
|
|
|
extern void bio_integrity_trim(struct bio *, unsigned int, unsigned int);
|
|
|
|
extern void bio_integrity_split(struct bio *, struct bio_pair *, int);
|
|
|
|
extern int bio_integrity_clone(struct bio *, struct bio *, struct bio_set *);
|
|
|
|
extern int bioset_integrity_create(struct bio_set *, int);
|
|
|
|
extern void bioset_integrity_free(struct bio_set *);
|
|
|
|
extern void bio_integrity_init_slab(void);
|
|
|
|
|
|
|
|
#else /* CONFIG_BLK_DEV_INTEGRITY */
|
|
|
|
|
|
|
|
#define bio_integrity(a) (0)
|
|
|
|
#define bioset_integrity_create(a, b) (0)
|
|
|
|
#define bio_integrity_prep(a) (0)
|
|
|
|
#define bio_integrity_enabled(a) (0)
|
|
|
|
#define bio_integrity_clone(a, b, c) (0)
|
|
|
|
#define bioset_integrity_free(a) do { } while (0)
|
|
|
|
#define bio_integrity_free(a, b) do { } while (0)
|
|
|
|
#define bio_integrity_endio(a, b) do { } while (0)
|
|
|
|
#define bio_integrity_advance(a, b) do { } while (0)
|
|
|
|
#define bio_integrity_trim(a, b, c) do { } while (0)
|
|
|
|
#define bio_integrity_split(a, b, c) do { } while (0)
|
|
|
|
#define bio_integrity_set_tag(a, b, c) do { } while (0)
|
|
|
|
#define bio_integrity_get_tag(a, b, c) do { } while (0)
|
|
|
|
#define bio_integrity_init_slab(a) do { } while (0)
|
|
|
|
|
|
|
|
#endif /* CONFIG_BLK_DEV_INTEGRITY */
|
|
|
|
|
2007-08-11 20:34:32 +00:00
|
|
|
#endif /* CONFIG_BLOCK */
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* __LINUX_BIO_H */
|