Merge branch 'fix/dw' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/spi into spi-dw

Conflicts:
	drivers/spi/spi-dw-mid.c

5 files changed, 52 insertions, 28 deletions

diff --git a/drivers/md/dm-cache-target.c b/drivers/md/dm-cache-target.c
index 1af40ee209e2..7130505c2425 100644
--- a/drivers/md/dm-cache-target.c
+++ b/drivers/md/dm-cache-target.c
@@ -895,8 +895,8 @@ static void migration_success_pre_commit(struct dm_cache_migration *mg)
         struct cache *cache = mg->cache;
 
         if (mg->writeback) {
-                cell_defer(cache, mg->old_ocell, false);
                 clear_dirty(cache, mg->old_oblock, mg->cblock);
+                cell_defer(cache, mg->old_ocell, false);
                 cleanup_migration(mg);
                 return;
 
@@ -951,13 +951,13 @@ static void migration_success_post_commit(struct dm_cache_migration *mg)
                 }
 
         } else {
+                clear_dirty(cache, mg->new_oblock, mg->cblock);
                 if (mg->requeue_holder)
                         cell_defer(cache, mg->new_ocell, true);
                 else {
                         bio_endio(mg->new_ocell->holder, 0);
                         cell_defer(cache, mg->new_ocell, false);
                 }
-                clear_dirty(cache, mg->new_oblock, mg->cblock);
                 cleanup_migration(mg);
         }
 }
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 2785007e0e46..cd15e0801228 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -1688,6 +1688,7 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
         unsigned int key_size, opt_params;
         unsigned long long tmpll;
         int ret;
+        size_t iv_size_padding;
         struct dm_arg_set as;
         const char *opt_string;
         char dummy;
@@ -1724,20 +1725,32 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 
         cc->dmreq_start = sizeof(struct ablkcipher_request);
         cc->dmreq_start += crypto_ablkcipher_reqsize(any_tfm(cc));
-        cc->dmreq_start = ALIGN(cc->dmreq_start, crypto_tfm_ctx_alignment());
-        cc->dmreq_start += crypto_ablkcipher_alignmask(any_tfm(cc)) &
-                           ~(crypto_tfm_ctx_alignment() - 1);
+        cc->dmreq_start = ALIGN(cc->dmreq_start, __alignof__(struct dm_crypt_request));
+
+        if (crypto_ablkcipher_alignmask(any_tfm(cc)) < CRYPTO_MINALIGN) {
+                /* Allocate the padding exactly */
+                iv_size_padding = -(cc->dmreq_start + sizeof(struct dm_crypt_request))
+                                & crypto_ablkcipher_alignmask(any_tfm(cc));
+        } else {
+                /*
+                 * If the cipher requires greater alignment than kmalloc
+                 * alignment, we don't know the exact position of the
+                 * initialization vector. We must assume worst case.
+                 */
+                iv_size_padding = crypto_ablkcipher_alignmask(any_tfm(cc));
+        }
 
         cc->req_pool = mempool_create_kmalloc_pool(MIN_IOS, cc->dmreq_start +
-                        sizeof(struct dm_crypt_request) + cc->iv_size);
+                        sizeof(struct dm_crypt_request) + iv_size_padding + cc->iv_size);
         if (!cc->req_pool) {
                 ti->error = "Cannot allocate crypt request mempool";
                 goto bad;
         }
 
         cc->per_bio_data_size = ti->per_bio_data_size =
