4 files changed, 78 insertions, 44 deletions

diff --git a/drivers/md/md.c b/drivers/md/md.c
index 1ed5152db450..f19b874753a9 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -163,9 +163,19 @@ void md_new_event(mddev_t *mddev)
 {
         atomic_inc(&md_event_count);
         wake_up(&md_event_waiters);
+        sysfs_notify(&mddev->kobj, NULL, "sync_action");
 }
 EXPORT_SYMBOL_GPL(md_new_event);
 
+/* Alternate version that can be called from interrupts
+ * when calling sysfs_notify isn't needed.
+ */
+void md_new_event_inintr(mddev_t *mddev)
+{
+        atomic_inc(&md_event_count);
+        wake_up(&md_event_waiters);
+}
+
 /*
  * Enables to iterate over all existing md arrays
  * all_mddevs_lock protects this list.
@@ -278,11 +288,6 @@ static inline int mddev_lock(mddev_t * mddev)
         return mutex_lock_interruptible(&mddev->reconfig_mutex);
 }
 
-static inline void mddev_lock_uninterruptible(mddev_t * mddev)
-{
-        mutex_lock(&mddev->reconfig_mutex);
-}
-
 static inline int mddev_trylock(mddev_t * mddev)
 {
         return mutex_trylock(&mddev->reconfig_mutex);
@@ -2256,7 +2261,7 @@ action_store(mddev_t *mddev, const char *page, size_t len)
         } else {
                 if (cmd_match(page, "check"))
                         set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
-                else if (cmd_match(page, "repair"))
+                else if (!cmd_match(page, "repair"))
                         return -EINVAL;
                 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
                 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
@@ -2457,9 +2462,11 @@ md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
 
         if (!entry->show)
                 return -EIO;
-        mddev_lock(mddev);
-        rv = entry->show(mddev, page);
-        mddev_unlock(mddev);
+        rv = mddev_lock(mddev);
+        if (!rv) {
+                rv = entry->show(mddev, page);
+                mddev_unlock(mddev);
+        }
         return rv;
 }
 
@@ -2473,9 +2480,11 @@ md_attr_store(struct kobject *kobj, struct attribute *attr,
 
         if (!entry->store)
                 return -EIO;
-        mddev_lock(mddev);
-        rv = entry->store(mddev, page, length);
-        mddev_unlock(mddev);
+        rv = mddev_lock(mddev);
+        if (!rv) {
+                rv = entry->store(mddev, page, length);
+                mddev_unlock(mddev);
+        }
         return rv;
 }
 
@@ -4149,7 +4158,7 @@ void md_error(mddev_t *mddev, mdk_rdev_t *rdev)
         set_bit(MD_RECOVERY_INTR, &mddev->recovery);
         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
         md_wakeup_thread(mddev->thread);
-        md_new_event(mddev);
+        md_new_event_inintr(mddev);
 }
 
 /* seq_file implementation /proc/mdstat */
@@ -4340,8 +4349,9 @@ static int md_seq_show(struct seq_file *seq, void *v)
                 return 0;
         }
 
-        if (mddev_lock(mddev)!=0) 
+        if (mddev_lock(mddev) < 0)
                 return -EINTR;
+
         if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
                 seq_printf(seq, "%s : %sactive", mdname(mddev),
                                                 mddev->pers ? "" : "in");
