1 files changed, 48 insertions, 48 deletions

diff --git a/drivers/md/md.c b/drivers/md/md.c
index be4a131e8c01..07ab6790e29d 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -413,7 +413,7 @@ static void free_disk_sb(mdk_rdev_t * rdev)
                 rdev->sb_loaded = 0;
                 rdev->sb_page = NULL;
                 rdev->sb_start = 0;
-                rdev->size = 0;
+                rdev->sectors = 0;
         }
 }
 
@@ -779,9 +779,9 @@ static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version
                 else 
                         ret = 0;
         }
-        rdev->size = calc_num_sectors(rdev, sb->chunk_size) / 2;
+        rdev->sectors = calc_num_sectors(rdev, sb->chunk_size);
 
-        if (rdev->size < sb->size && sb->level > 1)
+        if (rdev->sectors < sb->size * 2 && sb->level > 1)
                 /* "this cannot possibly happen" ... */
                 ret = -EINVAL;
 
@@ -1184,16 +1184,17 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
                         ret = 0;
         }
         if (minor_version)
-                rdev->size = ((rdev->bdev->bd_inode->i_size>>9) - le64_to_cpu(sb->data_offset)) / 2;
+                rdev->sectors = (rdev->bdev->bd_inode->i_size >> 9) -
+                        le64_to_cpu(sb->data_offset);
         else
-                rdev->size = rdev->sb_start / 2;
-        if (rdev->size < le64_to_cpu(sb->data_size)/2)
+                rdev->sectors = rdev->sb_start;
+        if (rdev->sectors < le64_to_cpu(sb->data_size))
                 return -EINVAL;
-        rdev->size = le64_to_cpu(sb->data_size)/2;
+        rdev->sectors = le64_to_cpu(sb->data_size);
         if (le32_to_cpu(sb->chunksize))
-                rdev->size &= ~((sector_t)le32_to_cpu(sb->chunksize)/2 - 1);
+                rdev->sectors &= ~((sector_t)le32_to_cpu(sb->chunksize) - 1);
 
-        if (le64_to_cpu(sb->size) > rdev->size*2)
+        if (le64_to_cpu(sb->size) > rdev->sectors)
                 return -EINVAL;
         return ret;
 }
@@ -1390,7 +1391,7 @@ super_1_rdev_size_change(mdk_rdev_t *rdev, sector_t num_sectors)
                 sector_t sb_start;
                 sb_start = (rdev->bdev->bd_inode->i_size >> 9) - 8*2;
                 sb_start &= ~(sector_t)(4*2 - 1);
-                max_sectors = rdev->size * 2 + sb_start - rdev->sb_start;
+                max_sectors = rdev->sectors + sb_start - rdev->sb_start;
                 if (!num_sectors || num_sectors > max_sectors)
                         num_sectors = max_sectors;
                 rdev->sb_start = sb_start;
@@ -1490,9 +1491,9 @@ static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
         if (find_rdev(mddev, rdev->bdev->bd_dev))
                 return -EEXIST;
 
