Merge tag 'md-3.5' of git://neil.brown.name/md

Pull md updates from NeilBrown:
 "It's been a busy cycle for md - lots of fun stuff here..  if you like
  this kind of thing :-)

  Main features:
   - RAID10 arrays can be reshaped - adding and removing devices and
     changing chunks (not 'far' array though)
   - allow RAID5 arrays to be reshaped with a backup file (not tested
     yet, but the priciple works fine for RAID10).
   - arrays can be reshaped while a bitmap is present - you no longer
     need to remove it first
   - SSSE3 support for RAID6 syndrome calculations

  and of course a number of minor fixes etc."

* tag 'md-3.5' of git://neil.brown.name/md: (56 commits)
  md/bitmap: record the space available for the bitmap in the superblock.
  md/raid10: Remove extras after reshape to smaller number of devices.
  md/raid5: improve removal of extra devices after reshape.
  md: check the return of mddev_find()
  MD RAID1: Further conditionalize 'fullsync'
  DM RAID: Use md_error() in place of simply setting Faulty bit
  DM RAID: Record and handle missing devices
  DM RAID: Set recovery flags on resume
  md/raid5: Allow reshape while a bitmap is present.
  md/raid10: resize bitmap when required during reshape.
  md: allow array to be resized while bitmap is present.
  md/bitmap: make sure reshape request are reflected in superblock.
  md/bitmap: add bitmap_resize function to allow bitmap resizing.
  md/bitmap: use DIV_ROUND_UP instead of open-code
  md/bitmap: create a 'struct bitmap_counts' substructure of 'struct bitmap'
  md/bitmap: make bitmap bitops atomic.
  md/bitmap: make _page_attr bitops atomic.
  md/bitmap: merge bitmap_file_unmap and bitmap_file_put.
  md/bitmap: remove async freeing of bitmap file.
  md/bitmap: convert some spin_lock_irqsave to spin_lock_irq
  ...

1 files changed, 11 insertions, 11 deletions

diff --git a/drivers/md/dm-raid.c b/drivers/md/dm-raid.c
index 68965e663248..017c34d78d61 100644
--- a/drivers/md/dm-raid.c
+++ b/drivers/md/dm-raid.c
@@ -155,10 +155,7 @@ static void context_free(struct raid_set *rs)
         for (i = 0; i < rs->md.raid_disks; i++) {
                 if (rs->dev[i].meta_dev)
                         dm_put_device(rs->ti, rs->dev[i].meta_dev);
-                if (rs->dev[i].rdev.sb_page)
-                        put_page(rs->dev[i].rdev.sb_page);
-                rs->dev[i].rdev.sb_page = NULL;
-                rs->dev[i].rdev.sb_loaded = 0;
+                md_rdev_clear(&rs->dev[i].rdev);
                 if (rs->dev[i].data_dev)
                         dm_put_device(rs->ti, rs->dev[i].data_dev);
         }
@@ -606,7 +603,7 @@ static int read_disk_sb(struct md_rdev *rdev, int size)
         if (!sync_page_io(rdev, 0, size, rdev->sb_page, READ, 1)) {
                 DMERR("Failed to read superblock of device at position %d",
                       rdev->raid_disk);
-                set_bit(Faulty, &rdev->flags);
+                md_error(rdev->mddev, rdev);
                 return -EINVAL;
         }
 
@@ -617,16 +614,18 @@ static int read_disk_sb(struct md_rdev *rdev, int size)
 
 static void super_sync(struct mddev *mddev, struct md_rdev *rdev)
 {
-        struct md_rdev *r;
+        int i;
         uint64_t failed_devices;
         struct dm_raid_superblock *sb;
+        struct raid_set *rs = container_of(mddev, struct raid_set, md);
 
         sb = page_address(rdev->sb_page);
         failed_devices = le64_to_cpu(sb->failed_devices);
 
-        rdev_for_each(r, mddev)
-                if ((r->raid_disk >= 0) && test_bit(Faulty, &r->flags))
-                        failed_devices |= (1ULL << r->raid_disk);
+        for (i = 0; i < mddev->raid_disks; i++)
+                if (!rs->dev[i].data_dev ||
+                    test_bit(Faulty, &(rs->dev[i].rdev.flags)))
+                        failed_devices |= (1ULL << i);
 
         memset(sb, 0, sizeof(*sb));
 
@@ -1252,12 +1251,13 @@ static void raid_resume(struct dm_target *ti)
 {
         struct raid_set *rs = ti->private;
 
+        set_bit(MD_CHANGE_DEVS, &rs->md.flags);
         if (!rs->bitmap_loaded) {
                 bitmap_load(&rs->md);
                 rs->bitmap_loaded = 1;
-        } else
-                md_wakeup_thread(rs->md.thread);
+        }
 
+        clear_bit(MD_RECOVERY_FROZEN, &rs->md.recovery);
         mddev_resume(&rs->md);
 }