1 files changed, 60 insertions, 24 deletions

diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index b6793d2e051f..f757023fc458 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -344,7 +344,8 @@ static void release_inactive_stripe_list(struct r5conf *conf,
                                          int hash)
 {
         int size;
-        bool do_wakeup = false;
+        unsigned long do_wakeup = 0;
+        int i = 0;
         unsigned long flags;
 
         if (hash == NR_STRIPE_HASH_LOCKS) {
@@ -365,15 +366,21 @@ static void release_inactive_stripe_list(struct r5conf *conf,
                             !list_empty(list))
                                 atomic_dec(&conf->empty_inactive_list_nr);
                         list_splice_tail_init(list, conf->inactive_list + hash);
-                        do_wakeup = true;
+                        do_wakeup |= 1 << hash;
                         spin_unlock_irqrestore(conf->hash_locks + hash, flags);
                 }
                 size--;
                 hash--;
         }
 
+        for (i = 0; i < NR_STRIPE_HASH_LOCKS; i++) {
+                if (do_wakeup & (1 << i))
+                        wake_up(&conf->wait_for_stripe[i]);
+        }
+
         if (do_wakeup) {
-                wake_up(&conf->wait_for_stripe);
+                if (atomic_read(&conf->active_stripes) == 0)
+                        wake_up(&conf->wait_for_quiescent);
                 if (conf->retry_read_aligned)
                         md_wakeup_thread(conf->mddev->thread);
         }
