Merge tag 'v3.4-rc6' into gpio/next

Linux 3.4-rc6

9 files changed, 88 insertions, 51 deletions

diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index 3d0dfa7a89a2..17e2b472e16d 100644
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -539,9 +539,6 @@ static int bitmap_new_disk_sb(struct bitmap *bitmap)
         bitmap->events_cleared = bitmap->mddev->events;
         sb->events_cleared = cpu_to_le64(bitmap->mddev->events);
 
-        bitmap->flags |= BITMAP_HOSTENDIAN;
-        sb->version = cpu_to_le32(BITMAP_MAJOR_HOSTENDIAN);
-
         kunmap_atomic(sb);
 
         return 0;
@@ -1730,8 +1727,7 @@ int bitmap_create(struct mddev *mddev)
         bitmap->chunkshift = (ffz(~mddev->bitmap_info.chunksize)
                               - BITMAP_BLOCK_SHIFT);
 
-        /* now that chunksize and chunkshift are set, we can use these macros */
-        chunks = (blocks + bitmap->chunkshift - 1) >>
+        chunks = (blocks + (1 << bitmap->chunkshift) - 1) >>
                         bitmap->chunkshift;
         pages = (chunks + PAGE_COUNTER_RATIO - 1) / PAGE_COUNTER_RATIO;
 
@@ -1788,7 +1784,9 @@ int bitmap_load(struct mddev *mddev)
                  * re-add of a missing device */
                 start = mddev->recovery_cp;
 
+        mutex_lock(&mddev->bitmap_info.mutex);
         err = bitmap_init_from_disk(bitmap, start);
+        mutex_unlock(&mddev->bitmap_info.mutex);
 
         if (err)
                 goto out;
diff --git a/drivers/md/bitmap.h b/drivers/md/bitmap.h
index 55ca5aec84e4..b44b0aba2d47 100644
--- a/drivers/md/bitmap.h
+++ b/drivers/md/bitmap.h
@@ -101,9 +101,6 @@ typedef __u16 bitmap_counter_t;
 
 #define BITMAP_BLOCK_SHIFT 9
 
-/* how many blocks per chunk? (this is variable) */
-#define CHUNK_BLOCK_RATIO(bitmap) ((bitmap)->mddev->bitmap_info.chunksize >> BITMAP_BLOCK_SHIFT)
-
 #endif
 
 /*
diff --git a/drivers/md/dm-raid.c b/drivers/md/dm-raid.c
index b0ba52459ed7..68965e663248 100644
--- a/drivers/md/dm-raid.c
+++ b/drivers/md/dm-raid.c
@@ -859,7 +859,7 @@ static int analyse_superblocks(struct dm_target *ti, struct raid_set *rs)
         int ret;
         unsigned redundancy = 0;
         struct raid_dev *dev;
-        struct md_rdev *rdev, *freshest;
+        struct md_rdev *rdev, *tmp, *freshest;
         struct mddev *mddev = &rs->md;
 
         switch (rs->raid_type->level) {
@@ -877,7 +877,7 @@ static int analyse_superblocks(struct dm_target *ti, struct raid_set *rs)
         }
 
         freshest = NULL;
-        rdev_for_each(rdev, mddev) {
+        rdev_for_each_safe(rdev, tmp, mddev) {
                 if (!rdev->meta_bdev)
                         continue;
 
diff --git a/drivers/md/linear.c b/drivers/md/linear.c
index b0fcc7d02adb..fa211d80fc0a 100644
--- a/drivers/md/linear.c
+++ b/drivers/md/linear.c
@@ -198,6 +198,7 @@ out:
 static int linear_run (struct mddev *mddev)
 {
         struct linear_conf *conf;
+        int ret;
 
         if (md_check_no_bitmap(mddev))
                 return -EINVAL;
@@ -211,7 +212,13 @@ static int linear_run (struct mddev *mddev)
         blk_queue_merge_bvec(mddev->queue, linear_mergeable_bvec);
         mddev->queue->backing_dev_info.congested_fn = linear_congested;
         mddev->queue->backing_dev_info.congested_data = mddev;
-        return md_integrity_register(mddev);
+
+        ret =  md_integrity_register(mddev);
+        if (ret) {
+                kfree(conf);
+                mddev->private = NULL;
+        }
+        return ret;
 }
 
 static int linear_add(struct mddev *mddev, struct md_rdev *rdev)
diff --git a/drivers/md/md.c b/drivers/md/md.c
index b572e1e386ce..477eb2e180c0 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -7560,14 +7560,14 @@ void md_check_recovery(struct mddev *mddev)
                  * any transients in the value of "sync_action".
                  */
                 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
