[PATCH] md: Cleanups for md to move device size calculations into personalities

diff --git a/drivers/md/linear.c b/drivers/md/linear.c
index f1cbccd2096a9824898d460d464777944d1d7a73..feb4123a687805a822dd84e81d42727081338c1d 100644 (file)
--- a/drivers/md/linear.c
+++ b/drivers/md/linear.c
@@ -91,6 +91,8 @@ static int linear_run (mddev_t *mddev)
 
        conf->smallest = NULL;
        cnt = 0;
+       mddev->array_size = 0;
+
        ITERATE_RDEV(mddev,rdev,tmp) {
                int j = rdev->raid_disk;
                dev_info_t *disk = conf->disks + j;
@@ -102,6 +104,7 @@ static int linear_run (mddev_t *mddev)
 
                disk->rdev = rdev;
                disk->size = rdev->size;
+               mddev->array_size += rdev->size;
 
                if (!conf->smallest || (disk->size < conf->smallest->size))
                        conf->smallest = disk;
@@ -121,7 +124,7 @@ static int linear_run (mddev_t *mddev)
                unsigned round;
                unsigned long base;
 
-               sz = md_size[mdidx(mddev)];
+               sz = mddev->array_size;
                base = conf->smallest->size;
                round = sector_div(sz, base);
                nb_zone = conf->nr_zones = sz + (round ? 1 : 0);

diff --git a/drivers/md/md.c b/drivers/md/md.c
index 1198488bf5c384ce92bef9c29ccfc956ef2e39d5..8662d0fe38c97e293e1f096582bba612c0092483 100644 (file)
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -125,8 +125,6 @@ static ctl_table raid_root_table[] = {
        { .ctl_name = 0 }
 };
 
-sector_t md_size[MAX_MD_DEVS];
-
 static struct block_device_operations md_fops;
 
 static struct gendisk *disks[MAX_MD_DEVS];
@@ -288,21 +286,6 @@ static sector_t calc_dev_size(mdk_rdev_t *rdev, unsigned chunk_size)
        return size;
 }
 
-static sector_t zoned_raid_size(mddev_t *mddev)
-{
-       mdk_rdev_t * rdev;
-       struct list_head *tmp;
-
-       /*
-        * do size and offset calculations.
-        */
-
-       ITERATE_RDEV(mddev,rdev,tmp)
-               md_size[mdidx(mddev)] += rdev->size;
-
-       return 0;
-}
-
 static int alloc_disk_sb(mdk_rdev_t * rdev)
 {
        if (rdev->sb_page)
@@ -1453,87 +1436,6 @@ abort:
        return 1;
 }
 
-static int device_size_calculation(mddev_t * mddev)
-{
-       int data_disks = 0;
-       unsigned int readahead;
-       struct list_head *tmp;
-       mdk_rdev_t *rdev;
-
-       /*
-        * Do device size calculation. Bail out if too small.
-        * (we have to do this after having validated chunk_size,
-        * because device size has to be modulo chunk_size)
-        */
-
-       ITERATE_RDEV(mddev,rdev,tmp) {
-               if (rdev->faulty)
-                       continue;
-               if (rdev->size < mddev->chunk_size / 1024) {
-                       printk(KERN_WARNING
-                               "md: Dev %s smaller than chunk_size:"
-                               " %lluk < %dk\n",
-                               bdev_partition_name(rdev->bdev),
-                               (unsigned long long)rdev->size,
-                               mddev->chunk_size / 1024);
-                       return -EINVAL;
-               }
-       }
-
-       switch (mddev->level) {
-               case LEVEL_MULTIPATH:
-                       data_disks = 1;
-                       break;
-               case -3:
-                       data_disks = 1;
-                       break;
-               case -2:
-                       data_disks = 1;
-                       break;
-               case LEVEL_LINEAR:
-                       zoned_raid_size(mddev);
-                       data_disks = 1;
-                       break;
-               case 0:
-                       zoned_raid_size(mddev);
-                       data_disks = mddev->raid_disks;
-                       break;
-               case 1:
-                       data_disks = 1;
-                       break;
-               case 4:
-               case 5:
-                       data_disks = mddev->raid_disks-1;
-                       break;
-               default:
-                       printk(KERN_ERR "md: md%d: unsupported raid level %d\n",
-                               mdidx(mddev), mddev->level);
-                       goto abort;
-       }
-       if (!md_size[mdidx(mddev)])
-               md_size[mdidx(mddev)] = mddev->size * data_disks;
-
-       readahead = (VM_MAX_READAHEAD * 1024) / PAGE_SIZE;
-       if (!mddev->level || (mddev->level == 4) || (mddev->level == 5)) {
-               readahead = (mddev->chunk_size>>PAGE_SHIFT) * 4 * data_disks;
-               if (readahead < data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2)
-                       readahead = data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2;
-       } else {
-               // (no multipath branch - it uses the default setting)
-               if (mddev->level == -3)
-                       readahead = 0;
-       }
-
-       printk(KERN_INFO "md%d: max total readahead window set to %ldk\n",
-               mdidx(mddev), readahead*(PAGE_SIZE/1024));
-
-       printk(KERN_INFO
-               "md%d: %d data-disks, max readahead per data-disk: %ldk\n",
-               mdidx(mddev), data_disks, readahead/data_disks*(PAGE_SIZE/1024));
-       return 0;
-abort:
-       return 1;
-}
 
 static struct gendisk *md_probe(dev_t dev, int *part, void *data)
 {
@@ -1596,12 +1498,6 @@ static int do_md_run(mddev_t * mddev)
        if (mddev->pers)
                return -EBUSY;
 
-       /*
-        * Resize disks to align partitions size on a given
-        * chunk size.
-        */
-       md_size[mdidx(mddev)] = 0;
-
        /*
         * Analyze all RAID superblock(s)
         */
@@ -1642,6 +1538,21 @@ static int do_md_run(mddev_t * mddev)
                                chunk_size, PAGE_SIZE);
                        return -EINVAL;
                }
