17 files changed, 159 insertions, 123 deletions
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 9933eb861c71..ed1038164019 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -776,7 +776,7 @@ static void kcryptd_crypt_write_convert(struct dm_crypt_io *io)
                 * But don't wait if split was due to the io size restriction
                 */
                if (unlikely(out_of_pages))
-                        congestion_wait(WRITE, HZ/100);
+                        congestion_wait(BLK_RW_ASYNC, HZ/100);
                /*
                 * With async crypto it is unsafe to share the crypto context
@@ -1318,7 +1318,7 @@ static int crypt_iterate_devices(struct dm_target *ti,
 {
        struct crypt_config *cc = ti->private;
-        return fn(ti, cc->dev, cc->start, data);
+        return fn(ti, cc->dev, cc->start, ti->len, data);
 }
 static struct target_type crypt_target = {
diff --git a/drivers/md/dm-delay.c b/drivers/md/dm-delay.c
index 4e5b843cd4d7..ebe7381f47c8 100644
--- a/drivers/md/dm-delay.c
+++ b/drivers/md/dm-delay.c
@@ -324,12 +324,12 @@ static int delay_iterate_devices(struct dm_target *ti,
        struct delay_c *dc = ti->private;
        int ret = 0;
-        ret = fn(ti, dc->dev_read, dc->start_read, data);
+        ret = fn(ti, dc->dev_read, dc->start_read, ti->len, data);
        if (ret)
                goto out;
        if (dc->dev_write)
-                ret = fn(ti, dc->dev_write, dc->start_write, data);
+                ret = fn(ti, dc->dev_write, dc->start_write, ti->len, data);
 out:
        return ret;
diff --git a/drivers/md/dm-linear.c b/drivers/md/dm-linear.c
index 9184b6deb868..82f7d6e6b1ea 100644
--- a/drivers/md/dm-linear.c
+++ b/drivers/md/dm-linear.c
@@ -139,7 +139,7 @@ static int linear_iterate_devices(struct dm_target *ti,
 {
        struct linear_c *lc = ti->private;
-        return fn(ti, lc->dev, lc->start, data);
+        return fn(ti, lc->dev, lc->start, ti->len, data);
 }
 static struct target_type linear_target = {
diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
index c70604a20897..6f0d90d4a541 100644
--- a/drivers/md/dm-mpath.c
+++ b/drivers/md/dm-mpath.c
@@ -1453,7 +1453,7 @@ static int multipath_iterate_devices(struct dm_target *ti,
        list_for_each_entry(pg, &m->priority_groups, list) {
                list_for_each_entry(p, &pg->pgpaths, list) {
-                        ret = fn(ti, p->path.dev, ti->begin, data);
+                        ret = fn(ti, p->path.dev, ti->begin, ti->len, data);
                        if (ret)
                                goto out;
                }
diff --git a/drivers/md/dm-raid1.c b/drivers/md/dm-raid1.c
index ce8868c768cc..9726577cde49 100644
--- a/drivers/md/dm-raid1.c
+++ b/drivers/md/dm-raid1.c
@@ -638,6 +638,7 @@ static void do_writes(struct mirror_set *ms, struct bio_list *writes)
                spin_lock_irq(&ms->lock);
                bio_list_merge(&ms->writes, &requeue);
                spin_unlock_irq(&ms->lock);
+                delayed_wake(ms);
        }
        /*
@@ -1292,7 +1293,7 @@ static int mirror_iterate_devices(struct dm_target *ti,
        for (i = 0; !ret && i < ms->nr_mirrors; i++)
                ret = fn(ti, ms->mirror[i].dev,
-                         ms->mirror[i].offset, data);
+                         ms->mirror[i].offset, ti->len, data);
        return ret;
 }
diff --git a/drivers/md/dm-stripe.c b/drivers/md/dm-stripe.c
index b240e85ae39a..4e0e5937e42a 100644
--- a/drivers/md/dm-stripe.c
+++ b/drivers/md/dm-stripe.c
@@ -320,10 +320,11 @@ static int stripe_iterate_devices(struct dm_target *ti,
        int ret = 0;
        unsigned i = 0;
-        do
+        do {
                ret = fn(ti, sc->stripe[i].dev,
-                         sc->stripe[i].physical_start, data);
+                         sc->stripe[i].physical_start,
-        while (!ret && ++i < sc->stripes);
+                         sc->stripe_width, data);
+        } while (!ret && ++i < sc->stripes);
        return ret;
 }
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 2cba557d9e61..d952b3441913 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -346,7 +346,7 @@ static void close_dev(struct dm_dev_internal *d, struct mapped_device *md)
 * If possible, this checks an area of a destination device is valid.
 */
 static int device_area_is_valid(struct dm_target *ti, struct dm_dev *dev,
-                                sector_t start, void *data)
+                                sector_t start, sector_t len, void *data)
 {
        struct queue_limits *limits = data;
        struct block_device *bdev = dev->bdev;
@@ -359,7 +359,7 @@ static int device_area_is_valid(struct dm_target *ti, struct dm_dev *dev,
        if (!dev_size)
                return 1;
-        if ((start >= dev_size) || (start + ti->len > dev_size)) {
+        if ((start >= dev_size) || (start + len > dev_size)) {
                DMWARN("%s: %s too small for target",
                       dm_device_name(ti->table->md), bdevname(bdev, b));
                return 0;
@@ -377,11 +377,11 @@ static int device_area_is_valid(struct dm_target *ti, struct dm_dev *dev,
                return 0;
        }
-        if (ti->len & (logical_block_size_sectors - 1)) {
+        if (len & (logical_block_size_sectors - 1)) {
                DMWARN("%s: len=%llu not aligned to h/w "
                       "logical block size %hu of %s",
                       dm_device_name(ti->table->md),
-                       (unsigned long long)ti->len,
+                       (unsigned long long)len,
                       limits->logical_block_size, bdevname(bdev, b));
                return 0;
        }
@@ -482,7 +482,7 @@ static int __table_get_device(struct dm_table *t, struct dm_target *ti,
 #define min_not_zero(l, r) (l == 0) ? r : ((r == 0) ? l : min(l, r))
 int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev,
-                         sector_t start, void *data)
+                         sector_t start, sector_t len, void *data)
 {
        struct queue_limits *limits = data;
        struct block_device *bdev = dev->bdev;
@@ -830,11 +830,6 @@ unsigned dm_table_get_type(struct dm_table *t)
        return t->type;
 }
-bool dm_table_bio_based(struct dm_table *t)
-{
-        return dm_table_get_type(t) == DM_TYPE_BIO_BASED;
-}
 bool dm_table_request_based(struct dm_table *t)
 {
        return dm_table_get_type(t) == DM_TYPE_REQUEST_BASED;
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 9acd54a5cffb..8a311ea0d441 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -2203,16 +2203,6 @@ int dm_swap_table(struct mapped_device *md, struct dm_table *table)
                goto out;
        }
-        /*
-         * It is enought that blk_queue_ordered() is called only once when
-         * the first bio-based table is bound.
-         *
-         * This setting should be moved to alloc_dev() when request-based dm
-         * supports barrier.
-         */
-        if (!md->map && dm_table_bio_based(table))
-                blk_queue_ordered(md->queue, QUEUE_ORDERED_DRAIN, NULL);
        __unbind(md);
        r = __bind(md, table, &limits);
diff --git a/drivers/md/dm.h b/drivers/md/dm.h
index 23278ae80f08..a7663eba17e2 100644
--- a/drivers/md/dm.h
+++ b/drivers/md/dm.h
@@ -61,7 +61,6 @@ int dm_table_any_congested(struct dm_table *t, int bdi_bits);
 int dm_table_any_busy_target(struct dm_table *t);
 int dm_table_set_type(struct dm_table *t);
 unsigned dm_table_get_type(struct dm_table *t);
-bool dm_table_bio_based(struct dm_table *t);
 bool dm_table_request_based(struct dm_table *t);
 int dm_table_alloc_md_mempools(struct dm_table *t);
 void dm_table_free_md_mempools(struct dm_table *t);
diff --git a/drivers/md/linear.c b/drivers/md/linear.c
index 5810fa906af0..5fe39c2a3d2b 100644
--- a/drivers/md/linear.c
+++ b/drivers/md/linear.c
@@ -220,6 +220,7 @@ static int linear_run (mddev_t *mddev)
        mddev->queue->unplug_fn = linear_unplug;
        mddev->queue->backing_dev_info.congested_fn = linear_congested;
        mddev->queue->backing_dev_info.congested_data = mddev;
+        md_integrity_register(mddev);
        return 0;
 }
@@ -256,6 +257,7 @@ static int linear_add(mddev_t *mddev, mdk_rdev_t *rdev)
        rcu_assign_pointer(mddev->private, newconf);
        md_set_array_sectors(mddev, linear_size(mddev, 0, 0));
        set_capacity(mddev->gendisk, mddev->array_sectors);
+        revalidate_disk(mddev->gendisk);
        call_rcu(&oldconf->rcu, free_conf);
        return 0;
 }
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 0f4a70c43ffc..5b98bea4ff9b 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -1308,7 +1308,12 @@ static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev)
        }
        if (mddev->level != LEVEL_MULTIPATH) {
                int role;
-                role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
+                if (rdev->desc_nr < 0 ||
+                    rdev->desc_nr >= le32_to_cpu(sb->max_dev)) {
+                        role = 0xffff;
+                        rdev->desc_nr = -1;
+                } else
+                        role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
                switch(role) {
                case 0xffff: /* spare */
                        break;
@@ -1394,8 +1399,14 @@ static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
                if (rdev2->desc_nr+1 > max_dev)
                        max_dev = rdev2->desc_nr+1;
-        if (max_dev > le32_to_cpu(sb->max_dev))
+        if (max_dev > le32_to_cpu(sb->max_dev)) {
+                int bmask;
                sb->max_dev = cpu_to_le32(max_dev);
+                rdev->sb_size = max_dev * 2 + 256;
+                bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
+                if (rdev->sb_size & bmask)
+                        rdev->sb_size = (rdev->sb_size | bmask) + 1;
+        }
        for (i=0; i<max_dev;i++)
                sb->dev_roles[i] = cpu_to_le16(0xfffe);
        
@@ -1487,37 +1498,76 @@ static int match_mddev_units(mddev_t *mddev1, mddev_t *mddev2)
 static LIST_HEAD(pending_raid_disks);
-static void md_integrity_check(mdk_rdev_t *rdev, mddev_t *mddev)
+/*
+ * Try to register data integrity profile for an mddev
+ *
+ * This is called when an array is started and after a disk has been kicked
+ * from the array. It only succeeds if all working and active component devices
+ * are integrity capable with matching profiles.
+ */
+int md_integrity_register(mddev_t *mddev)
+{
+        mdk_rdev_t *rdev, *reference = NULL;
+        if (list_empty(&mddev->disks))
+                return 0; /* nothing to do */
+        if (blk_get_integrity(mddev->gendisk))
+                return 0; /* already registered */
+        list_for_each_entry(rdev, &mddev->disks, same_set) {
+                /* skip spares and non-functional disks */
+                if (test_bit(Faulty, &rdev->flags))
+                        continue;
+                if (rdev->raid_disk < 0)
+                        continue;
+                /*
+                 * If at least one rdev is not integrity capable, we can not
+                 * enable data integrity for the md device.
+                 */
+                if (!bdev_get_integrity(rdev->bdev))
+                        return -EINVAL;
+                if (!reference) {
+                        /* Use the first rdev as the reference */
+                        reference = rdev;
+                        continue;
+                }
+                /* does this rdev's profile match the reference profile? */
+                if (blk_integrity_compare(reference->bdev->bd_disk,
+                                rdev->bdev->bd_disk) < 0)
+                        return -EINVAL;
+        }
+        /*
+         * All component devices are integrity capable and have matching
+         * profiles, register the common profile for the md device.
+         */
+        if (blk_integrity_register(mddev->gendisk,
+                        bdev_get_integrity(reference->bdev)) != 0) {
+                printk(KERN_ERR "md: failed to register integrity for %s\n",
+                        mdname(mddev));
+                return -EINVAL;
+        }
+        printk(KERN_NOTICE "md: data integrity on %s enabled\n",
+                mdname(mddev));
+        return 0;
+}
+EXPORT_SYMBOL(md_integrity_register);
+/* Disable data integrity if non-capable/non-matching disk is being added */
+void md_integrity_add_rdev(mdk_rdev_t *rdev, mddev_t *mddev)
 {
-        struct mdk_personality *pers = mddev->pers;
-        struct gendisk *disk = mddev->gendisk;
        struct blk_integrity *bi_rdev = bdev_get_integrity(rdev->bdev);
-        struct blk_integrity *bi_mddev = blk_get_integrity(disk);
+        struct blk_integrity *bi_mddev = blk_get_integrity(mddev->gendisk);
-        /* Data integrity passthrough not supported on RAID 4, 5 and 6 */
+        if (!bi_mddev) /* nothing to do */
-        if (pers && pers->level >= 4 && pers->level <= 6)
                return;
+        if (rdev->raid_disk < 0) /* skip spares */
-        /* If rdev is integrity capable, register profile for mddev */
-        if (!bi_mddev && bi_rdev) {
-                if (blk_integrity_register(disk, bi_rdev))
-                        printk(KERN_ERR "%s: %s Could not register integrity!\n",
-                               __func__, disk->disk_name);
-                else
-                        printk(KERN_NOTICE "Enabling data integrity on %s\n",
-                               disk->disk_name);
                return;
-        }
+        if (bi_rdev && blk_integrity_compare(mddev->gendisk,
+                                             rdev->bdev->bd_disk) >= 0)
-        /* Check that mddev and rdev have matching profiles */
+                return;
-        if (blk_integrity_compare(disk, rdev->bdev->bd_disk) < 0) {
+        printk(KERN_NOTICE "disabling data integrity on %s\n", mdname(mddev));
-                printk(KERN_ERR "%s: %s/%s integrity mismatch!\n", __func__,
+        blk_integrity_unregister(mddev->gendisk);
-                       disk->disk_name, rdev->bdev->bd_disk->disk_name);
-                printk(KERN_NOTICE "Disabling data integrity on %s\n",
-                       disk->disk_name);
-                blk_integrity_unregister(disk);
-        }
 }
+EXPORT_SYMBOL(md_integrity_add_rdev);
 static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
 {
@@ -1591,7 +1641,6 @@ static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
        /* May as well allow recovery to be retried once */
        mddev->recovery_disabled = 0;
-        md_integrity_check(rdev, mddev);
        return 0;
 fail:
@@ -1756,9 +1805,10 @@ static void print_sb_1(struct mdp_superblock_1 *sb)
        __u8 *uuid;
        uuid = sb->set_uuid;
-        printk(KERN_INFO "md:  SB: (V:%u) (F:0x%08x) Array-ID:<%02x%02x%02x%02x"
+        printk(KERN_INFO
-                        ":%02x%02x:%02x%02x:%02x%02x:%02x%02x%02x%02x%02x%02x>\n"
+               "md:  SB: (V:%u) (F:0x%08x) Array-ID:<%02x%02x%02x%02x"
-               KERN_INFO "md:    Name: \"%s\" CT:%llu\n",
+               ":%02x%02x:%02x%02x:%02x%02x:%02x%02x%02x%02x%02x%02x>\n"
+               "md:    Name: \"%s\" CT:%llu\n",
                le32_to_cpu(sb->major_version),
                le32_to_cpu(sb->feature_map),
                uuid[0], uuid[1], uuid[2], uuid[3],
@@ -1770,12 +1820,13 @@ static void print_sb_1(struct mdp_superblock_1 *sb)
                       & MD_SUPERBLOCK_1_TIME_SEC_MASK);
        uuid = sb->device_uuid;
-        printk(KERN_INFO "md:       L%u SZ%llu RD:%u LO:%u CS:%u DO:%llu DS:%llu SO:%llu"
+        printk(KERN_INFO
+               "md:       L%u SZ%llu RD:%u LO:%u CS:%u DO:%llu DS:%llu SO:%llu"
                        " RO:%llu\n"
-               KERN_INFO "md:     Dev:%08x UUID: %02x%02x%02x%02x:%02x%02x:%02x%02x:%02x%02x"
+               "md:     Dev:%08x UUID: %02x%02x%02x%02x:%02x%02x:%02x%02x:%02x%02x"
-                        ":%02x%02x%02x%02x%02x%02x\n"
+                        ":%02x%02x%02x%02x%02x%02x\n"
-               KERN_INFO "md:       (F:0x%08x) UT:%llu Events:%llu ResyncOffset:%llu CSUM:0x%08x\n"
+               "md:       (F:0x%08x) UT:%llu Events:%llu ResyncOffset:%llu CSUM:0x%08x\n"
-               KERN_INFO "md:         (MaxDev:%u) \n",
+               "md:         (MaxDev:%u) \n",
                le32_to_cpu(sb->level),
                (unsigned long long)le64_to_cpu(sb->size),
                le32_to_cpu(sb->raid_disks),
@@ -2655,6 +2706,7 @@ level_store(mddev_t *mddev, const char *buf, size_t len)
        ssize_t rv = len;
        struct mdk_personality *pers;
        void *priv;
+        mdk_rdev_t *rdev;
        if (mddev->pers == NULL) {
                if (len == 0)
@@ -2734,6 +2786,12 @@ level_store(mddev_t *mddev, const char *buf, size_t len)
        mddev_suspend(mddev);
        mddev->pers->stop(mddev);
        module_put(mddev->pers->owner);
+        /* Invalidate devices that are now superfluous */
+        list_for_each_entry(rdev, &mddev->disks, same_set)
+                if (rdev->raid_disk >= mddev->raid_disks) {
+                        rdev->raid_disk = -1;
+                        clear_bit(In_sync, &rdev->flags);
+                }
        mddev->pers = pers;
        mddev->private = priv;
        strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
@@ -3683,17 +3741,8 @@ array_size_store(mddev_t *mddev, const char *buf, size_t len)
        mddev->array_sectors = sectors;
        set_capacity(mddev->gendisk, mddev->array_sectors);
-        if (mddev->pers) {
+        if (mddev->pers)
-                struct block_device *bdev = bdget_disk(mddev->gendisk, 0);
+                revalidate_disk(mddev->gendisk);
-                if (bdev) {
-                        mutex_lock(&bdev->bd_inode->i_mutex);
-                        i_size_write(bdev->bd_inode,
-                                     (loff_t)mddev->array_sectors << 9);
-                        mutex_unlock(&bdev->bd_inode->i_mutex);
-                        bdput(bdev);
-                }
-        }
        return len;
 }
@@ -4046,10 +4095,6 @@ static int do_md_run(mddev_t * mddev)
        }
        strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
-        if (pers->level >= 4 && pers->level <= 6)
-                /* Cannot support integrity (yet) */
-                blk_integrity_unregister(mddev->gendisk);
        if (mddev->reshape_position != MaxSector &&
            pers->start_reshape == NULL) {
                /* This personality cannot handle reshaping... */
@@ -4187,6 +4232,7 @@ static int do_md_run(mddev_t * mddev)
        md_wakeup_thread(mddev->thread);
        md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
+        revalidate_disk(mddev->gendisk);
        mddev->changed = 1;
        md_new_event(mddev);
        sysfs_notify_dirent(mddev->sysfs_state);
@@ -5085,18 +5131,8 @@ static int update_size(mddev_t *mddev, sector_t num_sectors)
                        return -ENOSPC;
        }
        rv = mddev->pers->resize(mddev, num_sectors);
-        if (!rv) {
+        if (!rv)
-                struct block_device *bdev;
+                revalidate_disk(mddev->gendisk);
-                bdev = bdget_disk(mddev->gendisk, 0);
-                if (bdev) {
-                        mutex_lock(&bdev->bd_inode->i_mutex);
-                        i_size_write(bdev->bd_inode,
-                                     (loff_t)mddev->array_sectors << 9);
-                        mutex_unlock(&bdev->bd_inode->i_mutex);
-                        bdput(bdev);
-                }
-        }
        return rv;
 }
diff --git a/drivers/md/md.h b/drivers/md/md.h
index 9430a110db93..78f03168baf9 100644
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -431,5 +431,7 @@ extern int md_allow_write(mddev_t *mddev);
 extern void md_wait_for_blocked_rdev(mdk_rdev_t *rdev, mddev_t *mddev);
 extern void md_set_array_sectors(mddev_t *mddev, sector_t array_sectors);
 extern int md_check_no_bitmap(mddev_t *mddev);
+extern int md_integrity_register(mddev_t *mddev);
+void md_integrity_add_rdev(mdk_rdev_t *rdev, mddev_t *mddev);
 #endif /* _MD_MD_H */
diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
index 237fe3fd235c..7140909f6662 100644
--- a/drivers/md/multipath.c
+++ b/drivers/md/multipath.c
@@ -313,6 +313,7 @@ static int multipath_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
                        set_bit(In_sync, &rdev->flags);
                        rcu_assign_pointer(p->rdev, rdev);
                        err = 0;
+                        md_integrity_add_rdev(rdev, mddev);
                        break;
                }
@@ -345,7 +346,9 @@ static int multipath_remove_disk(mddev_t *mddev, int number)
                        /* lost the race, try later */
                        err = -EBUSY;
                        p->rdev = rdev;
+                        goto abort;
                }
+                md_integrity_register(mddev);
        }
 abort:
@@ -519,7 +522,7 @@ static int multipath_run (mddev_t *mddev)
        mddev->queue->unplug_fn = multipath_unplug;
        mddev->queue->backing_dev_info.congested_fn = multipath_congested;
        mddev->queue->backing_dev_info.congested_data = mddev;
+        md_integrity_register(mddev);
        return 0;
 out_free_conf:
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index 335f490dcad6..898e2bdfee47 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -351,6 +351,7 @@ static int raid0_run(mddev_t *mddev)
        blk_queue_merge_bvec(mddev->queue, raid0_mergeable_bvec);
        dump_zones(mddev);
+        md_integrity_register(mddev);
        return 0;
 }
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 0569efba0c02..8726fd7ebce5 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1144,7 +1144,7 @@ static int raid1_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
                        rcu_assign_pointer(p->rdev, rdev);
                        break;
                }
