block/blk-mq.c

   1 /*
   2  * Block multiqueue core code
   3  *
   4  * Copyright (C) 2013-2014 Jens Axboe
   5  * Copyright (C) 2013-2014 Christoph Hellwig
   6  */
   7 #include <linux/kernel.h>
   8 #include <linux/module.h>
   9 #include <linux/backing-dev.h>
  10 #include <linux/bio.h>
  11 #include <linux/blkdev.h>
  12 #include <linux/mm.h>
  13 #include <linux/init.h>
  14 #include <linux/slab.h>
  15 #include <linux/workqueue.h>
  16 #include <linux/smp.h>
  17 #include <linux/llist.h>
  18 #include <linux/list_sort.h>
  19 #include <linux/cpu.h>
  20 #include <linux/cache.h>
  21 #include <linux/sched/sysctl.h>
  22 #include <linux/delay.h>
  23 #include <linux/crash_dump.h>
  24
  25 #include <trace/events/block.h>
  26
  27 #include <linux/blk-mq.h>
  28 #include "blk.h"
  29 #include "blk-mq.h"
  30 #include "blk-mq-tag.h"
  31
  32 static DEFINE_MUTEX(all_q_mutex);
  33 static LIST_HEAD(all_q_list);
  34
  35 static void __blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx);
  36
  37 /*
  38  * Check if any of the ctx's have pending work in this hardware queue
  39  */
  40 static bool blk_mq_hctx_has_pending(struct blk_mq_hw_ctx *hctx)
  41 {
  42         unsigned int i;
  43
  44         for (i = 0; i < hctx->ctx_map.map_size; i++)
  45                 if (hctx->ctx_map.map[i].word)
  46                         return true;
  47
  48         return false;
  49 }
  50
  51 static inline struct blk_align_bitmap *get_bm(struct blk_mq_hw_ctx *hctx,
  52                                               struct blk_mq_ctx *ctx)
  53 {
  54         return &hctx->ctx_map.map[ctx->index_hw / hctx->ctx_map.bits_per_word];
  55 }
  56
  57 #define CTX_TO_BIT(hctx, ctx)   \
  58         ((ctx)->index_hw & ((hctx)->ctx_map.bits_per_word - 1))
  59
  60 /*
  61  * Mark this ctx as having pending work in this hardware queue
  62  */
  63 static void blk_mq_hctx_mark_pending(struct blk_mq_hw_ctx *hctx,
  64                                      struct blk_mq_ctx *ctx)
  65 {
  66         struct blk_align_bitmap *bm = get_bm(hctx, ctx);
  67
  68         if (!test_bit(CTX_TO_BIT(hctx, ctx), &bm->word))
  69                 set_bit(CTX_TO_BIT(hctx, ctx), &bm->word);
  70 }
  71
  72 static void blk_mq_hctx_clear_pending(struct blk_mq_hw_ctx *hctx,
  73                                       struct blk_mq_ctx *ctx)
  74 {
  75         struct blk_align_bitmap *bm = get_bm(hctx, ctx);
  76
  77         clear_bit(CTX_TO_BIT(hctx, ctx), &bm->word);
  78 }
  79
  80 static int blk_mq_queue_enter(struct request_queue *q)
  81 {
  82         while (true) {
  83                 int ret;
  84
  85                 if (percpu_ref_tryget_live(&q->mq_usage_counter))
  86                         return 0;
  87
  88                 ret = wait_event_interruptible(q->mq_freeze_wq,
  89                                 !q->mq_freeze_depth || blk_queue_dying(q));
  90                 if (blk_queue_dying(q))
  91                         return -ENODEV;
  92                 if (ret)
  93                         return ret;
  94         }
  95 }
  96
  97 static void blk_mq_queue_exit(struct request_queue *q)
  98 {
  99         percpu_ref_put(&q->mq_usage_counter);
 100 }
 101
 102 static void blk_mq_usage_counter_release(struct percpu_ref *ref)
 103 {
 104         struct request_queue *q =
 105                 container_of(ref, struct request_queue, mq_usage_counter);
 106
 107         wake_up_all(&q->mq_freeze_wq);
 108 }
 109
 110 void blk_mq_freeze_queue_start(struct request_queue *q)
 111 {
 112         bool freeze;
 113
 114         spin_lock_irq(q->queue_lock);
 115         freeze = !q->mq_freeze_depth++;
 116         spin_unlock_irq(q->queue_lock);
 117
 118         if (freeze) {
 119                 percpu_ref_kill(&q->mq_usage_counter);
 120                 blk_mq_run_queues(q, false);
 121         }
 122 }
 123 EXPORT_SYMBOL_GPL(blk_mq_freeze_queue_start);
 124
 125 static void blk_mq_freeze_queue_wait(struct request_queue *q)
 126 {
 127         wait_event(q->mq_freeze_wq, percpu_ref_is_zero(&q->mq_usage_counter));
 128 }
 129
 130 /*
 131  * Guarantee no request is in use, so we can change any data structure of
 132  * the queue afterward.
 133  */
 134 void blk_mq_freeze_queue(struct request_queue *q)
 135 {
 136         blk_mq_freeze_queue_start(q);
 137         blk_mq_freeze_queue_wait(q);
 138 }
 139 EXPORT_SYMBOL_GPL(blk_mq_freeze_queue);
 140
 141 void blk_mq_unfreeze_queue(struct request_queue *q)
 142 {
 143         bool wake;
 144
 145         spin_lock_irq(q->queue_lock);
 146         wake = !--q->mq_freeze_depth;
 147         WARN_ON_ONCE(q->mq_freeze_depth < 0);
 148         spin_unlock_irq(q->queue_lock);
 149         if (wake) {
 150                 percpu_ref_reinit(&q->mq_usage_counter);
 151                 wake_up_all(&q->mq_freeze_wq);
 152         }
 153 }
 154 EXPORT_SYMBOL_GPL(blk_mq_unfreeze_queue);
 155
 156 void blk_mq_wake_waiters(struct request_queue *q)
 157 {
 158         struct blk_mq_hw_ctx *hctx;
 159         unsigned int i;
 160
 161         queue_for_each_hw_ctx(q, hctx, i)
 162                 if (blk_mq_hw_queue_mapped(hctx))
 163                         blk_mq_tag_wakeup_all(hctx->tags, true);
 164 }
 165
 166 bool blk_mq_can_queue(struct blk_mq_hw_ctx *hctx)
 167 {
 168         return blk_mq_has_free_tags(hctx->tags);
 169 }
 170 EXPORT_SYMBOL(blk_mq_can_queue);
 171
 172 static void blk_mq_rq_ctx_init(struct request_queue *q, struct blk_mq_ctx *ctx,
 173                                struct request *rq, unsigned int rw_flags)
 174 {
 175         if (blk_queue_io_stat(q))
 176                 rw_flags |= REQ_IO_STAT;
 177
 178         INIT_LIST_HEAD(&rq->queuelist);
 179         /* csd/requeue_work/fifo_time is initialized before use */
 180         rq->q = q;
 181         rq->mq_ctx = ctx;
 182         rq->cmd_flags |= rw_flags;
 183         /* do not touch atomic flags, it needs atomic ops against the timer */
 184         rq->cpu = -1;
 185         INIT_HLIST_NODE(&rq->hash);
 186         RB_CLEAR_NODE(&rq->rb_node);
 187         rq->rq_disk = NULL;
 188         rq->part = NULL;
 189         rq->start_time = jiffies;
 190 #ifdef CONFIG_BLK_CGROUP
 191         rq->rl = NULL;
 192         set_start_time_ns(rq);
 193         rq->io_start_time_ns = 0;
 194 #endif
 195         rq->nr_phys_segments = 0;
 196 #if defined(CONFIG_BLK_DEV_INTEGRITY)
 197         rq->nr_integrity_segments = 0;
 198 #endif
 199         rq->special = NULL;
 200         /* tag was already set */
 201         rq->errors = 0;
 202
 203         rq->cmd = rq->__cmd;
 204
 205         rq->extra_len = 0;
 206         rq->sense_len = 0;
 207         rq->resid_len = 0;
 208         rq->sense = NULL;
 209
 210         INIT_LIST_HEAD(&rq->timeout_list);
 211         rq->timeout = 0;
 212
 213         rq->end_io = NULL;
 214         rq->end_io_data = NULL;
 215         rq->next_rq = NULL;
 216
 217         ctx->rq_dispatched[rw_is_sync(rw_flags)]++;
 218 }
 219
 220 static struct request *
 221 __blk_mq_alloc_request(struct blk_mq_alloc_data *data, int rw)
 222 {
 223         struct request *rq;
 224         unsigned int tag;
 225
 226         tag = blk_mq_get_tag(data);
 227         if (tag != BLK_MQ_TAG_FAIL) {
 228                 rq = data->hctx->tags->rqs[tag];
 229
 230                 if (blk_mq_tag_busy(data->hctx)) {
 231                         rq->cmd_flags = REQ_MQ_INFLIGHT;
 232                         atomic_inc(&data->hctx->nr_active);
 233                 }
 234
 235                 rq->tag = tag;
 236                 blk_mq_rq_ctx_init(data->q, data->ctx, rq, rw);
 237                 return rq;
 238         }
 239
 240         return NULL;
 241 }
 242
 243 struct request *blk_mq_alloc_request(struct request_queue *q, int rw, gfp_t gfp,
 244                 bool reserved)
 245 {
 246         struct blk_mq_ctx *ctx;
 247         struct blk_mq_hw_ctx *hctx;
 248         struct request *rq;
 249         struct blk_mq_alloc_data alloc_data;
 250         int ret;
 251
 252         ret = blk_mq_queue_enter(q);
 253         if (ret)
 254                 return ERR_PTR(ret);
 255
 256         ctx = blk_mq_get_ctx(q);
 257         hctx = q->mq_ops->map_queue(q, ctx->cpu);
 258         blk_mq_set_alloc_data(&alloc_data, q, gfp & ~__GFP_WAIT,
 259                         reserved, ctx, hctx);
 260
 261         rq = __blk_mq_alloc_request(&alloc_data, rw);
 262         if (!rq && (gfp & __GFP_WAIT)) {
 263                 __blk_mq_run_hw_queue(hctx);
 264                 blk_mq_put_ctx(ctx);
 265
 266                 ctx = blk_mq_get_ctx(q);
 267                 hctx = q->mq_ops->map_queue(q, ctx->cpu);
 268                 blk_mq_set_alloc_data(&alloc_data, q, gfp, reserved, ctx,
 269                                 hctx);
 270                 rq =  __blk_mq_alloc_request(&alloc_data, rw);
 271                 ctx = alloc_data.ctx;
 272         }
 273         blk_mq_put_ctx(ctx);
 274         if (!rq) {
 275                 blk_mq_queue_exit(q);
 276                 return ERR_PTR(-EWOULDBLOCK);
 277         }
 278         return rq;
 279 }
 280 EXPORT_SYMBOL(blk_mq_alloc_request);
 281
 282 static void __blk_mq_free_request(struct blk_mq_hw_ctx *hctx,
 283                                   struct blk_mq_ctx *ctx, struct request *rq)
 284 {
 285         const int tag = rq->tag;
 286         struct request_queue *q = rq->q;
 287
 288         if (rq->cmd_flags & REQ_MQ_INFLIGHT)
 289                 atomic_dec(&hctx->nr_active);
 290         rq->cmd_flags = 0;
 291
 292         clear_bit(REQ_ATOM_STARTED, &rq->atomic_flags);
 293         blk_mq_put_tag(hctx, tag, &ctx->last_tag);
 294         blk_mq_queue_exit(q);
 295 }
 296
 297 void blk_mq_free_hctx_request(struct blk_mq_hw_ctx *hctx, struct request *rq)
 298 {
 299         struct blk_mq_ctx *ctx = rq->mq_ctx;
 300
 301         ctx->rq_completed[rq_is_sync(rq)]++;
 302         __blk_mq_free_request(hctx, ctx, rq);
 303
 304 }
 305 EXPORT_SYMBOL_GPL(blk_mq_free_hctx_request);
 306
 307 void blk_mq_free_request(struct request *rq)
 308 {
 309         struct blk_mq_hw_ctx *hctx;
 310         struct request_queue *q = rq->q;
 311
 312         hctx = q->mq_ops->map_queue(q, rq->mq_ctx->cpu);
 313         blk_mq_free_hctx_request(hctx, rq);
 314 }
 315 EXPORT_SYMBOL_GPL(blk_mq_free_request);
 316
 317 inline void __blk_mq_end_request(struct request *rq, int error)
 318 {
 319         blk_account_io_done(rq);
 320
 321         if (rq->end_io) {
 322                 rq->end_io(rq, error);
 323         } else {
 324                 if (unlikely(blk_bidi_rq(rq)))
 325                         blk_mq_free_request(rq->next_rq);
 326                 blk_mq_free_request(rq);
 327         }
 328 }
 329 EXPORT_SYMBOL(__blk_mq_end_request);
 330
 331 void blk_mq_end_request(struct request *rq, int error)
 332 {
 333         if (blk_update_request(rq, error, blk_rq_bytes(rq)))
 334                 BUG();
 335         __blk_mq_end_request(rq, error);
 336 }
 337 EXPORT_SYMBOL(blk_mq_end_request);
 338
 339 static void __blk_mq_complete_request_remote(void *data)
 340 {
 341         struct request *rq = data;
 342
 343         rq->q->softirq_done_fn(rq);
 344 }
 345
 346 static void blk_mq_ipi_complete_request(struct request *rq)
 347 {
 348         struct blk_mq_ctx *ctx = rq->mq_ctx;
 349         bool shared = false;
 350         int cpu;
 351
 352         if (!test_bit(QUEUE_FLAG_SAME_COMP, &rq->q->queue_flags)) {
 353                 rq->q->softirq_done_fn(rq);
 354                 return;
 355         }
 356
 357         cpu = get_cpu();
 358         if (!test_bit(QUEUE_FLAG_SAME_FORCE, &rq->q->queue_flags))
 359                 shared = cpus_share_cache(cpu, ctx->cpu);
 360
 361         if (cpu != ctx->cpu && !shared && cpu_online(ctx->cpu)) {
 362                 rq->csd.func = __blk_mq_complete_request_remote;
 363                 rq->csd.info = rq;
 364                 rq->csd.flags = 0;
 365                 smp_call_function_single_async(ctx->cpu, &rq->csd);
 366         } else {
 367                 rq->q->softirq_done_fn(rq);
 368         }
 369         put_cpu();
 370 }
 371
 372 void __blk_mq_complete_request(struct request *rq)
 373 {
 374         struct request_queue *q = rq->q;
 375
 376         if (!q->softirq_done_fn)
 377                 blk_mq_end_request(rq, rq->errors);
 378         else
 379                 blk_mq_ipi_complete_request(rq);
 380 }
 381
 382 /**
 383  * blk_mq_complete_request - end I/O on a request
 384  * @rq:         the request being processed
 385  *
 386  * Description:
 387  *      Ends all I/O on a request. It does not handle partial completions.
 388  *      The actual completion happens out-of-order, through a IPI handler.
 389  **/
 390 void blk_mq_complete_request(struct request *rq)
 391 {
 392         struct request_queue *q = rq->q;
 393
 394         if (unlikely(blk_should_fake_timeout(q)))
 395                 return;
 396         if (!blk_mark_rq_complete(rq))
 397                 __blk_mq_complete_request(rq);
 398 }
 399 EXPORT_SYMBOL(blk_mq_complete_request);
 400
 401 void blk_mq_start_request(struct request *rq)
 402 {
 403         struct request_queue *q = rq->q;
 404
 405         trace_block_rq_issue(q, rq);
 406
 407         rq->resid_len = blk_rq_bytes(rq);
 408         if (unlikely(blk_bidi_rq(rq)))
 409                 rq->next_rq->resid_len = blk_rq_bytes(rq->next_rq);
 410
 411         blk_add_timer(rq);
 412
 413         /*
 414          * Ensure that ->deadline is visible before set the started
 415          * flag and clear the completed flag.
 416          */
 417         smp_mb__before_atomic();
 418
 419         /*
 420          * Mark us as started and clear complete. Complete might have been
 421          * set if requeue raced with timeout, which then marked it as
 422          * complete. So be sure to clear complete again when we start
 423          * the request, otherwise we'll ignore the completion event.
 424          */
 425         if (!test_bit(REQ_ATOM_STARTED, &rq->atomic_flags))
 426                 set_bit(REQ_ATOM_STARTED, &rq->atomic_flags);
 427         if (test_bit(REQ_ATOM_COMPLETE, &rq->atomic_flags))
 428                 clear_bit(REQ_ATOM_COMPLETE, &rq->atomic_flags);
 429
 430         if (q->dma_drain_size && blk_rq_bytes(rq)) {
 431                 /*
 432                  * Make sure space for the drain appears.  We know we can do
 433                  * this because max_hw_segments has been adjusted to be one
 434                  * fewer than the device can handle.
 435                  */
 436                 rq->nr_phys_segments++;
 437         }
 438 }
 439 EXPORT_SYMBOL(blk_mq_start_request);
 440
 441 static void __blk_mq_requeue_request(struct request *rq)
 442 {
 443         struct request_queue *q = rq->q;
 444
 445         trace_block_rq_requeue(q, rq);
 446
 447         if (test_and_clear_bit(REQ_ATOM_STARTED, &rq->atomic_flags)) {
 448                 if (q->dma_drain_size && blk_rq_bytes(rq))
 449                         rq->nr_phys_segments--;
 450         }
 451 }
 452
 453 void blk_mq_requeue_request(struct request *rq)
 454 {
 455         __blk_mq_requeue_request(rq);
 456
 457         BUG_ON(blk_queued_rq(rq));
 458         blk_mq_add_to_requeue_list(rq, true);
 459 }
 460 EXPORT_SYMBOL(blk_mq_requeue_request);
 461
 462 static void blk_mq_requeue_work(struct work_struct *work)
 463 {
 464         struct request_queue *q =
 465                 container_of(work, struct request_queue, requeue_work);
 466         LIST_HEAD(rq_list);
 467         struct request *rq, *next;
 468         unsigned long flags;
 469
 470         spin_lock_irqsave(&q->requeue_lock, flags);
 471         list_splice_init(&q->requeue_list, &rq_list);
 472         spin_unlock_irqrestore(&q->requeue_lock, flags);
 473
 474         list_for_each_entry_safe(rq, next, &rq_list, queuelist) {
 475                 if (!(rq->cmd_flags & REQ_SOFTBARRIER))
 476                         continue;
 477
 478                 rq->cmd_flags &= ~REQ_SOFTBARRIER;
 479                 list_del_init(&rq->queuelist);
 480                 blk_mq_insert_request(rq, true, false, false);
 481         }
 482
 483         while (!list_empty(&rq_list)) {
 484                 rq = list_entry(rq_list.next, struct request, queuelist);
 485                 list_del_init(&rq->queuelist);
 486                 blk_mq_insert_request(rq, false, false, false);
 487         }
 488
 489         /*
 490          * Use the start variant of queue running here, so that running
 491          * the requeue work will kick stopped queues.
 492          */
 493         blk_mq_start_hw_queues(q);
 494 }
 495
 496 void blk_mq_add_to_requeue_list(struct request *rq, bool at_head)
 497 {
 498         struct request_queue *q = rq->q;
 499         unsigned long flags;
 500
 501         /*
 502          * We abuse this flag that is otherwise used by the I/O scheduler to
 503          * request head insertation from the workqueue.
 504          */
 505         BUG_ON(rq->cmd_flags & REQ_SOFTBARRIER);
 506
 507         spin_lock_irqsave(&q->requeue_lock, flags);
 508         if (at_head) {
 509                 rq->cmd_flags |= REQ_SOFTBARRIER;
 510                 list_add(&rq->queuelist, &q->requeue_list);
 511         } else {
 512                 list_add_tail(&rq->queuelist, &q->requeue_list);
 513         }
 514         spin_unlock_irqrestore(&q->requeue_lock, flags);
 515 }
 516 EXPORT_SYMBOL(blk_mq_add_to_requeue_list);
 517
 518 void blk_mq_kick_requeue_list(struct request_queue *q)
 519 {
 520         kblockd_schedule_work(&q->requeue_work);
 521 }
 522 EXPORT_SYMBOL(blk_mq_kick_requeue_list);
 523
 524 static inline bool is_flush_request(struct request *rq,
 525                 struct blk_flush_queue *fq, unsigned int tag)
 526 {
 527         return ((rq->cmd_flags & REQ_FLUSH_SEQ) &&
 528                         fq->flush_rq->tag == tag);
 529 }
 530
 531 struct request *blk_mq_tag_to_rq(struct blk_mq_tags *tags, unsigned int tag)
 532 {
 533         struct request *rq = tags->rqs[tag];
 534         /* mq_ctx of flush rq is always cloned from the corresponding req */
 535         struct blk_flush_queue *fq = blk_get_flush_queue(rq->q, rq->mq_ctx);
 536
 537         if (!is_flush_request(rq, fq, tag))
 538                 return rq;
 539
 540         return fq->flush_rq;
 541 }
 542 EXPORT_SYMBOL(blk_mq_tag_to_rq);
 543
 544 struct blk_mq_timeout_data {
 545         unsigned long next;
 546         unsigned int next_set;
 547 };
 548
 549 void blk_mq_rq_timed_out(struct request *req, bool reserved)
 550 {
 551         struct blk_mq_ops *ops = req->q->mq_ops;
 552         enum blk_eh_timer_return ret = BLK_EH_RESET_TIMER;
 553
 554         /*
 555          * We know that complete is set at this point. If STARTED isn't set
 556          * anymore, then the request isn't active and the "timeout" should
 557          * just be ignored. This can happen due to the bitflag ordering.
 558          * Timeout first checks if STARTED is set, and if it is, assumes
 559          * the request is active. But if we race with completion, then
 560          * we both flags will get cleared. So check here again, and ignore
 561          * a timeout event with a request that isn't active.
 562          */
 563         if (!test_bit(REQ_ATOM_STARTED, &req->atomic_flags))
 564                 return;
 565
 566         if (ops->timeout)
 567                 ret = ops->timeout(req, reserved);
 568
 569         switch (ret) {
 570         case BLK_EH_HANDLED:
 571                 __blk_mq_complete_request(req);
 572                 break;
 573         case BLK_EH_RESET_TIMER:
 574                 blk_add_timer(req);
 575                 blk_clear_rq_complete(req);
 576                 break;
 577         case BLK_EH_NOT_HANDLED:
 578                 break;
 579         default:
 580                 printk(KERN_ERR "block: bad eh return: %d\n", ret);
 581                 break;
 582         }
 583 }
 584
 585 static void blk_mq_check_expired(struct blk_mq_hw_ctx *hctx,
 586                 struct request *rq, void *priv, bool reserved)
 587 {
 588         struct blk_mq_timeout_data *data = priv;
 589
 590         if (!test_bit(REQ_ATOM_STARTED, &rq->atomic_flags))
 591                 return;
 592
 593         if (time_after_eq(jiffies, rq->deadline)) {
 594                 if (!blk_mark_rq_complete(rq))
 595                         blk_mq_rq_timed_out(rq, reserved);
 596         } else if (!data->next_set || time_after(data->next, rq->deadline)) {
 597                 data->next = rq->deadline;
 598                 data->next_set = 1;
 599         }
 600 }
 601
 602 static void blk_mq_rq_timer(unsigned long priv)
 603 {
 604         struct request_queue *q = (struct request_queue *)priv;
 605         struct blk_mq_timeout_data data = {
 606                 .next           = 0,
 607                 .next_set       = 0,
 608         };
 609         struct blk_mq_hw_ctx *hctx;
 610         int i;
 611
 612         queue_for_each_hw_ctx(q, hctx, i) {
 613                 /*
 614                  * If not software queues are currently mapped to this
 615                  * hardware queue, there's nothing to check
 616                  */
 617                 if (!blk_mq_hw_queue_mapped(hctx))
 618                         continue;
 619
 620                 blk_mq_tag_busy_iter(hctx, blk_mq_check_expired, &data);
 621         }
 622
 623         if (data.next_set) {
 624                 data.next = blk_rq_timeout(round_jiffies_up(data.next));
 625                 mod_timer(&q->timeout, data.next);
 626         } else {
 627                 queue_for_each_hw_ctx(q, hctx, i)
 628                         blk_mq_tag_idle(hctx);
 629         }
 630 }
 631
 632 /*
 633  * Reverse check our software queue for entries that we could potentially
 634  * merge with. Currently includes a hand-wavy stop count of 8, to not spend
 635  * too much time checking for merges.
 636  */
 637 static bool blk_mq_attempt_merge(struct request_queue *q,
 638                                  struct blk_mq_ctx *ctx, struct bio *bio)
 639 {
 640         struct request *rq;
 641         int checked = 8;
 642
 643         list_for_each_entry_reverse(rq, &ctx->rq_list, queuelist) {
 644                 int el_ret;
 645
 646                 if (!checked--)
 647                         break;
 648
 649                 if (!blk_rq_merge_ok(rq, bio))
 650                         continue;
 651
 652                 el_ret = blk_try_merge(rq, bio);
 653                 if (el_ret == ELEVATOR_BACK_MERGE) {
 654                         if (bio_attempt_back_merge(q, rq, bio)) {
 655                                 ctx->rq_merged++;
 656                                 return true;
 657                         }
 658                         break;
 659                 } else if (el_ret == ELEVATOR_FRONT_MERGE) {
 660                         if (bio_attempt_front_merge(q, rq, bio)) {
 661                                 ctx->rq_merged++;
 662                                 return true;
 663                         }
 664                         break;
 665                 }
 666         }
 667
 668         return false;
 669 }
 670
 671 /*
 672  * Process software queues that have been marked busy, splicing them
 673  * to the for-dispatch
 674  */
 675 static void flush_busy_ctxs(struct blk_mq_hw_ctx *hctx, struct list_head *list)
 676 {
 677         struct blk_mq_ctx *ctx;
 678         int i;
 679
 680         for (i = 0; i < hctx->ctx_map.map_size; i++) {
 681                 struct blk_align_bitmap *bm = &hctx->ctx_map.map[i];
 682                 unsigned int off, bit;
 683
 684                 if (!bm->word)
 685                         continue;
 686
 687                 bit = 0;
 688                 off = i * hctx->ctx_map.bits_per_word;
 689                 do {
 690                         bit = find_next_bit(&bm->word, bm->depth, bit);
 691                         if (bit >= bm->depth)
 692                                 break;
 693
 694                         ctx = hctx->ctxs[bit + off];
 695                         clear_bit(bit, &bm->word);
 696                         spin_lock(&ctx->lock);
 697                         list_splice_tail_init(&ctx->rq_list, list);
 698                         spin_unlock(&ctx->lock);
 699
 700                         bit++;
 701                 } while (1);
 702         }
 703 }
 704
 705 /*
 706  * Run this hardware queue, pulling any software queues mapped to it in.
 707  * Note that this function currently has various problems around ordering
 708  * of IO. In particular, we'd like FIFO behaviour on handling existing
 709  * items on the hctx->dispatch list. Ignore that for now.
 710  */
 711 static void __blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx)
 712 {
 713         struct request_queue *q = hctx->queue;
 714         struct request *rq;
 715         LIST_HEAD(rq_list);
 716         LIST_HEAD(driver_list);
 717         struct list_head *dptr;
 718         int queued;
 719
 720         WARN_ON(!cpumask_test_cpu(raw_smp_processor_id(), hctx->cpumask));
 721
 722         if (unlikely(test_bit(BLK_MQ_S_STOPPED, &hctx->state)))
 723                 return;
 724
 725         hctx->run++;
 726
 727         /*
 728          * Touch any software queue that has pending entries.
 729          */
 730         flush_busy_ctxs(hctx, &rq_list);
 731
 732         /*
 733          * If we have previous entries on our dispatch list, grab them
 734          * and stuff them at the front for more fair dispatch.
 735          */
 736         if (!list_empty_careful(&hctx->dispatch)) {
 737                 spin_lock(&hctx->lock);
 738                 if (!list_empty(&hctx->dispatch))
 739                         list_splice_init(&hctx->dispatch, &rq_list);
 740                 spin_unlock(&hctx->lock);
 741         }
 742
 743         /*
 744          * Start off with dptr being NULL, so we start the first request
 745          * immediately, even if we have more pending.
 746          */
 747         dptr = NULL;
 748
 749         /*
 750          * Now process all the entries, sending them to the driver.
 751          */
 752         queued = 0;
 753         while (!list_empty(&rq_list)) {
 754                 struct blk_mq_queue_data bd;
 755                 int ret;
 756
 757                 rq = list_first_entry(&rq_list, struct request, queuelist);
 758                 list_del_init(&rq->queuelist);
 759
 760                 bd.rq = rq;
 761                 bd.list = dptr;
 762                 bd.last = list_empty(&rq_list);
 763
 764                 ret = q->mq_ops->queue_rq(hctx, &bd);
 765                 switch (ret) {
 766                 case BLK_MQ_RQ_QUEUE_OK:
 767                         queued++;
 768                         continue;
 769                 case BLK_MQ_RQ_QUEUE_BUSY:
 770                         list_add(&rq->queuelist, &rq_list);
 771                         __blk_mq_requeue_request(rq);
 772                         break;
 773                 default:
 774                         pr_err("blk-mq: bad return on queue: %d\n", ret);
 775                 case BLK_MQ_RQ_QUEUE_ERROR:
 776                         rq->errors = -EIO;
 777                         blk_mq_end_request(rq, rq->errors);
 778                         break;
 779                 }
 780
 781                 if (ret == BLK_MQ_RQ_QUEUE_BUSY)
 782                         break;
 783
 784                 /*
 785                  * We've done the first request. If we have more than 1
 786                  * left in the list, set dptr to defer issue.
 787                  */
 788                 if (!dptr && rq_list.next != rq_list.prev)
 789                         dptr = &driver_list;
 790         }
 791
 792         if (!queued)
 793                 hctx->dispatched[0]++;
 794         else if (queued < (1 << (BLK_MQ_MAX_DISPATCH_ORDER - 1)))
 795                 hctx->dispatched[ilog2(queued) + 1]++;
 796
 797         /*
 798          * Any items that need requeuing? Stuff them into hctx->dispatch,
 799          * that is where we will continue on next queue run.
 800          */
 801         if (!list_empty(&rq_list)) {
 802                 spin_lock(&hctx->lock);
 803                 list_splice(&rq_list, &hctx->dispatch);
 804                 spin_unlock(&hctx->lock);
 805         }
 806 }
 807
 808 /*
 809  * It'd be great if the workqueue API had a way to pass
 810  * in a mask and had some smarts for more clever placement.
 811  * For now we just round-robin here, switching for every
 812  * BLK_MQ_CPU_WORK_BATCH queued items.
 813  */
 814 static int blk_mq_hctx_next_cpu(struct blk_mq_hw_ctx *hctx)
 815 {
 816         if (hctx->queue->nr_hw_queues == 1)
 817                 return WORK_CPU_UNBOUND;
 818
 819         if (--hctx->next_cpu_batch <= 0) {
 820                 int cpu = hctx->next_cpu, next_cpu;
 821
 822                 next_cpu = cpumask_next(hctx->next_cpu, hctx->cpumask);
 823                 if (next_cpu >= nr_cpu_ids)
 824                         next_cpu = cpumask_first(hctx->cpumask);
 825
 826                 hctx->next_cpu = next_cpu;
 827                 hctx->next_cpu_batch = BLK_MQ_CPU_WORK_BATCH;
 828
 829                 return cpu;
 830         }
 831
 832         return hctx->next_cpu;
 833 }
 834
 835 void blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx, bool async)
 836 {
 837         if (unlikely(test_bit(BLK_MQ_S_STOPPED, &hctx->state) ||
 838             !blk_mq_hw_queue_mapped(hctx)))
 839                 return;
 840
 841         if (!async) {
 842                 int cpu = get_cpu();
 843                 if (cpumask_test_cpu(cpu, hctx->cpumask)) {
 844                         __blk_mq_run_hw_queue(hctx);
 845                         put_cpu();
 846                         return;
 847                 }
 848
 849                 put_cpu();
 850         }
 851
 852         kblockd_schedule_delayed_work_on(blk_mq_hctx_next_cpu(hctx),
 853                         &hctx->run_work, 0);
 854 }
 855
 856 void blk_mq_run_queues(struct request_queue *q, bool async)
 857 {
 858         struct blk_mq_hw_ctx *hctx;
 859         int i;
 860
 861         queue_for_each_hw_ctx(q, hctx, i) {
 862                 if ((!blk_mq_hctx_has_pending(hctx) &&
 863                     list_empty_careful(&hctx->dispatch)) ||
 864                     test_bit(BLK_MQ_S_STOPPED, &hctx->state))
 865                         continue;
 866
 867                 blk_mq_run_hw_queue(hctx, async);
 868         }
 869 }
 870 EXPORT_SYMBOL(blk_mq_run_queues);
 871
 872 void blk_mq_stop_hw_queue(struct blk_mq_hw_ctx *hctx)
 873 {
 874         cancel_delayed_work(&hctx->run_work);
 875         cancel_delayed_work(&hctx->delay_work);
 876         set_bit(BLK_MQ_S_STOPPED, &hctx->state);
 877 }
 878 EXPORT_SYMBOL(blk_mq_stop_hw_queue);
 879
 880 void blk_mq_stop_hw_queues(struct request_queue *q)
 881 {
 882         struct blk_mq_hw_ctx *hctx;
 883         int i;
 884
 885         queue_for_each_hw_ctx(q, hctx, i)
 886                 blk_mq_stop_hw_queue(hctx);
 887 }
 888 EXPORT_SYMBOL(blk_mq_stop_hw_queues);
 889
 890 void blk_mq_start_hw_queue(struct blk_mq_hw_ctx *hctx)
 891 {
 892         clear_bit(BLK_MQ_S_STOPPED, &hctx->state);
 893
 894         blk_mq_run_hw_queue(hctx, false);
 895 }
 896 EXPORT_SYMBOL(blk_mq_start_hw_queue);
 897
 898 void blk_mq_start_hw_queues(struct request_queue *q)
 899 {
 900         struct blk_mq_hw_ctx *hctx;
 901         int i;
 902
 903         queue_for_each_hw_ctx(q, hctx, i)
 904                 blk_mq_start_hw_queue(hctx);
 905 }
 906 EXPORT_SYMBOL(blk_mq_start_hw_queues);
 907
 908
 909 void blk_mq_start_stopped_hw_queues(struct request_queue *q, bool async)
 910 {
 911         struct blk_mq_hw_ctx *hctx;
 912         int i;
 913
 914         queue_for_each_hw_ctx(q, hctx, i) {
 915                 if (!test_bit(BLK_MQ_S_STOPPED, &hctx->state))
 916                         continue;
 917
 918                 clear_bit(BLK_MQ_S_STOPPED, &hctx->state);
 919                 blk_mq_run_hw_queue(hctx, async);
 920         }
 921 }
 922 EXPORT_SYMBOL(blk_mq_start_stopped_hw_queues);
 923
 924 static void blk_mq_run_work_fn(struct work_struct *work)
 925 {
 926         struct blk_mq_hw_ctx *hctx;
 927
 928         hctx = container_of(work, struct blk_mq_hw_ctx, run_work.work);
 929
 930         __blk_mq_run_hw_queue(hctx);
 931 }
 932
 933 static void blk_mq_delay_work_fn(struct work_struct *work)
 934 {
 935         struct blk_mq_hw_ctx *hctx;
 936
 937         hctx = container_of(work, struct blk_mq_hw_ctx, delay_work.work);
 938
 939         if (test_and_clear_bit(BLK_MQ_S_STOPPED, &hctx->state))
 940                 __blk_mq_run_hw_queue(hctx);
 941 }
 942
 943 void blk_mq_delay_queue(struct blk_mq_hw_ctx *hctx, unsigned long msecs)
 944 {
 945         if (unlikely(!blk_mq_hw_queue_mapped(hctx)))
 946                 return;
 947
 948         kblockd_schedule_delayed_work_on(blk_mq_hctx_next_cpu(hctx),
 949                         &hctx->delay_work, msecs_to_jiffies(msecs));
 950 }
 951 EXPORT_SYMBOL(blk_mq_delay_queue);
 952
 953 static void __blk_mq_insert_request(struct blk_mq_hw_ctx *hctx,
 954                                     struct request *rq, bool at_head)
 955 {
 956         struct blk_mq_ctx *ctx = rq->mq_ctx;
 957
 958         trace_block_rq_insert(hctx->queue, rq);
 959
 960         if (at_head)
 961                 list_add(&rq->queuelist, &ctx->rq_list);
 962         else
 963                 list_add_tail(&rq->queuelist, &ctx->rq_list);
 964
 965         blk_mq_hctx_mark_pending(hctx, ctx);
 966 }
 967
 968 void blk_mq_insert_request(struct request *rq, bool at_head, bool run_queue,
 969                 bool async)
 970 {
 971         struct request_queue *q = rq->q;
 972         struct blk_mq_hw_ctx *hctx;
 973         struct blk_mq_ctx *ctx = rq->mq_ctx, *current_ctx;
 974
 975         current_ctx = blk_mq_get_ctx(q);
 976         if (!cpu_online(ctx->cpu))
 977                 rq->mq_ctx = ctx = current_ctx;
 978
 979         hctx = q->mq_ops->map_queue(q, ctx->cpu);
 980
 981         spin_lock(&ctx->lock);
 982         __blk_mq_insert_request(hctx, rq, at_head);
 983         spin_unlock(&ctx->lock);
 984
 985         if (run_queue)
 986                 blk_mq_run_hw_queue(hctx, async);
 987
 988         blk_mq_put_ctx(current_ctx);
 989 }
 990
 991 static void blk_mq_insert_requests(struct request_queue *q,
 992                                      struct blk_mq_ctx *ctx,
 993                                      struct list_head *list,
 994                                      int depth,
 995                                      bool from_schedule)
 996
 997 {
 998         struct blk_mq_hw_ctx *hctx;
 999         struct blk_mq_ctx *current_ctx;
1000
1001         trace_block_unplug(q, depth, !from_schedule);
1002
1003         current_ctx = blk_mq_get_ctx(q);
1004
1005         if (!cpu_online(ctx->cpu))
1006                 ctx = current_ctx;
1007         hctx = q->mq_ops->map_queue(q, ctx->cpu);
1008
1009         /*
1010          * preemption doesn't flush plug list, so it's possible ctx->cpu is
1011          * offline now
1012          */
1013         spin_lock(&ctx->lock);
1014         while (!list_empty(list)) {
1015                 struct request *rq;
1016
1017                 rq = list_first_entry(list, struct request, queuelist);
1018                 list_del_init(&rq->queuelist);
1019                 rq->mq_ctx = ctx;
1020                 __blk_mq_insert_request(hctx, rq, false);
1021         }
1022         spin_unlock(&ctx->lock);
1023
1024         blk_mq_run_hw_queue(hctx, from_schedule);
1025         blk_mq_put_ctx(current_ctx);
1026 }
1027
1028 static int plug_ctx_cmp(void *priv, struct list_head *a, struct list_head *b)
1029 {
1030         struct request *rqa = container_of(a, struct request, queuelist);
1031         struct request *rqb = container_of(b, struct request, queuelist);
1032
1033         return !(rqa->mq_ctx < rqb->mq_ctx ||
1034                  (rqa->mq_ctx == rqb->mq_ctx &&
1035                   blk_rq_pos(rqa) < blk_rq_pos(rqb)));
1036 }
1037
1038 void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule)
1039 {
1040         struct blk_mq_ctx *this_ctx;
1041         struct request_queue *this_q;
1042         struct request *rq;
1043         LIST_HEAD(list);
1044         LIST_HEAD(ctx_list);
1045         unsigned int depth;
1046
1047         list_splice_init(&plug->mq_list, &list);
1048
1049         list_sort(NULL, &list, plug_ctx_cmp);
1050
1051         this_q = NULL;
1052         this_ctx = NULL;
1053         depth = 0;
1054
1055         while (!list_empty(&list)) {
1056                 rq = list_entry_rq(list.next);
1057                 list_del_init(&rq->queuelist);
1058                 BUG_ON(!rq->q);
1059                 if (rq->mq_ctx != this_ctx) {
1060                         if (this_ctx) {
1061                                 blk_mq_insert_requests(this_q, this_ctx,
1062                                                         &ctx_list, depth,
1063                                                         from_schedule);
1064                         }
1065
1066                         this_ctx = rq->mq_ctx;
1067                         this_q = rq->q;
1068                         depth = 0;
1069                 }
1070
1071                 depth++;
1072                 list_add_tail(&rq->queuelist, &ctx_list);
1073         }
1074
1075         /*
1076          * If 'this_ctx' is set, we know we have entries to complete
1077          * on 'ctx_list'. Do those.
1078          */
1079         if (this_ctx) {
1080                 blk_mq_insert_requests(this_q, this_ctx, &ctx_list, depth,
1081                                        from_schedule);
1082         }
1083 }
1084
1085 static void blk_mq_bio_to_request(struct request *rq, struct bio *bio)
1086 {
1087         init_request_from_bio(rq, bio);
1088
1089         if (blk_do_io_stat(rq))
1090                 blk_account_io_start(rq, 1);
1091 }
1092
1093 static inline bool hctx_allow_merges(struct blk_mq_hw_ctx *hctx)
1094 {
1095         return (hctx->flags & BLK_MQ_F_SHOULD_MERGE) &&
1096                 !blk_queue_nomerges(hctx->queue);
1097 }
1098
1099 static inline bool blk_mq_merge_queue_io(struct blk_mq_hw_ctx *hctx,
1100                                          struct blk_mq_ctx *ctx,
1101                                          struct request *rq, struct bio *bio)
1102 {
1103         if (!hctx_allow_merges(hctx)) {
1104                 blk_mq_bio_to_request(rq, bio);
1105                 spin_lock(&ctx->lock);
1106 insert_rq:
1107                 __blk_mq_insert_request(hctx, rq, false);
1108                 spin_unlock(&ctx->lock);
1109                 return false;
1110         } else {
1111                 struct request_queue *q = hctx->queue;
1112
1113                 spin_lock(&ctx->lock);
1114                 if (!blk_mq_attempt_merge(q, ctx, bio)) {
1115                         blk_mq_bio_to_request(rq, bio);
1116                         goto insert_rq;
1117                 }
1118
1119                 spin_unlock(&ctx->lock);
1120                 __blk_mq_free_request(hctx, ctx, rq);
1121                 return true;
1122         }
1123 }
1124
1125 struct blk_map_ctx {
1126         struct blk_mq_hw_ctx *hctx;
1127         struct blk_mq_ctx *ctx;
1128 };
1129
1130 static struct request *blk_mq_map_request(struct request_queue *q,
1131                                           struct bio *bio,
1132                                           struct blk_map_ctx *data)
1133 {
1134         struct blk_mq_hw_ctx *hctx;
1135         struct blk_mq_ctx *ctx;
1136         struct request *rq;
1137         int rw = bio_data_dir(bio);
1138         struct blk_mq_alloc_data alloc_data;
1139
1140         if (unlikely(blk_mq_queue_enter(q))) {
1141                 bio_endio(bio, -EIO);
1142                 return NULL;
1143         }
1144
1145         ctx = blk_mq_get_ctx(q);
1146         hctx = q->mq_ops->map_queue(q, ctx->cpu);
1147
1148         if (rw_is_sync(bio->bi_rw))
1149                 rw |= REQ_SYNC;
1150
1151         trace_block_getrq(q, bio, rw);
1152         blk_mq_set_alloc_data(&alloc_data, q, GFP_ATOMIC, false, ctx,
1153                         hctx);
1154         rq = __blk_mq_alloc_request(&alloc_data, rw);
1155         if (unlikely(!rq)) {
1156                 __blk_mq_run_hw_queue(hctx);
1157                 blk_mq_put_ctx(ctx);
1158                 trace_block_sleeprq(q, bio, rw);
1159
1160                 ctx = blk_mq_get_ctx(q);
1161                 hctx = q->mq_ops->map_queue(q, ctx->cpu);
1162                 blk_mq_set_alloc_data(&alloc_data, q,
1163                                 __GFP_WAIT|GFP_ATOMIC, false, ctx, hctx);
1164                 rq = __blk_mq_alloc_request(&alloc_data, rw);
1165                 ctx = alloc_data.ctx;
1166                 hctx = alloc_data.hctx;
1167         }
1168
1169         hctx->queued++;
1170         data->hctx = hctx;
1171         data->ctx = ctx;
1172         return rq;
1173 }
1174
1175 /*
1176  * Multiple hardware queue variant. This will not use per-process plugs,
1177  * but will attempt to bypass the hctx queueing if we can go straight to
1178  * hardware for SYNC IO.
1179  */
1180 static void blk_mq_make_request(struct request_queue *q, struct bio *bio)
1181 {
1182         const int is_sync = rw_is_sync(bio->bi_rw);
1183         const int is_flush_fua = bio->bi_rw & (REQ_FLUSH | REQ_FUA);
1184         struct blk_map_ctx data;
1185         struct request *rq;
1186
1187         blk_queue_bounce(q, &bio);
1188
1189         if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {
1190                 bio_endio(bio, -EIO);
1191                 return;
1192         }
1193
1194         rq = blk_mq_map_request(q, bio, &data);
1195         if (unlikely(!rq))
1196                 return;
1197
1198         if (unlikely(is_flush_fua)) {
1199                 blk_mq_bio_to_request(rq, bio);
1200                 blk_insert_flush(rq);
1201                 goto run_queue;
1202         }
1203
1204         /*
1205          * If the driver supports defer issued based on 'last', then
1206          * queue it up like normal since we can potentially save some
1207          * CPU this way.
1208          */
1209         if (is_sync && !(data.hctx->flags & BLK_MQ_F_DEFER_ISSUE)) {
1210                 struct blk_mq_queue_data bd = {
1211                         .rq = rq,
1212                         .list = NULL,
1213                         .last = 1
1214                 };
1215                 int ret;
1216
1217                 blk_mq_bio_to_request(rq, bio);
1218
1219                 /*
1220                  * For OK queue, we are done. For error, kill it. Any other
1221                  * error (busy), just add it to our list as we previously
1222                  * would have done
1223                  */
1224                 ret = q->mq_ops->queue_rq(data.hctx, &bd);
1225                 if (ret == BLK_MQ_RQ_QUEUE_OK)
1226                         goto done;
1227                 else {
1228                         __blk_mq_requeue_request(rq);
1229
1230                         if (ret == BLK_MQ_RQ_QUEUE_ERROR) {
1231                                 rq->errors = -EIO;
1232                                 blk_mq_end_request(rq, rq->errors);
1233                                 goto done;
1234                         }
1235                 }
1236         }
1237
1238         if (!blk_mq_merge_queue_io(data.hctx, data.ctx, rq, bio)) {
1239                 /*
1240                  * For a SYNC request, send it to the hardware immediately. For
1241                  * an ASYNC request, just ensure that we run it later on. The
1242                  * latter allows for merging opportunities and more efficient
1243                  * dispatching.
1244                  */
1245 run_queue:
1246                 blk_mq_run_hw_queue(data.hctx, !is_sync || is_flush_fua);
1247         }
1248 done:
1249         blk_mq_put_ctx(data.ctx);
1250 }
1251
1252 /*
1253  * Single hardware queue variant. This will attempt to use any per-process
1254  * plug for merging and IO deferral.
1255  */
1256 static void blk_sq_make_request(struct request_queue *q, struct bio *bio)
1257 {
1258         const int is_sync = rw_is_sync(bio->bi_rw);
1259         const int is_flush_fua = bio->bi_rw & (REQ_FLUSH | REQ_FUA);
1260         unsigned int use_plug, request_count = 0;
1261         struct blk_map_ctx data;
1262         struct request *rq;
1263
1264         /*
1265          * If we have multiple hardware queues, just go directly to
1266          * one of those for sync IO.
1267          */
1268         use_plug = !is_flush_fua && !is_sync;
1269
1270         blk_queue_bounce(q, &bio);
1271
1272         if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {
1273                 bio_endio(bio, -EIO);
1274                 return;
1275         }
1276
1277         if (use_plug && !blk_queue_nomerges(q) &&
1278             blk_attempt_plug_merge(q, bio, &request_count))
1279                 return;
1280
1281         rq = blk_mq_map_request(q, bio, &data);
1282         if (unlikely(!rq))
1283                 return;
1284
1285         if (unlikely(is_flush_fua)) {
1286                 blk_mq_bio_to_request(rq, bio);
1287                 blk_insert_flush(rq);
1288                 goto run_queue;
1289         }
1290
1291         /*
1292          * A task plug currently exists. Since this is completely lockless,
1293          * utilize that to temporarily store requests until the task is
1294          * either done or scheduled away.
1295          */
1296         if (use_plug) {
1297                 struct blk_plug *plug = current->plug;
1298
1299                 if (plug) {
1300                         blk_mq_bio_to_request(rq, bio);
1301                         if (list_empty(&plug->mq_list))
1302                                 trace_block_plug(q);
1303                         else if (request_count >= BLK_MAX_REQUEST_COUNT) {
1304                                 blk_flush_plug_list(plug, false);
1305                                 trace_block_plug(q);
1306                         }
1307                         list_add_tail(&rq->queuelist, &plug->mq_list);
1308                         blk_mq_put_ctx(data.ctx);
1309                         return;
1310                 }
1311         }
1312
1313         if (!blk_mq_merge_queue_io(data.hctx, data.ctx, rq, bio)) {
1314                 /*
1315                  * For a SYNC request, send it to the hardware immediately. For
1316                  * an ASYNC request, just ensure that we run it later on. The
1317                  * latter allows for merging opportunities and more efficient
1318                  * dispatching.
1319                  */
1320 run_queue:
1321                 blk_mq_run_hw_queue(data.hctx, !is_sync || is_flush_fua);
1322         }
1323
1324         blk_mq_put_ctx(data.ctx);
1325 }
1326
1327 /*
1328  * Default mapping to a software queue, since we use one per CPU.
1329  */
1330 struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *q, const int cpu)
1331 {
1332         return q->queue_hw_ctx[q->mq_map[cpu]];
1333 }
1334 EXPORT_SYMBOL(blk_mq_map_queue);
1335
1336 static void blk_mq_free_rq_map(struct blk_mq_tag_set *set,
1337                 struct blk_mq_tags *tags, unsigned int hctx_idx)
1338 {
1339         struct page *page;
1340
1341         if (tags->rqs && set->ops->exit_request) {
1342                 int i;
1343
1344                 for (i = 0; i < tags->nr_tags; i++) {
1345                         if (!tags->rqs[i])
1346                                 continue;
1347                         set->ops->exit_request(set->driver_data, tags->rqs[i],
1348                                                 hctx_idx, i);
1349                         tags->rqs[i] = NULL;
1350                 }
1351         }
1352
1353         while (!list_empty(&tags->page_list)) {
1354                 page = list_first_entry(&tags->page_list, struct page, lru);
1355                 list_del_init(&page->lru);
1356                 __free_pages(page, page->private);
1357         }
1358
1359         kfree(tags->rqs);
1360
1361         blk_mq_free_tags(tags);
1362 }
1363
1364 static size_t order_to_size(unsigned int order)
1365 {
1366         return (size_t)PAGE_SIZE << order;
1367 }
1368
1369 static struct blk_mq_tags *blk_mq_init_rq_map(struct blk_mq_tag_set *set,
1370                 unsigned int hctx_idx)
1371 {
1372         struct blk_mq_tags *tags;
1373         unsigned int i, j, entries_per_page, max_order = 4;
1374         size_t rq_size, left;
1375
1376         tags = blk_mq_init_tags(set->queue_depth, set->reserved_tags,
1377                                 set->numa_node);
1378         if (!tags)
1379                 return NULL;
1380
1381         INIT_LIST_HEAD(&tags->page_list);
1382
1383         tags->rqs = kzalloc_node(set->queue_depth * sizeof(struct request *),
1384                                  GFP_KERNEL | __GFP_NOWARN | __GFP_NORETRY,
1385                                  set->numa_node);
1386         if (!tags->rqs) {
1387                 blk_mq_free_tags(tags);
1388                 return NULL;
1389         }
1390
1391         /*
1392          * rq_size is the size of the request plus driver payload, rounded
1393          * to the cacheline size
1394          */
1395         rq_size = round_up(sizeof(struct request) + set->cmd_size,
1396                                 cache_line_size());
1397         left = rq_size * set->queue_depth;
1398
1399         for (i = 0; i < set->queue_depth; ) {
1400                 int this_order = max_order;
1401                 struct page *page;
1402                 int to_do;
1403                 void *p;
1404
1405                 while (left < order_to_size(this_order - 1) && this_order)
1406                         this_order--;
1407
1408                 do {
1409                         page = alloc_pages_node(set->numa_node,
1410                                 GFP_KERNEL | __GFP_NOWARN | __GFP_NORETRY,
1411                                 this_order);
1412                         if (page)
1413                                 break;
1414                         if (!this_order--)
1415                                 break;
1416                         if (order_to_size(this_order) < rq_size)
1417                                 break;
1418                 } while (1);
1419
1420                 if (!page)
1421                         goto fail;
1422
1423                 page->private = this_order;
1424                 list_add_tail(&page->lru, &tags->page_list);
1425
1426                 p = page_address(page);
1427                 entries_per_page = order_to_size(this_order) / rq_size;
1428                 to_do = min(entries_per_page, set->queue_depth - i);
1429                 left -= to_do * rq_size;
1430                 for (j = 0; j < to_do; j++) {
1431                         tags->rqs[i] = p;
1432                         tags->rqs[i]->atomic_flags = 0;
1433                         tags->rqs[i]->cmd_flags = 0;
1434                         if (set->ops->init_request) {
1435                                 if (set->ops->init_request(set->driver_data,
1436                                                 tags->rqs[i], hctx_idx, i,
1437                                                 set->numa_node)) {
1438                                         tags->rqs[i] = NULL;
1439                                         goto fail;
1440                                 }
1441                         }
1442
1443                         p += rq_size;
1444                         i++;
1445                 }
1446         }
1447
1448         return tags;
1449
1450 fail:
1451         blk_mq_free_rq_map(set, tags, hctx_idx);
1452         return NULL;
1453 }
1454
1455 static void blk_mq_free_bitmap(struct blk_mq_ctxmap *bitmap)
1456 {
1457         kfree(bitmap->map);
1458 }
1459
1460 static int blk_mq_alloc_bitmap(struct blk_mq_ctxmap *bitmap, int node)
1461 {
1462         unsigned int bpw = 8, total, num_maps, i;
1463
1464         bitmap->bits_per_word = bpw;
1465
1466         num_maps = ALIGN(nr_cpu_ids, bpw) / bpw;
1467         bitmap->map = kzalloc_node(num_maps * sizeof(struct blk_align_bitmap),
1468                                         GFP_KERNEL, node);
1469         if (!bitmap->map)
1470                 return -ENOMEM;
1471
1472         bitmap->map_size = num_maps;
1473
1474         total = nr_cpu_ids;
1475         for (i = 0; i < num_maps; i++) {
1476                 bitmap->map[i].depth = min(total, bitmap->bits_per_word);
1477                 total -= bitmap->map[i].depth;
1478         }
1479
1480         return 0;
1481 }
1482
1483 static int blk_mq_hctx_cpu_offline(struct blk_mq_hw_ctx *hctx, int cpu)
1484 {
1485         struct request_queue *q = hctx->queue;
1486         struct blk_mq_ctx *ctx;
1487         LIST_HEAD(tmp);
1488
1489         /*
1490          * Move ctx entries to new CPU, if this one is going away.
1491          */
1492         ctx = __blk_mq_get_ctx(q, cpu);
1493
1494         spin_lock(&ctx->lock);
1495         if (!list_empty(&ctx->rq_list)) {
1496                 list_splice_init(&ctx->rq_list, &tmp);
1497                 blk_mq_hctx_clear_pending(hctx, ctx);
1498         }
1499         spin_unlock(&ctx->lock);
1500
1501         if (list_empty(&tmp))
1502                 return NOTIFY_OK;
1503
1504         ctx = blk_mq_get_ctx(q);
1505         spin_lock(&ctx->lock);
1506
1507         while (!list_empty(&tmp)) {
1508                 struct request *rq;
1509
1510                 rq = list_first_entry(&tmp, struct request, queuelist);
1511                 rq->mq_ctx = ctx;
1512                 list_move_tail(&rq->queuelist, &ctx->rq_list);
1513         }
1514
1515         hctx = q->mq_ops->map_queue(q, ctx->cpu);
1516         blk_mq_hctx_mark_pending(hctx, ctx);
1517
1518         spin_unlock(&ctx->lock);
1519
1520         blk_mq_run_hw_queue(hctx, true);
1521         blk_mq_put_ctx(ctx);
1522         return NOTIFY_OK;
1523 }
1524
1525 static int blk_mq_hctx_cpu_online(struct blk_mq_hw_ctx *hctx, int cpu)
1526 {
1527         struct request_queue *q = hctx->queue;
1528         struct blk_mq_tag_set *set = q->tag_set;
1529
1530         if (set->tags[hctx->queue_num])
1531                 return NOTIFY_OK;
1532
1533         set->tags[hctx->queue_num] = blk_mq_init_rq_map(set, hctx->queue_num);
1534         if (!set->tags[hctx->queue_num])
1535                 return NOTIFY_STOP;
1536
1537         hctx->tags = set->tags[hctx->queue_num];
1538         return NOTIFY_OK;
1539 }
1540
1541 static int blk_mq_hctx_notify(void *data, unsigned long action,
1542                               unsigned int cpu)
1543 {
1544         struct blk_mq_hw_ctx *hctx = data;
1545
1546         if (action == CPU_DEAD || action == CPU_DEAD_FROZEN)
1547                 return blk_mq_hctx_cpu_offline(hctx, cpu);
1548         else if (action == CPU_ONLINE || action == CPU_ONLINE_FROZEN)
1549                 return blk_mq_hctx_cpu_online(hctx, cpu);
1550
1551         return NOTIFY_OK;
1552 }
1553
1554 static void blk_mq_exit_hctx(struct request_queue *q,
1555                 struct blk_mq_tag_set *set,
1556                 struct blk_mq_hw_ctx *hctx, unsigned int hctx_idx)
1557 {
1558         unsigned flush_start_tag = set->queue_depth;
1559
1560         blk_mq_tag_idle(hctx);
1561
1562         if (set->ops->exit_request)
1563                 set->ops->exit_request(set->driver_data,
1564                                        hctx->fq->flush_rq, hctx_idx,
1565                                        flush_start_tag + hctx_idx);
1566
1567         if (set->ops->exit_hctx)
1568                 set->ops->exit_hctx(hctx, hctx_idx);
1569
1570         blk_mq_unregister_cpu_notifier(&hctx->cpu_notifier);
1571         blk_free_flush_queue(hctx->fq);
1572         kfree(hctx->ctxs);
1573         blk_mq_free_bitmap(&hctx->ctx_map);
1574 }
1575
1576 static void blk_mq_exit_hw_queues(struct request_queue *q,
1577                 struct blk_mq_tag_set *set, int nr_queue)
1578 {
1579         struct blk_mq_hw_ctx *hctx;
1580         unsigned int i;
1581
1582         queue_for_each_hw_ctx(q, hctx, i) {
1583                 if (i == nr_queue)
1584                         break;
1585                 blk_mq_exit_hctx(q, set, hctx, i);
1586         }
1587 }
1588
1589 static void blk_mq_free_hw_queues(struct request_queue *q,
1590                 struct blk_mq_tag_set *set)
1591 {
1592         struct blk_mq_hw_ctx *hctx;
1593         unsigned int i;
1594
1595         queue_for_each_hw_ctx(q, hctx, i) {
1596                 free_cpumask_var(hctx->cpumask);
1597                 kfree(hctx);
1598         }
1599 }
1600
1601 static int blk_mq_init_hctx(struct request_queue *q,
1602                 struct blk_mq_tag_set *set,
1603                 struct blk_mq_hw_ctx *hctx, unsigned hctx_idx)
1604 {
1605         int node;
1606         unsigned flush_start_tag = set->queue_depth;
1607
1608         node = hctx->numa_node;
1609         if (node == NUMA_NO_NODE)
1610                 node = hctx->numa_node = set->numa_node;
1611
1612         INIT_DELAYED_WORK(&hctx->run_work, blk_mq_run_work_fn);
1613         INIT_DELAYED_WORK(&hctx->delay_work, blk_mq_delay_work_fn);
1614         spin_lock_init(&hctx->lock);
1615         INIT_LIST_HEAD(&hctx->dispatch);
1616         hctx->queue = q;
1617         hctx->queue_num = hctx_idx;
1618         hctx->flags = set->flags;
1619         hctx->cmd_size = set->cmd_size;
1620
1621         blk_mq_init_cpu_notifier(&hctx->cpu_notifier,
1622                                         blk_mq_hctx_notify, hctx);
1623         blk_mq_register_cpu_notifier(&hctx->cpu_notifier);
1624
1625         hctx->tags = set->tags[hctx_idx];
1626
1627         /*
1628          * Allocate space for all possible cpus to avoid allocation at
1629          * runtime
1630          */
1631         hctx->ctxs = kmalloc_node(nr_cpu_ids * sizeof(void *),
1632                                         GFP_KERNEL, node);
1633         if (!hctx->ctxs)
1634                 goto unregister_cpu_notifier;
1635
1636         if (blk_mq_alloc_bitmap(&hctx->ctx_map, node))
1637                 goto free_ctxs;
1638
1639         hctx->nr_ctx = 0;
1640
1641         if (set->ops->init_hctx &&
1642             set->ops->init_hctx(hctx, set->driver_data, hctx_idx))
1643                 goto free_bitmap;
1644
1645         hctx->fq = blk_alloc_flush_queue(q, hctx->numa_node, set->cmd_size);
1646         if (!hctx->fq)
1647                 goto exit_hctx;
1648
1649         if (set->ops->init_request &&
1650             set->ops->init_request(set->driver_data,
1651                                    hctx->fq->flush_rq, hctx_idx,
1652                                    flush_start_tag + hctx_idx, node))
1653                 goto free_fq;
1654
1655         return 0;
1656
1657  free_fq:
1658         kfree(hctx->fq);
1659  exit_hctx:
1660         if (set->ops->exit_hctx)
1661                 set->ops->exit_hctx(hctx, hctx_idx);
1662  free_bitmap:
1663         blk_mq_free_bitmap(&hctx->ctx_map);
1664  free_ctxs:
1665         kfree(hctx->ctxs);
1666  unregister_cpu_notifier:
1667         blk_mq_unregister_cpu_notifier(&hctx->cpu_notifier);
1668
1669         return -1;
1670 }
1671
1672 static int blk_mq_init_hw_queues(struct request_queue *q,
1673                 struct blk_mq_tag_set *set)
1674 {
1675         struct blk_mq_hw_ctx *hctx;
1676         unsigned int i;
1677
1678         /*
1679          * Initialize hardware queues
1680          */
1681         queue_for_each_hw_ctx(q, hctx, i) {
1682                 if (blk_mq_init_hctx(q, set, hctx, i))
1683                         break;
1684         }
1685
1686         if (i == q->nr_hw_queues)
1687                 return 0;
1688
1689         /*
1690          * Init failed
1691          */
1692         blk_mq_exit_hw_queues(q, set, i);
1693
1694         return 1;
1695 }
1696
1697 static void blk_mq_init_cpu_queues(struct request_queue *q,
1698                                    unsigned int nr_hw_queues)
1699 {
1700         unsigned int i;
1701
1702         for_each_possible_cpu(i) {
1703                 struct blk_mq_ctx *__ctx = per_cpu_ptr(q->queue_ctx, i);
1704                 struct blk_mq_hw_ctx *hctx;
1705
1706                 memset(__ctx, 0, sizeof(*__ctx));
1707                 __ctx->cpu = i;
1708                 spin_lock_init(&__ctx->lock);
1709                 INIT_LIST_HEAD(&__ctx->rq_list);
1710                 __ctx->queue = q;
1711
1712                 /* If the cpu isn't online, the cpu is mapped to first hctx */
1713                 if (!cpu_online(i))
1714                         continue;
1715
1716                 hctx = q->mq_ops->map_queue(q, i);
1717                 cpumask_set_cpu(i, hctx->cpumask);
1718                 hctx->nr_ctx++;
1719
1720                 /*
1721                  * Set local node, IFF we have more than one hw queue. If
1722                  * not, we remain on the home node of the device
1723                  */
1724                 if (nr_hw_queues > 1 && hctx->numa_node == NUMA_NO_NODE)
1725                         hctx->numa_node = cpu_to_node(i);
1726         }
1727 }
1728
1729 static void blk_mq_map_swqueue(struct request_queue *q)
1730 {
1731         unsigned int i;
1732         struct blk_mq_hw_ctx *hctx;
1733         struct blk_mq_ctx *ctx;
1734
1735         queue_for_each_hw_ctx(q, hctx, i) {
1736                 cpumask_clear(hctx->cpumask);
1737                 hctx->nr_ctx = 0;
1738         }
1739
1740         /*
1741          * Map software to hardware queues
1742          */
1743         queue_for_each_ctx(q, ctx, i) {
1744                 /* If the cpu isn't online, the cpu is mapped to first hctx */
1745                 if (!cpu_online(i))
1746                         continue;
1747
1748                 hctx = q->mq_ops->map_queue(q, i);
1749                 cpumask_set_cpu(i, hctx->cpumask);
1750                 ctx->index_hw = hctx->nr_ctx;
1751                 hctx->ctxs[hctx->nr_ctx++] = ctx;
1752         }
1753
1754         queue_for_each_hw_ctx(q, hctx, i) {
1755                 /*
1756                  * If no software queues are mapped to this hardware queue,
1757                  * disable it and free the request entries.
1758                  */
1759                 if (!hctx->nr_ctx) {
1760                         struct blk_mq_tag_set *set = q->tag_set;
1761
1762                         if (set->tags[i]) {
1763                                 blk_mq_free_rq_map(set, set->tags[i], i);
1764                                 set->tags[i] = NULL;
1765                                 hctx->tags = NULL;
1766                         }
1767                         continue;
1768                 }
1769
1770                 /*
1771                  * Initialize batch roundrobin counts
1772                  */
1773                 hctx->next_cpu = cpumask_first(hctx->cpumask);
1774                 hctx->next_cpu_batch = BLK_MQ_CPU_WORK_BATCH;
1775         }
1776 }
1777
1778 static void blk_mq_update_tag_set_depth(struct blk_mq_tag_set *set)
1779 {
1780         struct blk_mq_hw_ctx *hctx;
1781         struct request_queue *q;
1782         bool shared;
1783         int i;
1784
1785         if (set->tag_list.next == set->tag_list.prev)
1786                 shared = false;
1787         else
1788                 shared = true;
1789
1790         list_for_each_entry(q, &set->tag_list, tag_set_list) {
1791                 blk_mq_freeze_queue(q);
1792
1793                 queue_for_each_hw_ctx(q, hctx, i) {
1794                         if (shared)
1795                                 hctx->flags |= BLK_MQ_F_TAG_SHARED;
1796                         else
1797                                 hctx->flags &= ~BLK_MQ_F_TAG_SHARED;
1798                 }
1799                 blk_mq_unfreeze_queue(q);
1800         }
1801 }
1802
1803 static void blk_mq_del_queue_tag_set(struct request_queue *q)
1804 {
1805         struct blk_mq_tag_set *set = q->tag_set;
1806
1807         mutex_lock(&set->tag_list_lock);
1808         list_del_init(&q->tag_set_list);
1809         blk_mq_update_tag_set_depth(set);
1810         mutex_unlock(&set->tag_list_lock);
1811 }
1812
1813 static void blk_mq_add_queue_tag_set(struct blk_mq_tag_set *set,
1814                                      struct request_queue *q)
1815 {
1816         q->tag_set = set;
1817
1818         mutex_lock(&set->tag_list_lock);
1819         list_add_tail(&q->tag_set_list, &set->tag_list);
1820         blk_mq_update_tag_set_depth(set);
1821         mutex_unlock(&set->tag_list_lock);
1822 }
1823
1824 struct request_queue *blk_mq_init_queue(struct blk_mq_tag_set *set)
1825 {
1826         struct blk_mq_hw_ctx **hctxs;
1827         struct blk_mq_ctx __percpu *ctx;
1828         struct request_queue *q;
1829         unsigned int *map;
1830         int i;
1831
1832         ctx = alloc_percpu(struct blk_mq_ctx);
1833         if (!ctx)
1834                 return ERR_PTR(-ENOMEM);
1835
1836         hctxs = kmalloc_node(set->nr_hw_queues * sizeof(*hctxs), GFP_KERNEL,
1837                         set->numa_node);
1838
1839         if (!hctxs)
1840                 goto err_percpu;
1841
1842         map = blk_mq_make_queue_map(set);
1843         if (!map)
1844                 goto err_map;
1845
1846         for (i = 0; i < set->nr_hw_queues; i++) {
1847                 int node = blk_mq_hw_queue_to_node(map, i);
1848
1849                 hctxs[i] = kzalloc_node(sizeof(struct blk_mq_hw_ctx),
1850                                         GFP_KERNEL, node);
1851                 if (!hctxs[i])
1852                         goto err_hctxs;
1853
1854                 if (!zalloc_cpumask_var_node(&hctxs[i]->cpumask, GFP_KERNEL,
1855                                                 node))
1856                         goto err_hctxs;
1857
1858                 atomic_set(&hctxs[i]->nr_active, 0);
1859                 hctxs[i]->numa_node = node;
1860                 hctxs[i]->queue_num = i;
1861         }
1862
1863         q = blk_alloc_queue_node(GFP_KERNEL, set->numa_node);
1864         if (!q)
1865                 goto err_hctxs;
1866
1867         /*
1868          * Init percpu_ref in atomic mode so that it's faster to shutdown.
1869          * See blk_register_queue() for details.
1870          */
1871         if (percpu_ref_init(&q->mq_usage_counter, blk_mq_usage_counter_release,
1872                             PERCPU_REF_INIT_ATOMIC, GFP_KERNEL))
1873                 goto err_map;
1874
1875         setup_timer(&q->timeout, blk_mq_rq_timer, (unsigned long) q);
1876         blk_queue_rq_timeout(q, 30000);
1877
1878         q->nr_queues = nr_cpu_ids;
1879         q->nr_hw_queues = set->nr_hw_queues;
1880         q->mq_map = map;
1881
1882         q->queue_ctx = ctx;
1883         q->queue_hw_ctx = hctxs;
1884
1885         q->mq_ops = set->ops;
1886         q->queue_flags |= QUEUE_FLAG_MQ_DEFAULT;
1887
1888         if (!(set->flags & BLK_MQ_F_SG_MERGE))
1889                 q->queue_flags |= 1 << QUEUE_FLAG_NO_SG_MERGE;
1890
1891         q->sg_reserved_size = INT_MAX;
1892
1893         INIT_WORK(&q->requeue_work, blk_mq_requeue_work);
1894         INIT_LIST_HEAD(&q->requeue_list);
1895         spin_lock_init(&q->requeue_lock);
1896
1897         if (q->nr_hw_queues > 1)
1898                 blk_queue_make_request(q, blk_mq_make_request);
1899         else
1900                 blk_queue_make_request(q, blk_sq_make_request);
1901
1902         if (set->timeout)
1903                 blk_queue_rq_timeout(q, set->timeout);
1904
1905         /*
1906          * Do this after blk_queue_make_request() overrides it...
1907          */
1908         q->nr_requests = set->queue_depth;
1909
1910         if (set->ops->complete)
1911                 blk_queue_softirq_done(q, set->ops->complete);
1912
1913         blk_mq_init_cpu_queues(q, set->nr_hw_queues);
1914
1915         if (blk_mq_init_hw_queues(q, set))
1916                 goto err_hw;
1917
1918         mutex_lock(&all_q_mutex);
1919         list_add_tail(&q->all_q_node, &all_q_list);
1920         mutex_unlock(&all_q_mutex);
1921
1922         blk_mq_add_queue_tag_set(set, q);
1923
1924         blk_mq_map_swqueue(q);
1925
1926         return q;
1927
1928 err_hw:
1929         blk_cleanup_queue(q);
1930 err_hctxs:
1931         kfree(map);
1932         for (i = 0; i < set->nr_hw_queues; i++) {
1933                 if (!hctxs[i])
1934                         break;
1935                 free_cpumask_var(hctxs[i]->cpumask);
1936                 kfree(hctxs[i]);
1937         }
1938 err_map:
1939         kfree(hctxs);
1940 err_percpu:
1941         free_percpu(ctx);
1942         return ERR_PTR(-ENOMEM);
1943 }
1944 EXPORT_SYMBOL(blk_mq_init_queue);
1945
1946 void blk_mq_free_queue(struct request_queue *q)
1947 {
1948         struct blk_mq_tag_set   *set = q->tag_set;
1949
1950         blk_mq_del_queue_tag_set(q);
1951
1952         blk_mq_exit_hw_queues(q, set, set->nr_hw_queues);
1953         blk_mq_free_hw_queues(q, set);
1954
1955         percpu_ref_exit(&q->mq_usage_counter);
1956
1957         free_percpu(q->queue_ctx);
1958         kfree(q->queue_hw_ctx);
1959         kfree(q->mq_map);
1960
1961         q->queue_ctx = NULL;
1962         q->queue_hw_ctx = NULL;
1963         q->mq_map = NULL;
1964
1965         mutex_lock(&all_q_mutex);
1966         list_del_init(&q->all_q_node);
1967         mutex_unlock(&all_q_mutex);
1968 }
1969
1970 /* Basically redo blk_mq_init_queue with queue frozen */
1971 static void blk_mq_queue_reinit(struct request_queue *q)
1972 {
1973         WARN_ON_ONCE(!q->mq_freeze_depth);
1974
1975         blk_mq_sysfs_unregister(q);
1976
1977         blk_mq_update_queue_map(q->mq_map, q->nr_hw_queues);
1978
1979         /*
1980          * redo blk_mq_init_cpu_queues and blk_mq_init_hw_queues. FIXME: maybe
1981          * we should change hctx numa_node according to new topology (this
1982          * involves free and re-allocate memory, worthy doing?)
1983          */
1984
1985         blk_mq_map_swqueue(q);
1986
1987         blk_mq_sysfs_register(q);
1988 }
1989
1990 static int blk_mq_queue_reinit_notify(struct notifier_block *nb,
1991                                       unsigned long action, void *hcpu)
1992 {
1993         struct request_queue *q;
1994
1995         /*
1996          * Before new mappings are established, hotadded cpu might already
1997          * start handling requests. This doesn't break anything as we map
1998          * offline CPUs to first hardware queue. We will re-init the queue
1999          * below to get optimal settings.
2000          */
2001         if (action != CPU_DEAD && action != CPU_DEAD_FROZEN &&
2002             action != CPU_ONLINE && action != CPU_ONLINE_FROZEN)
2003                 return NOTIFY_OK;
2004
2005         mutex_lock(&all_q_mutex);
2006
2007         /*
2008          * We need to freeze and reinit all existing queues.  Freezing
2009          * involves synchronous wait for an RCU grace period and doing it
2010          * one by one may take a long time.  Start freezing all queues in
2011          * one swoop and then wait for the completions so that freezing can
2012          * take place in parallel.
2013          */
2014         list_for_each_entry(q, &all_q_list, all_q_node)
2015                 blk_mq_freeze_queue_start(q);
2016         list_for_each_entry(q, &all_q_list, all_q_node)
2017                 blk_mq_freeze_queue_wait(q);
2018
2019         list_for_each_entry(q, &all_q_list, all_q_node)
2020                 blk_mq_queue_reinit(q);
2021
2022         list_for_each_entry(q, &all_q_list, all_q_node)
2023                 blk_mq_unfreeze_queue(q);
2024
2025         mutex_unlock(&all_q_mutex);
2026         return NOTIFY_OK;
2027 }
2028
2029 static int __blk_mq_alloc_rq_maps(struct blk_mq_tag_set *set)
2030 {
2031         int i;
2032
2033         for (i = 0; i < set->nr_hw_queues; i++) {
2034                 set->tags[i] = blk_mq_init_rq_map(set, i);
2035                 if (!set->tags[i])
2036                         goto out_unwind;
2037         }
2038
2039         return 0;
2040
2041 out_unwind:
2042         while (--i >= 0)
2043                 blk_mq_free_rq_map(set, set->tags[i], i);
2044
2045         return -ENOMEM;
2046 }
2047
2048 /*
2049  * Allocate the request maps associated with this tag_set. Note that this
2050  * may reduce the depth asked for, if memory is tight. set->queue_depth
2051  * will be updated to reflect the allocated depth.
2052  */
2053 static int blk_mq_alloc_rq_maps(struct blk_mq_tag_set *set)
2054 {
2055         unsigned int depth;
2056         int err;
2057
2058         depth = set->queue_depth;
2059         do {
2060                 err = __blk_mq_alloc_rq_maps(set);
2061                 if (!err)
2062                         break;
2063
2064                 set->queue_depth >>= 1;
2065                 if (set->queue_depth < set->reserved_tags + BLK_MQ_TAG_MIN) {
2066                         err = -ENOMEM;
2067                         break;
2068                 }
2069         } while (set->queue_depth);
2070
2071         if (!set->queue_depth || err) {
2072                 pr_err("blk-mq: failed to allocate request map\n");
2073                 return -ENOMEM;
2074         }
2075
2076         if (depth != set->queue_depth)
2077                 pr_info("blk-mq: reduced tag depth (%u -> %u)\n",
2078                                                 depth, set->queue_depth);
2079
2080         return 0;
2081 }
2082
2083 /*
2084  * Alloc a tag set to be associated with one or more request queues.
2085  * May fail with EINVAL for various error conditions. May adjust the
2086  * requested depth down, if if it too large. In that case, the set
2087  * value will be stored in set->queue_depth.
2088  */
2089 int blk_mq_alloc_tag_set(struct blk_mq_tag_set *set)
2090 {
2091         BUILD_BUG_ON(BLK_MQ_MAX_DEPTH > 1 << BLK_MQ_UNIQUE_TAG_BITS);
2092
2093         if (!set->nr_hw_queues)
2094                 return -EINVAL;
2095         if (!set->queue_depth)
2096                 return -EINVAL;
2097         if (set->queue_depth < set->reserved_tags + BLK_MQ_TAG_MIN)
2098                 return -EINVAL;
2099
2100         if (!set->nr_hw_queues || !set->ops->queue_rq || !set->ops->map_queue)
2101                 return -EINVAL;
2102
2103         if (set->queue_depth > BLK_MQ_MAX_DEPTH) {
2104                 pr_info("blk-mq: reduced tag depth to %u\n",
2105                         BLK_MQ_MAX_DEPTH);
2106                 set->queue_depth = BLK_MQ_MAX_DEPTH;
2107         }
2108
2109         /*
2110          * If a crashdump is active, then we are potentially in a very
2111          * memory constrained environment. Limit us to 1 queue and
2112          * 64 tags to prevent using too much memory.
2113          */
2114         if (is_kdump_kernel()) {
2115                 set->nr_hw_queues = 1;
2116                 set->queue_depth = min(64U, set->queue_depth);
2117         }
2118
2119         set->tags = kmalloc_node(set->nr_hw_queues *
2120                                  sizeof(struct blk_mq_tags *),
2121                                  GFP_KERNEL, set->numa_node);
2122         if (!set->tags)
2123                 return -ENOMEM;
2124
2125         if (blk_mq_alloc_rq_maps(set))
2126                 goto enomem;
2127
2128         mutex_init(&set->tag_list_lock);
2129         INIT_LIST_HEAD(&set->tag_list);
2130
2131         return 0;
2132 enomem:
2133         kfree(set->tags);
2134         set->tags = NULL;
2135         return -ENOMEM;
2136 }
2137 EXPORT_SYMBOL(blk_mq_alloc_tag_set);
2138
2139 void blk_mq_free_tag_set(struct blk_mq_tag_set *set)
2140 {
2141         int i;
2142
2143         for (i = 0; i < set->nr_hw_queues; i++) {
2144                 if (set->tags[i])
2145                         blk_mq_free_rq_map(set, set->tags[i], i);
2146         }
2147
2148         kfree(set->tags);
2149         set->tags = NULL;
2150 }
2151 EXPORT_SYMBOL(blk_mq_free_tag_set);
2152
2153 int blk_mq_update_nr_requests(struct request_queue *q, unsigned int nr)
2154 {
2155         struct blk_mq_tag_set *set = q->tag_set;
2156         struct blk_mq_hw_ctx *hctx;
2157         int i, ret;
2158
2159         if (!set || nr > set->queue_depth)
2160                 return -EINVAL;
2161
2162         ret = 0;
2163         queue_for_each_hw_ctx(q, hctx, i) {
2164                 ret = blk_mq_tag_update_depth(hctx->tags, nr);
2165                 if (ret)
2166                         break;
2167         }
2168
2169         if (!ret)
2170                 q->nr_requests = nr;
2171
2172         return ret;
2173 }
2174
2175 void blk_mq_disable_hotplug(void)
2176 {
2177         mutex_lock(&all_q_mutex);
2178 }
2179
2180 void blk_mq_enable_hotplug(void)
2181 {
2182         mutex_unlock(&all_q_mutex);
2183 }
2184
2185 static int __init blk_mq_init(void)
2186 {
2187         blk_mq_cpu_init();
2188
2189         hotcpu_notifier(blk_mq_queue_reinit_notify, 0);
2190
2191         return 0;
2192 }
2193 subsys_initcall(blk_mq_init);