+
+               /* devices must have minimum size of one chunk */
+               ITERATE_RDEV(mddev,rdev,tmp) {
+                       if (rdev->faulty)
+                               continue;
+                       if (rdev->size < chunk_size / 1024) {
+                               printk(KERN_WARNING
+                                       "md: Dev %s smaller than chunk_size:"
+                                       " %lluk < %dk\n",
+                                       bdev_partition_name(rdev->bdev),
+                                       (unsigned long long)rdev->size,
+                                       chunk_size / 1024);
+                               return -EINVAL;
+                       }
+               }
        }
 
        if (pnum >= MAX_PERSONALITY) {
@@ -1658,9 +1569,6 @@ static int do_md_run(mddev_t * mddev)
        }
 #endif
 
-       if (device_size_calculation(mddev))
-               return -EINVAL;
-
        /*
         * Drop all container device buffers, from now on
         * the only valid external interface is through the md
@@ -1672,18 +1580,6 @@ static int do_md_run(mddev_t * mddev)
                        continue;
                sync_blockdev(rdev->bdev);
                invalidate_bdev(rdev->bdev, 0);
-#if 0
-       /*
-        * Aside of obvious breakage (code below results in block size set
-        * according to the sector size of last component instead of the
-        * maximal sector size), we have more interesting problem here.
-        * Namely, we actually ought to set _sector_ size for the array
-        * and that requires per-array request queues.  Disabled for now.
-        */
-               md_blocksizes[mdidx(mddev)] = 1024;
-               if (bdev_hardsect_size(rdev->bdev) > md_blocksizes[mdidx(mddev)])
-                       md_blocksizes[mdidx(mddev)] = bdev_hardsect_size(rdev->bdev);
-#endif
        }
 
        md_probe(mdidx(mddev), NULL, NULL);
@@ -1727,8 +1623,8 @@ static int do_md_run(mddev_t * mddev)
        
        set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
        md_wakeup_thread(mddev->thread);
-       set_capacity(disk, md_size[mdidx(mddev)]<<1);
-       return (0);
+       set_capacity(disk, mddev->array_size<<1);
+       return 0;
 }
 
 static int restart_array(mddev_t *mddev)
@@ -1828,7 +1724,7 @@ static int do_md_stop(mddev_t * mddev, int ro)
 
                export_array(mddev);
 
-               md_size[mdidx(mddev)] = 0;
+               mddev->array_size = 0;
                disk = disks[mdidx(mddev)];
                if (disk)
                        set_capacity(disk, 0);
@@ -3052,9 +2948,10 @@ static int md_seq_show(struct seq_file *seq, void *v)
                if (!list_empty(&mddev->disks)) {
                        if (mddev->pers)
                                seq_printf(seq, "\n      %llu blocks",
-                                                (unsigned long long)md_size[mdidx(mddev)]);
+                                       (unsigned long long)mddev->array_size);
                        else
