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                                 BLK_MQ_FLAG_TO_ALLOC_POLICY(set->flags));
1379         if (!tags)
1380                 return NULL;
1381
1382         INIT_LIST_HEAD(&tags->page_list);
1383
1384         tags->rqs = kzalloc_node(set->queue_depth * sizeof(struct request *),
1385                                  GFP_KERNEL | __GFP_NOWARN | __GFP_NORETRY,
1386                                  set->numa_node);
1387         if (!tags->rqs) {
1388                 blk_mq_free_tags(tags);
1389                 return NULL;
1390         }
1391
1392         /*
1393          * rq_size is the size of the request plus driver payload, rounded
1394          * to the cacheline size
1395          */
1396         rq_size = round_up(sizeof(struct request) + set->cmd_size,
1397                                 cache_line_size());
1398         left = rq_size * set->queue_depth;
1399
1400         for (i = 0; i < set->queue_depth; ) {
1401                 int this_order = max_order;
1402                 struct page *page;
1403                 int to_do;
1404                 void *p;
1405
1406                 while (left < order_to_size(this_order - 1) && this_order)
1407                         this_order--;
1408
1409                 do {
1410                         page = alloc_pages_node(set->numa_node,
1411                                 GFP_KERNEL | __GFP_NOWARN | __GFP_NORETRY,
1412                                 this_order);
1413                         if (page)
1414                                 break;
1415                         if (!this_order--)
1416                                 break;
1417                         if (order_to_size(this_order) < rq_size)
1418                                 break;
1419                 } while (1);
1420
1421                 if (!page)
1422                         goto fail;
1423
1424                 page->private = this_order;
1425                 list_add_tail(&page->lru, &tags->page_list);
1426
1427                 p = page_address(page);
1428                 entries_per_page = order_to_size(this_order) / rq_size;
1429                 to_do = min(entries_per_page, set->queue_depth - i);
1430                 left -= to_do * rq_size;
1431                 for (j = 0; j < to_do; j++) {
1432                         tags->rqs[i] = p;
1433                         tags->rqs[i]->atomic_flags = 0;
1434                         tags->rqs[i]->cmd_flags = 0;
1435                         if (set->ops->init_request) {
1436                                 if (set->ops->init_request(set->driver_data,
1437                                                 tags->rqs[i], hctx_idx, i,
1438                                                 set->numa_node)) {
1439                                         tags->rqs[i] = NULL;
1440                                         goto fail;
1441                                 }
1442                         }
1443
1444                         p += rq_size;
1445                         i++;
1446                 }
1447         }
1448
1449         return tags;
1450
1451 fail:
1452         blk_mq_free_rq_map(set, tags, hctx_idx);
1453         return NULL;
1454 }
1455
1456 static void blk_mq_free_bitmap(struct blk_mq_ctxmap *bitmap)
1457 {
1458         kfree(bitmap->map);
1459 }
1460
1461 static int blk_mq_alloc_bitmap(struct blk_mq_ctxmap *bitmap, int node)
1462 {
1463         unsigned int bpw = 8, total, num_maps, i;
1464
1465         bitmap->bits_per_word = bpw;
1466
1467         num_maps = ALIGN(nr_cpu_ids, bpw) / bpw;
1468         bitmap->map = kzalloc_node(num_maps * sizeof(struct blk_align_bitmap),
1469                                         GFP_KERNEL, node);
1470         if (!bitmap->map)
1471                 return -ENOMEM;
1472
1473         bitmap->map_size = num_maps;
1474
1475         total = nr_cpu_ids;
1476         for (i = 0; i < num_maps; i++) {
1477                 bitmap->map[i].depth = min(total, bitmap->bits_per_word);
1478                 total -= bitmap->map[i].depth;
1479         }
1480
1481         return 0;
1482 }
1483
1484 static int blk_mq_hctx_cpu_offline(struct blk_mq_hw_ctx *hctx, int cpu)
1485 {
1486         struct request_queue *q = hctx->queue;
1487         struct blk_mq_ctx *ctx;
1488         LIST_HEAD(tmp);
1489
1490         /*
1491          * Move ctx entries to new CPU, if this one is going away.
1492          */
1493         ctx = __blk_mq_get_ctx(q, cpu);
1494
1495         spin_lock(&ctx->lock);
1496         if (!list_empty(&ctx->rq_list)) {
1497                 list_splice_init(&ctx->rq_list, &tmp);
1498                 blk_mq_hctx_clear_pending(hctx, ctx);
1499         }
1500         spin_unlock(&ctx->lock);
1501
1502         if (list_empty(&tmp))
1503                 return NOTIFY_OK;
1504
1505         ctx = blk_mq_get_ctx(q);
1506         spin_lock(&ctx->lock);
1507
1508         while (!list_empty(&tmp)) {
1509                 struct request *rq;
1510
1511                 rq = list_first_entry(&tmp, struct request, queuelist);
1512                 rq->mq_ctx = ctx;
1513                 list_move_tail(&rq->queuelist, &ctx->rq_list);
1514         }
1515
1516         hctx = q->mq_ops->map_queue(q, ctx->cpu);
1517         blk_mq_hctx_mark_pending(hctx, ctx);
1518
1519         spin_unlock(&ctx->lock);
1520
1521         blk_mq_run_hw_queue(hctx, true);
1522         blk_mq_put_ctx(ctx);
1523         return NOTIFY_OK;
1524 }
1525
1526 static int blk_mq_hctx_cpu_online(struct blk_mq_hw_ctx *hctx, int cpu)
1527 {
1528         struct request_queue *q = hctx->queue;
1529         struct blk_mq_tag_set *set = q->tag_set;
1530
1531         if (set->tags[hctx->queue_num])
1532                 return NOTIFY_OK;
1533
1534         set->tags[hctx->queue_num] = blk_mq_init_rq_map(set, hctx->queue_num);
1535         if (!set->tags[hctx->queue_num])
1536                 return NOTIFY_STOP;
1537
1538         hctx->tags = set->tags[hctx->queue_num];
1539         return NOTIFY_OK;
1540 }
1541
1542 static int blk_mq_hctx_notify(void *data, unsigned long action,
1543                               unsigned int cpu)
1544 {
1545         struct blk_mq_hw_ctx *hctx = data;
1546
1547         if (action == CPU_DEAD || action == CPU_DEAD_FROZEN)
1548                 return blk_mq_hctx_cpu_offline(hctx, cpu);
1549         else if (action == CPU_ONLINE || action == CPU_ONLINE_FROZEN)
1550                 return blk_mq_hctx_cpu_online(hctx, cpu);
1551
1552         return NOTIFY_OK;
1553 }
1554
1555 static void blk_mq_exit_hctx(struct request_queue *q,
1556                 struct blk_mq_tag_set *set,
1557                 struct blk_mq_hw_ctx *hctx, unsigned int hctx_idx)
1558 {
1559         unsigned flush_start_tag = set->queue_depth;
1560
1561         blk_mq_tag_idle(hctx);
1562
1563         if (set->ops->exit_request)
1564                 set->ops->exit_request(set->driver_data,
1565                                        hctx->fq->flush_rq, hctx_idx,
1566                                        flush_start_tag + hctx_idx);
1567
1568         if (set->ops->exit_hctx)
1569                 set->ops->exit_hctx(hctx, hctx_idx);
1570
1571         blk_mq_unregister_cpu_notifier(&hctx->cpu_notifier);
1572         blk_free_flush_queue(hctx->fq);
1573         kfree(hctx->ctxs);
1574         blk_mq_free_bitmap(&hctx->ctx_map);
1575 }
1576
1577 static void blk_mq_exit_hw_queues(struct request_queue *q,
1578                 struct blk_mq_tag_set *set, int nr_queue)
1579 {
1580         struct blk_mq_hw_ctx *hctx;
1581         unsigned int i;
1582
1583         queue_for_each_hw_ctx(q, hctx, i) {
1584                 if (i == nr_queue)
1585                         break;
1586                 blk_mq_exit_hctx(q, set, hctx, i);
1587         }
1588 }
1589
1590 static void blk_mq_free_hw_queues(struct request_queue *q,
1591                 struct blk_mq_tag_set *set)
1592 {
1593         struct blk_mq_hw_ctx *hctx;
1594         unsigned int i;
1595
1596         queue_for_each_hw_ctx(q, hctx, i) {
1597                 free_cpumask_var(hctx->cpumask);
1598                 kfree(hctx);
1599         }
1600 }
1601
1602 static int blk_mq_init_hctx(struct request_queue *q,
1603                 struct blk_mq_tag_set *set,
1604                 struct blk_mq_hw_ctx *hctx, unsigned hctx_idx)
1605 {
1606         int node;
1607         unsigned flush_start_tag = set->queue_depth;
1608
1609         node = hctx->numa_node;
1610         if (node == NUMA_NO_NODE)
1611                 node = hctx->numa_node = set->numa_node;
1612
1613         INIT_DELAYED_WORK(&hctx->run_work, blk_mq_run_work_fn);
1614         INIT_DELAYED_WORK(&hctx->delay_work, blk_mq_delay_work_fn);
1615         spin_lock_init(&hctx->lock);
1616         INIT_LIST_HEAD(&hctx->dispatch);
1617         hctx->queue = q;
1618         hctx->queue_num = hctx_idx;
1619         hctx->flags = set->flags;
1620         hctx->cmd_size = set->cmd_size;
1621
1622         blk_mq_init_cpu_notifier(&hctx->cpu_notifier,
1623                                         blk_mq_hctx_notify, hctx);
1624         blk_mq_register_cpu_notifier(&hctx->cpu_notifier);
1625
1626         hctx->tags = set->tags[hctx_idx];
1627
1628         /*
1629          * Allocate space for all possible cpus to avoid allocation at
1630          * runtime
1631          */
1632         hctx->ctxs = kmalloc_node(nr_cpu_ids * sizeof(void *),
1633                                         GFP_KERNEL, node);
1634         if (!hctx->ctxs)
1635                 goto unregister_cpu_notifier;
1636
1637         if (blk_mq_alloc_bitmap(&hctx->ctx_map, node))
1638                 goto free_ctxs;
1639
1640         hctx->nr_ctx = 0;
1641
1642         if (set->ops->init_hctx &&
1643             set->ops->init_hctx(hctx, set->driver_data, hctx_idx))
1644                 goto free_bitmap;
1645
1646         hctx->fq = blk_alloc_flush_queue(q, hctx->numa_node, set->cmd_size);
1647         if (!hctx->fq)
1648                 goto exit_hctx;
1649
1650         if (set->ops->init_request &&
1651             set->ops->init_request(set->driver_data,
1652                                    hctx->fq->flush_rq, hctx_idx,
1653                                    flush_start_tag + hctx_idx, node))
1654                 goto free_fq;
1655
1656         return 0;
1657
1658  free_fq:
1659         kfree(hctx->fq);
1660  exit_hctx:
1661         if (set->ops->exit_hctx)
1662                 set->ops->exit_hctx(hctx, hctx_idx);
1663  free_bitmap:
1664         blk_mq_free_bitmap(&hctx->ctx_map);
1665  free_ctxs:
1666         kfree(hctx->ctxs);
1667  unregister_cpu_notifier:
1668         blk_mq_unregister_cpu_notifier(&hctx->cpu_notifier);
1669
1670         return -1;
1671 }
1672
1673 static int blk_mq_init_hw_queues(struct request_queue *q,
1674                 struct blk_mq_tag_set *set)
1675 {
1676         struct blk_mq_hw_ctx *hctx;
1677         unsigned int i;
1678
1679         /*
1680          * Initialize hardware queues
1681          */
1682         queue_for_each_hw_ctx(q, hctx, i) {
1683                 if (blk_mq_init_hctx(q, set, hctx, i))
1684                         break;
1685         }
1686
1687         if (i == q->nr_hw_queues)
1688                 return 0;
1689
1690         /*
1691          * Init failed
1692          */
1693         blk_mq_exit_hw_queues(q, set, i);
1694
1695         return 1;
1696 }
1697
1698 static void blk_mq_init_cpu_queues(struct request_queue *q,
1699                                    unsigned int nr_hw_queues)
1700 {
1701         unsigned int i;
1702
1703         for_each_possible_cpu(i) {
1704                 struct blk_mq_ctx *__ctx = per_cpu_ptr(q->queue_ctx, i);
1705                 struct blk_mq_hw_ctx *hctx;
1706
1707                 memset(__ctx, 0, sizeof(*__ctx));
1708                 __ctx->cpu = i;
1709                 spin_lock_init(&__ctx->lock);
1710                 INIT_LIST_HEAD(&__ctx->rq_list);
1711                 __ctx->queue = q;
1712
1713                 /* If the cpu isn't online, the cpu is mapped to first hctx */
1714                 if (!cpu_online(i))
1715                         continue;
1716
1717                 hctx = q->mq_ops->map_queue(q, i);
1718                 cpumask_set_cpu(i, hctx->cpumask);
1719                 hctx->nr_ctx++;
1720
1721                 /*
1722                  * Set local node, IFF we have more than one hw queue. If
1723                  * not, we remain on the home node of the device
1724                  */
1725                 if (nr_hw_queues > 1 && hctx->numa_node == NUMA_NO_NODE)
1726                         hctx->numa_node = cpu_to_node(i);
1727         }
1728 }
1729
1730 static void blk_mq_map_swqueue(struct request_queue *q)
1731 {
1732         unsigned int i;
1733         struct blk_mq_hw_ctx *hctx;
1734         struct blk_mq_ctx *ctx;
1735
1736         queue_for_each_hw_ctx(q, hctx, i) {
1737                 cpumask_clear(hctx->cpumask);
1738                 hctx->nr_ctx = 0;
1739         }
1740
1741         /*
1742          * Map software to hardware queues
1743          */
1744         queue_for_each_ctx(q, ctx, i) {
1745                 /* If the cpu isn't online, the cpu is mapped to first hctx */
1746                 if (!cpu_online(i))
1747                         continue;
1748
1749                 hctx = q->mq_ops->map_queue(q, i);
1750                 cpumask_set_cpu(i, hctx->cpumask);
1751                 ctx->index_hw = hctx->nr_ctx;
1752                 hctx->ctxs[hctx->nr_ctx++] = ctx;
1753         }
1754
1755         queue_for_each_hw_ctx(q, hctx, i) {
1756                 /*
1757                  * If no software queues are mapped to this hardware queue,
1758                  * disable it and free the request entries.
1759                  */
1760                 if (!hctx->nr_ctx) {
1761                         struct blk_mq_tag_set *set = q->tag_set;
1762
1763                         if (set->tags[i]) {
1764                                 blk_mq_free_rq_map(set, set->tags[i], i);
1765                                 set->tags[i] = NULL;
1766                                 hctx->tags = NULL;
1767                         }
1768                         continue;
1769                 }
1770
1771                 /*
1772                  * Initialize batch roundrobin counts
1773                  */
1774                 hctx->next_cpu = cpumask_first(hctx->cpumask);
1775                 hctx->next_cpu_batch = BLK_MQ_CPU_WORK_BATCH;
1776         }
1777 }
1778
1779 static void blk_mq_update_tag_set_depth(struct blk_mq_tag_set *set)
1780 {
1781         struct blk_mq_hw_ctx *hctx;
1782         struct request_queue *q;
1783         bool shared;
1784         int i;
1785
1786         if (set->tag_list.next == set->tag_list.prev)
1787                 shared = false;
1788         else
1789                 shared = true;
1790
1791         list_for_each_entry(q, &set->tag_list, tag_set_list) {
1792                 blk_mq_freeze_queue(q);
1793
1794                 queue_for_each_hw_ctx(q, hctx, i) {
1795                         if (shared)
1796                                 hctx->flags |= BLK_MQ_F_TAG_SHARED;
1797                         else
1798                                 hctx->flags &= ~BLK_MQ_F_TAG_SHARED;
1799                 }
1800                 blk_mq_unfreeze_queue(q);
1801         }
1802 }
1803
1804 static void blk_mq_del_queue_tag_set(struct request_queue *q)
1805 {
1806         struct blk_mq_tag_set *set = q->tag_set;
1807
1808         mutex_lock(&set->tag_list_lock);
1809         list_del_init(&q->tag_set_list);
1810         blk_mq_update_tag_set_depth(set);
1811         mutex_unlock(&set->tag_list_lock);
1812 }
1813
1814 static void blk_mq_add_queue_tag_set(struct blk_mq_tag_set *set,
1815                                      struct request_queue *q)
1816 {
1817         q->tag_set = set;
1818
1819         mutex_lock(&set->tag_list_lock);
1820         list_add_tail(&q->tag_set_list, &set->tag_list);
1821         blk_mq_update_tag_set_depth(set);
1822         mutex_unlock(&set->tag_list_lock);
1823 }
1824
1825 struct request_queue *blk_mq_init_queue(struct blk_mq_tag_set *set)
1826 {
1827         struct blk_mq_hw_ctx **hctxs;
1828         struct blk_mq_ctx __percpu *ctx;
1829         struct request_queue *q;
1830         unsigned int *map;
1831         int i;
1832
1833         ctx = alloc_percpu(struct blk_mq_ctx);
1834         if (!ctx)
1835                 return ERR_PTR(-ENOMEM);
1836
1837         hctxs = kmalloc_node(set->nr_hw_queues * sizeof(*hctxs), GFP_KERNEL,
1838                         set->numa_node);
1839
1840         if (!hctxs)
1841                 goto err_percpu;
1842
1843         map = blk_mq_make_queue_map(set);
1844         if (!map)
1845                 goto err_map;
1846
1847         for (i = 0; i < set->nr_hw_queues; i++) {
1848                 int node = blk_mq_hw_queue_to_node(map, i);
1849
1850                 hctxs[i] = kzalloc_node(sizeof(struct blk_mq_hw_ctx),
1851                                         GFP_KERNEL, node);
1852                 if (!hctxs[i])
1853                         goto err_hctxs;
1854
1855                 if (!zalloc_cpumask_var_node(&hctxs[i]->cpumask, GFP_KERNEL,
1856                                                 node))
1857                         goto err_hctxs;
1858
1859                 atomic_set(&hctxs[i]->nr_active, 0);
1860                 hctxs[i]->numa_node = node;
1861                 hctxs[i]->queue_num = i;
1862         }
1863
1864         q = blk_alloc_queue_node(GFP_KERNEL, set->numa_node);
1865         if (!q)
1866                 goto err_hctxs;
1867
1868         /*
1869          * Init percpu_ref in atomic mode so that it's faster to shutdown.
1870          * See blk_register_queue() for details.
1871          */
1872         if (percpu_ref_init(&q->mq_usage_counter, blk_mq_usage_counter_release,
1873                             PERCPU_REF_INIT_ATOMIC, GFP_KERNEL))
1874                 goto err_map;
1875
1876         setup_timer(&q->timeout, blk_mq_rq_timer, (unsigned long) q);
1877         blk_queue_rq_timeout(q, 30000);
1878
1879         q->nr_queues = nr_cpu_ids;
1880         q->nr_hw_queues = set->nr_hw_queues;
1881         q->mq_map = map;
1882
1883         q->queue_ctx = ctx;
1884         q->queue_hw_ctx = hctxs;
1885
1886         q->mq_ops = set->ops;
1887         q->queue_flags |= QUEUE_FLAG_MQ_DEFAULT;
1888
1889         if (!(set->flags & BLK_MQ_F_SG_MERGE))
1890                 q->queue_flags |= 1 << QUEUE_FLAG_NO_SG_MERGE;
1891
1892         q->sg_reserved_size = INT_MAX;
1893
1894         INIT_WORK(&q->requeue_work, blk_mq_requeue_work);
1895         INIT_LIST_HEAD(&q->requeue_list);
1896         spin_lock_init(&q->requeue_lock);
1897
1898         if (q->nr_hw_queues > 1)
1899                 blk_queue_make_request(q, blk_mq_make_request);
1900         else
1901                 blk_queue_make_request(q, blk_sq_make_request);
1902
1903         if (set->timeout)
1904                 blk_queue_rq_timeout(q, set->timeout);
1905
1906         /*
1907          * Do this after blk_queue_make_request() overrides it...
1908          */
1909         q->nr_requests = set->queue_depth;
1910
1911         if (set->ops->complete)
1912                 blk_queue_softirq_done(q, set->ops->complete);
1913
1914         blk_mq_init_cpu_queues(q, set->nr_hw_queues);
1915
1916         if (blk_mq_init_hw_queues(q, set))
1917                 goto err_hw;
1918
1919         mutex_lock(&all_q_mutex);
1920         list_add_tail(&q->all_q_node, &all_q_list);
1921         mutex_unlock(&all_q_mutex);
1922
1923         blk_mq_add_queue_tag_set(set, q);
1924
1925         blk_mq_map_swqueue(q);
1926
1927         return q;
1928
1929 err_hw:
1930         blk_cleanup_queue(q);
1931 err_hctxs:
1932         kfree(map);
1933         for (i = 0; i < set->nr_hw_queues; i++) {
1934                 if (!hctxs[i])
1935                         break;
1936                 free_cpumask_var(hctxs[i]->cpumask);
1937                 kfree(hctxs[i]);
1938         }
1939 err_map:
1940         kfree(hctxs);
1941 err_percpu:
1942         free_percpu(ctx);
1943         return ERR_PTR(-ENOMEM);
1944 }
1945 EXPORT_SYMBOL(blk_mq_init_queue);
1946
1947 void blk_mq_free_queue(struct request_queue *q)
1948 {
1949         struct blk_mq_tag_set   *set = q->tag_set;
1950
1951         blk_mq_del_queue_tag_set(q);
1952
1953         blk_mq_exit_hw_queues(q, set, set->nr_hw_queues);
1954         blk_mq_free_hw_queues(q, set);
1955
1956         percpu_ref_exit(&q->mq_usage_counter);
1957
1958         free_percpu(q->queue_ctx);
1959         kfree(q->queue_hw_ctx);
1960         kfree(q->mq_map);
1961
1962         q->queue_ctx = NULL;
1963         q->queue_hw_ctx = NULL;
1964         q->mq_map = NULL;
1965
1966         mutex_lock(&all_q_mutex);
1967         list_del_init(&q->all_q_node);
1968         mutex_unlock(&all_q_mutex);
1969 }
1970
1971 /* Basically redo blk_mq_init_queue with queue frozen */
1972 static void blk_mq_queue_reinit(struct request_queue *q)
1973 {
1974         WARN_ON_ONCE(!q->mq_freeze_depth);
1975
1976         blk_mq_sysfs_unregister(q);
1977
1978         blk_mq_update_queue_map(q->mq_map, q->nr_hw_queues);
1979
1980         /*
1981          * redo blk_mq_init_cpu_queues and blk_mq_init_hw_queues. FIXME: maybe
1982          * we should change hctx numa_node according to new topology (this
1983          * involves free and re-allocate memory, worthy doing?)
1984          */
1985
1986         blk_mq_map_swqueue(q);
1987
1988         blk_mq_sysfs_register(q);
1989 }
1990
1991 static int blk_mq_queue_reinit_notify(struct notifier_block *nb,
1992                                       unsigned long action, void *hcpu)
1993 {
1994         struct request_queue *q;
1995
1996         /*
1997          * Before new mappings are established, hotadded cpu might already
1998          * start handling requests. This doesn't break anything as we map
1999          * offline CPUs to first hardware queue. We will re-init the queue
2000          * below to get optimal settings.
2001          */
2002         if (action != CPU_DEAD && action != CPU_DEAD_FROZEN &&
2003             action != CPU_ONLINE && action != CPU_ONLINE_FROZEN)
2004                 return NOTIFY_OK;
2005
2006         mutex_lock(&all_q_mutex);
2007
2008         /*
2009          * We need to freeze and reinit all existing queues.  Freezing
2010          * involves synchronous wait for an RCU grace period and doing it
2011          * one by one may take a long time.  Start freezing all queues in
2012          * one swoop and then wait for the completions so that freezing can
2013          * take place in parallel.
2014          */
2015         list_for_each_entry(q, &all_q_list, all_q_node)
2016                 blk_mq_freeze_queue_start(q);
2017         list_for_each_entry(q, &all_q_list, all_q_node)
2018                 blk_mq_freeze_queue_wait(q);
2019
2020         list_for_each_entry(q, &all_q_list, all_q_node)
2021                 blk_mq_queue_reinit(q);
2022
2023         list_for_each_entry(q, &all_q_list, all_q_node)
2024                 blk_mq_unfreeze_queue(q);
2025
2026         mutex_unlock(&all_q_mutex);
2027         return NOTIFY_OK;
2028 }
2029
2030 static int __blk_mq_alloc_rq_maps(struct blk_mq_tag_set *set)
2031 {
2032         int i;
2033
2034         for (i = 0; i < set->nr_hw_queues; i++) {
2035                 set->tags[i] = blk_mq_init_rq_map(set, i);
2036                 if (!set->tags[i])
2037                         goto out_unwind;
2038         }
2039
2040         return 0;
2041
2042 out_unwind:
2043         while (--i >= 0)
2044                 blk_mq_free_rq_map(set, set->tags[i], i);
2045
2046         return -ENOMEM;
2047 }
2048
2049 /*
2050  * Allocate the request maps associated with this tag_set. Note that this
2051  * may reduce the depth asked for, if memory is tight. set->queue_depth
2052  * will be updated to reflect the allocated depth.
2053  */
2054 static int blk_mq_alloc_rq_maps(struct blk_mq_tag_set *set)
2055 {
2056         unsigned int depth;
2057         int err;
2058
2059         depth = set->queue_depth;
2060         do {
2061                 err = __blk_mq_alloc_rq_maps(set);
2062                 if (!err)
2063                         break;
2064
2065                 set->queue_depth >>= 1;
2066                 if (set->queue_depth < set->reserved_tags + BLK_MQ_TAG_MIN) {
2067                         err = -ENOMEM;
2068                         break;
2069                 }
2070         } while (set->queue_depth);
2071
2072         if (!set->queue_depth || err) {
2073                 pr_err("blk-mq: failed to allocate request map\n");
2074                 return -ENOMEM;
2075         }
2076
2077         if (depth != set->queue_depth)
2078                 pr_info("blk-mq: reduced tag depth (%u -> %u)\n",
2079                                                 depth, set->queue_depth);
2080
2081         return 0;
2082 }
2083
2084 /*
2085  * Alloc a tag set to be associated with one or more request queues.
2086  * May fail with EINVAL for various error conditions. May adjust the
2087  * requested depth down, if if it too large. In that case, the set
2088  * value will be stored in set->queue_depth.
2089  */
2090 int blk_mq_alloc_tag_set(struct blk_mq_tag_set *set)
2091 {
2092         BUILD_BUG_ON(BLK_MQ_MAX_DEPTH > 1 << BLK_MQ_UNIQUE_TAG_BITS);
2093
2094         if (!set->nr_hw_queues)
2095                 return -EINVAL;
2096         if (!set->queue_depth)
2097                 return -EINVAL;
2098         if (set->queue_depth < set->reserved_tags + BLK_MQ_TAG_MIN)
2099                 return -EINVAL;
2100
2101         if (!set->nr_hw_queues || !set->ops->queue_rq || !set->ops->map_queue)
2102                 return -EINVAL;
2103
2104         if (set->queue_depth > BLK_MQ_MAX_DEPTH) {
2105                 pr_info("blk-mq: reduced tag depth to %u\n",
2106                         BLK_MQ_MAX_DEPTH);
2107                 set->queue_depth = BLK_MQ_MAX_DEPTH;
2108         }
2109
2110         /*
2111          * If a crashdump is active, then we are potentially in a very
2112          * memory constrained environment. Limit us to 1 queue and
2113          * 64 tags to prevent using too much memory.
2114          */
2115         if (is_kdump_kernel()) {
2116                 set->nr_hw_queues = 1;
2117                 set->queue_depth = min(64U, set->queue_depth);
2118         }
2119
2120         set->tags = kmalloc_node(set->nr_hw_queues *
2121                                  sizeof(struct blk_mq_tags *),
2122                                  GFP_KERNEL, set->numa_node);
2123         if (!set->tags)
2124                 return -ENOMEM;
2125
2126         if (blk_mq_alloc_rq_maps(set))
2127                 goto enomem;
2128
2129         mutex_init(&set->tag_list_lock);
2130         INIT_LIST_HEAD(&set->tag_list);
2131
2132         return 0;
2133 enomem:
2134         kfree(set->tags);
2135         set->tags = NULL;
2136         return -ENOMEM;
2137 }
2138 EXPORT_SYMBOL(blk_mq_alloc_tag_set);
2139
2140 void blk_mq_free_tag_set(struct blk_mq_tag_set *set)
2141 {
2142         int i;
2143
2144         for (i = 0; i < set->nr_hw_queues; i++) {
2145                 if (set->tags[i])
2146                         blk_mq_free_rq_map(set, set->tags[i], i);
2147         }
2148
2149         kfree(set->tags);
2150         set->tags = NULL;
2151 }
2152 EXPORT_SYMBOL(blk_mq_free_tag_set);
2153
2154 int blk_mq_update_nr_requests(struct request_queue *q, unsigned int nr)
2155 {
2156         struct blk_mq_tag_set *set = q->tag_set;
2157         struct blk_mq_hw_ctx *hctx;
2158         int i, ret;
2159
2160         if (!set || nr > set->queue_depth)
2161                 return -EINVAL;
2162
2163         ret = 0;
2164         queue_for_each_hw_ctx(q, hctx, i) {
2165                 ret = blk_mq_tag_update_depth(hctx->tags, nr);
2166                 if (ret)
2167                         break;
2168         }
2169
2170         if (!ret)
2171                 q->nr_requests = nr;
2172
2173         return ret;
2174 }
2175
2176 void blk_mq_disable_hotplug(void)
2177 {
2178         mutex_lock(&all_q_mutex);
2179 }
2180
2181 void blk_mq_enable_hotplug(void)
2182 {
2183         mutex_unlock(&all_q_mutex);
2184 }
2185
2186 static int __init blk_mq_init(void)
2187 {
2188         blk_mq_cpu_init();
2189
2190         hotcpu_notifier(blk_mq_queue_reinit_notify, 0);
2191
2192         return 0;
2193 }
2194 subsys_initcall(blk_mq_init);