-        /* make sure rdev->size exceeds mddev->dev_sectors / 2 */
-        if (rdev->size && (mddev->dev_sectors == 0 ||
-                        rdev->size < mddev->dev_sectors / 2)) {
+        /* make sure rdev->sectors exceeds mddev->dev_sectors */
+        if (rdev->sectors && (mddev->dev_sectors == 0 ||
+                        rdev->sectors < mddev->dev_sectors)) {
                 if (mddev->pers) {
                         /* Cannot change size, so fail
                          * If mddev->level <= 0, then we don't care
@@ -1501,7 +1502,7 @@ static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
                         if (mddev->level > 0)
                                 return -ENOSPC;
                 } else
-                        mddev->dev_sectors = rdev->size * 2;
+                        mddev->dev_sectors = rdev->sectors;
         }
 
         /* Verify rdev->desc_nr is unique.
@@ -1757,8 +1758,8 @@ static void print_sb_1(struct mdp_superblock_1 *sb)
 static void print_rdev(mdk_rdev_t *rdev, int major_version)
 {
         char b[BDEVNAME_SIZE];
-        printk(KERN_INFO "md: rdev %s, SZ:%08llu F:%d S:%d DN:%u\n",
-                bdevname(rdev->bdev,b), (unsigned long long)rdev->size,
+        printk(KERN_INFO "md: rdev %s, Sect:%08llu F:%d S:%d DN:%u\n",
+                bdevname(rdev->bdev, b), (unsigned long long)rdev->sectors,
                 test_bit(Faulty, &rdev->flags), test_bit(In_sync, &rdev->flags),
                 rdev->desc_nr);
         if (rdev->sb_loaded) {
@@ -2197,7 +2198,7 @@ offset_store(mdk_rdev_t *rdev, const char *buf, size_t len)
                 return -EINVAL;
         if (rdev->mddev->pers && rdev->raid_disk >= 0)
                 return -EBUSY;
-        if (rdev->size && rdev->mddev->external)
+        if (rdev->sectors && rdev->mddev->external)
                 /* Must set offset before size, so overlap checks
                  * can be sane */
                 return -EBUSY;
@@ -2211,7 +2212,7 @@ __ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store);
 static ssize_t
 rdev_size_show(mdk_rdev_t *rdev, char *page)
 {
-        return sprintf(page, "%llu\n", (unsigned long long)rdev->size);
+        return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2);
 }
 
 static int overlaps(sector_t s1, sector_t l1, sector_t s2, sector_t l2)
@@ -2227,31 +2228,31 @@ static int overlaps(sector_t s1, sector_t l1, sector_t s2, sector_t l2)
 static ssize_t
 rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len)
 {
-        unsigned long long size;
-        unsigned long long oldsize = rdev->size;
         mddev_t *my_mddev = rdev->mddev;
+        sector_t oldsectors = rdev->sectors;
+        unsigned long long sectors;
 
-        if (strict_strtoull(buf, 10, &size) < 0)
+        if (strict_strtoull(buf, 10, &sectors) < 0)
                 return -EINVAL;
+        sectors *= 2;
         if (my_mddev->pers && rdev->raid_disk >= 0) {
                 if (my_mddev->persistent) {
-                        size = super_types[my_mddev->major_version].
-                                rdev_size_change(rdev, size * 2);
-                        if (!size)
+                        sectors = super_types[my_mddev->major_version].
+                                rdev_size_change(rdev, sectors);
+                        if (!sectors)
                                 return -EBUSY;
-                } else if (!size) {
-                        size = (rdev->bdev->bd_inode->i_size >> 10);
-                        size -= rdev->data_offset/2;
-                }
+                } else if (!sectors)
+                        sectors = (rdev->bdev->bd_inode->i_size >> 9) -
+                                rdev->data_offset;
         }
-        if (size < my_mddev->dev_sectors / 2)
+        if (sectors < my_mddev->dev_sectors)
                 return -EINVAL; /* component must fit device */
 
-        rdev->size = size;
-        if (size > oldsize && my_mddev->external) {
+        rdev->sectors = sectors;
+        if (sectors > oldsectors && my_mddev->external) {
                 /* need to check that all other rdevs with the same ->bdev
                  * do not overlap.  We need to unlock the mddev to avoid
-                 * a deadlock.  We have already changed rdev->size, and if
+                 * a deadlock.  We have already changed rdev->sectors, and if
                  * we have to change it back, we will have the lock again.
                  */
                 mddev_t *mddev;
@@ -2267,9 +2268,9 @@ rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len)
                                 if (test_bit(AllReserved, &rdev2->flags) ||
                                     (rdev->bdev == rdev2->bdev &&
                                      rdev != rdev2 &&
-                                     overlaps(rdev->data_offset, rdev->size * 2,
+                                     overlaps(rdev->data_offset, rdev->sectors,
                                               rdev2->data_offset,
-                                              rdev2->size * 2))) {
+                                              rdev2->sectors))) {
                                         overlap = 1;
                                         break;
                                 }
