11 files changed, 104 insertions, 63 deletions

diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 9933eb861c71..529e2ba505c3 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
diff --git a/drivers/md/dm-exception-store.c b/drivers/md/dm-exception-store.c
index c3ae51584b12..3710ff88fc10 100644
--- a/drivers/md/dm-exception-store.c
+++ b/drivers/md/dm-exception-store.c
@@ -195,7 +195,7 @@ int dm_exception_store_create(struct dm_target *ti, int argc, char **argv,
                               struct dm_exception_store **store)
 {
         int r = 0;
-        struct dm_exception_store_type *type;
+        struct dm_exception_store_type *type = NULL;
         struct dm_exception_store *tmp_store;
         char persistent;
 
@@ -211,12 +211,15 @@ int dm_exception_store_create(struct dm_target *ti, int argc, char **argv,
         }
 
         persistent = toupper(*argv[1]);
-        if (persistent != 'P' && persistent != 'N') {
+        if (persistent == 'P')
+                type = get_type("P");
+        else if (persistent == 'N')
+                type = get_type("N");
+        else {
                 ti->error = "Persistent flag is not P or N";
                 return -EINVAL;
         }
 
-        type = get_type(&persistent);
         if (!type) {
                 ti->error = "Exception store type not recognised";
                 r = -EINVAL;
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 4899ebe767c8..2cba557d9e61 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -495,7 +495,7 @@ int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev,
                 return 0;
         }
 
-        if (blk_stack_limits(limits, &q->limits, start) < 0)
+        if (blk_stack_limits(limits, &q->limits, start << 9) < 0)
                 DMWARN("%s: target device %s is misaligned",
                        dm_device_name(ti->table->md), bdevname(bdev, b));
 
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 3c6d4ee8921d..9acd54a5cffb 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -1017,7 +1017,7 @@ static struct bio *split_bvec(struct bio *bio, sector_t sector,
         clone->bi_flags |= 1 << BIO_CLONED;
 
         if (bio_integrity(bio)) {
-                bio_integrity_clone(clone, bio, GFP_NOIO);
+                bio_integrity_clone(clone, bio, GFP_NOIO, bs);
                 bio_integrity_trim(clone,
                                    bio_sector_offset(bio, idx, offset), len);
         }
@@ -1045,7 +1045,7 @@ static struct bio *clone_bio(struct bio *bio, sector_t sector,
         clone->bi_flags &= ~(1 << BIO_SEG_VALID);
 
         if (bio_integrity(bio)) {
-                bio_integrity_clone(clone, bio, GFP_NOIO);
+                bio_integrity_clone(clone, bio, GFP_NOIO, bs);
 
                 if (idx != bio->bi_idx || clone->bi_size < bio->bi_size)
                         bio_integrity_trim(clone,
diff --git a/drivers/md/linear.c b/drivers/md/linear.c
index 15c8b7b25a9b..5810fa906af0 100644
--- a/drivers/md/linear.c
+++ b/drivers/md/linear.c
@@ -166,8 +166,8 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)
                         rdev->sectors = sectors * mddev->chunk_sectors;
                 }
 
-                blk_queue_stack_limits(mddev->queue,
-                                       rdev->bdev->bd_disk->queue);
+                disk_stack_limits(mddev->gendisk, rdev->bdev,
+                                  rdev->data_offset << 9);
                 /* as we don't honour merge_bvec_fn, we must never risk
                  * violating it, so limit ->max_sector to one PAGE, as
                  * a one page request is never in violation.
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 09be637d52cb..d4351ff0849f 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -1756,9 +1756,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"
-                        ":%02x%02x:%02x%02x:%02x%02x:%02x%02x%02x%02x%02x%02x>\n"
-               KERN_INFO "md:    Name: \"%s\" CT:%llu\n",
+        printk(KERN_INFO
+               "md:  SB: (V:%u) (F:0x%08x) Array-ID:<%02x%02x%02x%02x"
+               ":%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 +1771,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"
-                        ":%02x%02x%02x%02x%02x%02x\n"
-               KERN_INFO "md:       (F:0x%08x) UT:%llu Events:%llu ResyncOffset:%llu CSUM:0x%08x\n"
-               KERN_INFO "md:         (MaxDev:%u) \n",
+               "md:     Dev:%08x UUID: %02x%02x%02x%02x:%02x%02x:%02x%02x:%02x%02x"
+                        ":%02x%02x%02x%02x%02x%02x\n"
+               "md:       (F:0x%08x) UT:%llu Events:%llu ResyncOffset:%llu CSUM:0x%08x\n"
+               "md:         (MaxDev:%u) \n",
                 le32_to_cpu(sb->level),
                 (unsigned long long)le64_to_cpu(sb->size),
                 le32_to_cpu(sb->raid_disks),
@@ -3573,7 +3575,8 @@ suspend_lo_store(mddev_t *mddev, const char *buf, size_t len)
         char *e;
         unsigned long long new = simple_strtoull(buf, &e, 10);
 
-        if (mddev->pers->quiesce == NULL)
+        if (mddev->pers == NULL || 
+            mddev->pers->quiesce == NULL)
                 return -EINVAL;
         if (buf == e || (*e && *e != '\n'))
                 return -EINVAL;
@@ -3601,7 +3604,8 @@ suspend_hi_store(mddev_t *mddev, const char *buf, size_t len)
         char *e;
         unsigned long long new = simple_strtoull(buf, &e, 10);
 
-        if (mddev->pers->quiesce == NULL)
+        if (mddev->pers == NULL ||
+            mddev->pers->quiesce == NULL)
                 return -EINVAL;
         if (buf == e || (*e && *e != '\n'))
                 return -EINVAL;
@@ -3844,11 +3848,9 @@ static int md_alloc(dev_t dev, char *name)
         flush_scheduled_work();
 
         mutex_lock(&disks_mutex);
-        if (mddev->gendisk) {
-                mutex_unlock(&disks_mutex);
-                mddev_put(mddev);
-                return -EEXIST;
-        }
+        error = -EEXIST;
+        if (mddev->gendisk)
+                goto abort;
 
         if (name) {
                 /* Need to ensure that 'name' is not a duplicate.
@@ -3860,17 +3862,15 @@ static int md_alloc(dev_t dev, char *name)
                         if (mddev2->gendisk &&
                             strcmp(mddev2->gendisk->disk_name, name) == 0) {
                                 spin_unlock(&all_mddevs_lock);
-                                return -EEXIST;
+                                goto abort;
                         }
                 spin_unlock(&all_mddevs_lock);
         }
 
+        error = -ENOMEM;
         mddev->queue = blk_alloc_queue(GFP_KERNEL);
-        if (!mddev->queue) {
-                mutex_unlock(&disks_mutex);
-                mddev_put(mddev);
-                return -ENOMEM;
-        }
+        if (!mddev->queue)
+                goto abort;
         mddev->queue->queuedata = mddev;
 
         /* Can be unlocked because the queue is new: no concurrency */
@@ -3880,11 +3880,9 @@ static int md_alloc(dev_t dev, char *name)
 
         disk = alloc_disk(1 << shift);
         if (!disk) {
-                mutex_unlock(&disks_mutex);
                 blk_cleanup_queue(mddev->queue);
                 mddev->queue = NULL;
-                mddev_put(mddev);
-                return -ENOMEM;
+                goto abort;
         }
         disk->major = MAJOR(mddev->unit);
         disk->first_minor = unit << shift;
@@ -3906,16 +3904,22 @@ static int md_alloc(dev_t dev, char *name)
         mddev->gendisk = disk;
         error = kobject_init_and_add(&mddev->kobj, &md_ktype,
                                      &disk_to_dev(disk)->kobj, "%s", "md");
-        mutex_unlock(&disks_mutex);
-        if (error)
+        if (error) {
+                /* This isn't possible, but as kobject_init_and_add is marked
+                 * __must_check, we must do something with the result
+                 */
                 printk(KERN_WARNING "md: cannot register %s/md - name in use\n",
                        disk->disk_name);
-        else {
+                error = 0;
+        }
+ abort:
+        mutex_unlock(&disks_mutex);
+        if (!error) {
                 kobject_uevent(&mddev->kobj, KOBJ_ADD);
                 mddev->sysfs_state = sysfs_get_dirent(mddev->kobj.sd, "array_state");
         }
         mddev_put(mddev);
-        return 0;
+        return error;
 }
 
 static struct kobject *md_probe(dev_t dev, int *part, void *data)
@@ -6334,10 +6338,16 @@ void md_do_sync(mddev_t *mddev)
                         sysfs_notify(&mddev->kobj, NULL, "sync_completed");
                 }
 
-                if (j >= mddev->resync_max)
-                        wait_event(mddev->recovery_wait,
-                                   mddev->resync_max > j
-                                   || kthread_should_stop());
+                while (j >= mddev->resync_max && !kthread_should_stop()) {
+                        /* As this condition is controlled by user-space,
+                         * we can block indefinitely, so use '_interruptible'
+                         * to avoid triggering warnings.
+                         */
+                        flush_signals(current); /* just in case */
+                        wait_event_interruptible(mddev->recovery_wait,
+                                                 mddev->resync_max > j
+                                                 || kthread_should_stop());
+                }
 
                 if (kthread_should_stop())
                         goto interrupted;
diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
index cbe368fa6598..237fe3fd235c 100644
--- a/drivers/md/multipath.c
+++ b/drivers/md/multipath.c
@@ -294,7 +294,8 @@ static int multipath_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
         for (path = first; path <= last; path++)
                 if ((p=conf->multipaths+path)->rdev == NULL) {
                         q = rdev->bdev->bd_disk->queue;
-                        blk_queue_stack_limits(mddev->queue, q);
+                        disk_stack_limits(mddev->gendisk, rdev->bdev,
+                                          rdev->data_offset << 9);
 
                 /* as we don't honour merge_bvec_fn, we must never risk
                  * violating it, so limit ->max_sector to one PAGE, as
@@ -463,9 +464,9 @@ static int multipath_run (mddev_t *mddev)
 
                 disk = conf->multipaths + disk_idx;
                 disk->rdev = rdev;
+                disk_stack_limits(mddev->gendisk, rdev->bdev,
+                                  rdev->data_offset << 9);
 
-                blk_queue_stack_limits(mddev->queue,
-                                       rdev->bdev->bd_disk->queue);
                 /* as we don't honour merge_bvec_fn, we must never risk
                  * violating it, not that we ever expect a device with
                  * a merge_bvec_fn to be involved in multipath */
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index ab4a489d8695..335f490dcad6 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -170,8 +170,8 @@ static int create_strip_zones(mddev_t *mddev)
                 }
                 dev[j] = rdev1;
 
-                blk_queue_stack_limits(mddev->queue,
-                                       rdev1->bdev->bd_disk->queue);
+                disk_stack_limits(mddev->gendisk, rdev1->bdev,
+                                  rdev1->data_offset << 9);
                 /* as we don't honour merge_bvec_fn, we must never risk
                  * violating it, so limit ->max_sector to one PAGE, as
                  * a one page request is never in violation.
@@ -250,6 +250,11 @@ static int create_strip_zones(mddev_t *mddev)
                        mddev->chunk_sectors << 9);
                 goto abort;
         }
+
+        blk_queue_io_min(mddev->queue, mddev->chunk_sectors << 9);
+        blk_queue_io_opt(mddev->queue,
+                         (mddev->chunk_sectors << 9) * mddev->raid_disks);
+
         printk(KERN_INFO "raid0: done.\n");
         mddev->private = conf;
         return 0;
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 89939a7aef57..0569efba0c02 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1123,8 +1123,8 @@ static int raid1_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
         for (mirror = first; mirror <= last; mirror++)
                 if ( !(p=conf->mirrors+mirror)->rdev) {
 
-                        blk_queue_stack_limits(mddev->queue,
-                                               rdev->bdev->bd_disk->queue);
+                        disk_stack_limits(mddev->gendisk, rdev->bdev,
+                                          rdev->data_offset << 9);
                         /* as we don't honour merge_bvec_fn, we must never risk
                          * violating it, so limit ->max_sector to one PAGE, as
                          * a one page request is never in violation.
@@ -1988,9 +1988,8 @@ static int run(mddev_t *mddev)
                 disk = conf->mirrors + disk_idx;
 
                 disk->rdev = rdev;
-
-                blk_queue_stack_limits(mddev->queue,
-                                       rdev->bdev->bd_disk->queue);
+                disk_stack_limits(mddev->gendisk, rdev->bdev,
+                                  rdev->data_offset << 9);
                 /* as we don't honour merge_bvec_fn, we must never risk
                  * violating it, so limit ->max_sector to one PAGE, as
                  * a one page request is never in violation.
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index ae12ceafe10c..7298a5e5a183 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -1151,8 +1151,8 @@ static int raid10_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
         for ( ; mirror <= last ; mirror++)
                 if ( !(p=conf->mirrors+mirror)->rdev) {
 
-                        blk_queue_stack_limits(mddev->queue,
-                                               rdev->bdev->bd_disk->queue);
+                        disk_stack_limits(mddev->gendisk, rdev->bdev,
+                                          rdev->data_offset << 9);
                         /* as we don't honour merge_bvec_fn, we must never risk
                          * violating it, so limit ->max_sector to one PAGE, as
                          * a one page request is never in violation.
@@ -2044,7 +2044,7 @@ raid10_size(mddev_t *mddev, sector_t sectors, int raid_disks)
 static int run(mddev_t *mddev)
 {
         conf_t *conf;
-        int i, disk_idx;
+        int i, disk_idx, chunk_size;
         mirror_info_t *disk;
         mdk_rdev_t *rdev;
         int nc, fc, fo;
@@ -2130,6 +2130,14 @@ static int run(mddev_t *mddev)
         spin_lock_init(&conf->device_lock);
         mddev->queue->queue_lock = &conf->device_lock;
 
+        chunk_size = mddev->chunk_sectors << 9;
+        blk_queue_io_min(mddev->queue, chunk_size);
+        if (conf->raid_disks % conf->near_copies)
+                blk_queue_io_opt(mddev->queue, chunk_size * conf->raid_disks);
+        else
+                blk_queue_io_opt(mddev->queue, chunk_size *
+                                 (conf->raid_disks / conf->near_copies));
+
         list_for_each_entry(rdev, &mddev->disks, same_set) {
                 disk_idx = rdev->raid_disk;
                 if (disk_idx >= mddev->raid_disks
@@ -2138,9 +2146,8 @@ static int run(mddev_t *mddev)
                 disk = conf->mirrors + disk_idx;
 
                 disk->rdev = rdev;
-
-                blk_queue_stack_limits(mddev->queue,
-                                       rdev->bdev->bd_disk->queue);
+                disk_stack_limits(mddev->gendisk, rdev->bdev,
+                                  rdev->data_offset << 9);
                 /* as we don't honour merge_bvec_fn, we must never risk
                  * violating it, so limit ->max_sector to one PAGE, as
                  * a one page request is never in violation.
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index f9f991e6e138..37835538b58e 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -3699,13 +3699,21 @@ static int make_request(struct request_queue *q, struct bio * bi)
                                         goto retry;
                                 }
                         }
-                        /* FIXME what if we get a false positive because these
-                         * are being updated.
-                         */
-                        if (logical_sector >= mddev->suspend_lo &&
+
+                        if (bio_data_dir(bi) == WRITE &&
+                            logical_sector >= mddev->suspend_lo &&
                             logical_sector < mddev->suspend_hi) {
                                 release_stripe(sh);
-                                schedule();
+                                /* As the suspend_* range is controlled by
+                                 * userspace, we want an interruptible
+                                 * wait.
+                                 */
+                                flush_signals(current);
+                                prepare_to_wait(&conf->wait_for_overlap,
+                                                &w, TASK_INTERRUPTIBLE);
+                                if (logical_sector >= mddev->suspend_lo &&
+                                    logical_sector < mddev->suspend_hi)
+                                        schedule();
                                 goto retry;
                         }
 
@@ -4452,7 +4460,7 @@ static raid5_conf_t *setup_conf(mddev_t *mddev)
 static int run(mddev_t *mddev)
 {
         raid5_conf_t *conf;
-        int working_disks = 0;
+        int working_disks = 0, chunk_size;
         mdk_rdev_t *rdev;
 
         if (mddev->recovery_cp != MaxSector)
@@ -4607,6 +4615,14 @@ static int run(mddev_t *mddev)
         md_set_array_sectors(mddev, raid5_size(mddev, 0, 0));
 
         blk_queue_merge_bvec(mddev->queue, raid5_mergeable_bvec);
+        chunk_size = mddev->chunk_sectors << 9;
+        blk_queue_io_min(mddev->queue, chunk_size);
+        blk_queue_io_opt(mddev->queue, chunk_size *
+                         (conf->raid_disks - conf->max_degraded));
+
+        list_for_each_entry(rdev, &mddev->disks, same_set)
+                disk_stack_limits(mddev->gendisk, rdev->bdev,
+                                  rdev->data_offset << 9);
 
         return 0;
 abort: