md: change ITERATE_RDEV to rdev_for_each

As this is more in line with common practice in the kernel.  Also swap the
args around to be more like list_for_each.

Signed-off-by: Neil Brown <neilb@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 32 insertions, 32 deletions

diff --git a/drivers/md/md.c b/drivers/md/md.c
index c912ce2752a4..e02022864f08 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -311,7 +311,7 @@ static mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr)
         mdk_rdev_t * rdev;
         struct list_head *tmp;
 
-        ITERATE_RDEV(mddev,rdev,tmp) {
+        rdev_for_each(rdev, tmp, mddev) {
                 if (rdev->desc_nr == nr)
                         return rdev;
         }
@@ -323,7 +323,7 @@ static mdk_rdev_t * find_rdev(mddev_t * mddev, dev_t dev)
         struct list_head *tmp;
         mdk_rdev_t *rdev;
 
-        ITERATE_RDEV(mddev,rdev,tmp) {
+        rdev_for_each(rdev, tmp, mddev) {
                 if (rdev->bdev->bd_dev == dev)
                         return rdev;
         }
@@ -943,7 +943,7 @@ static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
                 sb->state |= (1<<MD_SB_BITMAP_PRESENT);
 
         sb->disks[0].state = (1<<MD_DISK_REMOVED);
-        ITERATE_RDEV(mddev,rdev2,tmp) {
+        rdev_for_each(rdev2, tmp, mddev) {
                 mdp_disk_t *d;
                 int desc_nr;
                 if (rdev2->raid_disk >= 0 && test_bit(In_sync, &rdev2->flags)
@@ -1295,7 +1295,7 @@ static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
         }
 
         max_dev = 0;
-        ITERATE_RDEV(mddev,rdev2,tmp)
+        rdev_for_each(rdev2, tmp, mddev)
                 if (rdev2->desc_nr+1 > max_dev)
                         max_dev = rdev2->desc_nr+1;
 
@@ -1304,7 +1304,7 @@ static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
         for (i=0; i<max_dev;i++)
                 sb->dev_roles[i] = cpu_to_le16(0xfffe);
         
-        ITERATE_RDEV(mddev,rdev2,tmp) {
+        rdev_for_each(rdev2, tmp, mddev) {
                 i = rdev2->desc_nr;
                 if (test_bit(Faulty, &rdev2->flags))
                         sb->dev_roles[i] = cpu_to_le16(0xfffe);
@@ -1342,8 +1342,8 @@ static int match_mddev_units(mddev_t *mddev1, mddev_t *mddev2)
         struct list_head *tmp, *tmp2;
         mdk_rdev_t *rdev, *rdev2;
 
-        ITERATE_RDEV(mddev1,rdev,tmp)
-                ITERATE_RDEV(mddev2, rdev2, tmp2)
+        rdev_for_each(rdev, tmp, mddev1)
+                rdev_for_each(rdev2, tmp2, mddev2)
                         if (rdev->bdev->bd_contains ==
                             rdev2->bdev->bd_contains)
                                 return 1;
@@ -1516,7 +1516,7 @@ static void export_array(mddev_t *mddev)
         struct list_head *tmp;
         mdk_rdev_t *rdev;
 
-        ITERATE_RDEV(mddev,rdev,tmp) {
+        rdev_for_each(rdev, tmp, mddev) {
                 if (!rdev->mddev) {
                         MD_BUG();
                         continue;
@@ -1600,11 +1600,11 @@ static void md_print_devices(void)
                         bitmap_print_sb(mddev->bitmap);
                 else
                         printk("%s: ", mdname(mddev));
-                ITERATE_RDEV(mddev,rdev,tmp2)
+                rdev_for_each(rdev, tmp2, mddev)
                         printk("<%s>", bdevname(rdev->bdev,b));
                 printk("\n");
 
-                ITERATE_RDEV(mddev,rdev,tmp2)
+                rdev_for_each(rdev, tmp2, mddev)
                         print_rdev(rdev);
         }
         printk("md:     **********************************\n");
@@ -1623,7 +1623,7 @@ static void sync_sbs(mddev_t * mddev, int nospares)
         mdk_rdev_t *rdev;
         struct list_head *tmp;
 
-        ITERATE_RDEV(mddev,rdev,tmp) {
+        rdev_for_each(rdev, tmp, mddev) {
                 if (rdev->sb_events == mddev->events ||
                     (nospares &&
                      rdev->raid_disk < 0 &&
@@ -1730,7 +1730,7 @@ repeat:
                 mdname(mddev),mddev->in_sync);
 
         bitmap_update_sb(mddev->bitmap);
-        ITERATE_RDEV(mddev,rdev,tmp) {
+        rdev_for_each(rdev, tmp, mddev) {
                 char b[BDEVNAME_SIZE];
                 dprintk(KERN_INFO "md: ");
                 if (rdev->sb_loaded != 1)
@@ -2016,7 +2016,7 @@ rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len)
                         mdk_rdev_t *rdev2;
 
                         mddev_lock(mddev);
-                        ITERATE_RDEV(mddev, rdev2, tmp2)
+                        rdev_for_each(rdev2, tmp2, mddev)
                                 if (test_bit(AllReserved, &rdev2->flags) ||
                                     (rdev->bdev == rdev2->bdev &&
                                      rdev != rdev2 &&
@@ -2202,7 +2202,7 @@ static void analyze_sbs(mddev_t * mddev)
         char b[BDEVNAME_SIZE];
 
         freshest = NULL;
-        ITERATE_RDEV(mddev,rdev,tmp)
+        rdev_for_each(rdev, tmp, mddev)
                 switch (super_types[mddev->major_version].
                         load_super(rdev, freshest, mddev->minor_version)) {
                 case 1:
@@ -2223,7 +2223,7 @@ static void analyze_sbs(mddev_t * mddev)
                 validate_super(mddev, freshest);
 
         i = 0;
-        ITERATE_RDEV(mddev,rdev,tmp) {
+        rdev_for_each(rdev, tmp, mddev) {
                 if (rdev != freshest)
                         if (super_types[mddev->major_version].
                             validate_super(mddev, rdev)) {
@@ -3317,7 +3317,7 @@ static int do_md_run(mddev_t * mddev)
                 }
 
                 /* devices must have minimum size of one chunk */
-                ITERATE_RDEV(mddev,rdev,tmp) {
+                rdev_for_each(rdev, tmp, mddev) {
                         if (test_bit(Faulty, &rdev->flags))
                                 continue;
                         if (rdev->size < chunk_size / 1024) {
@@ -3344,7 +3344,7 @@ static int do_md_run(mddev_t * mddev)
          * the only valid external interface is through the md
          * device.
          */
-        ITERATE_RDEV(mddev,rdev,tmp) {
+        rdev_for_each(rdev, tmp, mddev) {
                 if (test_bit(Faulty, &rdev->flags))
                         continue;
                 sync_blockdev(rdev->bdev);
@@ -3410,8 +3410,8 @@ static int do_md_run(mddev_t * mddev)
                 mdk_rdev_t *rdev2;
                 struct list_head *tmp2;
                 int warned = 0;
-                ITERATE_RDEV(mddev, rdev, tmp) {
-                        ITERATE_RDEV(mddev, rdev2, tmp2) {
+                rdev_for_each(rdev, tmp, mddev) {
+                        rdev_for_each(rdev2, tmp2, mddev) {
                                 if (rdev < rdev2 &&
                                     rdev->bdev->bd_contains ==
                                     rdev2->bdev->bd_contains) {
@@ -3471,7 +3471,7 @@ static int do_md_run(mddev_t * mddev)
         mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
         mddev->in_sync = 1;
 
-        ITERATE_RDEV(mddev,rdev,tmp)
+        rdev_for_each(rdev, tmp, mddev)
                 if (rdev->raid_disk >= 0) {
                         char nm[20];
                         sprintf(nm, "rd%d", rdev->raid_disk);
@@ -3504,7 +3504,7 @@ static int do_md_run(mddev_t * mddev)
         if (mddev->degraded && !mddev->sync_thread) {
                 struct list_head *rtmp;
                 int spares = 0;
-                ITERATE_RDEV(mddev,rdev,rtmp)
+                rdev_for_each(rdev, rtmp, mddev)
                         if (rdev->raid_disk >= 0 &&
                             !test_bit(In_sync, &rdev->flags) &&
                             !test_bit(Faulty, &rdev->flags))
@@ -3681,7 +3681,7 @@ static int do_md_stop(mddev_t * mddev, int mode)
                 }
                 mddev->bitmap_offset = 0;
 
-                ITERATE_RDEV(mddev,rdev,tmp)
+                rdev_for_each(rdev, tmp, mddev)
                         if (rdev->raid_disk >= 0) {
                                 char nm[20];
                                 sprintf(nm, "rd%d", rdev->raid_disk);
@@ -3723,7 +3723,7 @@ static void autorun_array(mddev_t *mddev)
 
         printk(KERN_INFO "md: running: ");
 
-        ITERATE_RDEV(mddev,rdev,tmp) {
+        rdev_for_each(rdev, tmp, mddev) {
                 char b[BDEVNAME_SIZE];
                 printk("<%s>", bdevname(rdev->bdev,b));
         }
@@ -3851,7 +3851,7 @@ static int get_array_info(mddev_t * mddev, void __user * arg)
         struct list_head *tmp;
 
         nr=working=active=failed=spare=0;
-        ITERATE_RDEV(mddev,rdev,tmp) {
+        rdev_for_each(rdev, tmp, mddev) {
                 nr++;
                 if (test_bit(Faulty, &rdev->flags))
                         failed++;
@@ -4391,7 +4391,7 @@ static int update_size(mddev_t *mddev, unsigned long size)
          */
         if (mddev->sync_thread)
                 return -EBUSY;
-        ITERATE_RDEV(mddev,rdev,tmp) {
+        rdev_for_each(rdev, tmp, mddev) {
                 sector_t avail;
                 avail = rdev->size * 2;
 
@@ -5132,7 +5132,7 @@ static int md_seq_show(struct seq_file *seq, void *v)
                 }
 
                 size = 0;
-                ITERATE_RDEV(mddev,rdev,tmp2) {
+                rdev_for_each(rdev, tmp2, mddev) {
                         char b[BDEVNAME_SIZE];
                         seq_printf(seq, " %s[%d]",
                                 bdevname(rdev->bdev,b), rdev->desc_nr);
@@ -5288,7 +5288,7 @@ static int is_mddev_idle(mddev_t *mddev)
         long curr_events;
 
         idle = 1;
-        ITERATE_RDEV(mddev,rdev,tmp) {
+        rdev_for_each(rdev, tmp, mddev) {
                 struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
                 curr_events = disk_stat_read(disk, sectors[0]) + 
                                 disk_stat_read(disk, sectors[1]) - 
@@ -5515,7 +5515,7 @@ void md_do_sync(mddev_t *mddev)
                 /* recovery follows the physical size of devices */
                 max_sectors = mddev->size << 1;
                 j = MaxSector;
-                ITERATE_RDEV(mddev,rdev,rtmp)
+                rdev_for_each(rdev, rtmp, mddev)
                         if (rdev->raid_disk >= 0 &&
                             !test_bit(Faulty, &rdev->flags) &&
                             !test_bit(In_sync, &rdev->flags) &&
@@ -5668,7 +5668,7 @@ void md_do_sync(mddev_t *mddev)
                 } else {
                         if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
                                 mddev->curr_resync = MaxSector;
-                        ITERATE_RDEV(mddev,rdev,rtmp)
+                        rdev_for_each(rdev, rtmp, mddev)
                                 if (rdev->raid_disk >= 0 &&
                                     !test_bit(Faulty, &rdev->flags) &&
                                     !test_bit(In_sync, &rdev->flags) &&
@@ -5706,7 +5706,7 @@ static int remove_and_add_spares(mddev_t *mddev)
         struct list_head *rtmp;
         int spares = 0;
 
-        ITERATE_RDEV(mddev,rdev,rtmp)
+        rdev_for_each(rdev, rtmp, mddev)
                 if (rdev->raid_disk >= 0 &&
                     !mddev->external &&
                     (test_bit(Faulty, &rdev->flags) ||
@@ -5722,7 +5722,7 @@ static int remove_and_add_spares(mddev_t *mddev)
                 }
 
         if (mddev->degraded) {
-                ITERATE_RDEV(mddev,rdev,rtmp)
+                rdev_for_each(rdev, rtmp, mddev)
                         if (rdev->raid_disk < 0
                             && !test_bit(Faulty, &rdev->flags)) {
                                 rdev->recovery_offset = 0;
@@ -5836,7 +5836,7 @@ void md_check_recovery(mddev_t *mddev)
                          * information must be scrapped
                          */
                         if (!mddev->degraded)
-                                ITERATE_RDEV(mddev,rdev,rtmp)
+                                rdev_for_each(rdev, rtmp, mddev)
                                         rdev->saved_raid_disk = -1;
 
                         mddev->recovery = 0;