@@ -2283,11 +2284,11 @@ rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len)
                 if (overlap) {
                         /* Someone else could have slipped in a size
                          * change here, but doing so is just silly.
-                         * We put oldsize back because we *know* it is
+                         * We put oldsectors back because we *know* it is
                          * safe, and trust userspace not to race with
                          * itself
                          */
-                        rdev->size = oldsize;
+                        rdev->sectors = oldsectors;
                         return -EBUSY;
                 }
         }
@@ -3760,13 +3761,13 @@ static int do_md_run(mddev_t * mddev)
                 list_for_each_entry(rdev, &mddev->disks, same_set) {
                         if (test_bit(Faulty, &rdev->flags))
                                 continue;
-                        if (rdev->size < chunk_size / 1024) {
+                        if (rdev->sectors < chunk_size / 512) {
                                 printk(KERN_WARNING
                                         "md: Dev %s smaller than chunk_size:"
-                                        " %lluk < %dk\n",
+                                        " %llu < %d\n",
                                         bdevname(rdev->bdev,b),
-                                        (unsigned long long)rdev->size,
-                                        chunk_size / 1024);
+                                        (unsigned long long)rdev->sectors,
+                                        chunk_size / 512);
                                 return -EINVAL;
                         }
                 }
@@ -4585,7 +4586,7 @@ static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info)
                         rdev->sb_start = rdev->bdev->bd_inode->i_size / 512;
                 } else 
                         rdev->sb_start = calc_dev_sboffset(rdev->bdev);
-                rdev->size = calc_num_sectors(rdev, mddev->chunk_size) / 2;
+                rdev->sectors = calc_num_sectors(rdev, mddev->chunk_size);
 
                 err = bind_rdev_to_array(rdev, mddev);
                 if (err) {
@@ -4655,7 +4656,7 @@ static int hot_add_disk(mddev_t * mddev, dev_t dev)
         else
                 rdev->sb_start = rdev->bdev->bd_inode->i_size / 512;
 
-        rdev->size = calc_num_sectors(rdev, mddev->chunk_size) / 2;
+        rdev->sectors = calc_num_sectors(rdev, mddev->chunk_size);
 
         if (test_bit(Faulty, &rdev->flags)) {
                 printk(KERN_WARNING 
@@ -4856,8 +4857,7 @@ static int update_size(mddev_t *mddev, sector_t num_sectors)
                  */
                 return -EBUSY;
         list_for_each_entry(rdev, &mddev->disks, same_set) {
-                sector_t avail;
-                avail = rdev->size * 2;
+                sector_t avail = rdev->sectors;
 
                 if (fit && (num_sectors == 0 || num_sectors > avail))
                         num_sectors = avail;
@@ -5585,7 +5585,7 @@ struct mdstat_info {
 static int md_seq_show(struct seq_file *seq, void *v)
 {
         mddev_t *mddev = v;
-        sector_t size;
+        sector_t sectors;
         mdk_rdev_t *rdev;
         struct mdstat_info *mi = seq->private;
         struct bitmap *bitmap;
@@ -5621,7 +5621,7 @@ static int md_seq_show(struct seq_file *seq, void *v)
                         seq_printf(seq, " %s", mddev->pers->name);
                 }
 
-                size = 0;
+                sectors = 0;
                 list_for_each_entry(rdev, &mddev->disks, same_set) {
                         char b[BDEVNAME_SIZE];
                         seq_printf(seq, " %s[%d]",
@@ -5633,7 +5633,7 @@ static int md_seq_show(struct seq_file *seq, void *v)
                                 continue;
                         } else if (rdev->raid_disk < 0)
                                 seq_printf(seq, "(S)"); /* spare */
-                        size += rdev->size;
+                        sectors += rdev->sectors;
                 }
 
                 if (!list_empty(&mddev->disks)) {
@@ -5643,7 +5643,7 @@ static int md_seq_show(struct seq_file *seq, void *v)
                                            mddev->array_sectors / 2);
                         else
                                 seq_printf(seq, "\n      %llu blocks",
-                                           (unsigned long long)size);
+                                           (unsigned long long)sectors / 2);
                 }
                 if (mddev->persistent) {
                         if (mddev->major_version != 0 ||