blk-mq: don't allocate driver tag upfront for flush rq

The idea behind it is simple:

1) for none scheduler, driver tag has to be borrowed for flush rq,
   otherwise we may run out of tag, and that causes an IO hang. And
   get/put driver tag is actually noop for none, so reordering tags
   isn't necessary at all.

2) for a real I/O scheduler, we need not allocate a driver tag upfront
   for flush rq. It works just fine to follow the same approach as
   normal requests: allocate driver tag for each rq just before calling
   ->queue_rq().

One driver visible change is that the driver tag isn't shared in the
flush request sequence. That won't be a problem, since we always do that
in legacy path.

Then flush rq need not be treated specially wrt. get/put driver tag.
This cleans up the code - for instance, reorder_tags_to_front() can be
removed, and we needn't worry about request ordering in dispatch list
for avoiding I/O deadlock.

Also we have to put the driver tag before requeueing.

Signed-off-by: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>

1 files changed, 6 insertions, 35 deletions

diff --git a/block/blk-mq.c b/block/blk-mq.c
index 14f6886fbec8..c501cbd0de93 100644
--- a/block/blk-mq.c
+++ b/block/blk-mq.c
@@ -653,6 +653,8 @@ static void __blk_mq_requeue_request(struct request *rq)
 {
         struct request_queue *q = rq->q;
 
+        blk_mq_put_driver_tag(rq);
+
         trace_block_rq_requeue(q, rq);
         wbt_requeue(q->rq_wb, &rq->issue_stat);
         blk_mq_sched_requeue_request(rq);
@@ -996,30 +998,6 @@ done:
         return rq->tag != -1;
 }
 
-/*
- * If we fail getting a driver tag because all the driver tags are already
- * assigned and on the dispatch list, BUT the first entry does not have a
- * tag, then we could deadlock. For that case, move entries with assigned
- * driver tags to the front, leaving the set of tagged requests in the
- * same order, and the untagged set in the same order.
- */
-static bool reorder_tags_to_front(struct list_head *list)
-{
-        struct request *rq, *tmp, *first = NULL;
-
-        list_for_each_entry_safe_reverse(rq, tmp, list, queuelist) {
-                if (rq == first)
-                        break;
-                if (rq->tag != -1) {
-                        list_move(&rq->queuelist, list);
-                        if (!first)
-                                first = rq;
-                }
-        }
-
-        return first != NULL;
-}
-
 static int blk_mq_dispatch_wake(wait_queue_entry_t *wait, unsigned mode, int flags,
                                 void *key)
 {
@@ -1080,9 +1058,6 @@ bool blk_mq_dispatch_rq_list(struct request_queue *q, struct list_head *list,
 
                 rq = list_first_entry(list, struct request, queuelist);
                 if (!blk_mq_get_driver_tag(rq, &hctx, false)) {
-                        if (!queued && reorder_tags_to_front(list))
-                                continue;
-
                         /*
                          * The initial allocation attempt failed, so we need to
                          * rerun the hardware queue when a tag is freed.
@@ -1133,7 +1108,6 @@ bool blk_mq_dispatch_rq_list(struct request_queue *q, struct list_head *list,
                                 nxt = list_first_entry(list, struct request, queuelist);
                                 blk_mq_put_driver_tag(nxt);
                         }
-                        blk_mq_put_driver_tag_hctx(hctx, rq);
                         list_add(&rq->queuelist, list);
                         __blk_mq_requeue_request(rq);
                         break;
@@ -1698,13 +1672,10 @@ static blk_qc_t blk_mq_make_request(struct request_queue *q, struct bio *bio)
         if (unlikely(is_flush_fua)) {
                 blk_mq_put_ctx(data.ctx);
                 blk_mq_bio_to_request(rq, bio);
-                if (q->elevator) {
-                        blk_mq_sched_insert_request(rq, false, true, true,
-                                        true);
-                } else {
-                        blk_insert_flush(rq);
-                        blk_mq_run_hw_queue(data.hctx, true);
-                }
+
+                /* bypass scheduler for flush rq */
+                blk_insert_flush(rq);
+                blk_mq_run_hw_queue(data.hctx, true);
         } else if (plug && q->nr_hw_queues == 1) {
                 struct request *last = NULL;