@@ -667,15 +674,15 @@ get_active_stripe(struct r5conf *conf, sector_t sector,
         spin_lock_irq(conf->hash_locks + hash);
 
         do {
-                wait_event_lock_irq(conf->wait_for_stripe,
+                wait_event_lock_irq(conf->wait_for_quiescent,
                                     conf->quiesce == 0 || noquiesce,
                                     *(conf->hash_locks + hash));
                 sh = __find_stripe(conf, sector, conf->generation - previous);
                 if (!sh) {
                         if (!test_bit(R5_INACTIVE_BLOCKED, &conf->cache_state)) {
                                 sh = get_free_stripe(conf, hash);
-                                if (!sh && llist_empty(&conf->released_stripes) &&
-                                    !test_bit(R5_DID_ALLOC, &conf->cache_state))
+                                if (!sh && !test_bit(R5_DID_ALLOC,
+                                                     &conf->cache_state))
                                         set_bit(R5_ALLOC_MORE,
                                                 &conf->cache_state);
                         }
@@ -684,14 +691,15 @@ get_active_stripe(struct r5conf *conf, sector_t sector,
                         if (!sh) {
                                 set_bit(R5_INACTIVE_BLOCKED,
                                         &conf->cache_state);
-                                wait_event_lock_irq(
-                                        conf->wait_for_stripe,
+                                wait_event_exclusive_cmd(
+                                        conf->wait_for_stripe[hash],
                                         !list_empty(conf->inactive_list + hash) &&
                                         (atomic_read(&conf->active_stripes)
                                          < (conf->max_nr_stripes * 3 / 4)
                                          || !test_bit(R5_INACTIVE_BLOCKED,
                                                       &conf->cache_state)),
-                                        *(conf->hash_locks + hash));
+                                        spin_unlock_irq(conf->hash_locks + hash),
+                                        spin_lock_irq(conf->hash_locks + hash));
                                 clear_bit(R5_INACTIVE_BLOCKED,
                                           &conf->cache_state);
                         } else {
@@ -716,6 +724,9 @@ get_active_stripe(struct r5conf *conf, sector_t sector,
                 }
         } while (sh == NULL);
 
+        if (!list_empty(conf->inactive_list + hash))
+                wake_up(&conf->wait_for_stripe[hash]);
+
         spin_unlock_irq(conf->hash_locks + hash);
         return sh;
 }
@@ -2151,6 +2162,9 @@ static int resize_stripes(struct r5conf *conf, int newsize)
         if (!sc)
                 return -ENOMEM;
 
+        /* Need to ensure auto-resizing doesn't interfere */
+        mutex_lock(&conf->cache_size_mutex);
+
         for (i = conf->max_nr_stripes; i; i--) {
                 nsh = alloc_stripe(sc, GFP_KERNEL);
                 if (!nsh)
@@ -2167,6 +2181,7 @@ static int resize_stripes(struct r5conf *conf, int newsize)
                         kmem_cache_free(sc, nsh);
                 }
                 kmem_cache_destroy(sc);
+                mutex_unlock(&conf->cache_size_mutex);
                 return -ENOMEM;
         }
         /* Step 2 - Must use GFP_NOIO now.
@@ -2177,7 +2192,7 @@ static int resize_stripes(struct r5conf *conf, int newsize)
         cnt = 0;
         list_for_each_entry(nsh, &newstripes, lru) {
                 lock_device_hash_lock(conf, hash);
-                wait_event_cmd(conf->wait_for_stripe,
+                wait_event_exclusive_cmd(conf->wait_for_stripe[hash],
                                     !list_empty(conf->inactive_list + hash),
                                     unlock_device_hash_lock(conf, hash),
                                     lock_device_hash_lock(conf, hash));
@@ -2213,6 +2228,7 @@ static int resize_stripes(struct r5conf *conf, int newsize)
         } else
                 err = -ENOMEM;
 
+        mutex_unlock(&conf->cache_size_mutex);
         /* Step 4, return new stripes to service */
         while(!list_empty(&newstripes)) {
                 nsh = list_entry(newstripes.next, struct stripe_head, lru);
@@ -2240,7 +2256,7 @@ static int resize_stripes(struct r5conf *conf, int newsize)
 static int drop_one_stripe(struct r5conf *conf)
 {
         struct stripe_head *sh;
-        int hash = (conf->max_nr_stripes - 1) % NR_STRIPE_HASH_LOCKS;
+        int hash = (conf->max_nr_stripes - 1) & STRIPE_HASH_LOCKS_MASK;
 
         spin_lock_irq(conf->hash_locks + hash);
         sh = get_free_stripe(conf, hash);
@@ -4050,8 +4066,10 @@ static void analyse_stripe(struct stripe_head *sh, struct stripe_head_state *s)
                                  &first_bad, &bad_sectors))
                         set_bit(R5_ReadRepl, &dev->flags);
                 else {
-                        if (rdev)
+                        if (rdev && !test_bit(Faulty, &rdev->flags))
                                 set_bit(R5_NeedReplace, &dev->flags);
+                        else
+                                clear_bit(R5_NeedReplace, &dev->flags);
                         rdev = rcu_dereference(conf->disks[i].rdev);
                         clear_bit(R5_ReadRepl, &dev->flags);
                 }
@@ -4760,7 +4778,7 @@ static void raid5_align_endio(struct bio *bi, int error)
                                          raid_bi, 0);
                 bio_endio(raid_bi, 0);
                 if (atomic_dec_and_test(&conf->active_aligned_reads))
-                        wake_up(&conf->wait_for_stripe);
+                        wake_up(&conf->wait_for_quiescent);
                 return;
         }
 
@@ -4855,7 +4873,7 @@ static int chunk_aligned_read(struct mddev *mddev, struct bio * raid_bio)
                 align_bi->bi_iter.bi_sector += rdev->data_offset;
 
                 spin_lock_irq(&conf->device_lock);
-                wait_event_lock_irq(conf->wait_for_stripe,
+                wait_event_lock_irq(conf->wait_for_quiescent,
                                     conf->quiesce == 0,
                                     conf->device_lock);
                 atomic_inc(&conf->active_aligned_reads);
@@ -5699,7 +5717,7 @@ static int  retry_aligned_read(struct r5conf *conf, struct bio *raid_bio)
                 bio_endio(raid_bio, 0);
         }
         if (atomic_dec_and_test(&conf->active_aligned_reads))
-                wake_up(&conf->wait_for_stripe);
+                wake_up(&conf->wait_for_quiescent);
         return handled;
 }
 
@@ -5846,12 +5864,14 @@ static void raid5d(struct md_thread *thread)
         pr_debug("%d stripes handled\n", handled);
 
         spin_unlock_irq(&conf->device_lock);