+        md_integrity_add_rdev(rdev, mddev);
        print_conf(conf);
        return err;
 }
@@ -1178,7 +1178,9 @@ static int raid1_remove_disk(mddev_t *mddev, int number)
                        /* lost the race, try later */
                        err = -EBUSY;
                        p->rdev = rdev;
+                        goto abort;
                }
+                md_integrity_register(mddev);
        }
 abort:
@@ -2067,7 +2069,7 @@ static int run(mddev_t *mddev)
        mddev->queue->unplug_fn = raid1_unplug;
        mddev->queue->backing_dev_info.congested_fn = raid1_congested;
        mddev->queue->backing_dev_info.congested_data = mddev;
+        md_integrity_register(mddev);
        return 0;
 out_no_mem:
@@ -2132,6 +2134,7 @@ static int raid1_resize(mddev_t *mddev, sector_t sectors)
                return -EINVAL;
        set_capacity(mddev->gendisk, mddev->array_sectors);
        mddev->changed = 1;
+        revalidate_disk(mddev->gendisk);
        if (sectors > mddev->dev_sectors &&
            mddev->recovery_cp == MaxSector) {
                mddev->recovery_cp = mddev->dev_sectors;
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 7298a5e5a183..3d9020cf6f6e 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -1170,6 +1170,7 @@ static int raid10_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
                        break;
                }