-                clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
                 /* Clear some bits that don't mean anything, but
                  * might be left set
                  */
                 clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
                 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
 
-                if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
+                if (!test_and_clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
+                    test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
                         goto unlock;
                 /* no recovery is running.
                  * remove any failed drives, then
@@ -8140,7 +8140,8 @@ static int md_notify_reboot(struct notifier_block *this,
 
         for_each_mddev(mddev, tmp) {
                 if (mddev_trylock(mddev)) {
-                        __md_stop_writes(mddev);
+                        if (mddev->pers)
+                                __md_stop_writes(mddev);
                         mddev->safemode = 2;
                         mddev_unlock(mddev);
                 }
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index 6f31f5596e01..de63a1fc3737 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -407,6 +407,8 @@ static sector_t raid0_size(struct mddev *mddev, sector_t sectors, int raid_disks
         return array_sectors;
 }
 
+static int raid0_stop(struct mddev *mddev);
+
 static int raid0_run(struct mddev *mddev)
 {
         struct r0conf *conf;
@@ -454,7 +456,12 @@ static int raid0_run(struct mddev *mddev)
 
         blk_queue_merge_bvec(mddev->queue, raid0_mergeable_bvec);
         dump_zones(mddev);
-        return md_integrity_register(mddev);
+
+        ret = md_integrity_register(mddev);
+        if (ret)
+                raid0_stop(mddev);
+
+        return ret;
 }
 
 static int raid0_stop(struct mddev *mddev)
@@ -625,6 +632,7 @@ static void *raid0_takeover_raid10(struct mddev *mddev)
 static void *raid0_takeover_raid1(struct mddev *mddev)
 {
         struct r0conf *priv_conf;
+        int chunksect;
 
         /* Check layout:
          *  - (N - 1) mirror drives must be already faulty
@@ -635,10 +643,25 @@ static void *raid0_takeover_raid1(struct mddev *mddev)
                 return ERR_PTR(-EINVAL);
         }
 
+        /*
+         * a raid1 doesn't have the notion of chunk size, so
+         * figure out the largest suitable size we can use.
+         */
+        chunksect = 64 * 2; /* 64K by default */
+
+        /* The array must be an exact multiple of chunksize */
+        while (chunksect && (mddev->array_sectors & (chunksect - 1)))
+                chunksect >>= 1;
+
+        if ((chunksect << 9) < PAGE_SIZE)
+                /* array size does not allow a suitable chunk size */
+                return ERR_PTR(-EINVAL);
+
         /* Set new parameters */
         mddev->new_level = 0;
         mddev->new_layout = 0;
-        mddev->new_chunk_sectors = 128; /* by default set chunk size to 64k */
+        mddev->new_chunk_sectors = chunksect;
+        mddev->chunk_sectors = chunksect;
         mddev->delta_disks = 1 - mddev->raid_disks;
         mddev->raid_disks = 1;
         /* make sure it will be not marked as dirty */
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 4a40a200d769..15dd59b84e94 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1712,6 +1712,7 @@ static int process_checks(struct r1bio *r1_bio)
         struct r1conf *conf = mddev->private;
         int primary;
         int i;
+        int vcnt;
 
         for (primary = 0; primary < conf->raid_disks * 2; primary++)
                 if (r1_bio->bios[primary]->bi_end_io == end_sync_read &&
@@ -1721,9 +1722,9 @@ static int process_checks(struct r1bio *r1_bio)
                         break;
                 }
         r1_bio->read_disk = primary;
+        vcnt = (r1_bio->sectors + PAGE_SIZE / 512 - 1) >> (PAGE_SHIFT - 9);
         for (i = 0; i < conf->raid_disks * 2; i++) {
                 int j;
-                int vcnt = r1_bio->sectors >> (PAGE_SHIFT- 9);
                 struct bio *pbio = r1_bio->bios[primary];
                 struct bio *sbio = r1_bio->bios[i];
                 int size;
@@ -1738,7 +1739,7 @@ static int process_checks(struct r1bio *r1_bio)
                                 s = sbio->bi_io_vec[j].bv_page;
                                 if (memcmp(page_address(p),
                                            page_address(s),
-                                           PAGE_SIZE))
+                                           sbio->bi_io_vec[j].bv_len))
                                         break;
                         }
                 } else
