ibmvnic: Fix releasing of sub-CRQ IRQs in interrupt context

[cascardo/linux.git] / block / blk-mq-tag.c

diff --git a/block/blk-mq-tag.c b/block/blk-mq-tag.c
index 2cbdecd..dcf5ce3 100644 (file)
--- a/block/blk-mq-tag.c
+++ b/block/blk-mq-tag.c
@@ -7,7 +7,6 @@
  */
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/random.h>
 
 #include <linux/blk-mq.h>
 #include "blk.h"
@@ -91,42 +90,21 @@ static inline bool hctx_may_queue(struct blk_mq_hw_ctx *hctx,
        return atomic_read(&hctx->nr_active) < depth;
 }
 
-#define BT_ALLOC_RR(tags) (tags->alloc_policy == BLK_TAG_ALLOC_RR)
-
-static int __bt_get(struct blk_mq_hw_ctx *hctx, struct sbitmap_queue *bt,
-                   unsigned int *tag_cache, struct blk_mq_tags *tags)
+static int __bt_get(struct blk_mq_hw_ctx *hctx, struct sbitmap_queue *bt)
 {
-       unsigned int last_tag;
-       int tag;
-
        if (!hctx_may_queue(hctx, bt))
                return -1;
-
-       last_tag = *tag_cache;
-       tag = sbitmap_get(&bt->sb, last_tag, BT_ALLOC_RR(tags));
-
-       if (tag == -1) {
-               *tag_cache = 0;
-       } else if (tag == last_tag || unlikely(BT_ALLOC_RR(tags))) {
-               last_tag = tag + 1;
-               if (last_tag >= bt->sb.depth - 1)
-                       last_tag = 0;
-               *tag_cache = last_tag;
-       }
-
-       return tag;
+       return __sbitmap_queue_get(bt);
 }
 