@@ -5027,8 +5037,10 @@ static int md_notify_reboot(struct notifier_block *this,
                 printk(KERN_INFO "md: stopping all md devices.\n");
 
                 ITERATE_MDDEV(mddev,tmp)
-                        if (mddev_trylock(mddev))
+                        if (mddev_trylock(mddev)) {
                                 do_md_stop (mddev, 1);
+                                mddev_unlock(mddev);
+                        }
                 /*
                  * certain more exotic SCSI devices are known to be
                  * volatile wrt too early system reboots. While the
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index 678f4dbbea1d..cb8c6317e4e5 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -331,13 +331,14 @@ static int raid0_run (mddev_t *mddev)
                 goto out_free_conf;
         size = conf->strip_zone[cur].size;
 
-        for (i=0; i< nb_zone; i++) {
-                conf->hash_table[i] = conf->strip_zone + cur;
+        conf->hash_table[0] = conf->strip_zone + cur;
+        for (i=1; i< nb_zone; i++) {
                 while (size <= conf->hash_spacing) {
                         cur++;
                         size += conf->strip_zone[cur].size;
                 }
                 size -= conf->hash_spacing;
+                conf->hash_table[i] = conf->strip_zone + cur;
         }
         if (conf->preshift) {
                 conf->hash_spacing >>= conf->preshift;
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 6081941de1b3..4070eff6f0f8 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -315,10 +315,11 @@ static int raid1_end_write_request(struct bio *bio, unsigned int bytes_done, int
                 if (r1_bio->bios[mirror] == bio)
                         break;
 
-        if (error == -ENOTSUPP && test_bit(R1BIO_Barrier, &r1_bio->state)) {
+        if (error == -EOPNOTSUPP && test_bit(R1BIO_Barrier, &r1_bio->state)) {
                 set_bit(BarriersNotsupp, &conf->mirrors[mirror].rdev->flags);
                 set_bit(R1BIO_BarrierRetry, &r1_bio->state);
                 r1_bio->mddev->barriers_work = 0;
+                /* Don't rdev_dec_pending in this branch - keep it for the retry */
         } else {
                 /*
                  * this branch is our 'one mirror IO has finished' event handler:
@@ -365,6 +366,7 @@ static int raid1_end_write_request(struct bio *bio, unsigned int bytes_done, int
                                 }
                         }
                 }
+                rdev_dec_pending(conf->mirrors[mirror].rdev, conf->mddev);
         }
         /*
          *
@@ -374,11 +376,9 @@ static int raid1_end_write_request(struct bio *bio, unsigned int bytes_done, int
         if (atomic_dec_and_test(&r1_bio->remaining)) {
                 if (test_bit(R1BIO_BarrierRetry, &r1_bio->state)) {
                         reschedule_retry(r1_bio);
-                        /* Don't dec_pending yet, we want to hold
-                         * the reference over the retry
-                         */
                         goto out;
                 }
