The protection interval is not necessarily tied to the logical block size of a block device. Stop using the terms "sector" and "sectors". Going forward we will use the term "seed" to describe the initial reference tag value for a given I/O. "Interval" will be used to describe the portion of the data buffer that a given piece of protection information is associated with.
Unified · Split
| @@ -185,20 +185,20 @@ bool bio_integrity_enabled(struct bio *bio) · 184 unmodified lines | |||
| 185 | EXPORT_SYMBOL(bio_integrity_enabled); | 185 | EXPORT_SYMBOL(bio_integrity_enabled); |
| 186 | 186 | ||
| 187 | /** | 187 | /** |
| 188 | * bio_integrity_hw_sectors - Convert 512b sectors to hardware ditto | 188 | * bio_integrity_intervals - Return number of integrity intervals for a bio |
| 189 | * @bi: blk_integrity profile for device | 189 | * @bi: blk_integrity profile for device |
| 190 | * @sectors: Number of 512 sectors to convert | 190 | * @sectors: Size of the bio in 512-byte sectors |
| 191 | * | 191 | * |
| 192 | * Description: The block layer calculates everything in 512 byte | 192 | * Description: The block layer calculates everything in 512 byte |
| 193 | * sectors but integrity metadata is done in terms of the hardware | 193 | * sectors but integrity metadata is done in terms of the data integrity |
| 194 | * sector size of the storage device. Convert the block layer sectors | 194 | * interval size of the storage device. Convert the block layer sectors |
| 195 | * to physical sectors. | 195 | * to the appropriate number of integrity intervals. |
| 196 | */ | 196 | */ |
| 197 | static inline unsigned int bio_integrity_hw_sectors(struct blk_integrity *bi, | 197 | static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi, |
| 198 | unsigned int sectors) | 198 | unsigned int sectors) |
| 199 | { | 199 | { |
| 200 | /* At this point there are only 512b or 4096b DIF/EPP devices */ | 200 | /* At this point there are only 512b or 4096b DIF/EPP devices */ |
| 201 | if (bi->sector_size == 4096) | 201 | if (bi->interval == 4096) |
| 202 | return sectors >>= 3; | 202 | return sectors >>= 3; |
| 203 | 203 | ||
| 204 | return sectors; | 204 | return sectors; |
| @@ -207,7 +207,7 @@ static inline unsigned int bio_integrity_hw_sectors(struct blk_integrity *bi, · 2 unmodified lines | |||
| 207 | static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi, | 207 | static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi, |
| 208 | unsigned int sectors) | 208 | unsigned int sectors) |
| 209 | { | 209 | { |
| 210 | return bio_integrity_hw_sectors(bi, sectors) * bi->tuple_size; | 210 | return bio_integrity_intervals(bi, sectors) * bi->tuple_size; |
| 211 | } | 211 | } |
| 212 | 212 | ||
| 213 | /** | 213 | /** |
| @@ -221,25 +221,25 @@ static int bio_integrity_generate_verify(struct bio *bio, int operate) · 7 unmodified lines | |||
| 221 | struct blk_integrity_exchg bix; | 221 | struct blk_integrity_exchg bix; |
| 222 | struct bio_vec *bv; | 222 | struct bio_vec *bv; |
| 223 | struct bio_integrity_payload *bip = bio_integrity(bio); | 223 | struct bio_integrity_payload *bip = bio_integrity(bio); |
| 224 | sector_t sector; | 224 | sector_t seed; |
| 225 | unsigned int sectors, ret = 0, i; | 225 | unsigned int intervals, ret = 0, i; |
| 226 | void *prot_buf = page_address(bip->bip_vec->bv_page) + | 226 | void *prot_buf = page_address(bip->bip_vec->bv_page) + |
| 227 | bip->bip_vec->bv_offset; | 227 | bip->bip_vec->bv_offset; |
| 228 | 228 | ||
| 229 | if (operate) | 229 | if (operate) |
| 230 | sector = bio->bi_iter.bi_sector; | 230 | seed = bio->bi_iter.bi_sector; |
| 231 | else | 231 | else |
| 232 | sector = bip->bip_iter.bi_sector; | 232 | seed = bip->bip_iter.bi_sector; |
| 233 | 233 | ||
| 234 | bix.disk_name = bio->bi_bdev->bd_disk->disk_name; | 234 | bix.disk_name = bio->bi_bdev->bd_disk->disk_name; |
| 235 | bix.sector_size = bi->sector_size; | 235 | bix.interval = bi->interval; |
| 236 | 236 | ||
| 237 | bio_for_each_segment_all(bv, bio, i) { | 237 | bio_for_each_segment_all(bv, bio, i) { |
| 238 | void *kaddr = kmap_atomic(bv->bv_page); | 238 | void *kaddr = kmap_atomic(bv->bv_page); |
| 239 | bix.data_buf = kaddr + bv->bv_offset; | 239 | bix.data_buf = kaddr + bv->bv_offset; |
| 240 | bix.data_size = bv->bv_len; | 240 | bix.data_size = bv->bv_len; |
| 241 | bix.prot_buf = prot_buf; | 241 | bix.prot_buf = prot_buf; |
| 242 | bix.sector = sector; | 242 | bix.seed = seed; |
| 243 | 243 | ||
| 244 | if (operate) | 244 | if (operate) |
| 245 | bi->generate_fn(&bix); | 245 | bi->generate_fn(&bix); |
| @@ -251,9 +251,9 @@ static int bio_integrity_generate_verify(struct bio *bio, int operate) · 5 unmodified lines | |||
| 251 | } | 251 | } |
| 252 | } | 252 | } |
| 253 | 253 | ||
| 254 | sectors = bv->bv_len / bi->sector_size; | 254 | intervals = bv->bv_len / bi->interval; |
| 255 | sector += sectors; | 255 | seed += intervals; |
| 256 | prot_buf += sectors * bi->tuple_size; | 256 | prot_buf += intervals * bi->tuple_size; |
| 257 | 257 | ||
| 258 | kunmap_atomic(kaddr); | 258 | kunmap_atomic(kaddr); |
| 259 | } | 259 | } |
| @@ -294,17 +294,17 @@ int bio_integrity_prep(struct bio *bio) · 34 unmodified lines | |||
| 294 | unsigned long start, end; | 294 | unsigned long start, end; |
| 295 | unsigned int len, nr_pages; | 295 | unsigned int len, nr_pages; |
| 296 | unsigned int bytes, offset, i; | 296 | unsigned int bytes, offset, i; |
| 297 | unsigned int sectors; | 297 | unsigned int intervals; |
| 298 | 298 | ||
| 299 | bi = bdev_get_integrity(bio->bi_bdev); | 299 | bi = bdev_get_integrity(bio->bi_bdev); |
| 300 | q = bdev_get_queue(bio->bi_bdev); | 300 | q = bdev_get_queue(bio->bi_bdev); |
| 301 | BUG_ON(bi == NULL); | 301 | BUG_ON(bi == NULL); |
| 302 | BUG_ON(bio_integrity(bio)); | 302 | BUG_ON(bio_integrity(bio)); |
| 303 | 303 | ||
| 304 | sectors = bio_integrity_hw_sectors(bi, bio_sectors(bio)); | 304 | intervals = bio_integrity_intervals(bi, bio_sectors(bio)); |
| 305 | 305 | ||
| 306 | /* Allocate kernel buffer for protection data */ | 306 | /* Allocate kernel buffer for protection data */ |
| 307 | len = sectors * bi->tuple_size; | 307 | len = intervals * bi->tuple_size; |
| 308 | buf = kmalloc(len, GFP_NOIO | q->bounce_gfp); | 308 | buf = kmalloc(len, GFP_NOIO | q->bounce_gfp); |
| 309 | if (unlikely(buf == NULL)) { | 309 | if (unlikely(buf == NULL)) { |
| 310 | printk(KERN_ERR "could not allocate integrity buffer\n"); | 310 | printk(KERN_ERR "could not allocate integrity buffer\n"); |
| @@ -154,10 +154,10 @@ int blk_integrity_compare(struct gendisk *gd1, struct gendisk *gd2) · 153 unmodified lines | |||
| 154 | if (!b1 || !b2) | 154 | if (!b1 || !b2) |
| 155 | return -1; | 155 | return -1; |
| 156 | 156 | ||
| 157 | if (b1->sector_size != b2->sector_size) { | 157 | if (b1->interval != b2->interval) { |
| 158 | printk(KERN_ERR "%s: %s/%s sector sz %u != %u\n", __func__, | 158 | pr_err("%s: %s/%s protection interval %u != %u\n", |
| 159 | gd1->disk_name, gd2->disk_name, | 159 | __func__, gd1->disk_name, gd2->disk_name, |
| 160 | b1->sector_size, b2->sector_size); | 160 | b1->interval, b2->interval); |
| 161 | return -1; | 161 | return -1; |
| 162 | } | 162 | } |
| 163 | 163 | ||
| @@ -407,7 +407,7 @@ int blk_integrity_register(struct gendisk *disk, struct blk_integrity *template) · 243 unmodified lines | |||
| 407 | kobject_uevent(&bi->kobj, KOBJ_ADD); | 407 | kobject_uevent(&bi->kobj, KOBJ_ADD); |
| 408 | 408 | ||
| 409 | bi->flags |= INTEGRITY_FLAG_READ | INTEGRITY_FLAG_WRITE; | 409 | bi->flags |= INTEGRITY_FLAG_READ | INTEGRITY_FLAG_WRITE; |
| 410 | bi->sector_size = queue_logical_block_size(disk->queue); | 410 | bi->interval = queue_logical_block_size(disk->queue); |
| 411 | disk->integrity = bi; | 411 | disk->integrity = bi; |
| 412 | } else | 412 | } else |
| 413 | bi = disk->integrity; | 413 | bi = disk->integrity; |
| @@ -57,16 +57,16 @@ static void sd_dif_type1_generate(struct blk_integrity_exchg *bix, csum_fn *fn) · 56 unmodified lines | |||
| 57 | { | 57 | { |
| 58 | void *buf = bix->data_buf; | 58 | void *buf = bix->data_buf; |
| 59 | struct sd_dif_tuple *sdt = bix->prot_buf; | 59 | struct sd_dif_tuple *sdt = bix->prot_buf; |
| 60 | sector_t sector = bix->sector; | 60 | sector_t seed = bix->seed; |
| 61 | unsigned int i; | 61 | unsigned int i; |
| 62 | 62 | ||
| 63 | for (i = 0 ; i < bix->data_size ; i += bix->sector_size, sdt++) { | 63 | for (i = 0 ; i < bix->data_size ; i += bix->interval, sdt++) { |
| 64 | sdt->guard_tag = fn(buf, bix->sector_size); | 64 | sdt->guard_tag = fn(buf, bix->interval); |
| 65 | sdt->ref_tag = cpu_to_be32(sector & 0xffffffff); | 65 | sdt->ref_tag = cpu_to_be32(seed & 0xffffffff); |
| 66 | sdt->app_tag = 0; | 66 | sdt->app_tag = 0; |
| 67 | 67 | ||
| 68 | buf += bix->sector_size; | 68 | buf += bix->interval; |
| 69 | sector++; | 69 | seed++; |
| 70 | } | 70 | } |
| 71 | } | 71 | } |
| 72 | 72 | ||
| @@ -84,35 +84,35 @@ static int sd_dif_type1_verify(struct blk_integrity_exchg *bix, csum_fn *fn) · 11 unmodified lines | |||
| 84 | { | 84 | { |
| 85 | void *buf = bix->data_buf; | 85 | void *buf = bix->data_buf; |
| 86 | struct sd_dif_tuple *sdt = bix->prot_buf; | 86 | struct sd_dif_tuple *sdt = bix->prot_buf; |
| 87 | sector_t sector = bix->sector; | 87 | sector_t seed = bix->seed; |
| 88 | unsigned int i; | 88 | unsigned int i; |
| 89 | __u16 csum; | 89 | __u16 csum; |
| 90 | 90 | ||
| 91 | for (i = 0 ; i < bix->data_size ; i += bix->sector_size, sdt++) { | 91 | for (i = 0 ; i < bix->data_size ; i += bix->interval, sdt++) { |
| 92 | /* Unwritten sectors */ | 92 | /* Unwritten sectors */ |
| 93 | if (sdt->app_tag == 0xffff) | 93 | if (sdt->app_tag == 0xffff) |
| 94 | return 0; | 94 | return 0; |
| 95 | 95 | ||
| 96 | if (be32_to_cpu(sdt->ref_tag) != (sector & 0xffffffff)) { | 96 | if (be32_to_cpu(sdt->ref_tag) != (seed & 0xffffffff)) { |
| 97 | printk(KERN_ERR | 97 | printk(KERN_ERR |
| 98 | "%s: ref tag error on sector %lu (rcvd %u)\n", | 98 | "%s: ref tag error on sector %lu (rcvd %u)\n", |
| 99 | bix->disk_name, (unsigned long)sector, | 99 | bix->disk_name, (unsigned long)seed, |
| 100 | be32_to_cpu(sdt->ref_tag)); | 100 | be32_to_cpu(sdt->ref_tag)); |
| 101 | return -EIO; | 101 | return -EIO; |
| 102 | } | 102 | } |
| 103 | 103 | ||
| 104 | csum = fn(buf, bix->sector_size); | 104 | csum = fn(buf, bix->interval); |
| 105 | 105 | ||
| 106 | if (sdt->guard_tag != csum) { | 106 | if (sdt->guard_tag != csum) { |
| 107 | printk(KERN_ERR "%s: guard tag error on sector %lu " \ | 107 | printk(KERN_ERR "%s: guard tag error on sector %lu " \ |
| 108 | "(rcvd %04x, data %04x)\n", bix->disk_name, | 108 | "(rcvd %04x, data %04x)\n", bix->disk_name, |
| 109 | (unsigned long)sector, | 109 | (unsigned long)seed, |
| 110 | be16_to_cpu(sdt->guard_tag), be16_to_cpu(csum)); | 110 | be16_to_cpu(sdt->guard_tag), be16_to_cpu(csum)); |
| 111 | return -EIO; | 111 | return -EIO; |
| 112 | } | 112 | } |
| 113 | 113 | ||
| 114 | buf += bix->sector_size; | 114 | buf += bix->interval; |
| 115 | sector++; | 115 | seed++; |
| 116 | } | 116 | } |
| 117 | 117 | ||
| 118 | return 0; | 118 | return 0; |
| @@ -155,12 +155,12 @@ static void sd_dif_type3_generate(struct blk_integrity_exchg *bix, csum_fn *fn) · 36 unmodified lines | |||
| 155 | struct sd_dif_tuple *sdt = bix->prot_buf; | 155 | struct sd_dif_tuple *sdt = bix->prot_buf; |
| 156 | unsigned int i; | 156 | unsigned int i; |
| 157 | 157 | ||
| 158 | for (i = 0 ; i < bix->data_size ; i += bix->sector_size, sdt++) { | 158 | for (i = 0 ; i < bix->data_size ; i += bix->interval, sdt++) { |
| 159 | sdt->guard_tag = fn(buf, bix->sector_size); | 159 | sdt->guard_tag = fn(buf, bix->interval); |
| 160 | sdt->ref_tag = 0; | 160 | sdt->ref_tag = 0; |
| 161 | sdt->app_tag = 0; | 161 | sdt->app_tag = 0; |
| 162 | 162 | ||
| 163 | buf += bix->sector_size; | 163 | buf += bix->interval; |
| 164 | } | 164 | } |
| 165 | } | 165 | } |
| 166 | 166 | ||
| @@ -178,27 +178,27 @@ static int sd_dif_type3_verify(struct blk_integrity_exchg *bix, csum_fn *fn) · 11 unmodified lines | |||
| 178 | { | 178 | { |
| 179 | void *buf = bix->data_buf; | 179 | void *buf = bix->data_buf; |
| 180 | struct sd_dif_tuple *sdt = bix->prot_buf; | 180 | struct sd_dif_tuple *sdt = bix->prot_buf; |
| 181 | sector_t sector = bix->sector; | 181 | sector_t seed = bix->seed; |
| 182 | unsigned int i; | 182 | unsigned int i; |
| 183 | __u16 csum; | 183 | __u16 csum; |
| 184 | 184 | ||
| 185 | for (i = 0 ; i < bix->data_size ; i += bix->sector_size, sdt++) { | 185 | for (i = 0 ; i < bix->data_size ; i += bix->interval, sdt++) { |
| 186 | /* Unwritten sectors */ | 186 | /* Unwritten sectors */ |
| 187 | if (sdt->app_tag == 0xffff && sdt->ref_tag == 0xffffffff) | 187 | if (sdt->app_tag == 0xffff && sdt->ref_tag == 0xffffffff) |
| 188 | return 0; | 188 | return 0; |
| 189 | 189 | ||
| 190 | csum = fn(buf, bix->sector_size); | 190 | csum = fn(buf, bix->interval); |
| 191 | 191 | ||
| 192 | if (sdt->guard_tag != csum) { | 192 | if (sdt->guard_tag != csum) { |
| 193 | printk(KERN_ERR "%s: guard tag error on sector %lu " \ | 193 | printk(KERN_ERR "%s: guard tag error on sector %lu " \ |
| 194 | "(rcvd %04x, data %04x)\n", bix->disk_name, | 194 | "(rcvd %04x, data %04x)\n", bix->disk_name, |
| 195 | (unsigned long)sector, | 195 | (unsigned long)seed, |
| 196 | be16_to_cpu(sdt->guard_tag), be16_to_cpu(csum)); | 196 | be16_to_cpu(sdt->guard_tag), be16_to_cpu(csum)); |
| 197 | return -EIO; | 197 | return -EIO; |
| 198 | } | 198 | } |
| 199 | 199 | ||
| 200 | buf += bix->sector_size; | 200 | buf += bix->interval; |
| 201 | sector++; | 201 | seed++; |
| 202 | } | 202 | } |
| 203 | 203 | ||
| 204 | return 0; | 204 | return 0; |
| @@ -1464,9 +1464,9 @@ static inline uint64_t rq_io_start_time_ns(struct request *req) · 1463 unmodified lines | |||
| 1464 | struct blk_integrity_exchg { | 1464 | struct blk_integrity_exchg { |
| 1465 | void *prot_buf; | 1465 | void *prot_buf; |
| 1466 | void *data_buf; | 1466 | void *data_buf; |
| 1467 | sector_t sector; | 1467 | sector_t seed; |
| 1468 | unsigned int data_size; | 1468 | unsigned int data_size; |
| 1469 | unsigned short sector_size; | 1469 | unsigned short interval; |
| 1470 | const char *disk_name; | 1470 | const char *disk_name; |
| 1471 | }; | 1471 | }; |
| 1472 | 1472 | ||
| @@ -1479,7 +1479,7 @@ struct blk_integrity { · 6 unmodified lines | |||
| 1479 | 1479 | ||
| 1480 | unsigned short flags; | 1480 | unsigned short flags; |
| 1481 | unsigned short tuple_size; | 1481 | unsigned short tuple_size; |
| 1482 | unsigned short sector_size; | 1482 | unsigned short interval; |
| 1483 | unsigned short tag_size; | 1483 | unsigned short tag_size; |
| 1484 | 1484 | ||
| 1485 | const char *name; | 1485 | const char *name; |