-                                sizeof(struct dm_crypt_io) + cc->dmreq_start +
-                                sizeof(struct dm_crypt_request) + cc->iv_size;
+                ALIGN(sizeof(struct dm_crypt_io) + cc->dmreq_start +
+                      sizeof(struct dm_crypt_request) + iv_size_padding + cc->iv_size,
+                      ARCH_KMALLOC_MINALIGN);
 
         cc->page_pool = mempool_create_page_pool(MIN_POOL_PAGES, 0);
         if (!cc->page_pool) {
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index d7690f86fdb9..55de4f6f7eaf 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -540,11 +540,7 @@ static int read_balance(struct r1conf *conf, struct r1bio *r1_bio, int *max_sect
         has_nonrot_disk = 0;
         choose_next_idle = 0;
 
-        if (conf->mddev->recovery_cp < MaxSector &&
-            (this_sector + sectors >= conf->next_resync))
-                choose_first = 1;
-        else
-                choose_first = 0;
+        choose_first = (conf->mddev->recovery_cp < this_sector + sectors);
 
         for (disk = 0 ; disk < conf->raid_disks * 2 ; disk++) {
                 sector_t dist;
@@ -831,7 +827,7 @@ static void flush_pending_writes(struct r1conf *conf)
  *    there is no normal IO happeing.  It must arrange to call
  *    lower_barrier when the particular background IO completes.
  */
-static void raise_barrier(struct r1conf *conf)
+static void raise_barrier(struct r1conf *conf, sector_t sector_nr)
 {
         spin_lock_irq(&conf->resync_lock);
 
@@ -841,6 +837,7 @@ static void raise_barrier(struct r1conf *conf)
 
         /* block any new IO from starting */
         conf->barrier++;
+        conf->next_resync = sector_nr;
 
         /* For these conditions we must wait:
          * A: while the array is in frozen state
@@ -849,14 +846,17 @@ static void raise_barrier(struct r1conf *conf)
          * C: next_resync + RESYNC_SECTORS > start_next_window, meaning
          *    next resync will reach to the window which normal bios are
          *    handling.
+         * D: while there are any active requests in the current window.
          */
         wait_event_lock_irq(conf->wait_barrier,
                             !conf->array_frozen &&
                             conf->barrier < RESYNC_DEPTH &&
+                            conf->current_window_requests == 0 &&
                             (conf->start_next_window >=
                              conf->next_resync + RESYNC_SECTORS),
                             conf->resync_lock);
 
+        conf->nr_pending++;
         spin_unlock_irq(&conf->resync_lock);
 }
 
@@ -866,6 +866,7 @@ static void lower_barrier(struct r1conf *conf)
         BUG_ON(conf->barrier <= 0);
         spin_lock_irqsave(&conf->resync_lock, flags);
         conf->barrier--;
+        conf->nr_pending--;
         spin_unlock_irqrestore(&conf->resync_lock, flags);
         wake_up(&conf->wait_barrier);
 }
@@ -877,12 +878,10 @@ static bool need_to_wait_for_sync(struct r1conf *conf, struct bio *bio)
         if (conf->array_frozen || !bio)
                 wait = true;
         else if (conf->barrier && bio_data_dir(bio) == WRITE) {
-                if (conf->next_resync < RESYNC_WINDOW_SECTORS)
-                        wait = true;
-                else if ((conf->next_resync - RESYNC_WINDOW_SECTORS
-                                >= bio_end_sector(bio)) ||
-                         (conf->next_resync + NEXT_NORMALIO_DISTANCE
-                                <= bio->bi_iter.bi_sector))
+                if ((conf->mddev->curr_resync_completed
+                     >= bio_end_sector(bio)) ||
+                    (conf->next_resync + NEXT_NORMALIO_DISTANCE
+                     <= bio->bi_iter.bi_sector))
                         wait = false;
                 else
                         wait = true;
@@ -919,8 +918,8 @@ static sector_t wait_barrier(struct r1conf *conf, struct bio *bio)
         }
 
         if (bio && bio_data_dir(bio) == WRITE) {
-                if (conf->next_resync + NEXT_NORMALIO_DISTANCE
-                    <= bio->bi_iter.bi_sector) {
+                if (bio->bi_iter.bi_sector >=
+                    conf->mddev->curr_resync_completed) {
                         if (conf->start_next_window == MaxSector)
                                 conf->start_next_window =
                                         conf->next_resync +
@@ -1186,6 +1185,7 @@ read_again:
                                    atomic_read(&bitmap->behind_writes) == 0);
                 }
                 r1_bio->read_disk = rdisk;
+                r1_bio->start_next_window = 0;
 
                 read_bio = bio_clone_mddev(bio, GFP_NOIO, mddev);
                 bio_trim(read_bio, r1_bio->sector - bio->bi_iter.bi_sector,
@@ -1548,8 +1548,13 @@ static void close_sync(struct r1conf *conf)
         mempool_destroy(conf->r1buf_pool);
         conf->r1buf_pool = NULL;
 
+        spin_lock_irq(&conf->resync_lock);
         conf->next_resync = 0;
         conf->start_next_window = MaxSector;
+        conf->current_window_requests +=
+                conf->next_window_requests;
+        conf->next_window_requests = 0;
+        spin_unlock_irq(&conf->resync_lock);
 }
 
 static int raid1_spare_active(struct mddev *mddev)
@@ -2150,7 +2155,7 @@ static void fix_read_error(struct r1conf *conf, int read_disk,
                         d--;
                         rdev = conf->mirrors[d].rdev;
                         if (rdev &&
-                            test_bit(In_sync, &rdev->flags))
+                            !test_bit(Faulty, &rdev->flags))
                                 r1_sync_page_io(rdev, sect, s,
                                                 conf->tmppage, WRITE);
                 }
@@ -2162,7 +2167,7 @@ static void fix_read_error(struct r1conf *conf, int read_disk,
                         d--;
                         rdev = conf->mirrors[d].rdev;
                         if (rdev &&
-                            test_bit(In_sync, &rdev->flags)) {
+                            !test_bit(Faulty, &rdev->flags)) {
                                 if (r1_sync_page_io(rdev, sect, s,
                                                     conf->tmppage, READ)) {
                                         atomic_add(s, &rdev->corrected_errors);
@@ -2541,9 +2546,8 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr, int *skipp
 
         bitmap_cond_end_sync(mddev->bitmap, sector_nr);
         r1_bio = mempool_alloc(conf->r1buf_pool, GFP_NOIO);
-        raise_barrier(conf);
 
-        conf->next_resync = sector_nr;
+        raise_barrier(conf, sector_nr);
 
         rcu_read_lock();
         /*
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index b08c18871323..6703751d87d7 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -2953,6 +2953,7 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr,
                  */
                 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) {
                         end_reshape(conf);
+                        close_sync(conf);
                         return 0;
                 }
 
@@ -3081,6 +3082,7 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr,
                         }
 
                         r10_bio = mempool_alloc(conf->r10buf_pool, GFP_NOIO);
+                        r10_bio->state = 0;
                         raise_barrier(conf, rb2 != NULL);
                         atomic_set(&r10_bio->remaining, 0);
 
@@ -3269,6 +3271,7 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr,
                 if (sync_blocks < max_sync)
                         max_sync = sync_blocks;
                 r10_bio = mempool_alloc(conf->r10buf_pool, GFP_NOIO);
+                r10_bio->state = 0;
 
                 r10_bio->mddev = mddev;
                 atomic_set(&r10_bio->remaining, 0);
@@ -4384,6 +4387,7 @@ static sector_t reshape_request(struct mddev *mddev, sector_t sector_nr,
 read_more:
         /* Now schedule reads for blocks from sector_nr to last */
         r10_bio = mempool_alloc(conf->r10buf_pool, GFP_NOIO);
+        r10_bio->state = 0;
         raise_barrier(conf, sectors_done != 0);
         atomic_set(&r10_bio->remaining, 0);
         r10_bio->mddev = mddev;
@@ -4398,6 +4402,7 @@ read_more:
                  * on all the target devices.
                  */
                 // FIXME
+                mempool_free(r10_bio, conf->r10buf_pool);
                 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
                 return sectors_done;
         }
@@ -4410,7 +4415,7 @@ read_more:
         read_bio->bi_private = r10_bio;
         read_bio->bi_end_io = end_sync_read;
         read_bio->bi_rw = READ;
-        read_bio->bi_flags &= ~(BIO_POOL_MASK - 1);
+        read_bio->bi_flags &= (~0UL << BIO_RESET_BITS);
         read_bio->bi_flags |= 1 << BIO_UPTODATE;
         read_bio->bi_vcnt = 0;
         read_bio->bi_iter.bi_size = 0;
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 6234b2e84587..183588b11fc1 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -2922,7 +2922,7 @@ static int fetch_block(struct stripe_head *sh, struct stripe_head_state *s,
               (!test_bit(R5_Insync, &dev->flags) || test_bit(STRIPE_PREREAD_ACTIVE, &sh->state)) &&
               !test_bit(R5_OVERWRITE, &fdev[0]->flags)) ||
              (sh->raid_conf->level == 6 && s->failed && s->to_write &&
-              s->to_write < sh->raid_conf->raid_disks - 2 &&
+              s->to_write - s->non_overwrite < sh->raid_conf->raid_disks - 2 &&
               (!test_bit(R5_Insync, &dev->flags) || test_bit(STRIPE_PREREAD_ACTIVE, &sh->state))))) {
                 /* we would like to get this block, possibly by computing it,
                  * otherwise read it if the backing disk is insync
@@ -3817,6 +3817,8 @@ static void handle_stripe(struct stripe_head *sh)
                                 set_bit(R5_Wantwrite, &dev->flags);
                                 if (prexor)
                                         continue;
+                                if (s.failed > 1)
+                                        continue;
                                 if (!test_bit(R5_Insync, &dev->flags) ||
                                     ((i == sh->pd_idx || i == sh->qd_idx)  &&
                                      s.failed == 0))