+                /* it really is the end of this request */
                 if (test_bit(R1BIO_BehindIO, &r1_bio->state)) {
                         /* free extra copy of the data pages */
                         int i = bio->bi_vcnt;
@@ -393,8 +393,6 @@ static int raid1_end_write_request(struct bio *bio, unsigned int bytes_done, int
                 md_write_end(r1_bio->mddev);
                 raid_end_bio_io(r1_bio);
         }
-
-        rdev_dec_pending(conf->mirrors[mirror].rdev, conf->mddev);
  out:
         if (to_put)
                 bio_put(to_put);
@@ -753,18 +751,24 @@ static int make_request(request_queue_t *q, struct bio * bio)
         const int rw = bio_data_dir(bio);
         int do_barriers;
 
-        if (unlikely(!mddev->barriers_work && bio_barrier(bio))) {
-                bio_endio(bio, bio->bi_size, -EOPNOTSUPP);
-                return 0;
-        }
-
         /*
          * Register the new request and wait if the reconstruction
          * thread has put up a bar for new requests.
          * Continue immediately if no resync is active currently.
+         * We test barriers_work *after* md_write_start as md_write_start
+         * may cause the first superblock write, and that will check out
+         * if barriers work.
          */
+
         md_write_start(mddev, bio); /* wait on superblock update early */
 
+        if (unlikely(!mddev->barriers_work && bio_barrier(bio))) {
+                if (rw == WRITE)
+                        md_write_end(mddev);
+                bio_endio(bio, bio->bi_size, -EOPNOTSUPP);
+                return 0;
+        }
+
         wait_barrier(conf);
 
         disk_stat_inc(mddev->gendisk, ios[rw]);
@@ -1404,10 +1408,11 @@ static void raid1d(mddev_t *mddev)
                         unplug = 1;
                 } else if (test_bit(R1BIO_BarrierRetry, &r1_bio->state)) {
                         /* some requests in the r1bio were BIO_RW_BARRIER
-                         * requests which failed with -ENOTSUPP.  Hohumm..
+                         * requests which failed with -EOPNOTSUPP.  Hohumm..
                          * Better resubmit without the barrier.
                          * We know which devices to resubmit for, because
                          * all others have had their bios[] entry cleared.
+                         * We already have a nr_pending reference on these rdevs.
                          */
                         int i;
                         clear_bit(R1BIO_BarrierRetry, &r1_bio->state);
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 617012bc107a..1440935414e6 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -1407,43 +1407,54 @@ static void raid10d(mddev_t *mddev)
                                 if (s > (PAGE_SIZE>>9))
                                         s = PAGE_SIZE >> 9;
 
+                                rcu_read_lock();
                                 do {
                                         int d = r10_bio->devs[sl].devnum;
-                                        rdev = conf->mirrors[d].rdev;
+                                        rdev = rcu_dereference(conf->mirrors[d].rdev);
                                         if (rdev &&
-                                            test_bit(In_sync, &rdev->flags) &&
-                                            sync_page_io(rdev->bdev,
-                                                         r10_bio->devs[sl].addr +
-                                                         sect + rdev->data_offset,
-                                                         s<<9,
-                                                         conf->tmppage, READ))
-                                                success = 1;
-                                        else {
-                                                sl++;
-                                                if (sl == conf->copies)
-                                                        sl = 0;
+                                            test_bit(In_sync, &rdev->flags)) {
+                                                atomic_inc(&rdev->nr_pending);
+                                                rcu_read_unlock();
+                                                success = sync_page_io(rdev->bdev,
+                                                                       r10_bio->devs[sl].addr +
+                                                                       sect + rdev->data_offset,
+                                                                       s<<9,
+                                                                       conf->tmppage, READ);
+                                                rdev_dec_pending(rdev, mddev);
+                                                rcu_read_lock();
+                                                if (success)
+                                                        break;
                                         }
+                                        sl++;
+                                        if (sl == conf->copies)
+                                                sl = 0;
                                 } while (!success && sl != r10_bio->read_slot);
+                                rcu_read_unlock();
 
                                 if (success) {
                                         int start = sl;
                                         /* write it back and re-read */
+                                        rcu_read_lock();
                                         while (sl != r10_bio->read_slot) {
                                                 int d;
                                                 if (sl==0)
                                                         sl = conf->copies;
                                                 sl--;
                                                 d = r10_bio->devs[sl].devnum;
-                                                rdev = conf->mirrors[d].rdev;
-                                                atomic_add(s, &rdev->corrected_errors);
+                                                rdev = rcu_dereference(conf->mirrors[d].rdev);
                                                 if (rdev &&
                                                     test_bit(In_sync, &rdev->flags)) {
+                                                        atomic_inc(&rdev->nr_pending);
+                                                        rcu_read_unlock();
+                                                        atomic_add(s, &rdev->corrected_errors);
                                                         if (sync_page_io(rdev->bdev,
                                                                          r10_bio->devs[sl].addr +
                                                                          sect + rdev->data_offset,
                                                                          s<<9, conf->tmppage, WRITE) == 0)
                                                                 /* Well, this device is dead */
                                                                 md_error(mddev, rdev);
+                                                        rdev_dec_pending(rdev, mddev);
+                                                        rcu_read_lock();
                                                 }
                                         }
                                         sl = start;
@@ -1453,17 +1464,22 @@ static void raid10d(mddev_t *mddev)
                                                         sl = conf->copies;
                                                 sl--;
                                                 d = r10_bio->devs[sl].devnum;
-                                                rdev = conf->mirrors[d].rdev;
+                                                rdev = rcu_dereference(conf->mirrors[d].rdev);
                                                 if (rdev &&
                                                     test_bit(In_sync, &rdev->flags)) {
+                                                        atomic_inc(&rdev->nr_pending);
+                                                        rcu_read_unlock();
                                                         if (sync_page_io(rdev->bdev,
                                                                          r10_bio->devs[sl].addr +
                                                                          sect + rdev->data_offset,
                                                                          s<<9, conf->tmppage, READ) == 0)
                                                                 /* Well, this device is dead */
                                                                 md_error(mddev, rdev);
+                                                        rdev_dec_pending(rdev, mddev);
+                                                        rcu_read_lock();
                                                 }
                                         }
+                                        rcu_read_unlock();
                                 } else {
                                         /* Cannot read from anywhere -- bye bye array */
                                         md_error(mddev, conf->mirrors[r10_bio->devs[r10_bio->read_slot].devnum].rdev);