4 files changed, 28 insertions, 34 deletions

diff --git a/block/blk-cgroup.h b/block/blk-cgroup.h
index 1610b22edf09..86154eab9523 100644
--- a/block/blk-cgroup.h
+++ b/block/blk-cgroup.h
@@ -435,9 +435,9 @@ static inline uint64_t blkg_stat_read(struct blkg_stat *stat)
         uint64_t v;
 
         do {
-                start = u64_stats_fetch_begin(&stat->syncp);
+                start = u64_stats_fetch_begin_bh(&stat->syncp);
                 v = stat->cnt;
-        } while (u64_stats_fetch_retry(&stat->syncp, start));
+        } while (u64_stats_fetch_retry_bh(&stat->syncp, start));
 
         return v;
 }
@@ -508,9 +508,9 @@ static inline struct blkg_rwstat blkg_rwstat_read(struct blkg_rwstat *rwstat)
         struct blkg_rwstat tmp;
 
         do {
-                start = u64_stats_fetch_begin(&rwstat->syncp);
+                start = u64_stats_fetch_begin_bh(&rwstat->syncp);
                 tmp = *rwstat;
-        } while (u64_stats_fetch_retry(&rwstat->syncp, start));
+        } while (u64_stats_fetch_retry_bh(&rwstat->syncp, start));
 
         return tmp;
 }
diff --git a/block/blk-flush.c b/block/blk-flush.c
index 331e627301ea..fb6f3c0ffa49 100644
--- a/block/blk-flush.c
+++ b/block/blk-flush.c
@@ -502,15 +502,6 @@ void blk_abort_flushes(struct request_queue *q)
         }
 }
 
