Merge branch 'for-4.8/core' of git://git.kernel.dk/linux-block

Pull core block updates from Jens Axboe:

   - the big change is the cleanup from Mike Christie, cleaning up our
     uses of command types and modified flags.  This is what will throw
     some merge conflicts

   - regression fix for the above for btrfs, from Vincent

   - following up to the above, better packing of struct request from
     Christoph

   - a 2038 fix for blktrace from Arnd

   - a few trivial/spelling fixes from Bart Van Assche

   - a front merge check fix from Damien, which could cause issues on
     SMR drives

   - Atari partition fix from Gabriel

   - convert cfq to highres timers, since jiffies isn't granular enough
     for some devices these days.  From Jan and Jeff

   - CFQ priority boost fix idle classes, from me

   - cleanup series from Ming, improving our bio/bvec iteration

   - a direct issue fix for blk-mq from Omar

   - fix for plug merging not involving the IO scheduler, like we do for
     other types of merges.  From Tahsin

   - expose DAX type internally and through sysfs.  From Toshi and Yigal

* 'for-4.8/core' of git://git.kernel.dk/linux-block: (76 commits)
  block: Fix front merge check
  block: do not merge requests without consulting with io scheduler
  block: Fix spelling in a source code comment
  block: expose QUEUE_FLAG_DAX in sysfs
  block: add QUEUE_FLAG_DAX for devices to advertise their DAX support
  Btrfs: fix comparison in __btrfs_map_block()
  block: atari: Return early for unsupported sector size
  Doc: block: Fix a typo in queue-sysfs.txt
  cfq-iosched: Charge at least 1 jiffie instead of 1 ns
  cfq-iosched: Fix regression in bonnie++ rewrite performance
  cfq-iosched: Convert slice_resid from u64 to s64
  block: Convert fifo_time from ulong to u64
  blktrace: avoid using timespec
  block/blk-cgroup.c: Declare local symbols static
  block/bio-integrity.c: Add #include "blk.h"
  block/partition-generic.c: Remove a set-but-not-used variable
  block: bio: kill BIO_MAX_SIZE
  cfq-iosched: temporarily boost queue priority for idle classes
  block: drbd: avoid to use BIO_MAX_SIZE
  block: bio: remove BIO_MAX_SECTORS
  ...

1 files changed, 22 insertions, 20 deletions

diff --git a/block/blk-mq.c b/block/blk-mq.c
index f9b9049b1284..2a1920c6d6e5 100644
--- a/block/blk-mq.c
+++ b/block/blk-mq.c
@@ -159,16 +159,17 @@ 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 request_queue *q, struct blk_mq_ctx *ctx,
-                               struct request *rq, unsigned int rw_flags)
+                               struct request *rq, int op,
+                               unsigned int op_flags)
 {
         if (blk_queue_io_stat(q))
-                rw_flags |= REQ_IO_STAT;
+                op_flags |= REQ_IO_STAT;
 
         INIT_LIST_HEAD(&rq->queuelist);
         /* csd/requeue_work/fifo_time is initialized before use */
         rq->q = q;
         rq->mq_ctx = ctx;
-        rq->cmd_flags |= rw_flags;
+        req_set_op_attrs(rq, op, op_flags);
         /* do not touch atomic flags, it needs atomic ops against the timer */
         rq->cpu = -1;
         INIT_HLIST_NODE(&rq->hash);
@@ -203,11 +204,11 @@ static void blk_mq_rq_ctx_init(struct request_queue *q, struct blk_mq_ctx *ctx,
         rq->end_io_data = NULL;
         rq->next_rq = NULL;
 
-        ctx->rq_dispatched[rw_is_sync(rw_flags)]++;
+        ctx->rq_dispatched[rw_is_sync(op, op_flags)]++;
 }
 
 static struct request *
-__blk_mq_alloc_request(struct blk_mq_alloc_data *data, int rw)
+__blk_mq_alloc_request(struct blk_mq_alloc_data *data, int op, int op_flags)
 {
         struct request *rq;
         unsigned int tag;
@@ -222,7 +223,7 @@ __blk_mq_alloc_request(struct blk_mq_alloc_data *data, int rw)
                 }
 
                 rq->tag = tag;
-                blk_mq_rq_ctx_init(data->q, data->ctx, rq, rw);
+                blk_mq_rq_ctx_init(data->q, data->ctx, rq, op, op_flags);
                 return rq;
         }
 
