md: Turn rdev->sb_offset into a sector-based quantity.

Rename it to sb_start to make sure all users have been converted.

Signed-off-by: Andre Noll <maan@systemlinux.org>
Signed-off-by: Neil Brown <neilb@suse.de>

3 files changed, 44 insertions, 49 deletions

diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index dedba16d42f7..eba83e25b678 100644
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -225,7 +225,7 @@ static struct page *read_sb_page(mddev_t *mddev, long offset, unsigned long inde
                     || test_bit(Faulty, &rdev->flags))
                         continue;
 
-                target = (rdev->sb_offset << 1) + offset + index * (PAGE_SIZE/512);
+                target = rdev->sb_start + offset + index * (PAGE_SIZE/512);
 
                 if (sync_page_io(rdev->bdev, target, PAGE_SIZE, page, READ)) {
                         page->index = index;
@@ -262,12 +262,12 @@ static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
                                         /* bitmap runs in to metadata */
                                         return -EINVAL;
                                 if (rdev->data_offset + mddev->size*2
-                                    > rdev->sb_offset*2 + bitmap->offset)
+                                    > rdev->sb_start + bitmap->offset)
                                         /* data runs in to bitmap */
                                         return -EINVAL;
-                        } else if (rdev->sb_offset*2 < rdev->data_offset) {
+                        } else if (rdev->sb_start < rdev->data_offset) {
                                 /* METADATA BITMAP DATA */
-                                if (rdev->sb_offset*2
+                                if (rdev->sb_start
                                     + bitmap->offset
                                     + page->index*(PAGE_SIZE/512) + size/512
                                     > rdev->data_offset)
@@ -277,7 +277,7 @@ static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
                                 /* DATA METADATA BITMAP - no problems */
                         }
                         md_super_write(mddev, rdev,
-                                       (rdev->sb_offset<<1) + bitmap->offset
+                                       rdev->sb_start + bitmap->offset
                                        + page->index * (PAGE_SIZE/512),
                                        size,
                                        page);
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 3276edde7576..5590cb54b584 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -356,7 +356,7 @@ static inline sector_t calc_dev_sboffset(struct block_device *bdev)
 
 static sector_t calc_num_sectors(mdk_rdev_t *rdev, unsigned chunk_size)
 {
-        sector_t num_sectors = rdev->sb_offset * 2;
+        sector_t num_sectors = rdev->sb_start;
 
         if (chunk_size)
                 num_sectors &= ~((sector_t)chunk_size/512 - 1);
@@ -383,7 +383,7 @@ static void free_disk_sb(mdk_rdev_t * rdev)
                 put_page(rdev->sb_page);
                 rdev->sb_loaded = 0;
                 rdev->sb_page = NULL;
-                rdev->sb_offset = 0;
+                rdev->sb_start = 0;
                 rdev->size = 0;
         }
 }
@@ -529,7 +529,7 @@ static int read_disk_sb(mdk_rdev_t * rdev, int size)
                 return 0;
 
 
-        if (!sync_page_io(rdev->bdev, rdev->sb_offset<<1, size, rdev->sb_page, READ))
+        if (!sync_page_io(rdev->bdev, rdev->sb_start, size, rdev->sb_page, READ))
                 goto fail;
         rdev->sb_loaded = 1;
         return 0;
@@ -666,16 +666,14 @@ static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version
         char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
         mdp_super_t *sb;
         int ret;
-        sector_t sb_offset;
 
         /*
-         * Calculate the position of the superblock,
+         * Calculate the position of the superblock (512byte sectors),
          * it's at the end of the disk.
          *
          * It also happens to be a multiple of 4Kb.
          */
-        sb_offset = calc_dev_sboffset(rdev->bdev) / 2;
-        rdev->sb_offset = sb_offset;
+        rdev->sb_start = calc_dev_sboffset(rdev->bdev);
 
         ret = read_disk_sb(rdev, MD_SB_BYTES);
         if (ret) return ret;
@@ -1007,10 +1005,10 @@ super_90_rdev_size_change(mdk_rdev_t *rdev, unsigned long long size)
         size *= 2; /* convert to sectors */
         if (rdev->mddev->bitmap_offset)
                 return 0; /* can't move bitmap */
-        rdev->sb_offset = calc_dev_sboffset(rdev->bdev) / 2;
-        if (!size || size > rdev->sb_offset*2)
-                size = rdev->sb_offset*2;
-        md_super_write(rdev->mddev, rdev, rdev->sb_offset << 1, rdev->sb_size,
+        rdev->sb_start = calc_dev_sboffset(rdev->bdev);
+        if (!size || size > rdev->sb_start)
+                size = rdev->sb_start;
+        md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
                        rdev->sb_page);
         md_super_wait(rdev->mddev);
         return size/2; /* kB for sysfs */
@@ -1048,12 +1046,12 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
 {
         struct mdp_superblock_1 *sb;
         int ret;
-        sector_t sb_offset;
+        sector_t sb_start;
         char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
         int bmask;
 
         /*
-         * Calculate the position of the superblock.
+         * Calculate the position of the superblock in 512byte sectors.
          * It is always aligned to a 4K boundary and
          * depeding on minor_version, it can be:
          * 0: At least 8K, but less than 12K, from end of device
@@ -1062,22 +1060,20 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
          */
         switch(minor_version) {
         case 0:
-                sb_offset = rdev->bdev->bd_inode->i_size >> 9;
-                sb_offset -= 8*2;
-                sb_offset &= ~(sector_t)(4*2-1);
-                /* convert from sectors to K */
-                sb_offset /= 2;
+                sb_start = rdev->bdev->bd_inode->i_size >> 9;
+                sb_start -= 8*2;
+                sb_start &= ~(sector_t)(4*2-1);
                 break;
         case 1:
-                sb_offset = 0;
+                sb_start = 0;
                 break;
         case 2:
-                sb_offset = 4;
+                sb_start = 8;
                 break;
         default:
                 return -EINVAL;
         }
-        rdev->sb_offset = sb_offset;
+        rdev->sb_start = sb_start;
 
         /* superblock is rarely larger than 1K, but it can be larger,
          * and it is safe to read 4k, so we do that
@@ -1091,7 +1087,7 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
         if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
             sb->major_version != cpu_to_le32(1) ||
             le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
-            le64_to_cpu(sb->super_offset) != (rdev->sb_offset<<1) ||
+            le64_to_cpu(sb->super_offset) != rdev->sb_start ||
             (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
                 return -EINVAL;
 
@@ -1127,7 +1123,7 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
                 rdev->sb_size = (rdev->sb_size | bmask) + 1;