-        if (test_and_clear_bit(R5_ALLOC_MORE, &conf->cache_state)) {
+        if (test_and_clear_bit(R5_ALLOC_MORE, &conf->cache_state) &&
+            mutex_trylock(&conf->cache_size_mutex)) {
                 grow_one_stripe(conf, __GFP_NOWARN);
                 /* Set flag even if allocation failed.  This helps
                  * slow down allocation requests when mem is short
                  */
                 set_bit(R5_DID_ALLOC, &conf->cache_state);
+                mutex_unlock(&conf->cache_size_mutex);
         }
 
         async_tx_issue_pending_all();
@@ -5883,18 +5903,22 @@ raid5_set_cache_size(struct mddev *mddev, int size)
                 return -EINVAL;
 
         conf->min_nr_stripes = size;
+        mutex_lock(&conf->cache_size_mutex);
         while (size < conf->max_nr_stripes &&
                drop_one_stripe(conf))
                 ;
+        mutex_unlock(&conf->cache_size_mutex);
 
 
         err = md_allow_write(mddev);
         if (err)
                 return err;
 
+        mutex_lock(&conf->cache_size_mutex);
         while (size > conf->max_nr_stripes)
                 if (!grow_one_stripe(conf, GFP_KERNEL))
                         break;
+        mutex_unlock(&conf->cache_size_mutex);
 
         return 0;
 }
@@ -6360,11 +6384,19 @@ static unsigned long raid5_cache_scan(struct shrinker *shrink,
                                       struct shrink_control *sc)
 {
         struct r5conf *conf = container_of(shrink, struct r5conf, shrinker);
-        int ret = 0;
-        while (ret < sc->nr_to_scan) {
-                if (drop_one_stripe(conf) == 0)
-                        return SHRINK_STOP;
-                ret++;
+        unsigned long ret = SHRINK_STOP;
+
+        if (mutex_trylock(&conf->cache_size_mutex)) {
+                ret= 0;
+                while (ret < sc->nr_to_scan &&
+                       conf->max_nr_stripes > conf->min_nr_stripes) {
+                        if (drop_one_stripe(conf) == 0) {
+                                ret = SHRINK_STOP;
+                                break;
+                        }
+                        ret++;
+                }
+                mutex_unlock(&conf->cache_size_mutex);
         }
         return ret;
 }
@@ -6433,7 +6465,11 @@ static struct r5conf *setup_conf(struct mddev *mddev)
                 goto abort;
         spin_lock_init(&conf->device_lock);
         seqcount_init(&conf->gen_lock);
-        init_waitqueue_head(&conf->wait_for_stripe);
+        mutex_init(&conf->cache_size_mutex);
+        init_waitqueue_head(&conf->wait_for_quiescent);
+        for (i = 0; i < NR_STRIPE_HASH_LOCKS; i++) {
+                init_waitqueue_head(&conf->wait_for_stripe[i]);
+        }
         init_waitqueue_head(&conf->wait_for_overlap);
         INIT_LIST_HEAD(&conf->handle_list);
         INIT_LIST_HEAD(&conf->hold_list);
@@ -7466,7 +7502,7 @@ static void raid5_quiesce(struct mddev *mddev, int state)
                  * active stripes can drain
                  */
                 conf->quiesce = 2;
-                wait_event_cmd(conf->wait_for_stripe,
+                wait_event_cmd(conf->wait_for_quiescent,
                                     atomic_read(&conf->active_stripes) == 0 &&
                                     atomic_read(&conf->active_aligned_reads) == 0,
                                     unlock_all_device_hash_locks_irq(conf),
@@ -7480,7 +7516,7 @@ static void raid5_quiesce(struct mddev *mddev, int state)
         case 0: /* re-enable writes */
                 lock_all_device_hash_locks_irq(conf);
                 conf->quiesce = 0;
-                wake_up(&conf->wait_for_stripe);
+                wake_up(&conf->wait_for_quiescent);
                 wake_up(&conf->wait_for_overlap);
                 unlock_all_device_hash_locks_irq(conf);
                 break;