@@ -246,7 +247,7 @@ struct request *blk_mq_alloc_request(struct request_queue *q, int rw,
         hctx = q->mq_ops->map_queue(q, ctx->cpu);
         blk_mq_set_alloc_data(&alloc_data, q, flags, ctx, hctx);
 
-        rq = __blk_mq_alloc_request(&alloc_data, rw);
+        rq = __blk_mq_alloc_request(&alloc_data, rw, 0);
         if (!rq && !(flags & BLK_MQ_REQ_NOWAIT)) {
                 __blk_mq_run_hw_queue(hctx);
                 blk_mq_put_ctx(ctx);
@@ -254,7 +255,7 @@ struct request *blk_mq_alloc_request(struct request_queue *q, int rw,
                 ctx = blk_mq_get_ctx(q);
                 hctx = q->mq_ops->map_queue(q, ctx->cpu);
                 blk_mq_set_alloc_data(&alloc_data, q, flags, ctx, hctx);
-                rq =  __blk_mq_alloc_request(&alloc_data, rw);
+                rq =  __blk_mq_alloc_request(&alloc_data, rw, 0);
                 ctx = alloc_data.ctx;
         }
         blk_mq_put_ctx(ctx);
@@ -784,7 +785,7 @@ static void __blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx)
                 switch (ret) {
                 case BLK_MQ_RQ_QUEUE_OK:
                         queued++;
-                        continue;
+                        break;
                 case BLK_MQ_RQ_QUEUE_BUSY:
                         list_add(&rq->queuelist, &rq_list);
                         __blk_mq_requeue_request(rq);
@@ -1169,28 +1170,29 @@ static struct request *blk_mq_map_request(struct request_queue *q,
         struct blk_mq_hw_ctx *hctx;
         struct blk_mq_ctx *ctx;
         struct request *rq;
-        int rw = bio_data_dir(bio);
+        int op = bio_data_dir(bio);
+        int op_flags = 0;
         struct blk_mq_alloc_data alloc_data;
 
         blk_queue_enter_live(q);
         ctx = blk_mq_get_ctx(q);
         hctx = q->mq_ops->map_queue(q, ctx->cpu);
 
-        if (rw_is_sync(bio->bi_rw))
-                rw |= REQ_SYNC;
+        if (rw_is_sync(bio_op(bio), bio->bi_rw))
+                op_flags |= REQ_SYNC;
 
-        trace_block_getrq(q, bio, rw);
+        trace_block_getrq(q, bio, op);
         blk_mq_set_alloc_data(&alloc_data, q, BLK_MQ_REQ_NOWAIT, ctx, hctx);
-        rq = __blk_mq_alloc_request(&alloc_data, rw);
+        rq = __blk_mq_alloc_request(&alloc_data, op, op_flags);
         if (unlikely(!rq)) {
                 __blk_mq_run_hw_queue(hctx);
                 blk_mq_put_ctx(ctx);
-                trace_block_sleeprq(q, bio, rw);
+                trace_block_sleeprq(q, bio, op);
 
                 ctx = blk_mq_get_ctx(q);
                 hctx = q->mq_ops->map_queue(q, ctx->cpu);
                 blk_mq_set_alloc_data(&alloc_data, q, 0, ctx, hctx);
-                rq = __blk_mq_alloc_request(&alloc_data, rw);
+                rq = __blk_mq_alloc_request(&alloc_data, op, op_flags);
                 ctx = alloc_data.ctx;
                 hctx = alloc_data.hctx;
         }
@@ -1244,8 +1246,8 @@ static int blk_mq_direct_issue_request(struct request *rq, blk_qc_t *cookie)
  */
 static blk_qc_t blk_mq_make_request(struct request_queue *q, struct bio *bio)
 {
-        const int is_sync = rw_is_sync(bio->bi_rw);
-        const int is_flush_fua = bio->bi_rw & (REQ_FLUSH | REQ_FUA);
+        const int is_sync = rw_is_sync(bio_op(bio), bio->bi_rw);
+        const int is_flush_fua = bio->bi_rw & (REQ_PREFLUSH | REQ_FUA);
         struct blk_map_ctx data;
         struct request *rq;
         unsigned int request_count = 0;
@@ -1338,8 +1340,8 @@ done:
  */
 static blk_qc_t blk_sq_make_request(struct request_queue *q, struct bio *bio)
 {
-        const int is_sync = rw_is_sync(bio->bi_rw);
-        const int is_flush_fua = bio->bi_rw & (REQ_FLUSH | REQ_FUA);
+        const int is_sync = rw_is_sync(bio_op(bio), bio->bi_rw);
+        const int is_flush_fua = bio->bi_rw & (REQ_PREFLUSH | REQ_FUA);
         struct blk_plug *plug;
         unsigned int request_count = 0;
         struct blk_map_ctx data;