+        md_integrity_add_rdev(rdev, mddev);
        print_conf(conf);
        return err;
 }
@@ -1203,7 +1204,9 @@ static int raid10_remove_disk(mddev_t *mddev, int number)
                        /* lost the race, try later */
                        err = -EBUSY;
                        p->rdev = rdev;
+                        goto abort;
                }
+                md_integrity_register(mddev);
        }
 abort:
@@ -2225,6 +2228,7 @@ static int run(mddev_t *mddev)
        if (conf->near_copies < mddev->raid_disks)
                blk_queue_merge_bvec(mddev->queue, raid10_mergeable_bvec);
+        md_integrity_register(mddev);
        return 0;
 out_free_conf:
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 37835538b58e..2b521ee67dfa 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -3999,6 +3999,9 @@ static inline sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *ski
                return 0;
        }
+        /* Allow raid5_quiesce to complete */
+        wait_event(conf->wait_for_overlap, conf->quiesce != 2);
        if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
                return reshape_request(mddev, sector_nr, skipped);
@@ -4316,6 +4319,15 @@ raid5_size(mddev_t *mddev, sector_t sectors, int raid_disks)
        return sectors * (raid_disks - conf->max_degraded);
 }
+static void free_conf(raid5_conf_t *conf)
+{
+        shrink_stripes(conf);
+        safe_put_page(conf->spare_page);
+        kfree(conf->disks);
+        kfree(conf->stripe_hashtbl);
+        kfree(conf);
+}
 static raid5_conf_t *setup_conf(mddev_t *mddev)
 {
        raid5_conf_t *conf;
@@ -4447,11 +4459,7 @@ static raid5_conf_t *setup_conf(mddev_t *mddev)
 abort:
        if (conf) {
-                shrink_stripes(conf);
+                free_conf(conf);
-                safe_put_page(conf->spare_page);
-                kfree(conf->disks);
-                kfree(conf->stripe_hashtbl);
-                kfree(conf);
                return ERR_PTR(-EIO);
        } else
                return ERR_PTR(-ENOMEM);
@@ -4629,12 +4637,8 @@ abort:
        md_unregister_thread(mddev->thread);
        mddev->thread = NULL;
        if (conf) {
-                shrink_stripes(conf);
                print_raid5_conf(conf);
-                safe_put_page(conf->spare_page);
+                free_conf(conf);
-                kfree(conf->disks);
-                kfree(conf->stripe_hashtbl);
-                kfree(conf);
        }
        mddev->private = NULL;
        printk(KERN_ALERT "raid5: failed to run raid set %s\n", mdname(mddev));
@@ -4649,13 +4653,10 @@ static int stop(mddev_t *mddev)
        md_unregister_thread(mddev->thread);
        mddev->thread = NULL;
-        shrink_stripes(conf);
-        kfree(conf->stripe_hashtbl);
        mddev->queue->backing_dev_info.congested_fn = NULL;
        blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
        sysfs_remove_group(&mddev->kobj, &raid5_attrs_group);
-        kfree(conf->disks);
+        free_conf(conf);
-        kfree(conf);
        mddev->private = NULL;
        return 0;
 }