-static void bio_end_flush(struct bio *bio, int err)
-{
-        if (err)
-                clear_bit(BIO_UPTODATE, &bio->bi_flags);
-        if (bio->bi_private)
-                complete(bio->bi_private);
-        bio_put(bio);
-}
-
 /**
  * blkdev_issue_flush - queue a flush
  * @bdev:       blockdev to issue flush for
@@ -526,7 +517,6 @@ static void bio_end_flush(struct bio *bio, int err)
 int blkdev_issue_flush(struct block_device *bdev, gfp_t gfp_mask,
                 sector_t *error_sector)
 {
-        DECLARE_COMPLETION_ONSTACK(wait);
         struct request_queue *q;
         struct bio *bio;
         int ret = 0;
@@ -548,13 +538,9 @@ int blkdev_issue_flush(struct block_device *bdev, gfp_t gfp_mask,
                 return -ENXIO;
 
         bio = bio_alloc(gfp_mask, 0);
-        bio->bi_end_io = bio_end_flush;
         bio->bi_bdev = bdev;
-        bio->bi_private = &wait;
 
-        bio_get(bio);
-        submit_bio(WRITE_FLUSH, bio);
-        wait_for_completion_io(&wait);
+        ret = submit_bio_wait(WRITE_FLUSH, bio);
 
         /*
          * The driver must store the error location in ->bi_sector, if
@@ -564,9 +550,6 @@ int blkdev_issue_flush(struct block_device *bdev, gfp_t gfp_mask,
         if (error_sector)
                 *error_sector = bio->bi_sector;
 
-        if (!bio_flagged(bio, BIO_UPTODATE))
-                ret = -EIO;
-
         bio_put(bio);
         return ret;
 }
diff --git a/block/blk-mq.c b/block/blk-mq.c
index 862f458d4760..c79126e11030 100644
--- a/block/blk-mq.c
+++ b/block/blk-mq.c
@@ -171,9 +171,12 @@ bool blk_mq_can_queue(struct blk_mq_hw_ctx *hctx)
 }
 EXPORT_SYMBOL(blk_mq_can_queue);
 
-static void blk_mq_rq_ctx_init(struct blk_mq_ctx *ctx, struct request *rq,
-                               unsigned int rw_flags)
+static void blk_mq_rq_ctx_init(struct request_queue *q, struct blk_mq_ctx *ctx,
+                               struct request *rq, unsigned int rw_flags)
 {
+        if (blk_queue_io_stat(q))
+                rw_flags |= REQ_IO_STAT;
+
         rq->mq_ctx = ctx;
         rq->cmd_flags = rw_flags;
         ctx->rq_dispatched[rw_is_sync(rw_flags)]++;
@@ -197,12 +200,14 @@ static struct request *blk_mq_alloc_request_pinned(struct request_queue *q,
 
                 rq = __blk_mq_alloc_request(hctx, gfp & ~__GFP_WAIT, reserved);
                 if (rq) {
-                        blk_mq_rq_ctx_init(ctx, rq, rw);
-                        break;
-                } else if (!(gfp & __GFP_WAIT))
+                        blk_mq_rq_ctx_init(q, ctx, rq, rw);
                         break;
+                }
 
                 blk_mq_put_ctx(ctx);
+                if (!(gfp & __GFP_WAIT))
+                        break;
+
                 __blk_mq_run_hw_queue(hctx);
                 blk_mq_wait_for_tags(hctx->tags);
         } while (1);
@@ -219,7 +224,8 @@ struct request *blk_mq_alloc_request(struct request_queue *q, int rw,
                 return NULL;
 
         rq = blk_mq_alloc_request_pinned(q, rw, gfp, reserved);
-        blk_mq_put_ctx(rq->mq_ctx);
+        if (rq)
+                blk_mq_put_ctx(rq->mq_ctx);
         return rq;
 }
 
@@ -232,7 +238,8 @@ struct request *blk_mq_alloc_reserved_request(struct request_queue *q, int rw,
                 return NULL;
 
         rq = blk_mq_alloc_request_pinned(q, rw, gfp, true);
-        blk_mq_put_ctx(rq->mq_ctx);
+        if (rq)
+                blk_mq_put_ctx(rq->mq_ctx);
         return rq;
 }
 EXPORT_SYMBOL(blk_mq_alloc_reserved_request);
@@ -305,12 +312,12 @@ void blk_mq_complete_request(struct request *rq, int error)
 
         blk_account_io_completion(rq, bytes);
 
+        blk_account_io_done(rq);
+
         if (rq->end_io)
                 rq->end_io(rq, error);
         else
                 blk_mq_free_request(rq);
-
-        blk_account_io_done(rq);
 }
 
 void __blk_mq_end_io(struct request *rq, int error)
@@ -718,6 +725,8 @@ static void __blk_mq_insert_request(struct blk_mq_hw_ctx *hctx,
 {
         struct blk_mq_ctx *ctx = rq->mq_ctx;
 
+        trace_block_rq_insert(hctx->queue, rq);
+
         list_add_tail(&rq->queuelist, &ctx->rq_list);
         blk_mq_hctx_mark_pending(hctx, ctx);
 
@@ -921,7 +930,7 @@ static void blk_mq_make_request(struct request_queue *q, struct bio *bio)
         trace_block_getrq(q, bio, rw);
         rq = __blk_mq_alloc_request(hctx, GFP_ATOMIC, false);
         if (likely(rq))
-                blk_mq_rq_ctx_init(ctx, rq, rw);
+                blk_mq_rq_ctx_init(q, ctx, rq, rw);
         else {
                 blk_mq_put_ctx(ctx);
                 trace_block_sleeprq(q, bio, rw);
@@ -1377,6 +1386,7 @@ struct request_queue *blk_mq_init_queue(struct blk_mq_reg *reg,
         q->queue_hw_ctx = hctxs;
 
         q->mq_ops = reg->ops;
+        q->queue_flags |= QUEUE_FLAG_MQ_DEFAULT;
 
         blk_queue_make_request(q, blk_mq_make_request);
         blk_queue_rq_timed_out(q, reg->ops->timeout);
diff --git a/block/partitions/efi.c b/block/partitions/efi.c
index a8287b49d062..dc51f467a560 100644
--- a/block/partitions/efi.c
+++ b/block/partitions/efi.c
@@ -96,6 +96,7 @@
  * - Code works, detects all the partitions.
  *
  ************************************************************/
+#include <linux/kernel.h>
 #include <linux/crc32.h>
 #include <linux/ctype.h>
 #include <linux/math64.h>
@@ -715,8 +716,8 @@ int efi_partition(struct parsed_partitions *state)
                 efi_guid_unparse(&ptes[i].unique_partition_guid, info->uuid);
 
                 /* Naively convert UTF16-LE to 7 bits. */
-                label_max = min(sizeof(info->volname) - 1,
-                                sizeof(ptes[i].partition_name));
+                label_max = min(ARRAY_SIZE(info->volname) - 1,
+                                ARRAY_SIZE(ptes[i].partition_name));
                 info->volname[label_max] = 0;
                 while (label_count < label_max) {
                         u8 c = ptes[i].partition_name[label_count] & 0xff;