1 files changed, 21 insertions, 21 deletions

diff --git a/block/bio-integrity.c b/block/bio-integrity.c
index e84f7fb8694b..6a3aacf57b19 100644
--- a/block/bio-integrity.c
+++ b/block/bio-integrity.c
@@ -185,20 +185,20 @@ bool bio_integrity_enabled(struct bio *bio)
 EXPORT_SYMBOL(bio_integrity_enabled);
 
 /**
- * bio_integrity_hw_sectors - Convert 512b sectors to hardware ditto
+ * bio_integrity_intervals - Return number of integrity intervals for a bio
  * @bi:         blk_integrity profile for device
- * @sectors:    Number of 512 sectors to convert
+ * @sectors:    Size of the bio in 512-byte sectors
  *
  * Description: The block layer calculates everything in 512 byte
- * sectors but integrity metadata is done in terms of the hardware
- * sector size of the storage device.  Convert the block layer sectors
- * to physical sectors.
+ * sectors but integrity metadata is done in terms of the data integrity
+ * interval size of the storage device.  Convert the block layer sectors
+ * to the appropriate number of integrity intervals.
  */
-static inline unsigned int bio_integrity_hw_sectors(struct blk_integrity *bi,
-                                                    unsigned int sectors)
+static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi,
+                                                   unsigned int sectors)
 {
         /* At this point there are only 512b or 4096b DIF/EPP devices */
-        if (bi->sector_size == 4096)
+        if (bi->interval == 4096)
                 return sectors >>= 3;
 
         return sectors;
@@ -207,7 +207,7 @@ static inline unsigned int bio_integrity_hw_sectors(struct blk_integrity *bi,
 static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi,
                                                unsigned int sectors)
 {
-        return bio_integrity_hw_sectors(bi, sectors) * bi->tuple_size;
+        return bio_integrity_intervals(bi, sectors) * bi->tuple_size;
 }
 
 /**
@@ -221,25 +221,25 @@ static int bio_integrity_generate_verify(struct bio *bio, int operate)
         struct blk_integrity_exchg bix;
         struct bio_vec *bv;
         struct bio_integrity_payload *bip = bio_integrity(bio);
-        sector_t sector;
-        unsigned int sectors, ret = 0, i;
+        sector_t seed;
+        unsigned int intervals, ret = 0, i;
         void *prot_buf = page_address(bip->bip_vec->bv_page) +
                 bip->bip_vec->bv_offset;
 
         if (operate)
-                sector = bio->bi_iter.bi_sector;
+                seed = bio->bi_iter.bi_sector;
         else
-                sector = bip->bip_iter.bi_sector;
+                seed = bip->bip_iter.bi_sector;
 
         bix.disk_name = bio->bi_bdev->bd_disk->disk_name;
-        bix.sector_size = bi->sector_size;
+        bix.interval = bi->interval;
 
         bio_for_each_segment_all(bv, bio, i) {
                 void *kaddr = kmap_atomic(bv->bv_page);
                 bix.data_buf = kaddr + bv->bv_offset;
                 bix.data_size = bv->bv_len;
                 bix.prot_buf = prot_buf;
-                bix.sector = sector;
+                bix.seed = seed;
 
                 if (operate)
                         bi->generate_fn(&bix);
@@ -251,9 +251,9 @@ static int bio_integrity_generate_verify(struct bio *bio, int operate)
                         }
                 }
 
-                sectors = bv->bv_len / bi->sector_size;
-                sector += sectors;
-                prot_buf += sectors * bi->tuple_size;
+                intervals = bv->bv_len / bi->interval;
+                seed += intervals;
+                prot_buf += intervals * bi->tuple_size;
 
                 kunmap_atomic(kaddr);
         }
@@ -294,17 +294,17 @@ int bio_integrity_prep(struct bio *bio)
         unsigned long start, end;
         unsigned int len, nr_pages;
         unsigned int bytes, offset, i;
-        unsigned int sectors;
+        unsigned int intervals;
 
         bi = bdev_get_integrity(bio->bi_bdev);
         q = bdev_get_queue(bio->bi_bdev);
         BUG_ON(bi == NULL);
         BUG_ON(bio_integrity(bio));
 
-        sectors = bio_integrity_hw_sectors(bi, bio_sectors(bio));
+        intervals = bio_integrity_intervals(bi, bio_sectors(bio));
 
         /* Allocate kernel buffer for protection data */
-        len = sectors * bi->tuple_size;
+        len = intervals * bi->tuple_size;
         buf = kmalloc(len, GFP_NOIO | q->bounce_gfp);
         if (unlikely(buf == NULL)) {
                 printk(KERN_ERR "could not allocate integrity buffer\n");