@@ -4857,6 +4858,7 @@ static int raid5_resize(mddev_t *mddev, sector_t sectors)
                return -EINVAL;
        set_capacity(mddev->gendisk, mddev->array_sectors);
        mddev->changed = 1;
+        revalidate_disk(mddev->gendisk);
        if (sectors > mddev->dev_sectors && mddev->recovery_cp == MaxSector) {
                mddev->recovery_cp = mddev->dev_sectors;
                set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
@@ -5002,7 +5004,7 @@ static int raid5_start_reshape(mddev_t *mddev)
                spin_unlock_irqrestore(&conf->device_lock, flags);
        }
        mddev->raid_disks = conf->raid_disks;
-        mddev->reshape_position = 0;
+        mddev->reshape_position = conf->reshape_progress;
        set_bit(MD_CHANGE_DEVS, &mddev->flags);
        clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
@@ -5057,7 +5059,6 @@ static void end_reshape(raid5_conf_t *conf)
 */
 static void raid5_finish_reshape(mddev_t *mddev)
 {
-        struct block_device *bdev;
        raid5_conf_t *conf = mddev->private;
        if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
@@ -5066,15 +5067,7 @@ static void raid5_finish_reshape(mddev_t *mddev)
                        md_set_array_sectors(mddev, raid5_size(mddev, 0, 0));
                        set_capacity(mddev->gendisk, mddev->array_sectors);
                        mddev->changed = 1;
+                        revalidate_disk(mddev->gendisk);
-                        bdev = bdget_disk(mddev->gendisk, 0);
-                        if (bdev) {
-                                mutex_lock(&bdev->bd_inode->i_mutex);
-                                i_size_write(bdev->bd_inode,
-                                             (loff_t)mddev->array_sectors << 9);
-                                mutex_unlock(&bdev->bd_inode->i_mutex);
-                                bdput(bdev);
-                        }
                } else {
                        int d;
                        mddev->degraded = conf->raid_disks;
@@ -5106,12 +5099,18 @@ static void raid5_quiesce(mddev_t *mddev, int state)
        case 1: /* stop all writes */
                spin_lock_irq(&conf->device_lock);
-                conf->quiesce = 1;
+                /* '2' tells resync/reshape to pause so that all
+                 * active stripes can drain
+                 */
+                conf->quiesce = 2;
                wait_event_lock_irq(conf->wait_for_stripe,
                                    atomic_read(&conf->active_stripes) == 0 &&
                                    atomic_read(&conf->active_aligned_reads) == 0,
                                    conf->device_lock, /* nothing */);
+                conf->quiesce = 1;
                spin_unlock_irq(&conf->device_lock);
+                /* allow reshape to continue */
+                wake_up(&conf->wait_for_overlap);
                break;
        case 0: /* re-enable writes */