11 files changed, 53 insertions, 252 deletions

diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 8216a6f75be5..64fee90bb68b 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -441,33 +441,12 @@ static struct bio *crypt_alloc_buffer(struct dm_crypt_io *io, unsigned size)
         return clone;
 }
 
-static void crypt_free_buffer_pages(struct crypt_config *cc,
-                                    struct bio *clone, unsigned int bytes)
+static void crypt_free_buffer_pages(struct crypt_config *cc, struct bio *clone)
 {
-        unsigned int i, start, end;
+        unsigned int i;
         struct bio_vec *bv;
 
-        /*
-         * This is ugly, but Jens Axboe thinks that using bi_idx in the
-         * endio function is too dangerous at the moment, so I calculate the
-         * correct position using bi_vcnt and bi_size.
-         * The bv_offset and bv_len fields might already be modified but we
-         * know that we always allocated whole pages.
-         * A fix to the bi_idx issue in the kernel is in the works, so
-         * we will hopefully be able to revert to the cleaner solution soon.
-         */
-        i = clone->bi_vcnt - 1;
-        bv = bio_iovec_idx(clone, i);
-        end = (i << PAGE_SHIFT) + (bv->bv_offset + bv->bv_len) - clone->bi_size;
-        start = end - bytes;
-
-        start >>= PAGE_SHIFT;
-        if (!clone->bi_size)
-                end = clone->bi_vcnt;
-        else
-                end >>= PAGE_SHIFT;
-
-        for (i = start; i < end; i++) {
+        for (i = 0; i < clone->bi_vcnt; i++) {
                 bv = bio_iovec_idx(clone, i);
                 BUG_ON(!bv->bv_page);
                 mempool_free(bv->bv_page, cc->page_pool);
@@ -519,7 +498,7 @@ static void crypt_endio(struct bio *clone, int error)
          * free the processed pages
          */
         if (!read_io) {
-                crypt_free_buffer_pages(cc, clone, clone->bi_size);
+                crypt_free_buffer_pages(cc, clone);
                 goto out;
         }
 
@@ -608,7 +587,7 @@ static void process_write(struct dm_crypt_io *io)
                 ctx.idx_out = 0;
 
                 if (unlikely(crypt_convert(cc, &ctx) < 0)) {
-                        crypt_free_buffer_pages(cc, clone, clone->bi_size);
+                        crypt_free_buffer_pages(cc, clone);
                         bio_put(clone);
                         dec_pending(io, -EIO);
                         return;
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 2bcde5798b5a..fbe477bb2c68 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -999,33 +999,6 @@ void dm_table_unplug_all(struct dm_table *t)
         }
 }
 
-int dm_table_flush_all(struct dm_table *t)
-{
-        struct list_head *d, *devices = dm_table_get_devices(t);
-        int ret = 0;
-        unsigned i;
-
-        for (i = 0; i < t->num_targets; i++)
-                if (t->targets[i].type->flush)
-                        t->targets[i].type->flush(&t->targets[i]);
-
-        for (d = devices->next; d != devices; d = d->next) {
-                struct dm_dev *dd = list_entry(d, struct dm_dev, list);
-                struct request_queue *q = bdev_get_queue(dd->bdev);
-                int err;
-
-                if (!q->issue_flush_fn)
-                        err = -EOPNOTSUPP;
-                else
-                        err = q->issue_flush_fn(q, dd->bdev->bd_disk, NULL);
-
-                if (!ret)
-                        ret = err;
-        }
-
-        return ret;
-}
-
 struct mapped_device *dm_table_get_md(struct dm_table *t)
 {
         dm_get(t->md);
@@ -1043,4 +1016,3 @@ EXPORT_SYMBOL(dm_table_get_md);
 EXPORT_SYMBOL(dm_table_put);
 EXPORT_SYMBOL(dm_table_get);
 EXPORT_SYMBOL(dm_table_unplug_all);
-EXPORT_SYMBOL(dm_table_flush_all);
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 167765c47747..d837d37f6209 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -840,21 +840,6 @@ static int dm_request(struct request_queue *q, struct bio *bio)
         return 0;
 }
 
-static int dm_flush_all(struct request_queue *q, struct gendisk *disk,
-                        sector_t *error_sector)
-{
-        struct mapped_device *md = q->queuedata;
-        struct dm_table *map = dm_get_table(md);
-        int ret = -ENXIO;
-
-        if (map) {
-                ret = dm_table_flush_all(map);
-                dm_table_put(map);
-        }
-
-        return ret;
-}
-
 static void dm_unplug_all(struct request_queue *q)
 {
         struct mapped_device *md = q->queuedata;
@@ -1003,7 +988,6 @@ static struct mapped_device *alloc_dev(int minor)
         blk_queue_make_request(md->queue, dm_request);
         blk_queue_bounce_limit(md->queue, BLK_BOUNCE_ANY);
         md->queue->unplug_fn = dm_unplug_all;
-        md->queue->issue_flush_fn = dm_flush_all;
 
         md->io_pool = mempool_create_slab_pool(MIN_IOS, _io_cache);
         if (!md->io_pool)
diff --git a/drivers/md/dm.h b/drivers/md/dm.h
index 462ee652a890..4b3faa45277e 100644
--- a/drivers/md/dm.h
+++ b/drivers/md/dm.h
@@ -111,7 +111,6 @@ void dm_table_postsuspend_targets(struct dm_table *t);
 int dm_table_resume_targets(struct dm_table *t);
 int dm_table_any_congested(struct dm_table *t, int bdi_bits);
 void dm_table_unplug_all(struct dm_table *t);
-int dm_table_flush_all(struct dm_table *t);
 
 /*-----------------------------------------------------------------
  * A registry of target types.
diff --git a/drivers/md/linear.c b/drivers/md/linear.c
index 550148770bb2..56a11f6c127b 100644
--- a/drivers/md/linear.c
+++ b/drivers/md/linear.c
@@ -92,25 +92,6 @@ static void linear_unplug(struct request_queue *q)
         }
 }
 
-static int linear_issue_flush(struct request_queue *q, struct gendisk *disk,
-                              sector_t *error_sector)
-{
-        mddev_t *mddev = q->queuedata;
-        linear_conf_t *conf = mddev_to_conf(mddev);
-        int i, ret = 0;
-
-        for (i=0; i < mddev->raid_disks && ret == 0; i++) {
-                struct block_device *bdev = conf->disks[i].rdev->bdev;
-                struct request_queue *r_queue = bdev_get_queue(bdev);
-
-                if (!r_queue->issue_flush_fn)
-                        ret = -EOPNOTSUPP;
-                else
-                        ret = r_queue->issue_flush_fn(r_queue, bdev->bd_disk, error_sector);
-        }
-        return ret;
-}
-
 static int linear_congested(void *data, int bits)
 {
         mddev_t *mddev = data;
@@ -279,7 +260,6 @@ static int linear_run (mddev_t *mddev)
 
         blk_queue_merge_bvec(mddev->queue, linear_mergeable_bvec);
         mddev->queue->unplug_fn = linear_unplug;
-        mddev->queue->issue_flush_fn = linear_issue_flush;
         mddev->queue->backing_dev_info.congested_fn = linear_congested;
         mddev->queue->backing_dev_info.congested_data = mddev;
         return 0;
diff --git a/drivers/md/md.c b/drivers/md/md.c
index acf1b81b47cb..c059ae6f37e5 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -2714,7 +2714,7 @@ action_show(mddev_t *mddev, char *page)
 {
         char *type = "idle";
         if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
-            test_bit(MD_RECOVERY_NEEDED, &mddev->recovery)) {
+            (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))) {
                 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
                         type = "reshape";
                 else if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
@@ -2833,6 +2833,12 @@ sync_max_store(mddev_t *mddev, const char *buf, size_t len)
 static struct md_sysfs_entry md_sync_max =
 __ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store);
 
+static ssize_t
+degraded_show(mddev_t *mddev, char *page)
+{
+        return sprintf(page, "%d\n", mddev->degraded);
+}
+static struct md_sysfs_entry md_degraded = __ATTR_RO(degraded);
 
 static ssize_t
 sync_speed_show(mddev_t *mddev, char *page)
@@ -2976,6 +2982,7 @@ static struct attribute *md_redundancy_attrs[] = {
         &md_suspend_lo.attr,
         &md_suspend_hi.attr,
         &md_bitmap.attr,
+        &md_degraded.attr,
         NULL,
 };
 static struct attribute_group md_redundancy_group = {
@@ -3463,7 +3470,6 @@ static int do_md_stop(mddev_t * mddev, int mode)
                         mddev->pers->stop(mddev);
                         mddev->queue->merge_bvec_fn = NULL;
                         mddev->queue->unplug_fn = NULL;
-                        mddev->queue->issue_flush_fn = NULL;
                         mddev->queue->backing_dev_info.congested_fn = NULL;
                         if (mddev->pers->sync_request)
                                 sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
@@ -5771,26 +5777,47 @@ static int __init md_init(void)
  * Searches all registered partitions for autorun RAID arrays
  * at boot time.
  */
-static dev_t detected_devices[128];
-static int dev_cnt;
+
+static LIST_HEAD(all_detected_devices);
+struct detected_devices_node {
+        struct list_head list;
+        dev_t dev;
+};
 
 void md_autodetect_dev(dev_t dev)
 {
-        if (dev_cnt >= 0 && dev_cnt < 127)
-                detected_devices[dev_cnt++] = dev;
+        struct detected_devices_node *node_detected_dev;
+
+        node_detected_dev = kzalloc(sizeof(*node_detected_dev), GFP_KERNEL);
+        if (node_detected_dev) {
+                node_detected_dev->dev = dev;
+                list_add_tail(&node_detected_dev->list, &all_detected_devices);
+        } else {
+                printk(KERN_CRIT "md: md_autodetect_dev: kzalloc failed"
+                        ", skipping dev(%d,%d)\n", MAJOR(dev), MINOR(dev));
+        }
 }
 
 
 static void autostart_arrays(int part)
 {
         mdk_rdev_t *rdev;
-        int i;
+        struct detected_devices_node *node_detected_dev;
+        dev_t dev;
+        int i_scanned, i_passed;
 
-        printk(KERN_INFO "md: Autodetecting RAID arrays.\n");
+        i_scanned = 0;
+        i_passed = 0;
 
-        for (i = 0; i < dev_cnt; i++) {
-                dev_t dev = detected_devices[i];
+        printk(KERN_INFO "md: Autodetecting RAID arrays.\n");
 
+        while (!list_empty(&all_detected_devices) && i_scanned < INT_MAX) {
+                i_scanned++;
+                node_detected_dev = list_entry(all_detected_devices.next,
+                                        struct detected_devices_node, list);
+                list_del(&node_detected_dev->list);
+                dev = node_detected_dev->dev;
+                kfree(node_detected_dev);
                 rdev = md_import_device(dev,0, 90);
                 if (IS_ERR(rdev))
                         continue;
@@ -5800,8 +5827,11 @@ static void autostart_arrays(int part)
                         continue;
                 }
                 list_add(&rdev->same_set, &pending_raid_disks);
+                i_passed++;
         }
-        dev_cnt = 0;
+
+        printk(KERN_INFO "md: Scanned %d and added %d devices.\n",
+                                                i_scanned, i_passed);
 
         autorun_devices(part);
 }
diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
index f2a63f394ad9..b35731cceac6 100644
--- a/drivers/md/multipath.c
+++ b/drivers/md/multipath.c
@@ -194,35 +194,6 @@ static void multipath_status (struct seq_file *seq, mddev_t *mddev)
         seq_printf (seq, "]");
 }
 
-static int multipath_issue_flush(struct request_queue *q, struct gendisk *disk,
-                                 sector_t *error_sector)
-{
-        mddev_t *mddev = q->queuedata;
-        multipath_conf_t *conf = mddev_to_conf(mddev);
-        int i, ret = 0;
-
-        rcu_read_lock();
-        for (i=0; i<mddev->raid_disks && ret == 0; i++) {
-                mdk_rdev_t *rdev = rcu_dereference(conf->multipaths[i].rdev);
-                if (rdev && !test_bit(Faulty, &rdev->flags)) {
-                        struct block_device *bdev = rdev->bdev;
-                        struct request_queue *r_queue = bdev_get_queue(bdev);
-
-                        if (!r_queue->issue_flush_fn)
-                                ret = -EOPNOTSUPP;
-                        else {
-                                atomic_inc(&rdev->nr_pending);
-                                rcu_read_unlock();
-                                ret = r_queue->issue_flush_fn(r_queue, bdev->bd_disk,
-                                                              error_sector);
-                                rdev_dec_pending(rdev, mddev);
-                                rcu_read_lock();
-                        }
-                }
-        }
-        rcu_read_unlock();
-        return ret;
-}
 static int multipath_congested(void *data, int bits)
 {
         mddev_t *mddev = data;
@@ -527,7 +498,6 @@ static int multipath_run (mddev_t *mddev)
         mddev->array_size = mddev->size;
 
         mddev->queue->unplug_fn = multipath_unplug;
-        mddev->queue->issue_flush_fn = multipath_issue_flush;
         mddev->queue->backing_dev_info.congested_fn = multipath_congested;
         mddev->queue->backing_dev_info.congested_data = mddev;
 
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index ef0da2d84959..c111105fc2dc 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -40,26 +40,6 @@ static void raid0_unplug(struct request_queue *q)
         }
 }
 
-static int raid0_issue_flush(struct request_queue *q, struct gendisk *disk,
-                             sector_t *error_sector)
-{
-        mddev_t *mddev = q->queuedata;
-        raid0_conf_t *conf = mddev_to_conf(mddev);
-        mdk_rdev_t **devlist = conf->strip_zone[0].dev;
-        int i, ret = 0;
-
-        for (i=0; i<mddev->raid_disks && ret == 0; i++) {
-                struct block_device *bdev = devlist[i]->bdev;
-                struct request_queue *r_queue = bdev_get_queue(bdev);
-
-                if (!r_queue->issue_flush_fn)
-                        ret = -EOPNOTSUPP;
-                else
-                        ret = r_queue->issue_flush_fn(r_queue, bdev->bd_disk, error_sector);
-        }
-        return ret;
-}
-
 static int raid0_congested(void *data, int bits)
 {
         mddev_t *mddev = data;
@@ -250,7 +230,6 @@ static int create_strip_zones (mddev_t *mddev)
 
         mddev->queue->unplug_fn = raid0_unplug;
 
-        mddev->queue->issue_flush_fn = raid0_issue_flush;
         mddev->queue->backing_dev_info.congested_fn = raid0_congested;
         mddev->queue->backing_dev_info.congested_data = mddev;
 
@@ -493,7 +472,7 @@ bad_map:
         bio_io_error(bio);
         return 0;
 }
-                           
+
 static void raid0_status (struct seq_file *seq, mddev_t *mddev)
 {
 #undef MD_DEBUG
@@ -501,18 +480,18 @@ static void raid0_status (struct seq_file *seq, mddev_t *mddev)
         int j, k, h;
         char b[BDEVNAME_SIZE];
         raid0_conf_t *conf = mddev_to_conf(mddev);
-  
+
         h = 0;
         for (j = 0; j < conf->nr_strip_zones; j++) {
                 seq_printf(seq, "      z%d", j);
                 if (conf->hash_table[h] == conf->strip_zone+j)
-                        seq_printf("(h%d)", h++);
+                        seq_printf(seq, "(h%d)", h++);
                 seq_printf(seq, "=[");
                 for (k = 0; k < conf->strip_zone[j].nb_dev; k++)
-                        seq_printf (seq, "%s/", bdevname(
+                        seq_printf(seq, "%s/", bdevname(
                                 conf->strip_zone[j].dev[k]->bdev,b));
 
-                seq_printf (seq, "] zo=%d do=%d s=%d\n",
+                seq_printf(seq, "] zo=%d do=%d s=%d\n",
                                 conf->strip_zone[j].zone_offset,
                                 conf->strip_zone[j].dev_offset,
                                 conf->strip_zone[j].size);
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 6d03bea6fa58..16775a0df7f6 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -567,36 +567,6 @@ static void raid1_unplug(struct request_queue *q)
         md_wakeup_thread(mddev->thread);
 }
 
-static int raid1_issue_flush(struct request_queue *q, struct gendisk *disk,
-                             sector_t *error_sector)
-{
-        mddev_t *mddev = q->queuedata;
-        conf_t *conf = mddev_to_conf(mddev);
-        int i, ret = 0;
-
-        rcu_read_lock();
-        for (i=0; i<mddev->raid_disks && ret == 0; i++) {
-                mdk_rdev_t *rdev = rcu_dereference(conf->mirrors[i].rdev);
-                if (rdev && !test_bit(Faulty, &rdev->flags)) {
-                        struct block_device *bdev = rdev->bdev;
-                        struct request_queue *r_queue = bdev_get_queue(bdev);
-
-                        if (!r_queue->issue_flush_fn)
-                                ret = -EOPNOTSUPP;
-                        else {
-                                atomic_inc(&rdev->nr_pending);
-                                rcu_read_unlock();
-                                ret = r_queue->issue_flush_fn(r_queue, bdev->bd_disk,
-                                                              error_sector);
-                                rdev_dec_pending(rdev, mddev);
-                                rcu_read_lock();
-                        }
-                }
-        }
-        rcu_read_unlock();
-        return ret;
-}
-
 static int raid1_congested(void *data, int bits)
 {
         mddev_t *mddev = data;
@@ -1244,7 +1214,8 @@ static void sync_request_write(mddev_t *mddev, r1bio_t *r1_bio)
                                         j = 0;
                                 if (j >= 0)
                                         mddev->resync_mismatches += r1_bio->sectors;
-                                if (j < 0 || test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) {
+                                if (j < 0 || (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)
+                                              && test_bit(BIO_UPTODATE, &sbio->bi_flags))) {
                                         sbio->bi_end_io = NULL;
                                         rdev_dec_pending(conf->mirrors[i].rdev, mddev);
                                 } else {
@@ -1997,7 +1968,6 @@ static int run(mddev_t *mddev)
         mddev->array_size = mddev->size;
 
         mddev->queue->unplug_fn = raid1_unplug;
-        mddev->queue->issue_flush_fn = raid1_issue_flush;
         mddev->queue->backing_dev_info.congested_fn = raid1_congested;
         mddev->queue->backing_dev_info.congested_data = mddev;
 
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 25a96c42bdb0..fc6607acb6e4 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -611,36 +611,6 @@ static void raid10_unplug(struct request_queue *q)
         md_wakeup_thread(mddev->thread);
 }
 
-static int raid10_issue_flush(struct request_queue *q, struct gendisk *disk,
-                             sector_t *error_sector)
-{
-        mddev_t *mddev = q->queuedata;
-        conf_t *conf = mddev_to_conf(mddev);
-        int i, ret = 0;
-
-        rcu_read_lock();
-        for (i=0; i<mddev->raid_disks && ret == 0; i++) {
-                mdk_rdev_t *rdev = rcu_dereference(conf->mirrors[i].rdev);
-                if (rdev && !test_bit(Faulty, &rdev->flags)) {
-                        struct block_device *bdev = rdev->bdev;
-                        struct request_queue *r_queue = bdev_get_queue(bdev);
-
-                        if (!r_queue->issue_flush_fn)
-                                ret = -EOPNOTSUPP;
-                        else {
-                                atomic_inc(&rdev->nr_pending);
-                                rcu_read_unlock();
-                                ret = r_queue->issue_flush_fn(r_queue, bdev->bd_disk,
-                                                              error_sector);
-                                rdev_dec_pending(rdev, mddev);
-                                rcu_read_lock();
-                        }
-                }
-        }
-        rcu_read_unlock();
-        return ret;
-}
-
 static int raid10_congested(void *data, int bits)
 {
         mddev_t *mddev = data;
@@ -2118,7 +2088,6 @@ static int run(mddev_t *mddev)
         mddev->resync_max_sectors = size << conf->chunk_shift;
 
         mddev->queue->unplug_fn = raid10_unplug;
-        mddev->queue->issue_flush_fn = raid10_issue_flush;
         mddev->queue->backing_dev_info.congested_fn = raid10_congested;
         mddev->queue->backing_dev_info.congested_data = mddev;
 
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index caaca9e178bc..8ee181a01f52 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -3204,36 +3204,6 @@ static void raid5_unplug_device(struct request_queue *q)
         unplug_slaves(mddev);
 }
 
-static int raid5_issue_flush(struct request_queue *q, struct gendisk *disk,
-                             sector_t *error_sector)
-{
-        mddev_t *mddev = q->queuedata;
-        raid5_conf_t *conf = mddev_to_conf(mddev);
-        int i, ret = 0;
-
-        rcu_read_lock();
-        for (i=0; i<mddev->raid_disks && ret == 0; i++) {
-                mdk_rdev_t *rdev = rcu_dereference(conf->disks[i].rdev);
-                if (rdev && !test_bit(Faulty, &rdev->flags)) {
-                        struct block_device *bdev = rdev->bdev;
-                        struct request_queue *r_queue = bdev_get_queue(bdev);
-
-                        if (!r_queue->issue_flush_fn)
-                                ret = -EOPNOTSUPP;
-                        else {
-                                atomic_inc(&rdev->nr_pending);
-                                rcu_read_unlock();
-                                ret = r_queue->issue_flush_fn(r_queue, bdev->bd_disk,
-                                                              error_sector);
-                                rdev_dec_pending(rdev, mddev);
-                                rcu_read_lock();
-                        }
-                }
-        }
-        rcu_read_unlock();
-        return ret;
-}
-
 static int raid5_congested(void *data, int bits)
 {
         mddev_t *mddev = data;
@@ -4263,7 +4233,6 @@ static int run(mddev_t *mddev)
                        mdname(mddev));
 
         mddev->queue->unplug_fn = raid5_unplug_device;
-        mddev->queue->issue_flush_fn = raid5_issue_flush;
         mddev->queue->backing_dev_info.congested_data = mddev;
         mddev->queue->backing_dev_info.congested_fn = raid5_congested;