redonkable
/
alistair23-linux
1
0
Fork 0
Code Releases Activity

block: Replace bi_integrity with bi_special 

For commands like REQ_COPY we need a way to pass extra information along
with each bio. Like integrity metadata this information must be
available at the bottom of the stack so bi_private does not suffice.

Rename the existing bi_integrity field to bi_special and make it a union
so we can have different bio extensions for each class of command.

We previously used bi_integrity != NULL as a way to identify whether a
bio had integrity metadata or not. Introduce a REQ_INTEGRITY to be the
indicator now that bi_special can contain different things.

In addition, bio_integrity(bio) will now return a pointer to the
integrity payload (when applicable).

Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Sagi Grimberg <sagig@mellanox.com>
Signed-off-by: Jens Axboe <axboe@fb.com>
hifive-unleashed-5.1
Martin K. Petersen 2014-09-26 19:19:56 -04:00 committed by Jens Axboe
parent e7258c1a26
commit 180b2f95dd
6 changed files with 36 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Documentation/block/data-integrity.txt
View File

@ -129,11 +129,11 @@ interface for this is being worked on.
4.1 BIO 4.1 BIO
The data integrity patches add a new field to struct bio when The data integrity patches add a new field to struct bio when
CONFIG_BLK_DEV_INTEGRITY is enabled. bio->bi_integrity is a pointer CONFIG_BLK_DEV_INTEGRITY is enabled. bio_integrity(bio) returns a
to a struct bip which contains the bio integrity payload. Essentially pointer to a struct bip which contains the bio integrity payload.
a bip is a trimmed down struct bio which holds a bio_vec containing Essentially a bip is a trimmed down struct bio which holds a bio_vec
the integrity metadata and the required housekeeping information (bvec containing the integrity metadata and the required housekeeping
pool, vector count, etc.) information (bvec pool, vector count, etc.)
A kernel subsystem can enable data integrity protection on a bio by A kernel subsystem can enable data integrity protection on a bio by
calling bio_integrity_alloc(bio). This will allocate and attach the calling bio_integrity_alloc(bio). This will allocate and attach the

19
block/bio-integrity.c
View File

@ -79,6 +79,7 @@ struct bio_integrity_payload *bio_integrity_alloc(struct bio *bio,
bip->bip_slab = idx; bip->bip_slab = idx;
bip->bip_bio = bio; bip->bip_bio = bio;
bio->bi_integrity = bip; bio->bi_integrity = bip;
bio->bi_rw |= REQ_INTEGRITY;
return bip; return bip;
err: err:
@ -96,7 +97,7 @@ EXPORT_SYMBOL(bio_integrity_alloc);
*/ */
void bio_integrity_free(struct bio *bio) void bio_integrity_free(struct bio *bio)
{ {
struct bio_integrity_payload *bip = bio->bi_integrity; struct bio_integrity_payload *bip = bio_integrity(bio);
struct bio_set *bs = bio->bi_pool; struct bio_set *bs = bio->bi_pool;
if (bip->bip_owns_buf) if (bip->bip_owns_buf)
@ -128,7 +129,7 @@ EXPORT_SYMBOL(bio_integrity_free);
int bio_integrity_add_page(struct bio *bio, struct page *page, int bio_integrity_add_page(struct bio *bio, struct page *page,
unsigned int len, unsigned int offset) unsigned int len, unsigned int offset)
{ {
struct bio_integrity_payload *bip = bio->bi_integrity; struct bio_integrity_payload *bip = bio_integrity(bio);
struct bio_vec *iv; struct bio_vec *iv;
if (bip->bip_vcnt >= bip->bip_max_vcnt) { if (bip->bip_vcnt >= bip->bip_max_vcnt) {
@ -229,7 +230,7 @@ EXPORT_SYMBOL(bio_integrity_tag_size);
static int bio_integrity_tag(struct bio *bio, void *tag_buf, unsigned int len, static int bio_integrity_tag(struct bio *bio, void *tag_buf, unsigned int len,
int set) int set)
{ {
struct bio_integrity_payload *bip = bio->bi_integrity; struct bio_integrity_payload *bip = bio_integrity(bio);
struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev); struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);
unsigned int nr_sectors; unsigned int nr_sectors;
@ -304,12 +305,12 @@ static int bio_integrity_generate_verify(struct bio *bio, int operate)
struct bio_vec *bv; struct bio_vec *bv;
sector_t sector; sector_t sector;
unsigned int sectors, ret = 0, i; unsigned int sectors, ret = 0, i;
void *prot_buf = bio->bi_integrity->bip_buf; void *prot_buf = bio_integrity(bio)->bip_buf;
if (operate) if (operate)
sector = bio->bi_iter.bi_sector; sector = bio->bi_iter.bi_sector;
else else
sector = bio->bi_integrity->bip_iter.bi_sector; sector = bio_integrity(bio)->bip_iter.bi_sector;
bix.disk_name = bio->bi_bdev->bd_disk->disk_name; bix.disk_name = bio->bi_bdev->bd_disk->disk_name;
bix.sector_size = bi->sector_size; bix.sector_size = bi->sector_size;
@ -505,7 +506,7 @@ static void bio_integrity_verify_fn(struct work_struct *work)
*/ */
void bio_integrity_endio(struct bio *bio, int error) void bio_integrity_endio(struct bio *bio, int error)
{ {
struct bio_integrity_payload *bip = bio->bi_integrity; struct bio_integrity_payload *bip = bio_integrity(bio);
BUG_ON(bip->bip_bio != bio); BUG_ON(bip->bip_bio != bio);
@ -536,7 +537,7 @@ EXPORT_SYMBOL(bio_integrity_endio);
*/ */
void bio_integrity_advance(struct bio *bio, unsigned int bytes_done) void bio_integrity_advance(struct bio *bio, unsigned int bytes_done)
{ {
struct bio_integrity_payload *bip = bio->bi_integrity; struct bio_integrity_payload *bip = bio_integrity(bio);
struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev); struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);
unsigned bytes = bio_integrity_bytes(bi, bytes_done >> 9); unsigned bytes = bio_integrity_bytes(bi, bytes_done >> 9);
@ -558,7 +559,7 @@ EXPORT_SYMBOL(bio_integrity_advance);
void bio_integrity_trim(struct bio *bio, unsigned int offset, void bio_integrity_trim(struct bio *bio, unsigned int offset,
unsigned int sectors) unsigned int sectors)
{ {
struct bio_integrity_payload *bip = bio->bi_integrity; struct bio_integrity_payload *bip = bio_integrity(bio);
struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev); struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);
bio_integrity_advance(bio, offset << 9); bio_integrity_advance(bio, offset << 9);
@ -577,7 +578,7 @@ EXPORT_SYMBOL(bio_integrity_trim);
int bio_integrity_clone(struct bio *bio, struct bio *bio_src, int bio_integrity_clone(struct bio *bio, struct bio *bio_src,
gfp_t gfp_mask) gfp_t gfp_mask)
{ {
struct bio_integrity_payload *bip_src = bio_src->bi_integrity; struct bio_integrity_payload *bip_src = bio_integrity(bio_src);
struct bio_integrity_payload *bip; struct bio_integrity_payload *bip;
BUG_ON(bip_src == NULL); BUG_ON(bip_src == NULL);

8
drivers/scsi/sd_dif.c
View File

@ -383,9 +383,9 @@ void sd_dif_prepare(struct request *rq, sector_t hw_sector,
if (bio_flagged(bio, BIO_MAPPED_INTEGRITY)) if (bio_flagged(bio, BIO_MAPPED_INTEGRITY))
break; break;
virt = bio->bi_integrity->bip_iter.bi_sector & 0xffffffff; virt = bio_integrity(bio)->bip_iter.bi_sector & 0xffffffff;
bip_for_each_vec(iv, bio->bi_integrity, iter) { bip_for_each_vec(iv, bio_integrity(bio), iter) {
sdt = kmap_atomic(iv.bv_page) sdt = kmap_atomic(iv.bv_page)
+ iv.bv_offset; + iv.bv_offset;
@ -434,9 +434,9 @@ void sd_dif_complete(struct scsi_cmnd *scmd, unsigned int good_bytes)
struct bio_vec iv; struct bio_vec iv;
struct bvec_iter iter; struct bvec_iter iter;
virt = bio->bi_integrity->bip_iter.bi_sector & 0xffffffff; virt = bio_integrity(bio)->bip_iter.bi_sector & 0xffffffff;
bip_for_each_vec(iv, bio->bi_integrity, iter) { bip_for_each_vec(iv, bio_integrity(bio), iter) {
sdt = kmap_atomic(iv.bv_page) sdt = kmap_atomic(iv.bv_page)
+ iv.bv_offset; + iv.bv_offset;

11
include/linux/bio.h
View File

@ -293,6 +293,15 @@ static inline unsigned bio_segments(struct bio *bio)
#define bio_get(bio) atomic_inc(&(bio)->bi_cnt) #define bio_get(bio) atomic_inc(&(bio)->bi_cnt)
#if defined(CONFIG_BLK_DEV_INTEGRITY) #if defined(CONFIG_BLK_DEV_INTEGRITY)
static inline struct bio_integrity_payload *bio_integrity(struct bio *bio)
{
if (bio->bi_rw & REQ_INTEGRITY)
return bio->bi_integrity;
return NULL;
}
/* /*
* bio integrity payload * bio integrity payload
*/ */
@ -661,8 +670,6 @@ struct biovec_slab {
for_each_bio(_bio) \ for_each_bio(_bio) \
bip_for_each_vec(_bvl, _bio->bi_integrity, _iter) bip_for_each_vec(_bvl, _bio->bi_integrity, _iter)
#define bio_integrity(bio) (bio->bi_integrity != NULL)
extern struct bio_integrity_payload *bio_integrity_alloc(struct bio *, gfp_t, unsigned int); extern struct bio_integrity_payload *bio_integrity_alloc(struct bio *, gfp_t, unsigned int);
extern void bio_integrity_free(struct bio *); extern void bio_integrity_free(struct bio *);
extern int bio_integrity_add_page(struct bio *, struct page *, unsigned int, unsigned int); extern int bio_integrity_add_page(struct bio *, struct page *, unsigned int, unsigned int);

8
include/linux/blk_types.h
View File

@ -78,9 +78,11 @@ struct bio {
struct io_context *bi_ioc; struct io_context *bi_ioc;
struct cgroup_subsys_state *bi_css; struct cgroup_subsys_state *bi_css;
#endif #endif
union {
#if defined(CONFIG_BLK_DEV_INTEGRITY) #if defined(CONFIG_BLK_DEV_INTEGRITY)
struct bio_integrity_payload *bi_integrity; /* data integrity */ struct bio_integrity_payload *bi_integrity; /* data integrity */
#endif #endif
};
unsigned short bi_vcnt; /* how many bio_vec's */ unsigned short bi_vcnt; /* how many bio_vec's */
@ -162,6 +164,7 @@ enum rq_flag_bits {
__REQ_WRITE_SAME, /* write same block many times */ __REQ_WRITE_SAME, /* write same block many times */
__REQ_NOIDLE, /* don't anticipate more IO after this one */ __REQ_NOIDLE, /* don't anticipate more IO after this one */
__REQ_INTEGRITY, /* I/O includes block integrity payload */
__REQ_FUA, /* forced unit access */ __REQ_FUA, /* forced unit access */
__REQ_FLUSH, /* request for cache flush */ __REQ_FLUSH, /* request for cache flush */
@ -203,13 +206,14 @@ enum rq_flag_bits {
#define REQ_DISCARD (1ULL << __REQ_DISCARD) #define REQ_DISCARD (1ULL << __REQ_DISCARD)
#define REQ_WRITE_SAME (1ULL << __REQ_WRITE_SAME) #define REQ_WRITE_SAME (1ULL << __REQ_WRITE_SAME)
#define REQ_NOIDLE (1ULL << __REQ_NOIDLE) #define REQ_NOIDLE (1ULL << __REQ_NOIDLE)
#define REQ_INTEGRITY (1ULL << __REQ_INTEGRITY)
#define REQ_FAILFAST_MASK \ #define REQ_FAILFAST_MASK \
(REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER) (REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER)
#define REQ_COMMON_MASK \ #define REQ_COMMON_MASK \
(REQ_WRITE | REQ_FAILFAST_MASK | REQ_SYNC | REQ_META | REQ_PRIO | \ (REQ_WRITE | REQ_FAILFAST_MASK | REQ_SYNC | REQ_META | REQ_PRIO | \
REQ_DISCARD | REQ_WRITE_SAME | REQ_NOIDLE | REQ_FLUSH | REQ_FUA | \ REQ_DISCARD | REQ_WRITE_SAME | REQ_NOIDLE | REQ_FLUSH | REQ_FUA | \
REQ_SECURE) REQ_SECURE | REQ_INTEGRITY)
#define REQ_CLONE_MASK REQ_COMMON_MASK #define REQ_CLONE_MASK REQ_COMMON_MASK
#define BIO_NO_ADVANCE_ITER_MASK (REQ_DISCARD|REQ_WRITE_SAME) #define BIO_NO_ADVANCE_ITER_MASK (REQ_DISCARD|REQ_WRITE_SAME)

7
include/linux/blkdev.h
View File

@ -1514,12 +1514,9 @@ static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
return disk->integrity; return disk->integrity;
} }
static inline int blk_integrity_rq(struct request *rq) static inline bool blk_integrity_rq(struct request *rq)
{ {
if (rq->bio == NULL) return rq->cmd_flags & REQ_INTEGRITY;
return 0;
return bio_integrity(rq->bio);
} }
static inline void blk_queue_max_integrity_segments(struct request_queue *q, static inline void blk_queue_max_integrity_segments(struct request_queue *q,