-                               seq_printf(seq, "\n      %llu blocks", (unsigned long long)size);
+                               seq_printf(seq, "\n      %llu blocks",
+                                       (unsigned long long)size);
                }
 
                if (mddev->pers) {
@@ -3563,11 +3460,6 @@ struct notifier_block md_notifier = {
 static void md_geninit(void)
 {
        struct proc_dir_entry *p;
-       int i;
-
-       for(i = 0; i < MAX_MD_DEVS; i++) {
-               md_size[i] = 0;
-       }
 
        dprintk("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
 
@@ -3682,7 +3574,6 @@ static __exit void md_exit(void)
 module_init(md_init)
 module_exit(md_exit)
 
-EXPORT_SYMBOL(md_size);
 EXPORT_SYMBOL(register_md_personality);
 EXPORT_SYMBOL(unregister_md_personality);
 EXPORT_SYMBOL(md_error);

diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
index 538059aafe81806328a210eafbf9114585d09ec8..f5479398c79f28ac590b2fceb3d2b7efdb0b758f 100644 (file)
--- a/drivers/md/multipath.c
+++ b/drivers/md/multipath.c
@@ -438,6 +438,7 @@ static int multipath_run (mddev_t *mddev)
        /*
         * Ok, everything is just fine now
         */
+       mddev->array_size = mddev->size;
        return 0;
 
 out_free_conf:

diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index 8ab132f45fd9f2752319ff8c2f06b8f04294833f..a8831cd2aa47e288e22dc633590e647475230bdf 100644 (file)
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -196,6 +196,8 @@ static int raid0_run (mddev_t *mddev)
        sector_t zone0_size;
        s64 size;
        raid0_conf_t *conf;
+       mdk_rdev_t *rdev;
+       struct list_head *tmp;
 
        conf = vmalloc(sizeof (raid0_conf_t));
        if (!conf)
@@ -205,15 +207,20 @@ static int raid0_run (mddev_t *mddev)
        if (create_strip_zones (mddev)) 
                goto out_free_conf;
 
+       /* calculate array device size */
+       mddev->array_size = 0;
+       ITERATE_RDEV(mddev,rdev,tmp)
+               mddev->array_size += rdev->size;
+
        printk("raid0 : md_size is %llu blocks.\n", 
-               (unsigned long long)md_size[mdidx(mddev)]);
+               (unsigned long long)mddev->array_size);
        printk("raid0 : conf->smallest->size is %llu blocks.\n",
                (unsigned long long)conf->smallest->size);
        {
 #if __GNUC__ < 3
                volatile
 #endif
-               sector_t s = md_size[mdidx(mddev)];
+               sector_t s = mddev->array_size;
                int round = sector_div(s, (unsigned long)conf->smallest->size) ? 1 : 0;
                nb_zone = s + round;
        }

diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index cbbea29e0cf316029ebdcf6304d26007bda8ff10..a567ffb8019cf7936b8475aba36dea43afaf4870 100644 (file)
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1156,6 +1156,8 @@ static int run(mddev_t *mddev)
        /*
         * Ok, everything is just fine now
         */
+       mddev->array_size = mddev->size;
+
        return 0;
 
 out_free_conf:

diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index f1996ef6cd3a961081eaf3cf91aee6cc77912ad5..c66c5eb95234ec69507d3bc52d0aeca034a39900 100644 (file)
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -1550,7 +1550,8 @@ memory = conf->max_nr_stripes * (sizeof(struct stripe_head) +
        print_raid5_conf(conf);
 
        /* Ok, everything is just fine now */
-       return (0);
+       mddev->array_size =  mddev->size * (mddev->raid_disks - 1);
+       return 0;
 abort:
        if (conf) {
                print_raid5_conf(conf);

diff --git a/include/linux/raid/md.h b/include/linux/raid/md.h
index 3d4faa9f7171cad80d92facee63da441d692053d..02ff30e5a1875d027e75f8681b3383eda31a700e 100644 (file)
--- a/include/linux/raid/md.h
+++ b/include/linux/raid/md.h
@@ -61,8 +61,6 @@
 #define MD_MINOR_VERSION                90
 #define MD_PATCHLEVEL_VERSION           0
 
-extern sector_t md_size[MAX_MD_DEVS];
-
 extern inline char * bdev_partition_name (struct block_device *bdev)
 {
        return partition_name(bdev ? bdev->bd_dev : 0);

diff --git a/include/linux/raid/md_k.h b/include/linux/raid/md_k.h
index c9716b27c04ef111c4616068385b56466ba94cbd..8a80a9ea69a0e7ef9a4002cb5a595b55cc476022 100644 (file)
--- a/include/linux/raid/md_k.h
+++ b/include/linux/raid/md_k.h
@@ -203,6 +203,7 @@ struct mddev_s
        int                             raid_disks;
        int                             max_disks;
        sector_t                        size; /* used size of component devices */
+       sector_t                        array_size; /* exported array size */
        __u64                           events;
 
        char                            uuid[16];