@@ -2386,8 +2387,7 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr, int *skipp
                 int ok = 1;
                 for (i = 0 ; i < conf->raid_disks * 2 ; i++)
                         if (r1_bio->bios[i]->bi_end_io == end_sync_write) {
-                                struct md_rdev *rdev =
-                                        rcu_dereference(conf->mirrors[i].rdev);
+                                struct md_rdev *rdev = conf->mirrors[i].rdev;
                                 ok = rdev_set_badblocks(rdev, sector_nr,
                                                         min_bad, 0
                                         ) && ok;
@@ -2636,11 +2636,13 @@ static struct r1conf *setup_conf(struct mddev *mddev)
         return ERR_PTR(err);
 }
 
+static int stop(struct mddev *mddev);
 static int run(struct mddev *mddev)
 {
         struct r1conf *conf;
         int i;
         struct md_rdev *rdev;
+        int ret;
 
         if (mddev->level != 1) {
                 printk(KERN_ERR "md/raid1:%s: raid level not set to mirroring (%d)\n",
@@ -2705,7 +2707,11 @@ static int run(struct mddev *mddev)
                 mddev->queue->backing_dev_info.congested_data = mddev;
                 blk_queue_merge_bvec(mddev->queue, raid1_mergeable_bvec);
         }
-        return md_integrity_register(mddev);
+
+        ret =  md_integrity_register(mddev);
+        if (ret)
+                stop(mddev);
+        return ret;
 }
 
 static int stop(struct mddev *mddev)
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 3540316886f2..c8dbb84d5357 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -1788,6 +1788,7 @@ static void sync_request_write(struct mddev *mddev, struct r10bio *r10_bio)
         struct r10conf *conf = mddev->private;
         int i, first;
         struct bio *tbio, *fbio;
+        int vcnt;
 
         atomic_set(&r10_bio->remaining, 1);
 
@@ -1802,10 +1803,10 @@ static void sync_request_write(struct mddev *mddev, struct r10bio *r10_bio)
         first = i;
         fbio = r10_bio->devs[i].bio;
 
+        vcnt = (r10_bio->sectors + (PAGE_SIZE >> 9) - 1) >> (PAGE_SHIFT - 9);
         /* now find blocks with errors */
         for (i=0 ; i < conf->copies ; i++) {
                 int  j, d;
-                int vcnt = r10_bio->sectors >> (PAGE_SHIFT-9);
 
                 tbio = r10_bio->devs[i].bio;
 
@@ -1821,7 +1822,7 @@ static void sync_request_write(struct mddev *mddev, struct r10bio *r10_bio)
                         for (j = 0; j < vcnt; j++)
                                 if (memcmp(page_address(fbio->bi_io_vec[j].bv_page),
                                            page_address(tbio->bi_io_vec[j].bv_page),
-                                           PAGE_SIZE))
+                                           fbio->bi_io_vec[j].bv_len))
                                         break;
                         if (j == vcnt)
                                 continue;