-static int bt_get(struct blk_mq_alloc_data *data,
-                 struct sbitmap_queue *bt,
-                 struct blk_mq_hw_ctx *hctx,
-                 unsigned int *last_tag, struct blk_mq_tags *tags)
+static int bt_get(struct blk_mq_alloc_data *data, struct sbitmap_queue *bt,
+                 struct blk_mq_hw_ctx *hctx, struct blk_mq_tags *tags)
 {
        struct sbq_wait_state *ws;
        DEFINE_WAIT(wait);
        int tag;
 
-       tag = __bt_get(hctx, bt, last_tag, tags);
+       tag = __bt_get(hctx, bt);
        if (tag != -1)
                return tag;
 
@@ -137,7 +115,7 @@ static int bt_get(struct blk_mq_alloc_data *data,
        do {
                prepare_to_wait(&ws->wait, &wait, TASK_UNINTERRUPTIBLE);
 
-               tag = __bt_get(hctx, bt, last_tag, tags);
+               tag = __bt_get(hctx, bt);
                if (tag != -1)
                        break;
 
@@ -154,7 +132,7 @@ static int bt_get(struct blk_mq_alloc_data *data,
                 * Retry tag allocation after running the hardware queue,
                 * as running the queue may also have found completions.
                 */
-               tag = __bt_get(hctx, bt, last_tag, tags);
+               tag = __bt_get(hctx, bt);
                if (tag != -1)
                        break;
 
@@ -163,12 +141,10 @@ static int bt_get(struct blk_mq_alloc_data *data,
                io_schedule();
 
                data->ctx = blk_mq_get_ctx(data->q);
-               data->hctx = data->q->mq_ops->map_queue(data->q,
-                               data->ctx->cpu);
+               data->hctx = blk_mq_map_queue(data->q, data->ctx->cpu);
                if (data->flags & BLK_MQ_REQ_RESERVED) {
                        bt = &data->hctx->tags->breserved_tags;
                } else {
-                       last_tag = &data->ctx->last_tag;
                        hctx = data->hctx;
                        bt = &hctx->tags->bitmap_tags;
                }
@@ -185,7 +161,7 @@ static unsigned int __blk_mq_get_tag(struct blk_mq_alloc_data *data)
        int tag;
 
        tag = bt_get(data, &data->hctx->tags->bitmap_tags, data->hctx,
-                       &data->ctx->last_tag, data->hctx->tags);
+                    data->hctx->tags);
        if (tag >= 0)
                return tag + data->hctx->tags->nr_reserved_tags;
 
@@ -194,15 +170,15 @@ static unsigned int __blk_mq_get_tag(struct blk_mq_alloc_data *data)
 
 static unsigned int __blk_mq_get_reserved_tag(struct blk_mq_alloc_data *data)
 {
-       int tag, zero = 0;
+       int tag;
 
        if (unlikely(!data->hctx->tags->nr_reserved_tags)) {
                WARN_ON_ONCE(1);
                return BLK_MQ_TAG_FAIL;
        }
 
-       tag = bt_get(data, &data->hctx->tags->breserved_tags, NULL, &zero,
-               data->hctx->tags);
+       tag = bt_get(data, &data->hctx->tags->breserved_tags, NULL,
+                    data->hctx->tags);
        if (tag < 0)
                return BLK_MQ_TAG_FAIL;
 
@@ -216,8 +192,8 @@ unsigned int blk_mq_get_tag(struct blk_mq_alloc_data *data)
        return __blk_mq_get_tag(data);
 }
 
-void blk_mq_put_tag(struct blk_mq_hw_ctx *hctx, unsigned int tag,
-                   unsigned int *last_tag)
+void blk_mq_put_tag(struct blk_mq_hw_ctx *hctx, struct blk_mq_ctx *ctx,
+                   unsigned int tag)
 {
        struct blk_mq_tags *tags = hctx->tags;
 
@@ -225,12 +201,10 @@ void blk_mq_put_tag(struct blk_mq_hw_ctx *hctx, unsigned int tag,
                const int real_tag = tag - tags->nr_reserved_tags;
 
                BUG_ON(real_tag >= tags->nr_tags);
-               sbitmap_queue_clear(&tags->bitmap_tags, real_tag);
-               if (likely(tags->alloc_policy == BLK_TAG_ALLOC_FIFO))
-                       *last_tag = real_tag;
+               sbitmap_queue_clear(&tags->bitmap_tags, real_tag, ctx->cpu);
        } else {
                BUG_ON(tag >= tags->nr_reserved_tags);
-               sbitmap_queue_clear(&tags->breserved_tags, tag);
+               sbitmap_queue_clear(&tags->breserved_tags, tag, ctx->cpu);
        }
 }
 
@@ -382,21 +356,23 @@ static unsigned int bt_unused_tags(const struct sbitmap_queue *bt)
        return bt->sb.depth - sbitmap_weight(&bt->sb);
 }
 
-static int bt_alloc(struct sbitmap_queue *bt, unsigned int depth, int node)
+static int bt_alloc(struct sbitmap_queue *bt, unsigned int depth,
+                   bool round_robin, int node)
 {
-       return sbitmap_queue_init_node(bt, depth, -1, GFP_KERNEL, node);
+       return sbitmap_queue_init_node(bt, depth, -1, round_robin, GFP_KERNEL,
+                                      node);
 }
 
 static struct blk_mq_tags *blk_mq_init_bitmap_tags(struct blk_mq_tags *tags,
                                                   int node, int alloc_policy)
 {
        unsigned int depth = tags->nr_tags - tags->nr_reserved_tags;
+       bool round_robin = alloc_policy == BLK_TAG_ALLOC_RR;
 
-       tags->alloc_policy = alloc_policy;
-
-       if (bt_alloc(&tags->bitmap_tags, depth, node))
+       if (bt_alloc(&tags->bitmap_tags, depth, round_robin, node))
                goto free_tags;
-       if (bt_alloc(&tags->breserved_tags, tags->nr_reserved_tags, node))
+       if (bt_alloc(&tags->breserved_tags, tags->nr_reserved_tags, round_robin,
+                    node))
                goto free_bitmap_tags;
 
        return tags;
@@ -422,11 +398,6 @@ struct blk_mq_tags *blk_mq_init_tags(unsigned int total_tags,
        if (!tags)
                return NULL;
 
-       if (!zalloc_cpumask_var(&tags->cpumask, GFP_KERNEL)) {
-               kfree(tags);
-               return NULL;
-       }
-
        tags->nr_tags = total_tags;
        tags->nr_reserved_tags = reserved_tags;
 
@@ -437,17 +408,9 @@ void blk_mq_free_tags(struct blk_mq_tags *tags)
 {
        sbitmap_queue_free(&tags->bitmap_tags);
        sbitmap_queue_free(&tags->breserved_tags);
-       free_cpumask_var(tags->cpumask);
        kfree(tags);
 }
 
-void blk_mq_tag_init_last_tag(struct blk_mq_tags *tags, unsigned int *tag)
-{
-       unsigned int depth = tags->nr_tags - tags->nr_reserved_tags;
-
-       *tag = prandom_u32() % depth;
-}
-
 int blk_mq_tag_update_depth(struct blk_mq_tags *tags, unsigned int tdepth)
 {
        tdepth -= tags->nr_reserved_tags;
@@ -483,7 +446,7 @@ u32 blk_mq_unique_tag(struct request *rq)
        int hwq = 0;
 
        if (q->mq_ops) {
-               hctx = q->mq_ops->map_queue(q, rq->mq_ctx->cpu);
+               hctx = blk_mq_map_queue(q, rq->mq_ctx->cpu);
                hwq = hctx->queue_num;
        }