@@ -1871,7 +1872,6 @@ static void sync_request_write(struct mddev *mddev, struct r10bio *r10_bio)
          */
         for (i = 0; i < conf->copies; i++) {
                 int j, d;
-                int vcnt = r10_bio->sectors >> (PAGE_SHIFT-9);
 
                 tbio = r10_bio->devs[i].repl_bio;
                 if (!tbio || !tbio->bi_end_io)
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 23ac880bba9a..f351422938e0 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -2471,39 +2471,41 @@ handle_failed_sync(struct r5conf *conf, struct stripe_head *sh,
         int abort = 0;
         int i;
 
-        md_done_sync(conf->mddev, STRIPE_SECTORS, 0);
         clear_bit(STRIPE_SYNCING, &sh->state);
         s->syncing = 0;
         s->replacing = 0;
         /* There is nothing more to do for sync/check/repair.
+         * Don't even need to abort as that is handled elsewhere
+         * if needed, and not always wanted e.g. if there is a known
+         * bad block here.
          * For recover/replace we need to record a bad block on all
          * non-sync devices, or abort the recovery
          */
-        if (!test_bit(MD_RECOVERY_RECOVER, &conf->mddev->recovery))
-                return;
-        /* During recovery devices cannot be removed, so locking and
-         * refcounting of rdevs is not needed
-         */
-        for (i = 0; i < conf->raid_disks; i++) {
-                struct md_rdev *rdev = conf->disks[i].rdev;
-                if (rdev
-                    && !test_bit(Faulty, &rdev->flags)
-                    && !test_bit(In_sync, &rdev->flags)
-                    && !rdev_set_badblocks(rdev, sh->sector,
-                                           STRIPE_SECTORS, 0))
-                        abort = 1;
-                rdev = conf->disks[i].replacement;
-                if (rdev
-                    && !test_bit(Faulty, &rdev->flags)
-                    && !test_bit(In_sync, &rdev->flags)
-                    && !rdev_set_badblocks(rdev, sh->sector,
-                                           STRIPE_SECTORS, 0))
-                        abort = 1;
-        }
-        if (abort) {
-                conf->recovery_disabled = conf->mddev->recovery_disabled;
-                set_bit(MD_RECOVERY_INTR, &conf->mddev->recovery);
+        if (test_bit(MD_RECOVERY_RECOVER, &conf->mddev->recovery)) {
+                /* During recovery devices cannot be removed, so
+                 * locking and refcounting of rdevs is not needed
+                 */
+                for (i = 0; i < conf->raid_disks; i++) {
+                        struct md_rdev *rdev = conf->disks[i].rdev;
+                        if (rdev
+                            && !test_bit(Faulty, &rdev->flags)
+                            && !test_bit(In_sync, &rdev->flags)
+                            && !rdev_set_badblocks(rdev, sh->sector,
+                                                   STRIPE_SECTORS, 0))
+                                abort = 1;
+                        rdev = conf->disks[i].replacement;
+                        if (rdev
+                            && !test_bit(Faulty, &rdev->flags)
+                            && !test_bit(In_sync, &rdev->flags)
+                            && !rdev_set_badblocks(rdev, sh->sector,
+                                                   STRIPE_SECTORS, 0))
+                                abort = 1;
+                }
+                if (abort)
+                        conf->recovery_disabled =
+                                conf->mddev->recovery_disabled;
         }
+        md_done_sync(conf->mddev, STRIPE_SECTORS, !abort);
 }
 
 static int want_replace(struct stripe_head *sh, int disk_idx)
@@ -3203,7 +3205,8 @@ static void analyse_stripe(struct stripe_head *sh, struct stripe_head_state *s)
                         /* Not in-sync */;
                 else if (is_bad) {
                         /* also not in-sync */
-                        if (!test_bit(WriteErrorSeen, &rdev->flags)) {
+                        if (!test_bit(WriteErrorSeen, &rdev->flags) &&
+                            test_bit(R5_UPTODATE, &dev->flags)) {
                                 /* treat as in-sync, but with a read error
                                  * which we can now try to correct
                                  */
@@ -3276,12 +3279,14 @@ static void analyse_stripe(struct stripe_head *sh, struct stripe_head_state *s)
                 /* If there is a failed device being replaced,
                  *     we must be recovering.
                  * else if we are after recovery_cp, we must be syncing
+                 * else if MD_RECOVERY_REQUESTED is set, we also are syncing.
                  * else we can only be replacing
                  * sync and recovery both need to read all devices, and so
                  * use the same flag.
                  */
                 if (do_recovery ||
-                    sh->sector >= conf->mddev->recovery_cp)
+                    sh->sector >= conf->mddev->recovery_cp ||
+                    test_bit(MD_RECOVERY_REQUESTED, &(conf->mddev->recovery)))
                         s->syncing = 1;
                 else
                         s->replacing = 1;