blk-mq.c 70.6 KB
Newer Older
1 2 3 4 5 6
/*
 * Block multiqueue core code
 *
 * Copyright (C) 2013-2014 Jens Axboe
 * Copyright (C) 2013-2014 Christoph Hellwig
 */
7 8 9 10 11
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/backing-dev.h>
#include <linux/bio.h>
#include <linux/blkdev.h>
12
#include <linux/kmemleak.h>
13 14 15 16 17 18 19 20 21 22
#include <linux/mm.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/workqueue.h>
#include <linux/smp.h>
#include <linux/llist.h>
#include <linux/list_sort.h>
#include <linux/cpu.h>
#include <linux/cache.h>
#include <linux/sched/sysctl.h>
23
#include <linux/sched/topology.h>
24
#include <linux/sched/signal.h>
25
#include <linux/delay.h>
26
#include <linux/crash_dump.h>
27
#include <linux/prefetch.h>
28 29 30 31 32 33

#include <trace/events/block.h>

#include <linux/blk-mq.h>
#include "blk.h"
#include "blk-mq.h"
34
#include "blk-mq-debugfs.h"
35
#include "blk-mq-tag.h"
36
#include "blk-stat.h"
J
Jens Axboe 已提交
37
#include "blk-wbt.h"
38
#include "blk-mq-sched.h"
39 40 41 42

static DEFINE_MUTEX(all_q_mutex);
static LIST_HEAD(all_q_list);

43 44
static void blk_mq_poll_stats_start(struct request_queue *q);
static void blk_mq_poll_stats_fn(struct blk_stat_callback *cb);
45
static void __blk_mq_stop_hw_queues(struct request_queue *q, bool sync);
46

47 48 49 50
static int blk_mq_poll_stats_bkt(const struct request *rq)
{
	int ddir, bytes, bucket;

J
Jens Axboe 已提交
51
	ddir = rq_data_dir(rq);
52 53 54 55 56 57 58 59 60 61 62 63
	bytes = blk_rq_bytes(rq);

	bucket = ddir + 2*(ilog2(bytes) - 9);

	if (bucket < 0)
		return -1;
	else if (bucket >= BLK_MQ_POLL_STATS_BKTS)
		return ddir + BLK_MQ_POLL_STATS_BKTS - 2;

	return bucket;
}

64 65 66
/*
 * Check if any of the ctx's have pending work in this hardware queue
 */
67
bool blk_mq_hctx_has_pending(struct blk_mq_hw_ctx *hctx)
68
{
69 70 71
	return sbitmap_any_bit_set(&hctx->ctx_map) ||
			!list_empty_careful(&hctx->dispatch) ||
			blk_mq_sched_has_work(hctx);
72 73
}

74 75 76 77 78 79
/*
 * Mark this ctx as having pending work in this hardware queue
 */
static void blk_mq_hctx_mark_pending(struct blk_mq_hw_ctx *hctx,
				     struct blk_mq_ctx *ctx)
{
80 81
	if (!sbitmap_test_bit(&hctx->ctx_map, ctx->index_hw))
		sbitmap_set_bit(&hctx->ctx_map, ctx->index_hw);
82 83 84 85 86
}

static void blk_mq_hctx_clear_pending(struct blk_mq_hw_ctx *hctx,
				      struct blk_mq_ctx *ctx)
{
87
	sbitmap_clear_bit(&hctx->ctx_map, ctx->index_hw);
88 89
}

90
void blk_freeze_queue_start(struct request_queue *q)
91
{
92
	int freeze_depth;
93

94 95
	freeze_depth = atomic_inc_return(&q->mq_freeze_depth);
	if (freeze_depth == 1) {
96
		percpu_ref_kill(&q->q_usage_counter);
97
		blk_mq_run_hw_queues(q, false);
98
	}
99
}
100
EXPORT_SYMBOL_GPL(blk_freeze_queue_start);
101

102
void blk_mq_freeze_queue_wait(struct request_queue *q)
103
{
104
	wait_event(q->mq_freeze_wq, percpu_ref_is_zero(&q->q_usage_counter));
105
}
106
EXPORT_SYMBOL_GPL(blk_mq_freeze_queue_wait);
107

108 109 110 111 112 113 114 115
int blk_mq_freeze_queue_wait_timeout(struct request_queue *q,
				     unsigned long timeout)
{
	return wait_event_timeout(q->mq_freeze_wq,
					percpu_ref_is_zero(&q->q_usage_counter),
					timeout);
}
EXPORT_SYMBOL_GPL(blk_mq_freeze_queue_wait_timeout);
116

117 118 119 120
/*
 * Guarantee no request is in use, so we can change any data structure of
 * the queue afterward.
 */
121
void blk_freeze_queue(struct request_queue *q)
122
{
123 124 125 126 127 128 129
	/*
	 * In the !blk_mq case we are only calling this to kill the
	 * q_usage_counter, otherwise this increases the freeze depth
	 * and waits for it to return to zero.  For this reason there is
	 * no blk_unfreeze_queue(), and blk_freeze_queue() is not
	 * exported to drivers as the only user for unfreeze is blk_mq.
	 */
130
	blk_freeze_queue_start(q);
131 132
	blk_mq_freeze_queue_wait(q);
}
133 134 135 136 137 138 139 140 141

void blk_mq_freeze_queue(struct request_queue *q)
{
	/*
	 * ...just an alias to keep freeze and unfreeze actions balanced
	 * in the blk_mq_* namespace
	 */
	blk_freeze_queue(q);
}
142
EXPORT_SYMBOL_GPL(blk_mq_freeze_queue);
143

144
void blk_mq_unfreeze_queue(struct request_queue *q)
145
{
146
	int freeze_depth;
147

148 149 150
	freeze_depth = atomic_dec_return(&q->mq_freeze_depth);
	WARN_ON_ONCE(freeze_depth < 0);
	if (!freeze_depth) {
151
		percpu_ref_reinit(&q->q_usage_counter);
152
		wake_up_all(&q->mq_freeze_wq);
153
	}
154
}
155
EXPORT_SYMBOL_GPL(blk_mq_unfreeze_queue);
156

157 158 159 160 161 162 163 164 165 166 167 168 169 170
/**
 * blk_mq_quiesce_queue() - wait until all ongoing queue_rq calls have finished
 * @q: request queue.
 *
 * Note: this function does not prevent that the struct request end_io()
 * callback function is invoked. Additionally, it is not prevented that
 * new queue_rq() calls occur unless the queue has been stopped first.
 */
void blk_mq_quiesce_queue(struct request_queue *q)
{
	struct blk_mq_hw_ctx *hctx;
	unsigned int i;
	bool rcu = false;

171
	__blk_mq_stop_hw_queues(q, true);
172 173 174 175 176 177 178 179 180 181 182 183

	queue_for_each_hw_ctx(q, hctx, i) {
		if (hctx->flags & BLK_MQ_F_BLOCKING)
			synchronize_srcu(&hctx->queue_rq_srcu);
		else
			rcu = true;
	}
	if (rcu)
		synchronize_rcu();
}
EXPORT_SYMBOL_GPL(blk_mq_quiesce_queue);

184 185 186 187 188 189 190 191
void blk_mq_wake_waiters(struct request_queue *q)
{
	struct blk_mq_hw_ctx *hctx;
	unsigned int i;

	queue_for_each_hw_ctx(q, hctx, i)
		if (blk_mq_hw_queue_mapped(hctx))
			blk_mq_tag_wakeup_all(hctx->tags, true);
192 193 194 195 196 197 198

	/*
	 * If we are called because the queue has now been marked as
	 * dying, we need to ensure that processes currently waiting on
	 * the queue are notified as well.
	 */
	wake_up_all(&q->mq_freeze_wq);
199 200
}

201 202 203 204 205 206
bool blk_mq_can_queue(struct blk_mq_hw_ctx *hctx)
{
	return blk_mq_has_free_tags(hctx->tags);
}
EXPORT_SYMBOL(blk_mq_can_queue);

207 208
void blk_mq_rq_ctx_init(struct request_queue *q, struct blk_mq_ctx *ctx,
			struct request *rq, unsigned int op)
209
{
210 211 212
	INIT_LIST_HEAD(&rq->queuelist);
	/* csd/requeue_work/fifo_time is initialized before use */
	rq->q = q;
213
	rq->mq_ctx = ctx;
214
	rq->cmd_flags = op;
215 216
	if (blk_queue_io_stat(q))
		rq->rq_flags |= RQF_IO_STAT;
217 218 219 220 221 222
	/* do not touch atomic flags, it needs atomic ops against the timer */
	rq->cpu = -1;
	INIT_HLIST_NODE(&rq->hash);
	RB_CLEAR_NODE(&rq->rb_node);
	rq->rq_disk = NULL;
	rq->part = NULL;
223
	rq->start_time = jiffies;
224 225
#ifdef CONFIG_BLK_CGROUP
	rq->rl = NULL;
226
	set_start_time_ns(rq);
227 228 229 230 231 232 233 234 235 236 237
	rq->io_start_time_ns = 0;
#endif
	rq->nr_phys_segments = 0;
#if defined(CONFIG_BLK_DEV_INTEGRITY)
	rq->nr_integrity_segments = 0;
#endif
	rq->special = NULL;
	/* tag was already set */
	rq->extra_len = 0;

	INIT_LIST_HEAD(&rq->timeout_list);
238 239
	rq->timeout = 0;

240 241 242 243
	rq->end_io = NULL;
	rq->end_io_data = NULL;
	rq->next_rq = NULL;

244
	ctx->rq_dispatched[op_is_sync(op)]++;
245
}
246
EXPORT_SYMBOL_GPL(blk_mq_rq_ctx_init);
247

248 249
struct request *__blk_mq_alloc_request(struct blk_mq_alloc_data *data,
				       unsigned int op)
250 251 252 253
{
	struct request *rq;
	unsigned int tag;

254
	tag = blk_mq_get_tag(data);
255
	if (tag != BLK_MQ_TAG_FAIL) {
256 257 258
		struct blk_mq_tags *tags = blk_mq_tags_from_data(data);

		rq = tags->static_rqs[tag];
259

260 261 262 263
		if (data->flags & BLK_MQ_REQ_INTERNAL) {
			rq->tag = -1;
			rq->internal_tag = tag;
		} else {
264 265 266 267
			if (blk_mq_tag_busy(data->hctx)) {
				rq->rq_flags = RQF_MQ_INFLIGHT;
				atomic_inc(&data->hctx->nr_active);
			}
268 269
			rq->tag = tag;
			rq->internal_tag = -1;
270
			data->hctx->tags->rqs[rq->tag] = rq;
271 272
		}

273
		blk_mq_rq_ctx_init(data->q, data->ctx, rq, op);
274 275 276 277 278
		return rq;
	}

	return NULL;
}
279
EXPORT_SYMBOL_GPL(__blk_mq_alloc_request);
280

281 282
struct request *blk_mq_alloc_request(struct request_queue *q, int rw,
		unsigned int flags)
283
{
284
	struct blk_mq_alloc_data alloc_data = { .flags = flags };
285
	struct request *rq;
286
	int ret;
287

288
	ret = blk_queue_enter(q, flags & BLK_MQ_REQ_NOWAIT);
289 290
	if (ret)
		return ERR_PTR(ret);
291

292
	rq = blk_mq_sched_get_request(q, NULL, rw, &alloc_data);
293

294 295 296 297
	blk_mq_put_ctx(alloc_data.ctx);
	blk_queue_exit(q);

	if (!rq)
298
		return ERR_PTR(-EWOULDBLOCK);
299 300 301 302

	rq->__data_len = 0;
	rq->__sector = (sector_t) -1;
	rq->bio = rq->biotail = NULL;
303 304
	return rq;
}
305
EXPORT_SYMBOL(blk_mq_alloc_request);
306

M
Ming Lin 已提交
307 308 309
struct request *blk_mq_alloc_request_hctx(struct request_queue *q, int rw,
		unsigned int flags, unsigned int hctx_idx)
{
310
	struct blk_mq_alloc_data alloc_data = { .flags = flags };
M
Ming Lin 已提交
311
	struct request *rq;
312
	unsigned int cpu;
M
Ming Lin 已提交
313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
	int ret;

	/*
	 * If the tag allocator sleeps we could get an allocation for a
	 * different hardware context.  No need to complicate the low level
	 * allocator for this for the rare use case of a command tied to
	 * a specific queue.
	 */
	if (WARN_ON_ONCE(!(flags & BLK_MQ_REQ_NOWAIT)))
		return ERR_PTR(-EINVAL);

	if (hctx_idx >= q->nr_hw_queues)
		return ERR_PTR(-EIO);

	ret = blk_queue_enter(q, true);
	if (ret)
		return ERR_PTR(ret);

331 332 333 334
	/*
	 * Check if the hardware context is actually mapped to anything.
	 * If not tell the caller that it should skip this queue.
	 */
335 336 337 338
	alloc_data.hctx = q->queue_hw_ctx[hctx_idx];
	if (!blk_mq_hw_queue_mapped(alloc_data.hctx)) {
		blk_queue_exit(q);
		return ERR_PTR(-EXDEV);
339
	}
340 341
	cpu = cpumask_first(alloc_data.hctx->cpumask);
	alloc_data.ctx = __blk_mq_get_ctx(q, cpu);
M
Ming Lin 已提交
342

343
	rq = blk_mq_sched_get_request(q, NULL, rw, &alloc_data);
344 345

	blk_queue_exit(q);
346 347 348 349 350

	if (!rq)
		return ERR_PTR(-EWOULDBLOCK);

	return rq;
M
Ming Lin 已提交
351 352 353
}
EXPORT_SYMBOL_GPL(blk_mq_alloc_request_hctx);

354 355
void __blk_mq_finish_request(struct blk_mq_hw_ctx *hctx, struct blk_mq_ctx *ctx,
			     struct request *rq)
356
{
357
	const int sched_tag = rq->internal_tag;
358 359
	struct request_queue *q = rq->q;

360
	if (rq->rq_flags & RQF_MQ_INFLIGHT)
361
		atomic_dec(&hctx->nr_active);
J
Jens Axboe 已提交
362 363

	wbt_done(q->rq_wb, &rq->issue_stat);
364
	rq->rq_flags = 0;
365

366
	clear_bit(REQ_ATOM_STARTED, &rq->atomic_flags);
367
	clear_bit(REQ_ATOM_POLL_SLEPT, &rq->atomic_flags);
368 369 370
	if (rq->tag != -1)
		blk_mq_put_tag(hctx, hctx->tags, ctx, rq->tag);
	if (sched_tag != -1)
371
		blk_mq_put_tag(hctx, hctx->sched_tags, ctx, sched_tag);
372
	blk_mq_sched_restart(hctx);
373
	blk_queue_exit(q);
374 375
}

376
static void blk_mq_finish_hctx_request(struct blk_mq_hw_ctx *hctx,
377
				     struct request *rq)
378 379 380 381
{
	struct blk_mq_ctx *ctx = rq->mq_ctx;

	ctx->rq_completed[rq_is_sync(rq)]++;
382 383 384 385 386 387
	__blk_mq_finish_request(hctx, ctx, rq);
}

void blk_mq_finish_request(struct request *rq)
{
	blk_mq_finish_hctx_request(blk_mq_map_queue(rq->q, rq->mq_ctx->cpu), rq);
388
}
O
Omar Sandoval 已提交
389
EXPORT_SYMBOL_GPL(blk_mq_finish_request);
390 391 392

void blk_mq_free_request(struct request *rq)
{
393
	blk_mq_sched_put_request(rq);
394
}
J
Jens Axboe 已提交
395
EXPORT_SYMBOL_GPL(blk_mq_free_request);
396

397
inline void __blk_mq_end_request(struct request *rq, int error)
398
{
M
Ming Lei 已提交
399 400
	blk_account_io_done(rq);

C
Christoph Hellwig 已提交
401
	if (rq->end_io) {
J
Jens Axboe 已提交
402
		wbt_done(rq->q->rq_wb, &rq->issue_stat);
403
		rq->end_io(rq, error);
C
Christoph Hellwig 已提交
404 405 406
	} else {
		if (unlikely(blk_bidi_rq(rq)))
			blk_mq_free_request(rq->next_rq);
407
		blk_mq_free_request(rq);
C
Christoph Hellwig 已提交
408
	}
409
}
410
EXPORT_SYMBOL(__blk_mq_end_request);
411

412
void blk_mq_end_request(struct request *rq, int error)
413 414 415
{
	if (blk_update_request(rq, error, blk_rq_bytes(rq)))
		BUG();
416
	__blk_mq_end_request(rq, error);
417
}
418
EXPORT_SYMBOL(blk_mq_end_request);
419

420
static void __blk_mq_complete_request_remote(void *data)
421
{
422
	struct request *rq = data;
423

424
	rq->q->softirq_done_fn(rq);
425 426
}

427
static void __blk_mq_complete_request(struct request *rq)
428 429
{
	struct blk_mq_ctx *ctx = rq->mq_ctx;
C
Christoph Hellwig 已提交
430
	bool shared = false;
431 432
	int cpu;

433 434 435 436 437 438 439
	if (rq->internal_tag != -1)
		blk_mq_sched_completed_request(rq);
	if (rq->rq_flags & RQF_STATS) {
		blk_mq_poll_stats_start(rq->q);
		blk_stat_add(rq);
	}

C
Christoph Hellwig 已提交
440
	if (!test_bit(QUEUE_FLAG_SAME_COMP, &rq->q->queue_flags)) {
441 442 443
		rq->q->softirq_done_fn(rq);
		return;
	}
444 445

	cpu = get_cpu();
C
Christoph Hellwig 已提交
446 447 448 449
	if (!test_bit(QUEUE_FLAG_SAME_FORCE, &rq->q->queue_flags))
		shared = cpus_share_cache(cpu, ctx->cpu);

	if (cpu != ctx->cpu && !shared && cpu_online(ctx->cpu)) {
450
		rq->csd.func = __blk_mq_complete_request_remote;
451 452
		rq->csd.info = rq;
		rq->csd.flags = 0;
453
		smp_call_function_single_async(ctx->cpu, &rq->csd);
454
	} else {
455
		rq->q->softirq_done_fn(rq);
456
	}
457 458
	put_cpu();
}
459 460 461 462 463 464 465 466 467

/**
 * blk_mq_complete_request - end I/O on a request
 * @rq:		the request being processed
 *
 * Description:
 *	Ends all I/O on a request. It does not handle partial completions.
 *	The actual completion happens out-of-order, through a IPI handler.
 **/
468
void blk_mq_complete_request(struct request *rq)
469
{
470 471 472
	struct request_queue *q = rq->q;

	if (unlikely(blk_should_fake_timeout(q)))
473
		return;
474
	if (!blk_mark_rq_complete(rq))
475
		__blk_mq_complete_request(rq);
476 477
}
EXPORT_SYMBOL(blk_mq_complete_request);
478

479 480 481 482 483 484
int blk_mq_request_started(struct request *rq)
{
	return test_bit(REQ_ATOM_STARTED, &rq->atomic_flags);
}
EXPORT_SYMBOL_GPL(blk_mq_request_started);

485
void blk_mq_start_request(struct request *rq)
486 487 488
{
	struct request_queue *q = rq->q;

489 490
	blk_mq_sched_started_request(rq);

491 492
	trace_block_rq_issue(q, rq);

493
	if (test_bit(QUEUE_FLAG_STATS, &q->queue_flags)) {
494
		blk_stat_set_issue(&rq->issue_stat, blk_rq_sectors(rq));
495
		rq->rq_flags |= RQF_STATS;
J
Jens Axboe 已提交
496
		wbt_issue(q->rq_wb, &rq->issue_stat);
497 498
	}

499
	blk_add_timer(rq);
500

501 502 503 504 505 506
	/*
	 * Ensure that ->deadline is visible before set the started
	 * flag and clear the completed flag.
	 */
	smp_mb__before_atomic();

507 508 509 510 511 512
	/*
	 * Mark us as started and clear complete. Complete might have been
	 * set if requeue raced with timeout, which then marked it as
	 * complete. So be sure to clear complete again when we start
	 * the request, otherwise we'll ignore the completion event.
	 */
513 514 515 516
	if (!test_bit(REQ_ATOM_STARTED, &rq->atomic_flags))
		set_bit(REQ_ATOM_STARTED, &rq->atomic_flags);
	if (test_bit(REQ_ATOM_COMPLETE, &rq->atomic_flags))
		clear_bit(REQ_ATOM_COMPLETE, &rq->atomic_flags);
517 518 519 520 521 522 523 524 525

	if (q->dma_drain_size && blk_rq_bytes(rq)) {
		/*
		 * Make sure space for the drain appears.  We know we can do
		 * this because max_hw_segments has been adjusted to be one
		 * fewer than the device can handle.
		 */
		rq->nr_phys_segments++;
	}
526
}
527
EXPORT_SYMBOL(blk_mq_start_request);
528

529 530
/*
 * When we reach here because queue is busy, REQ_ATOM_COMPLETE
531
 * flag isn't set yet, so there may be race with timeout handler,
532 533 534 535 536 537
 * but given rq->deadline is just set in .queue_rq() under
 * this situation, the race won't be possible in reality because
 * rq->timeout should be set as big enough to cover the window
 * between blk_mq_start_request() called from .queue_rq() and
 * clearing REQ_ATOM_STARTED here.
 */
538
static void __blk_mq_requeue_request(struct request *rq)
539 540 541 542
{
	struct request_queue *q = rq->q;

	trace_block_rq_requeue(q, rq);
J
Jens Axboe 已提交
543
	wbt_requeue(q->rq_wb, &rq->issue_stat);
544
	blk_mq_sched_requeue_request(rq);
545

546 547 548 549
	if (test_and_clear_bit(REQ_ATOM_STARTED, &rq->atomic_flags)) {
		if (q->dma_drain_size && blk_rq_bytes(rq))
			rq->nr_phys_segments--;
	}
550 551
}

552
void blk_mq_requeue_request(struct request *rq, bool kick_requeue_list)
553 554 555 556
{
	__blk_mq_requeue_request(rq);

	BUG_ON(blk_queued_rq(rq));
557
	blk_mq_add_to_requeue_list(rq, true, kick_requeue_list);
558 559 560
}
EXPORT_SYMBOL(blk_mq_requeue_request);

561 562 563
static void blk_mq_requeue_work(struct work_struct *work)
{
	struct request_queue *q =
564
		container_of(work, struct request_queue, requeue_work.work);
565 566 567 568 569 570 571 572 573
	LIST_HEAD(rq_list);
	struct request *rq, *next;
	unsigned long flags;

	spin_lock_irqsave(&q->requeue_lock, flags);
	list_splice_init(&q->requeue_list, &rq_list);
	spin_unlock_irqrestore(&q->requeue_lock, flags);

	list_for_each_entry_safe(rq, next, &rq_list, queuelist) {
574
		if (!(rq->rq_flags & RQF_SOFTBARRIER))
575 576
			continue;

577
		rq->rq_flags &= ~RQF_SOFTBARRIER;
578
		list_del_init(&rq->queuelist);
579
		blk_mq_sched_insert_request(rq, true, false, false, true);
580 581 582 583 584
	}

	while (!list_empty(&rq_list)) {
		rq = list_entry(rq_list.next, struct request, queuelist);
		list_del_init(&rq->queuelist);
585
		blk_mq_sched_insert_request(rq, false, false, false, true);
586 587
	}

588
	blk_mq_run_hw_queues(q, false);
589 590
}

591 592
void blk_mq_add_to_requeue_list(struct request *rq, bool at_head,
				bool kick_requeue_list)
593 594 595 596 597 598 599 600
{
	struct request_queue *q = rq->q;
	unsigned long flags;

	/*
	 * We abuse this flag that is otherwise used by the I/O scheduler to
	 * request head insertation from the workqueue.
	 */
601
	BUG_ON(rq->rq_flags & RQF_SOFTBARRIER);
602 603 604

	spin_lock_irqsave(&q->requeue_lock, flags);
	if (at_head) {
605
		rq->rq_flags |= RQF_SOFTBARRIER;
606 607 608 609 610
		list_add(&rq->queuelist, &q->requeue_list);
	} else {
		list_add_tail(&rq->queuelist, &q->requeue_list);
	}
	spin_unlock_irqrestore(&q->requeue_lock, flags);
611 612 613

	if (kick_requeue_list)
		blk_mq_kick_requeue_list(q);
614 615 616 617 618
}
EXPORT_SYMBOL(blk_mq_add_to_requeue_list);

void blk_mq_kick_requeue_list(struct request_queue *q)
{
619
	kblockd_schedule_delayed_work(&q->requeue_work, 0);
620 621 622
}
EXPORT_SYMBOL(blk_mq_kick_requeue_list);

623 624 625 626 627 628 629 630
void blk_mq_delay_kick_requeue_list(struct request_queue *q,
				    unsigned long msecs)
{
	kblockd_schedule_delayed_work(&q->requeue_work,
				      msecs_to_jiffies(msecs));
}
EXPORT_SYMBOL(blk_mq_delay_kick_requeue_list);

631 632
struct request *blk_mq_tag_to_rq(struct blk_mq_tags *tags, unsigned int tag)
{
633 634
	if (tag < tags->nr_tags) {
		prefetch(tags->rqs[tag]);
635
		return tags->rqs[tag];
636
	}
637 638

	return NULL;
639 640 641
}
EXPORT_SYMBOL(blk_mq_tag_to_rq);

642
struct blk_mq_timeout_data {
643 644
	unsigned long next;
	unsigned int next_set;
645 646
};

647
void blk_mq_rq_timed_out(struct request *req, bool reserved)
648
{
J
Jens Axboe 已提交
649
	const struct blk_mq_ops *ops = req->q->mq_ops;
650
	enum blk_eh_timer_return ret = BLK_EH_RESET_TIMER;
651 652 653 654 655 656 657

	/*
	 * We know that complete is set at this point. If STARTED isn't set
	 * anymore, then the request isn't active and the "timeout" should
	 * just be ignored. This can happen due to the bitflag ordering.
	 * Timeout first checks if STARTED is set, and if it is, assumes
	 * the request is active. But if we race with completion, then
658
	 * both flags will get cleared. So check here again, and ignore
659 660
	 * a timeout event with a request that isn't active.
	 */
661 662
	if (!test_bit(REQ_ATOM_STARTED, &req->atomic_flags))
		return;
663

664
	if (ops->timeout)
665
		ret = ops->timeout(req, reserved);
666 667 668 669 670 671 672 673 674 675 676 677 678 679 680

	switch (ret) {
	case BLK_EH_HANDLED:
		__blk_mq_complete_request(req);
		break;
	case BLK_EH_RESET_TIMER:
		blk_add_timer(req);
		blk_clear_rq_complete(req);
		break;
	case BLK_EH_NOT_HANDLED:
		break;
	default:
		printk(KERN_ERR "block: bad eh return: %d\n", ret);
		break;
	}
681
}
682

683 684 685 686
static void blk_mq_check_expired(struct blk_mq_hw_ctx *hctx,
		struct request *rq, void *priv, bool reserved)
{
	struct blk_mq_timeout_data *data = priv;
687

688
	if (!test_bit(REQ_ATOM_STARTED, &rq->atomic_flags))
689
		return;
690

691 692 693 694 695 696 697 698 699 700 701 702 703
	/*
	 * The rq being checked may have been freed and reallocated
	 * out already here, we avoid this race by checking rq->deadline
	 * and REQ_ATOM_COMPLETE flag together:
	 *
	 * - if rq->deadline is observed as new value because of
	 *   reusing, the rq won't be timed out because of timing.
	 * - if rq->deadline is observed as previous value,
	 *   REQ_ATOM_COMPLETE flag won't be cleared in reuse path
	 *   because we put a barrier between setting rq->deadline
	 *   and clearing the flag in blk_mq_start_request(), so
	 *   this rq won't be timed out too.
	 */
704 705
	if (time_after_eq(jiffies, rq->deadline)) {
		if (!blk_mark_rq_complete(rq))
706
			blk_mq_rq_timed_out(rq, reserved);
707 708 709 710
	} else if (!data->next_set || time_after(data->next, rq->deadline)) {
		data->next = rq->deadline;
		data->next_set = 1;
	}
711 712
}

713
static void blk_mq_timeout_work(struct work_struct *work)
714
{
715 716
	struct request_queue *q =
		container_of(work, struct request_queue, timeout_work);
717 718 719 720 721
	struct blk_mq_timeout_data data = {
		.next		= 0,
		.next_set	= 0,
	};
	int i;
722

723 724 725 726 727 728 729 730 731
	/* A deadlock might occur if a request is stuck requiring a
	 * timeout at the same time a queue freeze is waiting
	 * completion, since the timeout code would not be able to
	 * acquire the queue reference here.
	 *
	 * That's why we don't use blk_queue_enter here; instead, we use
	 * percpu_ref_tryget directly, because we need to be able to
	 * obtain a reference even in the short window between the queue
	 * starting to freeze, by dropping the first reference in
732
	 * blk_freeze_queue_start, and the moment the last request is
733 734 735 736
	 * consumed, marked by the instant q_usage_counter reaches
	 * zero.
	 */
	if (!percpu_ref_tryget(&q->q_usage_counter))
737 738
		return;

739
	blk_mq_queue_tag_busy_iter(q, blk_mq_check_expired, &data);
740

741 742 743
	if (data.next_set) {
		data.next = blk_rq_timeout(round_jiffies_up(data.next));
		mod_timer(&q->timeout, data.next);
744
	} else {
745 746
		struct blk_mq_hw_ctx *hctx;

747 748 749 750 751
		queue_for_each_hw_ctx(q, hctx, i) {
			/* the hctx may be unmapped, so check it here */
			if (blk_mq_hw_queue_mapped(hctx))
				blk_mq_tag_idle(hctx);
		}
752
	}
753
	blk_queue_exit(q);
754 755 756 757 758 759 760 761 762 763 764 765 766 767
}

/*
 * Reverse check our software queue for entries that we could potentially
 * merge with. Currently includes a hand-wavy stop count of 8, to not spend
 * too much time checking for merges.
 */
static bool blk_mq_attempt_merge(struct request_queue *q,
				 struct blk_mq_ctx *ctx, struct bio *bio)
{
	struct request *rq;
	int checked = 8;

	list_for_each_entry_reverse(rq, &ctx->rq_list, queuelist) {
768
		bool merged = false;
769 770 771 772 773 774 775

		if (!checked--)
			break;

		if (!blk_rq_merge_ok(rq, bio))
			continue;

776 777 778 779
		switch (blk_try_merge(rq, bio)) {
		case ELEVATOR_BACK_MERGE:
			if (blk_mq_sched_allow_merge(q, rq, bio))
				merged = bio_attempt_back_merge(q, rq, bio);
780
			break;
781 782 783
		case ELEVATOR_FRONT_MERGE:
			if (blk_mq_sched_allow_merge(q, rq, bio))
				merged = bio_attempt_front_merge(q, rq, bio);
784
			break;
785 786
		case ELEVATOR_DISCARD_MERGE:
			merged = bio_attempt_discard_merge(q, rq, bio);
787
			break;
788 789
		default:
			continue;
790
		}
791 792 793 794

		if (merged)
			ctx->rq_merged++;
		return merged;
795 796 797 798 799
	}

	return false;
}

800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817
struct flush_busy_ctx_data {
	struct blk_mq_hw_ctx *hctx;
	struct list_head *list;
};

static bool flush_busy_ctx(struct sbitmap *sb, unsigned int bitnr, void *data)
{
	struct flush_busy_ctx_data *flush_data = data;
	struct blk_mq_hw_ctx *hctx = flush_data->hctx;
	struct blk_mq_ctx *ctx = hctx->ctxs[bitnr];

	sbitmap_clear_bit(sb, bitnr);
	spin_lock(&ctx->lock);
	list_splice_tail_init(&ctx->rq_list, flush_data->list);
	spin_unlock(&ctx->lock);
	return true;
}

818 819 820 821
/*
 * Process software queues that have been marked busy, splicing them
 * to the for-dispatch
 */
822
void blk_mq_flush_busy_ctxs(struct blk_mq_hw_ctx *hctx, struct list_head *list)
823
{
824 825 826 827
	struct flush_busy_ctx_data data = {
		.hctx = hctx,
		.list = list,
	};
828

829
	sbitmap_for_each_set(&hctx->ctx_map, flush_busy_ctx, &data);
830
}
831
EXPORT_SYMBOL_GPL(blk_mq_flush_busy_ctxs);
832

833 834 835 836
static inline unsigned int queued_to_index(unsigned int queued)
{
	if (!queued)
		return 0;
837

838
	return min(BLK_MQ_MAX_DISPATCH_ORDER - 1, ilog2(queued) + 1);
839 840
}

841 842
bool blk_mq_get_driver_tag(struct request *rq, struct blk_mq_hw_ctx **hctx,
			   bool wait)
843 844 845 846 847 848 849
{
	struct blk_mq_alloc_data data = {
		.q = rq->q,
		.hctx = blk_mq_map_queue(rq->q, rq->mq_ctx->cpu),
		.flags = wait ? 0 : BLK_MQ_REQ_NOWAIT,
	};

850 851
	might_sleep_if(wait);

852 853
	if (rq->tag != -1)
		goto done;
854

855 856 857
	if (blk_mq_tag_is_reserved(data.hctx->sched_tags, rq->internal_tag))
		data.flags |= BLK_MQ_REQ_RESERVED;

858 859
	rq->tag = blk_mq_get_tag(&data);
	if (rq->tag >= 0) {
860 861 862 863
		if (blk_mq_tag_busy(data.hctx)) {
			rq->rq_flags |= RQF_MQ_INFLIGHT;
			atomic_inc(&data.hctx->nr_active);
		}
864 865 866
		data.hctx->tags->rqs[rq->tag] = rq;
	}

867 868 869 870
done:
	if (hctx)
		*hctx = data.hctx;
	return rq->tag != -1;
871 872
}

873 874
static void __blk_mq_put_driver_tag(struct blk_mq_hw_ctx *hctx,
				    struct request *rq)
875 876 877 878 879 880 881 882 883 884
{
	blk_mq_put_tag(hctx, hctx->tags, rq->mq_ctx, rq->tag);
	rq->tag = -1;

	if (rq->rq_flags & RQF_MQ_INFLIGHT) {
		rq->rq_flags &= ~RQF_MQ_INFLIGHT;
		atomic_dec(&hctx->nr_active);
	}
}

885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904
static void blk_mq_put_driver_tag_hctx(struct blk_mq_hw_ctx *hctx,
				       struct request *rq)
{
	if (rq->tag == -1 || rq->internal_tag == -1)
		return;

	__blk_mq_put_driver_tag(hctx, rq);
}

static void blk_mq_put_driver_tag(struct request *rq)
{
	struct blk_mq_hw_ctx *hctx;

	if (rq->tag == -1 || rq->internal_tag == -1)
		return;

	hctx = blk_mq_map_queue(rq->q, rq->mq_ctx->cpu);
	__blk_mq_put_driver_tag(hctx, rq);
}

905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928
/*
 * If we fail getting a driver tag because all the driver tags are already
 * assigned and on the dispatch list, BUT the first entry does not have a
 * tag, then we could deadlock. For that case, move entries with assigned
 * driver tags to the front, leaving the set of tagged requests in the
 * same order, and the untagged set in the same order.
 */
static bool reorder_tags_to_front(struct list_head *list)
{
	struct request *rq, *tmp, *first = NULL;

	list_for_each_entry_safe_reverse(rq, tmp, list, queuelist) {
		if (rq == first)
			break;
		if (rq->tag != -1) {
			list_move(&rq->queuelist, list);
			if (!first)
				first = rq;
		}
	}

	return first != NULL;
}

929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966
static int blk_mq_dispatch_wake(wait_queue_t *wait, unsigned mode, int flags,
				void *key)
{
	struct blk_mq_hw_ctx *hctx;

	hctx = container_of(wait, struct blk_mq_hw_ctx, dispatch_wait);

	list_del(&wait->task_list);
	clear_bit_unlock(BLK_MQ_S_TAG_WAITING, &hctx->state);
	blk_mq_run_hw_queue(hctx, true);
	return 1;
}

static bool blk_mq_dispatch_wait_add(struct blk_mq_hw_ctx *hctx)
{
	struct sbq_wait_state *ws;

	/*
	 * The TAG_WAITING bit serves as a lock protecting hctx->dispatch_wait.
	 * The thread which wins the race to grab this bit adds the hardware
	 * queue to the wait queue.
	 */
	if (test_bit(BLK_MQ_S_TAG_WAITING, &hctx->state) ||
	    test_and_set_bit_lock(BLK_MQ_S_TAG_WAITING, &hctx->state))
		return false;

	init_waitqueue_func_entry(&hctx->dispatch_wait, blk_mq_dispatch_wake);
	ws = bt_wait_ptr(&hctx->tags->bitmap_tags, hctx);

	/*
	 * As soon as this returns, it's no longer safe to fiddle with
	 * hctx->dispatch_wait, since a completion can wake up the wait queue
	 * and unlock the bit.
	 */
	add_wait_queue(&ws->wait, &hctx->dispatch_wait);
	return true;
}

967
bool blk_mq_dispatch_rq_list(struct request_queue *q, struct list_head *list)
968
{
969
	struct blk_mq_hw_ctx *hctx;
970
	struct request *rq;
971
	int errors, queued, ret = BLK_MQ_RQ_QUEUE_OK;
972

973 974 975
	if (list_empty(list))
		return false;

976 977 978
	/*
	 * Now process all the entries, sending them to the driver.
	 */
979
	errors = queued = 0;
980
	do {
981
		struct blk_mq_queue_data bd;
982

983
		rq = list_first_entry(list, struct request, queuelist);
984 985 986
		if (!blk_mq_get_driver_tag(rq, &hctx, false)) {
			if (!queued && reorder_tags_to_front(list))
				continue;
987 988

			/*
989 990
			 * The initial allocation attempt failed, so we need to
			 * rerun the hardware queue when a tag is freed.
991
			 */
992 993 994 995 996 997 998 999 1000
			if (!blk_mq_dispatch_wait_add(hctx))
				break;

			/*
			 * It's possible that a tag was freed in the window
			 * between the allocation failure and adding the
			 * hardware queue to the wait queue.
			 */
			if (!blk_mq_get_driver_tag(rq, &hctx, false))
1001
				break;
1002
		}
1003

1004 1005
		list_del_init(&rq->queuelist);

1006
		bd.rq = rq;
1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019

		/*
		 * Flag last if we have no more requests, or if we have more
		 * but can't assign a driver tag to it.
		 */
		if (list_empty(list))
			bd.last = true;
		else {
			struct request *nxt;

			nxt = list_first_entry(list, struct request, queuelist);
			bd.last = !blk_mq_get_driver_tag(nxt, NULL, false);
		}
1020 1021

		ret = q->mq_ops->queue_rq(hctx, &bd);
1022 1023 1024
		switch (ret) {
		case BLK_MQ_RQ_QUEUE_OK:
			queued++;
1025
			break;
1026
		case BLK_MQ_RQ_QUEUE_BUSY:
1027
			blk_mq_put_driver_tag_hctx(hctx, rq);
1028
			list_add(&rq->queuelist, list);
1029
			__blk_mq_requeue_request(rq);
1030 1031 1032 1033
			break;
		default:
			pr_err("blk-mq: bad return on queue: %d\n", ret);
		case BLK_MQ_RQ_QUEUE_ERROR:
1034
			errors++;
1035
			blk_mq_end_request(rq, -EIO);
1036 1037 1038 1039 1040
			break;
		}

		if (ret == BLK_MQ_RQ_QUEUE_BUSY)
			break;
1041
	} while (!list_empty(list));
1042

1043
	hctx->dispatched[queued_to_index(queued)]++;
1044 1045 1046 1047 1048

	/*
	 * Any items that need requeuing? Stuff them into hctx->dispatch,
	 * that is where we will continue on next queue run.
	 */
1049
	if (!list_empty(list)) {
1050
		/*
1051 1052
		 * If an I/O scheduler has been configured and we got a driver
		 * tag for the next request already, free it again.
1053 1054 1055 1056
		 */
		rq = list_first_entry(list, struct request, queuelist);
		blk_mq_put_driver_tag(rq);

1057
		spin_lock(&hctx->lock);
1058
		list_splice_init(list, &hctx->dispatch);
1059
		spin_unlock(&hctx->lock);
1060

1061
		/*
1062 1063 1064
		 * If SCHED_RESTART was set by the caller of this function and
		 * it is no longer set that means that it was cleared by another
		 * thread and hence that a queue rerun is needed.
1065
		 *
1066 1067 1068 1069
		 * If TAG_WAITING is set that means that an I/O scheduler has
		 * been configured and another thread is waiting for a driver
		 * tag. To guarantee fairness, do not rerun this hardware queue
		 * but let the other thread grab the driver tag.
1070
		 *
1071 1072 1073 1074 1075 1076 1077 1078 1079
		 * If no I/O scheduler has been configured it is possible that
		 * the hardware queue got stopped and restarted before requests
		 * were pushed back onto the dispatch list. Rerun the queue to
		 * avoid starvation. Notes:
		 * - blk_mq_run_hw_queue() checks whether or not a queue has
		 *   been stopped before rerunning a queue.
		 * - Some but not all block drivers stop a queue before
		 *   returning BLK_MQ_RQ_QUEUE_BUSY. Two exceptions are scsi-mq
		 *   and dm-rq.
1080
		 */
1081 1082
		if (!blk_mq_sched_needs_restart(hctx) &&
		    !test_bit(BLK_MQ_S_TAG_WAITING, &hctx->state))
1083
			blk_mq_run_hw_queue(hctx, true);
1084
	}
1085

1086
	return (queued + errors) != 0;
1087 1088
}

1089 1090 1091 1092 1093 1094 1095 1096 1097
static void __blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx)
{
	int srcu_idx;

	WARN_ON(!cpumask_test_cpu(raw_smp_processor_id(), hctx->cpumask) &&
		cpu_online(hctx->next_cpu));

	if (!(hctx->flags & BLK_MQ_F_BLOCKING)) {
		rcu_read_lock();
1098
		blk_mq_sched_dispatch_requests(hctx);
1099 1100
		rcu_read_unlock();
	} else {
1101 1102
		might_sleep();

1103
		srcu_idx = srcu_read_lock(&hctx->queue_rq_srcu);
1104
		blk_mq_sched_dispatch_requests(hctx);
1105 1106 1107 1108
		srcu_read_unlock(&hctx->queue_rq_srcu, srcu_idx);
	}
}

1109 1110 1111 1112 1113 1114 1115 1116
/*
 * It'd be great if the workqueue API had a way to pass
 * in a mask and had some smarts for more clever placement.
 * For now we just round-robin here, switching for every
 * BLK_MQ_CPU_WORK_BATCH queued items.
 */
static int blk_mq_hctx_next_cpu(struct blk_mq_hw_ctx *hctx)
{
1117 1118
	if (hctx->queue->nr_hw_queues == 1)
		return WORK_CPU_UNBOUND;
1119 1120

	if (--hctx->next_cpu_batch <= 0) {
1121
		int next_cpu;
1122 1123 1124 1125 1126 1127 1128 1129 1130

		next_cpu = cpumask_next(hctx->next_cpu, hctx->cpumask);
		if (next_cpu >= nr_cpu_ids)
			next_cpu = cpumask_first(hctx->cpumask);

		hctx->next_cpu = next_cpu;
		hctx->next_cpu_batch = BLK_MQ_CPU_WORK_BATCH;
	}

1131
	return hctx->next_cpu;
1132 1133
}

1134 1135
static void __blk_mq_delay_run_hw_queue(struct blk_mq_hw_ctx *hctx, bool async,
					unsigned long msecs)
1136
{
1137 1138
	if (unlikely(blk_mq_hctx_stopped(hctx) ||
		     !blk_mq_hw_queue_mapped(hctx)))
1139 1140
		return;

1141
	if (!async && !(hctx->flags & BLK_MQ_F_BLOCKING)) {
1142 1143
		int cpu = get_cpu();
		if (cpumask_test_cpu(cpu, hctx->cpumask)) {
1144
			__blk_mq_run_hw_queue(hctx);
1145
			put_cpu();
1146 1147
			return;
		}
1148

1149
		put_cpu();
1150
	}
1151

1152 1153 1154
	kblockd_schedule_delayed_work_on(blk_mq_hctx_next_cpu(hctx),
					 &hctx->run_work,
					 msecs_to_jiffies(msecs));
1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165
}

void blk_mq_delay_run_hw_queue(struct blk_mq_hw_ctx *hctx, unsigned long msecs)
{
	__blk_mq_delay_run_hw_queue(hctx, true, msecs);
}
EXPORT_SYMBOL(blk_mq_delay_run_hw_queue);

void blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx, bool async)
{
	__blk_mq_delay_run_hw_queue(hctx, async, 0);
1166
}
O
Omar Sandoval 已提交
1167
EXPORT_SYMBOL(blk_mq_run_hw_queue);
1168

1169
void blk_mq_run_hw_queues(struct request_queue *q, bool async)
1170 1171 1172 1173 1174
{
	struct blk_mq_hw_ctx *hctx;
	int i;

	queue_for_each_hw_ctx(q, hctx, i) {
1175
		if (!blk_mq_hctx_has_pending(hctx) ||
1176
		    blk_mq_hctx_stopped(hctx))
1177 1178
			continue;

1179
		blk_mq_run_hw_queue(hctx, async);
1180 1181
	}
}
1182
EXPORT_SYMBOL(blk_mq_run_hw_queues);
1183

1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203
/**
 * blk_mq_queue_stopped() - check whether one or more hctxs have been stopped
 * @q: request queue.
 *
 * The caller is responsible for serializing this function against
 * blk_mq_{start,stop}_hw_queue().
 */
bool blk_mq_queue_stopped(struct request_queue *q)
{
	struct blk_mq_hw_ctx *hctx;
	int i;

	queue_for_each_hw_ctx(q, hctx, i)
		if (blk_mq_hctx_stopped(hctx))
			return true;

	return false;
}
EXPORT_SYMBOL(blk_mq_queue_stopped);

1204
static void __blk_mq_stop_hw_queue(struct blk_mq_hw_ctx *hctx, bool sync)
1205
{
1206 1207 1208 1209 1210
	if (sync)
		cancel_delayed_work_sync(&hctx->run_work);
	else
		cancel_delayed_work(&hctx->run_work);

1211 1212
	set_bit(BLK_MQ_S_STOPPED, &hctx->state);
}
1213 1214 1215 1216 1217

void blk_mq_stop_hw_queue(struct blk_mq_hw_ctx *hctx)
{
	__blk_mq_stop_hw_queue(hctx, false);
}
1218 1219
EXPORT_SYMBOL(blk_mq_stop_hw_queue);

1220
static void __blk_mq_stop_hw_queues(struct request_queue *q, bool sync)
1221 1222 1223 1224 1225
{
	struct blk_mq_hw_ctx *hctx;
	int i;

	queue_for_each_hw_ctx(q, hctx, i)
1226 1227 1228 1229 1230 1231
		__blk_mq_stop_hw_queue(hctx, sync);
}

void blk_mq_stop_hw_queues(struct request_queue *q)
{
	__blk_mq_stop_hw_queues(q, false);
1232 1233 1234
}
EXPORT_SYMBOL(blk_mq_stop_hw_queues);

1235 1236 1237
void blk_mq_start_hw_queue(struct blk_mq_hw_ctx *hctx)
{
	clear_bit(BLK_MQ_S_STOPPED, &hctx->state);
1238

1239
	blk_mq_run_hw_queue(hctx, false);
1240 1241 1242
}
EXPORT_SYMBOL(blk_mq_start_hw_queue);

1243 1244 1245 1246 1247 1248 1249 1250 1251 1252
void blk_mq_start_hw_queues(struct request_queue *q)
{
	struct blk_mq_hw_ctx *hctx;
	int i;

	queue_for_each_hw_ctx(q, hctx, i)
		blk_mq_start_hw_queue(hctx);
}
EXPORT_SYMBOL(blk_mq_start_hw_queues);

1253 1254 1255 1256 1257 1258 1259 1260 1261 1262
void blk_mq_start_stopped_hw_queue(struct blk_mq_hw_ctx *hctx, bool async)
{
	if (!blk_mq_hctx_stopped(hctx))
		return;

	clear_bit(BLK_MQ_S_STOPPED, &hctx->state);
	blk_mq_run_hw_queue(hctx, async);
}
EXPORT_SYMBOL_GPL(blk_mq_start_stopped_hw_queue);

1263
void blk_mq_start_stopped_hw_queues(struct request_queue *q, bool async)
1264 1265 1266 1267
{
	struct blk_mq_hw_ctx *hctx;
	int i;

1268 1269
	queue_for_each_hw_ctx(q, hctx, i)
		blk_mq_start_stopped_hw_queue(hctx, async);
1270 1271 1272
}
EXPORT_SYMBOL(blk_mq_start_stopped_hw_queues);

1273
static void blk_mq_run_work_fn(struct work_struct *work)
1274 1275 1276
{
	struct blk_mq_hw_ctx *hctx;

1277
	hctx = container_of(work, struct blk_mq_hw_ctx, run_work.work);
1278

1279 1280 1281 1282 1283 1284 1285 1286
	/*
	 * If we are stopped, don't run the queue. The exception is if
	 * BLK_MQ_S_START_ON_RUN is set. For that case, we auto-clear
	 * the STOPPED bit and run it.
	 */
	if (test_bit(BLK_MQ_S_STOPPED, &hctx->state)) {
		if (!test_bit(BLK_MQ_S_START_ON_RUN, &hctx->state))
			return;
1287

1288 1289 1290
		clear_bit(BLK_MQ_S_START_ON_RUN, &hctx->state);
		clear_bit(BLK_MQ_S_STOPPED, &hctx->state);
	}
1291 1292 1293 1294

	__blk_mq_run_hw_queue(hctx);
}

1295 1296 1297

void blk_mq_delay_queue(struct blk_mq_hw_ctx *hctx, unsigned long msecs)
{
1298 1299
	if (unlikely(!blk_mq_hw_queue_mapped(hctx)))
		return;
1300

1301 1302 1303 1304 1305
	/*
	 * Stop the hw queue, then modify currently delayed work.
	 * This should prevent us from running the queue prematurely.
	 * Mark the queue as auto-clearing STOPPED when it runs.
	 */
1306
	blk_mq_stop_hw_queue(hctx);
1307 1308 1309 1310
	set_bit(BLK_MQ_S_START_ON_RUN, &hctx->state);
	kblockd_mod_delayed_work_on(blk_mq_hctx_next_cpu(hctx),
					&hctx->run_work,
					msecs_to_jiffies(msecs));
1311 1312 1313
}
EXPORT_SYMBOL(blk_mq_delay_queue);

1314 1315 1316
static inline void __blk_mq_insert_req_list(struct blk_mq_hw_ctx *hctx,
					    struct request *rq,
					    bool at_head)
1317
{
J
Jens Axboe 已提交
1318 1319
	struct blk_mq_ctx *ctx = rq->mq_ctx;

1320 1321
	trace_block_rq_insert(hctx->queue, rq);

1322 1323 1324 1325
	if (at_head)
		list_add(&rq->queuelist, &ctx->rq_list);
	else
		list_add_tail(&rq->queuelist, &ctx->rq_list);
1326
}
1327

1328 1329
void __blk_mq_insert_request(struct blk_mq_hw_ctx *hctx, struct request *rq,
			     bool at_head)
1330 1331 1332
{
	struct blk_mq_ctx *ctx = rq->mq_ctx;

J
Jens Axboe 已提交
1333
	__blk_mq_insert_req_list(hctx, rq, at_head);
1334 1335 1336
	blk_mq_hctx_mark_pending(hctx, ctx);
}

1337 1338
void blk_mq_insert_requests(struct blk_mq_hw_ctx *hctx, struct blk_mq_ctx *ctx,
			    struct list_head *list)
1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349

{
	/*
	 * preemption doesn't flush plug list, so it's possible ctx->cpu is
	 * offline now
	 */
	spin_lock(&ctx->lock);
	while (!list_empty(list)) {
		struct request *rq;

		rq = list_first_entry(list, struct request, queuelist);
J
Jens Axboe 已提交
1350
		BUG_ON(rq->mq_ctx != ctx);
1351
		list_del_init(&rq->queuelist);
J
Jens Axboe 已提交
1352
		__blk_mq_insert_req_list(hctx, rq, false);
1353
	}
1354
	blk_mq_hctx_mark_pending(hctx, ctx);
1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390
	spin_unlock(&ctx->lock);
}

static int plug_ctx_cmp(void *priv, struct list_head *a, struct list_head *b)
{
	struct request *rqa = container_of(a, struct request, queuelist);
	struct request *rqb = container_of(b, struct request, queuelist);

	return !(rqa->mq_ctx < rqb->mq_ctx ||
		 (rqa->mq_ctx == rqb->mq_ctx &&
		  blk_rq_pos(rqa) < blk_rq_pos(rqb)));
}

void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule)
{
	struct blk_mq_ctx *this_ctx;
	struct request_queue *this_q;
	struct request *rq;
	LIST_HEAD(list);
	LIST_HEAD(ctx_list);
	unsigned int depth;

	list_splice_init(&plug->mq_list, &list);

	list_sort(NULL, &list, plug_ctx_cmp);

	this_q = NULL;
	this_ctx = NULL;
	depth = 0;

	while (!list_empty(&list)) {
		rq = list_entry_rq(list.next);
		list_del_init(&rq->queuelist);
		BUG_ON(!rq->q);
		if (rq->mq_ctx != this_ctx) {
			if (this_ctx) {
1391 1392 1393 1394
				trace_block_unplug(this_q, depth, from_schedule);
				blk_mq_sched_insert_requests(this_q, this_ctx,
								&ctx_list,
								from_schedule);
1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410
			}

			this_ctx = rq->mq_ctx;
			this_q = rq->q;
			depth = 0;
		}

		depth++;
		list_add_tail(&rq->queuelist, &ctx_list);
	}

	/*
	 * If 'this_ctx' is set, we know we have entries to complete
	 * on 'ctx_list'. Do those.
	 */
	if (this_ctx) {
1411 1412 1413
		trace_block_unplug(this_q, depth, from_schedule);
		blk_mq_sched_insert_requests(this_q, this_ctx, &ctx_list,
						from_schedule);
1414 1415 1416 1417 1418
	}
}

static void blk_mq_bio_to_request(struct request *rq, struct bio *bio)
{
1419
	blk_init_request_from_bio(rq, bio);
1420

1421
	blk_account_io_start(rq, true);
1422 1423
}

1424 1425 1426 1427 1428 1429
static inline bool hctx_allow_merges(struct blk_mq_hw_ctx *hctx)
{
	return (hctx->flags & BLK_MQ_F_SHOULD_MERGE) &&
		!blk_queue_nomerges(hctx->queue);
}

1430 1431 1432
static inline bool blk_mq_merge_queue_io(struct blk_mq_hw_ctx *hctx,
					 struct blk_mq_ctx *ctx,
					 struct request *rq, struct bio *bio)
1433
{
1434
	if (!hctx_allow_merges(hctx) || !bio_mergeable(bio)) {
1435 1436 1437 1438 1439 1440 1441
		blk_mq_bio_to_request(rq, bio);
		spin_lock(&ctx->lock);
insert_rq:
		__blk_mq_insert_request(hctx, rq, false);
		spin_unlock(&ctx->lock);
		return false;
	} else {
1442 1443
		struct request_queue *q = hctx->queue;

1444 1445 1446 1447 1448
		spin_lock(&ctx->lock);
		if (!blk_mq_attempt_merge(q, ctx, bio)) {
			blk_mq_bio_to_request(rq, bio);
			goto insert_rq;
		}
1449

1450
		spin_unlock(&ctx->lock);
1451
		__blk_mq_finish_request(hctx, ctx, rq);
1452
		return true;
1453
	}
1454
}
1455

1456 1457
static blk_qc_t request_to_qc_t(struct blk_mq_hw_ctx *hctx, struct request *rq)
{
1458 1459 1460 1461
	if (rq->tag != -1)
		return blk_tag_to_qc_t(rq->tag, hctx->queue_num, false);

	return blk_tag_to_qc_t(rq->internal_tag, hctx->queue_num, true);
1462 1463
}

M
Ming Lei 已提交
1464 1465 1466
static void __blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx,
					struct request *rq,
					blk_qc_t *cookie, bool may_sleep)
1467 1468 1469 1470
{
	struct request_queue *q = rq->q;
	struct blk_mq_queue_data bd = {
		.rq = rq,
1471
		.last = true,
1472
	};
1473 1474
	blk_qc_t new_cookie;
	int ret;
M
Ming Lei 已提交
1475 1476 1477 1478 1479 1480
	bool run_queue = true;

	if (blk_mq_hctx_stopped(hctx)) {
		run_queue = false;
		goto insert;
	}
1481

1482
	if (q->elevator)
1483 1484
		goto insert;

M
Ming Lei 已提交
1485
	if (!blk_mq_get_driver_tag(rq, NULL, false))
1486 1487 1488 1489
		goto insert;

	new_cookie = request_to_qc_t(hctx, rq);

1490 1491 1492 1493 1494 1495
	/*
	 * For OK queue, we are done. For error, kill it. Any other
	 * error (busy), just add it to our list as we previously
	 * would have done
	 */
	ret = q->mq_ops->queue_rq(hctx, &bd);
1496 1497
	if (ret == BLK_MQ_RQ_QUEUE_OK) {
		*cookie = new_cookie;
1498
		return;
1499
	}
1500

1501 1502
	if (ret == BLK_MQ_RQ_QUEUE_ERROR) {
		*cookie = BLK_QC_T_NONE;
1503
		blk_mq_end_request(rq, -EIO);
1504
		return;
1505
	}
1506

1507
	__blk_mq_requeue_request(rq);
1508
insert:
M
Ming Lei 已提交
1509
	blk_mq_sched_insert_request(rq, false, run_queue, false, may_sleep);
1510 1511
}

1512 1513 1514 1515 1516
static void blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx,
		struct request *rq, blk_qc_t *cookie)
{
	if (!(hctx->flags & BLK_MQ_F_BLOCKING)) {
		rcu_read_lock();
M
Ming Lei 已提交
1517
		__blk_mq_try_issue_directly(hctx, rq, cookie, false);
1518 1519
		rcu_read_unlock();
	} else {
1520 1521 1522 1523 1524
		unsigned int srcu_idx;

		might_sleep();

		srcu_idx = srcu_read_lock(&hctx->queue_rq_srcu);
M
Ming Lei 已提交
1525
		__blk_mq_try_issue_directly(hctx, rq, cookie, true);
1526 1527 1528 1529
		srcu_read_unlock(&hctx->queue_rq_srcu, srcu_idx);
	}
}

1530
static blk_qc_t blk_mq_make_request(struct request_queue *q, struct bio *bio)
1531
{
1532
	const int is_sync = op_is_sync(bio->bi_opf);
1533
	const int is_flush_fua = op_is_flush(bio->bi_opf);
1534
	struct blk_mq_alloc_data data = { .flags = 0 };
1535
	struct request *rq;
1536
	unsigned int request_count = 0;
1537
	struct blk_plug *plug;
1538
	struct request *same_queue_rq = NULL;
1539
	blk_qc_t cookie;
J
Jens Axboe 已提交
1540
	unsigned int wb_acct;
1541 1542 1543

	blk_queue_bounce(q, &bio);

1544 1545
	blk_queue_split(q, &bio, q->bio_split);

1546
	if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {
1547
		bio_io_error(bio);
1548
		return BLK_QC_T_NONE;
1549 1550
	}

1551 1552 1553
	if (!is_flush_fua && !blk_queue_nomerges(q) &&
	    blk_attempt_plug_merge(q, bio, &request_count, &same_queue_rq))
		return BLK_QC_T_NONE;
1554

1555 1556 1557
	if (blk_mq_sched_bio_merge(q, bio))
		return BLK_QC_T_NONE;

J
Jens Axboe 已提交
1558 1559
	wb_acct = wbt_wait(q->rq_wb, bio, NULL);

1560 1561 1562
	trace_block_getrq(q, bio, bio->bi_opf);

	rq = blk_mq_sched_get_request(q, bio, bio->bi_opf, &data);
J
Jens Axboe 已提交
1563 1564
	if (unlikely(!rq)) {
		__wbt_done(q->rq_wb, wb_acct);
1565
		return BLK_QC_T_NONE;
J
Jens Axboe 已提交
1566 1567 1568
	}

	wbt_track(&rq->issue_stat, wb_acct);
1569

1570
	cookie = request_to_qc_t(data.hctx, rq);
1571

1572
	plug = current->plug;
1573
	if (unlikely(is_flush_fua)) {
1574
		blk_mq_put_ctx(data.ctx);
1575
		blk_mq_bio_to_request(rq, bio);
1576 1577 1578
		if (q->elevator) {
			blk_mq_sched_insert_request(rq, false, true, true,
					true);
1579
		} else {
1580 1581
			blk_insert_flush(rq);
			blk_mq_run_hw_queue(data.hctx, true);
1582
		}
1583
	} else if (plug && q->nr_hw_queues == 1) {
1584 1585
		struct request *last = NULL;

1586
		blk_mq_put_ctx(data.ctx);
1587
		blk_mq_bio_to_request(rq, bio);
1588 1589 1590 1591 1592 1593 1594

		/*
		 * @request_count may become stale because of schedule
		 * out, so check the list again.
		 */
		if (list_empty(&plug->mq_list))
			request_count = 0;
1595 1596 1597
		else if (blk_queue_nomerges(q))
			request_count = blk_plug_queued_count(q);

M
Ming Lei 已提交
1598
		if (!request_count)
1599
			trace_block_plug(q);
1600 1601
		else
			last = list_entry_rq(plug->mq_list.prev);
1602

1603 1604
		if (request_count >= BLK_MAX_REQUEST_COUNT || (last &&
		    blk_rq_bytes(last) >= BLK_PLUG_FLUSH_SIZE)) {
1605 1606
			blk_flush_plug_list(plug, false);
			trace_block_plug(q);
1607
		}
1608

1609
		list_add_tail(&rq->queuelist, &plug->mq_list);
1610
	} else if (plug && !blk_queue_nomerges(q)) {
1611
		blk_mq_bio_to_request(rq, bio);
1612 1613

		/*
1614
		 * We do limited plugging. If the bio can be merged, do that.
1615 1616
		 * Otherwise the existing request in the plug list will be
		 * issued. So the plug list will have one request at most
1617 1618
		 * The plug list might get flushed before this. If that happens,
		 * the plug list is empty, and same_queue_rq is invalid.
1619
		 */
1620 1621 1622 1623 1624 1625
		if (list_empty(&plug->mq_list))
			same_queue_rq = NULL;
		if (same_queue_rq)
			list_del_init(&same_queue_rq->queuelist);
		list_add_tail(&rq->queuelist, &plug->mq_list);

1626 1627
		blk_mq_put_ctx(data.ctx);

1628 1629 1630
		if (same_queue_rq) {
			data.hctx = blk_mq_map_queue(q,
					same_queue_rq->mq_ctx->cpu);
1631 1632
			blk_mq_try_issue_directly(data.hctx, same_queue_rq,
					&cookie);
1633
		}
1634
	} else if (q->nr_hw_queues > 1 && is_sync) {
1635
		blk_mq_put_ctx(data.ctx);
1636 1637
		blk_mq_bio_to_request(rq, bio);
		blk_mq_try_issue_directly(data.hctx, rq, &cookie);
1638
	} else if (q->elevator) {
1639
		blk_mq_put_ctx(data.ctx);
1640
		blk_mq_bio_to_request(rq, bio);
1641
		blk_mq_sched_insert_request(rq, false, true, true, true);
1642 1643
	} else if (!blk_mq_merge_queue_io(data.hctx, data.ctx, rq, bio)) {
		blk_mq_put_ctx(data.ctx);
1644
		blk_mq_run_hw_queue(data.hctx, true);
1645 1646
	} else
		blk_mq_put_ctx(data.ctx);
1647

1648
	return cookie;
1649 1650
}

1651 1652
void blk_mq_free_rqs(struct blk_mq_tag_set *set, struct blk_mq_tags *tags,
		     unsigned int hctx_idx)
1653
{
1654
	struct page *page;
1655

1656
	if (tags->rqs && set->ops->exit_request) {
1657
		int i;
1658

1659
		for (i = 0; i < tags->nr_tags; i++) {
J
Jens Axboe 已提交
1660 1661 1662
			struct request *rq = tags->static_rqs[i];

			if (!rq)
1663
				continue;
1664
			set->ops->exit_request(set, rq, hctx_idx);
J
Jens Axboe 已提交
1665
			tags->static_rqs[i] = NULL;
1666
		}
1667 1668
	}

1669 1670
	while (!list_empty(&tags->page_list)) {
		page = list_first_entry(&tags->page_list, struct page, lru);
1671
		list_del_init(&page->lru);
1672 1673 1674 1675 1676
		/*
		 * Remove kmemleak object previously allocated in
		 * blk_mq_init_rq_map().
		 */
		kmemleak_free(page_address(page));
1677 1678
		__free_pages(page, page->private);
	}
1679
}
1680

1681 1682
void blk_mq_free_rq_map(struct blk_mq_tags *tags)
{
1683
	kfree(tags->rqs);
1684
	tags->rqs = NULL;
J
Jens Axboe 已提交
1685 1686
	kfree(tags->static_rqs);
	tags->static_rqs = NULL;
1687

1688
	blk_mq_free_tags(tags);
1689 1690
}

1691 1692 1693 1694
struct blk_mq_tags *blk_mq_alloc_rq_map(struct blk_mq_tag_set *set,
					unsigned int hctx_idx,
					unsigned int nr_tags,
					unsigned int reserved_tags)
1695
{
1696
	struct blk_mq_tags *tags;
1697
	int node;
1698

1699 1700 1701 1702 1703
	node = blk_mq_hw_queue_to_node(set->mq_map, hctx_idx);
	if (node == NUMA_NO_NODE)
		node = set->numa_node;

	tags = blk_mq_init_tags(nr_tags, reserved_tags, node,
S
Shaohua Li 已提交
1704
				BLK_MQ_FLAG_TO_ALLOC_POLICY(set->flags));
1705 1706
	if (!tags)
		return NULL;
1707

1708
	tags->rqs = kzalloc_node(nr_tags * sizeof(struct request *),
1709
				 GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY,
1710
				 node);
1711 1712 1713 1714
	if (!tags->rqs) {
		blk_mq_free_tags(tags);
		return NULL;
	}
1715

J
Jens Axboe 已提交
1716 1717
	tags->static_rqs = kzalloc_node(nr_tags * sizeof(struct request *),
				 GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY,
1718
				 node);
J
Jens Axboe 已提交
1719 1720 1721 1722 1723 1724
	if (!tags->static_rqs) {
		kfree(tags->rqs);
		blk_mq_free_tags(tags);
		return NULL;
	}

1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737
	return tags;
}

static size_t order_to_size(unsigned int order)
{
	return (size_t)PAGE_SIZE << order;
}

int blk_mq_alloc_rqs(struct blk_mq_tag_set *set, struct blk_mq_tags *tags,
		     unsigned int hctx_idx, unsigned int depth)
{
	unsigned int i, j, entries_per_page, max_order = 4;
	size_t rq_size, left;
1738 1739 1740 1741 1742
	int node;

	node = blk_mq_hw_queue_to_node(set->mq_map, hctx_idx);
	if (node == NUMA_NO_NODE)
		node = set->numa_node;
1743 1744 1745

	INIT_LIST_HEAD(&tags->page_list);

1746 1747 1748 1749
	/*
	 * rq_size is the size of the request plus driver payload, rounded
	 * to the cacheline size
	 */
1750
	rq_size = round_up(sizeof(struct request) + set->cmd_size,
1751
				cache_line_size());
1752
	left = rq_size * depth;
1753

1754
	for (i = 0; i < depth; ) {
1755 1756 1757 1758 1759
		int this_order = max_order;
		struct page *page;
		int to_do;
		void *p;

1760
		while (this_order && left < order_to_size(this_order - 1))
1761 1762 1763
			this_order--;

		do {
1764
			page = alloc_pages_node(node,
1765
				GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY | __GFP_ZERO,
1766
				this_order);
1767 1768 1769 1770 1771 1772 1773 1774 1775
			if (page)
				break;
			if (!this_order--)
				break;
			if (order_to_size(this_order) < rq_size)
				break;
		} while (1);

		if (!page)
1776
			goto fail;
1777 1778

		page->private = this_order;
1779
		list_add_tail(&page->lru, &tags->page_list);
1780 1781

		p = page_address(page);
1782 1783 1784 1785
		/*
		 * Allow kmemleak to scan these pages as they contain pointers
		 * to additional allocations like via ops->init_request().
		 */
1786
		kmemleak_alloc(p, order_to_size(this_order), 1, GFP_NOIO);
1787
		entries_per_page = order_to_size(this_order) / rq_size;
1788
		to_do = min(entries_per_page, depth - i);
1789 1790
		left -= to_do * rq_size;
		for (j = 0; j < to_do; j++) {
J
Jens Axboe 已提交
1791 1792 1793
			struct request *rq = p;

			tags->static_rqs[i] = rq;
1794
			if (set->ops->init_request) {
1795
				if (set->ops->init_request(set, rq, hctx_idx,
1796
						node)) {
J
Jens Axboe 已提交
1797
					tags->static_rqs[i] = NULL;
1798
					goto fail;
1799
				}
1800 1801
			}

1802 1803 1804 1805
			p += rq_size;
			i++;
		}
	}
1806
	return 0;
1807

1808
fail:
1809 1810
	blk_mq_free_rqs(set, tags, hctx_idx);
	return -ENOMEM;
1811 1812
}

J
Jens Axboe 已提交
1813 1814 1815 1816 1817
/*
 * 'cpu' is going away. splice any existing rq_list entries from this
 * software queue to the hw queue dispatch list, and ensure that it
 * gets run.
 */
1818
static int blk_mq_hctx_notify_dead(unsigned int cpu, struct hlist_node *node)
1819
{
1820
	struct blk_mq_hw_ctx *hctx;
1821 1822 1823
	struct blk_mq_ctx *ctx;
	LIST_HEAD(tmp);

1824
	hctx = hlist_entry_safe(node, struct blk_mq_hw_ctx, cpuhp_dead);
J
Jens Axboe 已提交
1825
	ctx = __blk_mq_get_ctx(hctx->queue, cpu);
1826 1827 1828 1829 1830 1831 1832 1833 1834

	spin_lock(&ctx->lock);
	if (!list_empty(&ctx->rq_list)) {
		list_splice_init(&ctx->rq_list, &tmp);
		blk_mq_hctx_clear_pending(hctx, ctx);
	}
	spin_unlock(&ctx->lock);

	if (list_empty(&tmp))
1835
		return 0;
1836

J
Jens Axboe 已提交
1837 1838 1839
	spin_lock(&hctx->lock);
	list_splice_tail_init(&tmp, &hctx->dispatch);
	spin_unlock(&hctx->lock);
1840 1841

	blk_mq_run_hw_queue(hctx, true);
1842
	return 0;
1843 1844
}

1845
static void blk_mq_remove_cpuhp(struct blk_mq_hw_ctx *hctx)
1846
{
1847 1848
	cpuhp_state_remove_instance_nocalls(CPUHP_BLK_MQ_DEAD,
					    &hctx->cpuhp_dead);
1849 1850
}

1851
/* hctx->ctxs will be freed in queue's release handler */
1852 1853 1854 1855
static void blk_mq_exit_hctx(struct request_queue *q,
		struct blk_mq_tag_set *set,
		struct blk_mq_hw_ctx *hctx, unsigned int hctx_idx)
{
1856 1857
	blk_mq_debugfs_unregister_hctx(hctx);

1858 1859
	blk_mq_tag_idle(hctx);

1860
	if (set->ops->exit_request)
1861
		set->ops->exit_request(set, hctx->fq->flush_rq, hctx_idx);
1862

1863 1864
	blk_mq_sched_exit_hctx(q, hctx, hctx_idx);

1865 1866 1867
	if (set->ops->exit_hctx)
		set->ops->exit_hctx(hctx, hctx_idx);

1868 1869 1870
	if (hctx->flags & BLK_MQ_F_BLOCKING)
		cleanup_srcu_struct(&hctx->queue_rq_srcu);

1871
	blk_mq_remove_cpuhp(hctx);
1872
	blk_free_flush_queue(hctx->fq);
1873
	sbitmap_free(&hctx->ctx_map);
1874 1875
}

M
Ming Lei 已提交
1876 1877 1878 1879 1880 1881 1882 1883 1884
static void blk_mq_exit_hw_queues(struct request_queue *q,
		struct blk_mq_tag_set *set, int nr_queue)
{
	struct blk_mq_hw_ctx *hctx;
	unsigned int i;

	queue_for_each_hw_ctx(q, hctx, i) {
		if (i == nr_queue)
			break;
1885
		blk_mq_exit_hctx(q, set, hctx, i);
M
Ming Lei 已提交
1886 1887 1888
	}
}

1889 1890 1891
static int blk_mq_init_hctx(struct request_queue *q,
		struct blk_mq_tag_set *set,
		struct blk_mq_hw_ctx *hctx, unsigned hctx_idx)
1892
{
1893 1894 1895 1896 1897 1898
	int node;

	node = hctx->numa_node;
	if (node == NUMA_NO_NODE)
		node = hctx->numa_node = set->numa_node;

1899
	INIT_DELAYED_WORK(&hctx->run_work, blk_mq_run_work_fn);
1900 1901 1902 1903
	spin_lock_init(&hctx->lock);
	INIT_LIST_HEAD(&hctx->dispatch);
	hctx->queue = q;
	hctx->queue_num = hctx_idx;
1904
	hctx->flags = set->flags & ~BLK_MQ_F_TAG_SHARED;
1905

1906
	cpuhp_state_add_instance_nocalls(CPUHP_BLK_MQ_DEAD, &hctx->cpuhp_dead);
1907 1908

	hctx->tags = set->tags[hctx_idx];
1909 1910

	/*
1911 1912
	 * Allocate space for all possible cpus to avoid allocation at
	 * runtime
1913
	 */
1914 1915 1916 1917
	hctx->ctxs = kmalloc_node(nr_cpu_ids * sizeof(void *),
					GFP_KERNEL, node);
	if (!hctx->ctxs)
		goto unregister_cpu_notifier;
1918

1919 1920
	if (sbitmap_init_node(&hctx->ctx_map, nr_cpu_ids, ilog2(8), GFP_KERNEL,
			      node))
1921
		goto free_ctxs;
1922

1923
	hctx->nr_ctx = 0;
1924

1925 1926 1927
	if (set->ops->init_hctx &&
	    set->ops->init_hctx(hctx, set->driver_data, hctx_idx))
		goto free_bitmap;
1928

1929 1930 1931
	if (blk_mq_sched_init_hctx(q, hctx, hctx_idx))
		goto exit_hctx;

1932 1933
	hctx->fq = blk_alloc_flush_queue(q, hctx->numa_node, set->cmd_size);
	if (!hctx->fq)
1934
		goto sched_exit_hctx;
1935

1936
	if (set->ops->init_request &&
1937 1938
	    set->ops->init_request(set, hctx->fq->flush_rq, hctx_idx,
				   node))
1939
		goto free_fq;
1940

1941 1942 1943
	if (hctx->flags & BLK_MQ_F_BLOCKING)
		init_srcu_struct(&hctx->queue_rq_srcu);

1944 1945
	blk_mq_debugfs_register_hctx(q, hctx);

1946
	return 0;
1947

1948 1949
 free_fq:
	kfree(hctx->fq);
1950 1951
 sched_exit_hctx:
	blk_mq_sched_exit_hctx(q, hctx, hctx_idx);
1952 1953 1954
 exit_hctx:
	if (set->ops->exit_hctx)
		set->ops->exit_hctx(hctx, hctx_idx);
1955
 free_bitmap:
1956
	sbitmap_free(&hctx->ctx_map);
1957 1958 1959
 free_ctxs:
	kfree(hctx->ctxs);
 unregister_cpu_notifier:
1960
	blk_mq_remove_cpuhp(hctx);
1961 1962
	return -1;
}
1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981

static void blk_mq_init_cpu_queues(struct request_queue *q,
				   unsigned int nr_hw_queues)
{
	unsigned int i;

	for_each_possible_cpu(i) {
		struct blk_mq_ctx *__ctx = per_cpu_ptr(q->queue_ctx, i);
		struct blk_mq_hw_ctx *hctx;

		__ctx->cpu = i;
		spin_lock_init(&__ctx->lock);
		INIT_LIST_HEAD(&__ctx->rq_list);
		__ctx->queue = q;

		/* If the cpu isn't online, the cpu is mapped to first hctx */
		if (!cpu_online(i))
			continue;

C
Christoph Hellwig 已提交
1982
		hctx = blk_mq_map_queue(q, i);
1983

1984 1985 1986 1987 1988
		/*
		 * Set local node, IFF we have more than one hw queue. If
		 * not, we remain on the home node of the device
		 */
		if (nr_hw_queues > 1 && hctx->numa_node == NUMA_NO_NODE)
1989
			hctx->numa_node = local_memory_node(cpu_to_node(i));
1990 1991 1992
	}
}

1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014
static bool __blk_mq_alloc_rq_map(struct blk_mq_tag_set *set, int hctx_idx)
{
	int ret = 0;

	set->tags[hctx_idx] = blk_mq_alloc_rq_map(set, hctx_idx,
					set->queue_depth, set->reserved_tags);
	if (!set->tags[hctx_idx])
		return false;

	ret = blk_mq_alloc_rqs(set, set->tags[hctx_idx], hctx_idx,
				set->queue_depth);
	if (!ret)
		return true;

	blk_mq_free_rq_map(set->tags[hctx_idx]);
	set->tags[hctx_idx] = NULL;
	return false;
}

static void blk_mq_free_map_and_requests(struct blk_mq_tag_set *set,
					 unsigned int hctx_idx)
{
2015 2016 2017 2018 2019
	if (set->tags[hctx_idx]) {
		blk_mq_free_rqs(set, set->tags[hctx_idx], hctx_idx);
		blk_mq_free_rq_map(set->tags[hctx_idx]);
		set->tags[hctx_idx] = NULL;
	}
2020 2021
}

2022 2023
static void blk_mq_map_swqueue(struct request_queue *q,
			       const struct cpumask *online_mask)
2024
{
2025
	unsigned int i, hctx_idx;
2026 2027
	struct blk_mq_hw_ctx *hctx;
	struct blk_mq_ctx *ctx;
M
Ming Lei 已提交
2028
	struct blk_mq_tag_set *set = q->tag_set;
2029

2030 2031 2032 2033 2034
	/*
	 * Avoid others reading imcomplete hctx->cpumask through sysfs
	 */
	mutex_lock(&q->sysfs_lock);

2035
	queue_for_each_hw_ctx(q, hctx, i) {
2036
		cpumask_clear(hctx->cpumask);
2037 2038 2039 2040 2041 2042
		hctx->nr_ctx = 0;
	}

	/*
	 * Map software to hardware queues
	 */
2043
	for_each_possible_cpu(i) {
2044
		/* If the cpu isn't online, the cpu is mapped to first hctx */
2045
		if (!cpumask_test_cpu(i, online_mask))
2046 2047
			continue;

2048 2049
		hctx_idx = q->mq_map[i];
		/* unmapped hw queue can be remapped after CPU topo changed */
2050 2051
		if (!set->tags[hctx_idx] &&
		    !__blk_mq_alloc_rq_map(set, hctx_idx)) {
2052 2053 2054 2055 2056 2057
			/*
			 * If tags initialization fail for some hctx,
			 * that hctx won't be brought online.  In this
			 * case, remap the current ctx to hctx[0] which
			 * is guaranteed to always have tags allocated
			 */
2058
			q->mq_map[i] = 0;
2059 2060
		}

2061
		ctx = per_cpu_ptr(q->queue_ctx, i);
C
Christoph Hellwig 已提交
2062
		hctx = blk_mq_map_queue(q, i);
K
Keith Busch 已提交
2063

2064
		cpumask_set_cpu(i, hctx->cpumask);
2065 2066 2067
		ctx->index_hw = hctx->nr_ctx;
		hctx->ctxs[hctx->nr_ctx++] = ctx;
	}
2068

2069 2070
	mutex_unlock(&q->sysfs_lock);

2071
	queue_for_each_hw_ctx(q, hctx, i) {
2072
		/*
2073 2074
		 * If no software queues are mapped to this hardware queue,
		 * disable it and free the request entries.
2075 2076
		 */
		if (!hctx->nr_ctx) {
2077 2078 2079 2080
			/* Never unmap queue 0.  We need it as a
			 * fallback in case of a new remap fails
			 * allocation
			 */
2081 2082 2083
			if (i && set->tags[i])
				blk_mq_free_map_and_requests(set, i);

M
Ming Lei 已提交
2084
			hctx->tags = NULL;
2085 2086 2087
			continue;
		}

M
Ming Lei 已提交
2088 2089 2090
		hctx->tags = set->tags[i];
		WARN_ON(!hctx->tags);

2091 2092 2093 2094 2095
		/*
		 * Set the map size to the number of mapped software queues.
		 * This is more accurate and more efficient than looping
		 * over all possibly mapped software queues.
		 */
2096
		sbitmap_resize(&hctx->ctx_map, hctx->nr_ctx);
2097

2098 2099 2100
		/*
		 * Initialize batch roundrobin counts
		 */
2101 2102 2103
		hctx->next_cpu = cpumask_first(hctx->cpumask);
		hctx->next_cpu_batch = BLK_MQ_CPU_WORK_BATCH;
	}
2104 2105
}

2106 2107 2108 2109
/*
 * Caller needs to ensure that we're either frozen/quiesced, or that
 * the queue isn't live yet.
 */
2110
static void queue_set_hctx_shared(struct request_queue *q, bool shared)
2111 2112 2113 2114
{
	struct blk_mq_hw_ctx *hctx;
	int i;

2115
	queue_for_each_hw_ctx(q, hctx, i) {
2116 2117 2118
		if (shared) {
			if (test_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state))
				atomic_inc(&q->shared_hctx_restart);
2119
			hctx->flags |= BLK_MQ_F_TAG_SHARED;
2120 2121 2122
		} else {
			if (test_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state))
				atomic_dec(&q->shared_hctx_restart);
2123
			hctx->flags &= ~BLK_MQ_F_TAG_SHARED;
2124
		}
2125 2126 2127
	}
}

2128 2129
static void blk_mq_update_tag_set_depth(struct blk_mq_tag_set *set,
					bool shared)
2130 2131
{
	struct request_queue *q;
2132

2133 2134
	lockdep_assert_held(&set->tag_list_lock);

2135 2136
	list_for_each_entry(q, &set->tag_list, tag_set_list) {
		blk_mq_freeze_queue(q);
2137
		queue_set_hctx_shared(q, shared);
2138 2139 2140 2141 2142 2143 2144 2145 2146
		blk_mq_unfreeze_queue(q);
	}
}

static void blk_mq_del_queue_tag_set(struct request_queue *q)
{
	struct blk_mq_tag_set *set = q->tag_set;

	mutex_lock(&set->tag_list_lock);
2147 2148
	list_del_rcu(&q->tag_set_list);
	INIT_LIST_HEAD(&q->tag_set_list);
2149 2150 2151 2152 2153 2154
	if (list_is_singular(&set->tag_list)) {
		/* just transitioned to unshared */
		set->flags &= ~BLK_MQ_F_TAG_SHARED;
		/* update existing queue */
		blk_mq_update_tag_set_depth(set, false);
	}
2155
	mutex_unlock(&set->tag_list_lock);
2156 2157

	synchronize_rcu();
2158 2159 2160 2161 2162 2163 2164 2165
}

static void blk_mq_add_queue_tag_set(struct blk_mq_tag_set *set,
				     struct request_queue *q)
{
	q->tag_set = set;

	mutex_lock(&set->tag_list_lock);
2166 2167 2168 2169 2170 2171 2172 2173 2174

	/* Check to see if we're transitioning to shared (from 1 to 2 queues). */
	if (!list_empty(&set->tag_list) && !(set->flags & BLK_MQ_F_TAG_SHARED)) {
		set->flags |= BLK_MQ_F_TAG_SHARED;
		/* update existing queue */
		blk_mq_update_tag_set_depth(set, true);
	}
	if (set->flags & BLK_MQ_F_TAG_SHARED)
		queue_set_hctx_shared(q, true);
2175
	list_add_tail_rcu(&q->tag_set_list, &set->tag_list);
2176

2177 2178 2179
	mutex_unlock(&set->tag_list_lock);
}

2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191
/*
 * It is the actual release handler for mq, but we do it from
 * request queue's release handler for avoiding use-after-free
 * and headache because q->mq_kobj shouldn't have been introduced,
 * but we can't group ctx/kctx kobj without it.
 */
void blk_mq_release(struct request_queue *q)
{
	struct blk_mq_hw_ctx *hctx;
	unsigned int i;

	/* hctx kobj stays in hctx */
2192 2193 2194
	queue_for_each_hw_ctx(q, hctx, i) {
		if (!hctx)
			continue;
2195
		kobject_put(&hctx->kobj);
2196
	}
2197

2198 2199
	q->mq_map = NULL;

2200 2201
	kfree(q->queue_hw_ctx);

2202 2203 2204 2205 2206 2207
	/*
	 * release .mq_kobj and sw queue's kobject now because
	 * both share lifetime with request queue.
	 */
	blk_mq_sysfs_deinit(q);

2208 2209 2210
	free_percpu(q->queue_ctx);
}

2211
struct request_queue *blk_mq_init_queue(struct blk_mq_tag_set *set)
2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226
{
	struct request_queue *uninit_q, *q;

	uninit_q = blk_alloc_queue_node(GFP_KERNEL, set->numa_node);
	if (!uninit_q)
		return ERR_PTR(-ENOMEM);

	q = blk_mq_init_allocated_queue(set, uninit_q);
	if (IS_ERR(q))
		blk_cleanup_queue(uninit_q);

	return q;
}
EXPORT_SYMBOL(blk_mq_init_queue);

K
Keith Busch 已提交
2227 2228
static void blk_mq_realloc_hw_ctxs(struct blk_mq_tag_set *set,
						struct request_queue *q)
2229
{
K
Keith Busch 已提交
2230 2231
	int i, j;
	struct blk_mq_hw_ctx **hctxs = q->queue_hw_ctx;
2232

K
Keith Busch 已提交
2233
	blk_mq_sysfs_unregister(q);
2234
	for (i = 0; i < set->nr_hw_queues; i++) {
K
Keith Busch 已提交
2235
		int node;
2236

K
Keith Busch 已提交
2237 2238 2239 2240
		if (hctxs[i])
			continue;

		node = blk_mq_hw_queue_to_node(q->mq_map, i);
2241 2242
		hctxs[i] = kzalloc_node(sizeof(struct blk_mq_hw_ctx),
					GFP_KERNEL, node);
2243
		if (!hctxs[i])
K
Keith Busch 已提交
2244
			break;
2245

2246
		if (!zalloc_cpumask_var_node(&hctxs[i]->cpumask, GFP_KERNEL,
K
Keith Busch 已提交
2247 2248 2249 2250 2251
						node)) {
			kfree(hctxs[i]);
			hctxs[i] = NULL;
			break;
		}
2252

2253
		atomic_set(&hctxs[i]->nr_active, 0);
2254
		hctxs[i]->numa_node = node;
2255
		hctxs[i]->queue_num = i;
K
Keith Busch 已提交
2256 2257 2258 2259 2260 2261 2262 2263

		if (blk_mq_init_hctx(q, set, hctxs[i], i)) {
			free_cpumask_var(hctxs[i]->cpumask);
			kfree(hctxs[i]);
			hctxs[i] = NULL;
			break;
		}
		blk_mq_hctx_kobj_init(hctxs[i]);
2264
	}
K
Keith Busch 已提交
2265 2266 2267 2268
	for (j = i; j < q->nr_hw_queues; j++) {
		struct blk_mq_hw_ctx *hctx = hctxs[j];

		if (hctx) {
2269 2270
			if (hctx->tags)
				blk_mq_free_map_and_requests(set, j);
K
Keith Busch 已提交
2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283
			blk_mq_exit_hctx(q, set, hctx, j);
			kobject_put(&hctx->kobj);
			hctxs[j] = NULL;

		}
	}
	q->nr_hw_queues = i;
	blk_mq_sysfs_register(q);
}

struct request_queue *blk_mq_init_allocated_queue(struct blk_mq_tag_set *set,
						  struct request_queue *q)
{
M
Ming Lei 已提交
2284 2285 2286
	/* mark the queue as mq asap */
	q->mq_ops = set->ops;

2287
	q->poll_cb = blk_stat_alloc_callback(blk_mq_poll_stats_fn,
2288 2289
					     blk_mq_poll_stats_bkt,
					     BLK_MQ_POLL_STATS_BKTS, q);
2290 2291 2292
	if (!q->poll_cb)
		goto err_exit;

K
Keith Busch 已提交
2293 2294
	q->queue_ctx = alloc_percpu(struct blk_mq_ctx);
	if (!q->queue_ctx)
M
Ming Lin 已提交
2295
		goto err_exit;
K
Keith Busch 已提交
2296

2297 2298 2299
	/* init q->mq_kobj and sw queues' kobjects */
	blk_mq_sysfs_init(q);

K
Keith Busch 已提交
2300 2301 2302 2303 2304
	q->queue_hw_ctx = kzalloc_node(nr_cpu_ids * sizeof(*(q->queue_hw_ctx)),
						GFP_KERNEL, set->numa_node);
	if (!q->queue_hw_ctx)
		goto err_percpu;

2305
	q->mq_map = set->mq_map;
K
Keith Busch 已提交
2306 2307 2308 2309

	blk_mq_realloc_hw_ctxs(set, q);
	if (!q->nr_hw_queues)
		goto err_hctxs;
2310

2311
	INIT_WORK(&q->timeout_work, blk_mq_timeout_work);
2312
	blk_queue_rq_timeout(q, set->timeout ? set->timeout : 30 * HZ);
2313 2314 2315

	q->nr_queues = nr_cpu_ids;

2316
	q->queue_flags |= QUEUE_FLAG_MQ_DEFAULT;
2317

2318 2319 2320
	if (!(set->flags & BLK_MQ_F_SG_MERGE))
		q->queue_flags |= 1 << QUEUE_FLAG_NO_SG_MERGE;

2321 2322
	q->sg_reserved_size = INT_MAX;

2323
	INIT_DELAYED_WORK(&q->requeue_work, blk_mq_requeue_work);
2324 2325 2326
	INIT_LIST_HEAD(&q->requeue_list);
	spin_lock_init(&q->requeue_lock);

2327
	blk_queue_make_request(q, blk_mq_make_request);
2328

2329 2330 2331 2332 2333
	/*
	 * Do this after blk_queue_make_request() overrides it...
	 */
	q->nr_requests = set->queue_depth;

2334 2335 2336 2337 2338
	/*
	 * Default to classic polling
	 */
	q->poll_nsec = -1;

2339 2340
	if (set->ops->complete)
		blk_queue_softirq_done(q, set->ops->complete);
2341

2342
	blk_mq_init_cpu_queues(q, set->nr_hw_queues);
2343

2344
	get_online_cpus();
2345
	mutex_lock(&all_q_mutex);
2346

2347
	list_add_tail(&q->all_q_node, &all_q_list);
2348
	blk_mq_add_queue_tag_set(set, q);
2349
	blk_mq_map_swqueue(q, cpu_online_mask);
2350

2351
	mutex_unlock(&all_q_mutex);
2352
	put_online_cpus();
2353

2354 2355 2356 2357 2358 2359 2360 2361
	if (!(set->flags & BLK_MQ_F_NO_SCHED)) {
		int ret;

		ret = blk_mq_sched_init(q);
		if (ret)
			return ERR_PTR(ret);
	}

2362
	return q;
2363

2364
err_hctxs:
K
Keith Busch 已提交
2365
	kfree(q->queue_hw_ctx);
2366
err_percpu:
K
Keith Busch 已提交
2367
	free_percpu(q->queue_ctx);
M
Ming Lin 已提交
2368 2369
err_exit:
	q->mq_ops = NULL;
2370 2371
	return ERR_PTR(-ENOMEM);
}
2372
EXPORT_SYMBOL(blk_mq_init_allocated_queue);
2373 2374 2375

void blk_mq_free_queue(struct request_queue *q)
{
M
Ming Lei 已提交
2376
	struct blk_mq_tag_set	*set = q->tag_set;
2377

2378 2379 2380 2381
	mutex_lock(&all_q_mutex);
	list_del_init(&q->all_q_node);
	mutex_unlock(&all_q_mutex);

2382 2383
	blk_mq_del_queue_tag_set(q);

M
Ming Lei 已提交
2384
	blk_mq_exit_hw_queues(q, set, set->nr_hw_queues);
2385 2386 2387
}

/* Basically redo blk_mq_init_queue with queue frozen */
2388 2389
static void blk_mq_queue_reinit(struct request_queue *q,
				const struct cpumask *online_mask)
2390
{
2391
	WARN_ON_ONCE(!atomic_read(&q->mq_freeze_depth));
2392

2393
	blk_mq_debugfs_unregister_hctxs(q);
2394 2395
	blk_mq_sysfs_unregister(q);

2396 2397 2398 2399 2400 2401
	/*
	 * redo blk_mq_init_cpu_queues and blk_mq_init_hw_queues. FIXME: maybe
	 * we should change hctx numa_node according to new topology (this
	 * involves free and re-allocate memory, worthy doing?)
	 */

2402
	blk_mq_map_swqueue(q, online_mask);
2403

2404
	blk_mq_sysfs_register(q);
2405
	blk_mq_debugfs_register_hctxs(q);
2406 2407
}

2408 2409 2410 2411 2412 2413 2414 2415
/*
 * New online cpumask which is going to be set in this hotplug event.
 * Declare this cpumasks as global as cpu-hotplug operation is invoked
 * one-by-one and dynamically allocating this could result in a failure.
 */
static struct cpumask cpuhp_online_new;

static void blk_mq_queue_reinit_work(void)
2416 2417 2418 2419
{
	struct request_queue *q;

	mutex_lock(&all_q_mutex);
2420 2421 2422 2423 2424 2425 2426 2427
	/*
	 * We need to freeze and reinit all existing queues.  Freezing
	 * involves synchronous wait for an RCU grace period and doing it
	 * one by one may take a long time.  Start freezing all queues in
	 * one swoop and then wait for the completions so that freezing can
	 * take place in parallel.
	 */
	list_for_each_entry(q, &all_q_list, all_q_node)
2428
		blk_freeze_queue_start(q);
2429
	list_for_each_entry(q, &all_q_list, all_q_node)
2430 2431
		blk_mq_freeze_queue_wait(q);

2432
	list_for_each_entry(q, &all_q_list, all_q_node)
2433
		blk_mq_queue_reinit(q, &cpuhp_online_new);
2434 2435 2436 2437

	list_for_each_entry(q, &all_q_list, all_q_node)
		blk_mq_unfreeze_queue(q);

2438
	mutex_unlock(&all_q_mutex);
2439 2440 2441 2442
}

static int blk_mq_queue_reinit_dead(unsigned int cpu)
{
2443
	cpumask_copy(&cpuhp_online_new, cpu_online_mask);
2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458
	blk_mq_queue_reinit_work();
	return 0;
}

/*
 * Before hotadded cpu starts handling requests, new mappings must be
 * established.  Otherwise, these requests in hw queue might never be
 * dispatched.
 *
 * For example, there is a single hw queue (hctx) and two CPU queues (ctx0
 * for CPU0, and ctx1 for CPU1).
 *
 * Now CPU1 is just onlined and a request is inserted into ctx1->rq_list
 * and set bit0 in pending bitmap as ctx1->index_hw is still zero.
 *
2459 2460 2461 2462
 * And then while running hw queue, blk_mq_flush_busy_ctxs() finds bit0 is set
 * in pending bitmap and tries to retrieve requests in hctx->ctxs[0]->rq_list.
 * But htx->ctxs[0] is a pointer to ctx0, so the request in ctx1->rq_list is
 * ignored.
2463 2464 2465 2466 2467 2468 2469
 */
static int blk_mq_queue_reinit_prepare(unsigned int cpu)
{
	cpumask_copy(&cpuhp_online_new, cpu_online_mask);
	cpumask_set_cpu(cpu, &cpuhp_online_new);
	blk_mq_queue_reinit_work();
	return 0;
2470 2471
}

2472 2473 2474 2475
static int __blk_mq_alloc_rq_maps(struct blk_mq_tag_set *set)
{
	int i;

2476 2477
	for (i = 0; i < set->nr_hw_queues; i++)
		if (!__blk_mq_alloc_rq_map(set, i))
2478 2479 2480 2481 2482 2483
			goto out_unwind;

	return 0;

out_unwind:
	while (--i >= 0)
2484
		blk_mq_free_rq_map(set->tags[i]);
2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523

	return -ENOMEM;
}

/*
 * Allocate the request maps associated with this tag_set. Note that this
 * may reduce the depth asked for, if memory is tight. set->queue_depth
 * will be updated to reflect the allocated depth.
 */
static int blk_mq_alloc_rq_maps(struct blk_mq_tag_set *set)
{
	unsigned int depth;
	int err;

	depth = set->queue_depth;
	do {
		err = __blk_mq_alloc_rq_maps(set);
		if (!err)
			break;

		set->queue_depth >>= 1;
		if (set->queue_depth < set->reserved_tags + BLK_MQ_TAG_MIN) {
			err = -ENOMEM;
			break;
		}
	} while (set->queue_depth);

	if (!set->queue_depth || err) {
		pr_err("blk-mq: failed to allocate request map\n");
		return -ENOMEM;
	}

	if (depth != set->queue_depth)
		pr_info("blk-mq: reduced tag depth (%u -> %u)\n",
						depth, set->queue_depth);

	return 0;
}

2524 2525 2526 2527 2528 2529 2530 2531
static int blk_mq_update_queue_map(struct blk_mq_tag_set *set)
{
	if (set->ops->map_queues)
		return set->ops->map_queues(set);
	else
		return blk_mq_map_queues(set);
}

2532 2533 2534 2535 2536 2537
/*
 * Alloc a tag set to be associated with one or more request queues.
 * May fail with EINVAL for various error conditions. May adjust the
 * requested depth down, if if it too large. In that case, the set
 * value will be stored in set->queue_depth.
 */
2538 2539
int blk_mq_alloc_tag_set(struct blk_mq_tag_set *set)
{
2540 2541
	int ret;

B
Bart Van Assche 已提交
2542 2543
	BUILD_BUG_ON(BLK_MQ_MAX_DEPTH > 1 << BLK_MQ_UNIQUE_TAG_BITS);

2544 2545
	if (!set->nr_hw_queues)
		return -EINVAL;
2546
	if (!set->queue_depth)
2547 2548 2549 2550
		return -EINVAL;
	if (set->queue_depth < set->reserved_tags + BLK_MQ_TAG_MIN)
		return -EINVAL;

C
Christoph Hellwig 已提交
2551
	if (!set->ops->queue_rq)
2552 2553
		return -EINVAL;

2554 2555 2556 2557 2558
	if (set->queue_depth > BLK_MQ_MAX_DEPTH) {
		pr_info("blk-mq: reduced tag depth to %u\n",
			BLK_MQ_MAX_DEPTH);
		set->queue_depth = BLK_MQ_MAX_DEPTH;
	}
2559

2560 2561 2562 2563 2564 2565 2566 2567 2568
	/*
	 * If a crashdump is active, then we are potentially in a very
	 * memory constrained environment. Limit us to 1 queue and
	 * 64 tags to prevent using too much memory.
	 */
	if (is_kdump_kernel()) {
		set->nr_hw_queues = 1;
		set->queue_depth = min(64U, set->queue_depth);
	}
K
Keith Busch 已提交
2569 2570 2571 2572 2573
	/*
	 * There is no use for more h/w queues than cpus.
	 */
	if (set->nr_hw_queues > nr_cpu_ids)
		set->nr_hw_queues = nr_cpu_ids;
2574

K
Keith Busch 已提交
2575
	set->tags = kzalloc_node(nr_cpu_ids * sizeof(struct blk_mq_tags *),
2576 2577
				 GFP_KERNEL, set->numa_node);
	if (!set->tags)
2578
		return -ENOMEM;
2579

2580 2581 2582
	ret = -ENOMEM;
	set->mq_map = kzalloc_node(sizeof(*set->mq_map) * nr_cpu_ids,
			GFP_KERNEL, set->numa_node);
2583 2584 2585
	if (!set->mq_map)
		goto out_free_tags;

2586
	ret = blk_mq_update_queue_map(set);
2587 2588 2589 2590 2591
	if (ret)
		goto out_free_mq_map;

	ret = blk_mq_alloc_rq_maps(set);
	if (ret)
2592
		goto out_free_mq_map;
2593

2594 2595 2596
	mutex_init(&set->tag_list_lock);
	INIT_LIST_HEAD(&set->tag_list);

2597
	return 0;
2598 2599 2600 2601 2602

out_free_mq_map:
	kfree(set->mq_map);
	set->mq_map = NULL;
out_free_tags:
2603 2604
	kfree(set->tags);
	set->tags = NULL;
2605
	return ret;
2606 2607 2608 2609 2610 2611 2612
}
EXPORT_SYMBOL(blk_mq_alloc_tag_set);

void blk_mq_free_tag_set(struct blk_mq_tag_set *set)
{
	int i;

2613 2614
	for (i = 0; i < nr_cpu_ids; i++)
		blk_mq_free_map_and_requests(set, i);
2615

2616 2617 2618
	kfree(set->mq_map);
	set->mq_map = NULL;

M
Ming Lei 已提交
2619
	kfree(set->tags);
2620
	set->tags = NULL;
2621 2622 2623
}
EXPORT_SYMBOL(blk_mq_free_tag_set);

2624 2625 2626 2627 2628 2629
int blk_mq_update_nr_requests(struct request_queue *q, unsigned int nr)
{
	struct blk_mq_tag_set *set = q->tag_set;
	struct blk_mq_hw_ctx *hctx;
	int i, ret;

2630
	if (!set)
2631 2632
		return -EINVAL;

2633 2634
	blk_mq_freeze_queue(q);

2635 2636
	ret = 0;
	queue_for_each_hw_ctx(q, hctx, i) {
2637 2638
		if (!hctx->tags)
			continue;
2639 2640 2641 2642
		/*
		 * If we're using an MQ scheduler, just update the scheduler
		 * queue depth. This is similar to what the old code would do.
		 */
2643 2644 2645 2646 2647 2648 2649 2650
		if (!hctx->sched_tags) {
			ret = blk_mq_tag_update_depth(hctx, &hctx->tags,
							min(nr, set->queue_depth),
							false);
		} else {
			ret = blk_mq_tag_update_depth(hctx, &hctx->sched_tags,
							nr, true);
		}
2651 2652 2653 2654 2655 2656 2657
		if (ret)
			break;
	}

	if (!ret)
		q->nr_requests = nr;

2658 2659
	blk_mq_unfreeze_queue(q);

2660 2661 2662
	return ret;
}

2663 2664
static void __blk_mq_update_nr_hw_queues(struct blk_mq_tag_set *set,
							int nr_hw_queues)
K
Keith Busch 已提交
2665 2666 2667
{
	struct request_queue *q;

2668 2669
	lockdep_assert_held(&set->tag_list_lock);

K
Keith Busch 已提交
2670 2671 2672 2673 2674 2675 2676 2677 2678
	if (nr_hw_queues > nr_cpu_ids)
		nr_hw_queues = nr_cpu_ids;
	if (nr_hw_queues < 1 || nr_hw_queues == set->nr_hw_queues)
		return;

	list_for_each_entry(q, &set->tag_list, tag_set_list)
		blk_mq_freeze_queue(q);

	set->nr_hw_queues = nr_hw_queues;
2679
	blk_mq_update_queue_map(set);
K
Keith Busch 已提交
2680 2681 2682 2683 2684 2685 2686 2687
	list_for_each_entry(q, &set->tag_list, tag_set_list) {
		blk_mq_realloc_hw_ctxs(set, q);
		blk_mq_queue_reinit(q, cpu_online_mask);
	}

	list_for_each_entry(q, &set->tag_list, tag_set_list)
		blk_mq_unfreeze_queue(q);
}
2688 2689 2690 2691 2692 2693 2694

void blk_mq_update_nr_hw_queues(struct blk_mq_tag_set *set, int nr_hw_queues)
{
	mutex_lock(&set->tag_list_lock);
	__blk_mq_update_nr_hw_queues(set, nr_hw_queues);
	mutex_unlock(&set->tag_list_lock);
}
K
Keith Busch 已提交
2695 2696
EXPORT_SYMBOL_GPL(blk_mq_update_nr_hw_queues);

2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722
/* Enable polling stats and return whether they were already enabled. */
static bool blk_poll_stats_enable(struct request_queue *q)
{
	if (test_bit(QUEUE_FLAG_POLL_STATS, &q->queue_flags) ||
	    test_and_set_bit(QUEUE_FLAG_POLL_STATS, &q->queue_flags))
		return true;
	blk_stat_add_callback(q, q->poll_cb);
	return false;
}

static void blk_mq_poll_stats_start(struct request_queue *q)
{
	/*
	 * We don't arm the callback if polling stats are not enabled or the
	 * callback is already active.
	 */
	if (!test_bit(QUEUE_FLAG_POLL_STATS, &q->queue_flags) ||
	    blk_stat_is_active(q->poll_cb))
		return;

	blk_stat_activate_msecs(q->poll_cb, 100);
}

static void blk_mq_poll_stats_fn(struct blk_stat_callback *cb)
{
	struct request_queue *q = cb->data;
2723
	int bucket;
2724

2725 2726 2727 2728
	for (bucket = 0; bucket < BLK_MQ_POLL_STATS_BKTS; bucket++) {
		if (cb->stat[bucket].nr_samples)
			q->poll_stat[bucket] = cb->stat[bucket];
	}
2729 2730
}

2731 2732 2733 2734 2735
static unsigned long blk_mq_poll_nsecs(struct request_queue *q,
				       struct blk_mq_hw_ctx *hctx,
				       struct request *rq)
{
	unsigned long ret = 0;
2736
	int bucket;
2737 2738 2739 2740 2741

	/*
	 * If stats collection isn't on, don't sleep but turn it on for
	 * future users
	 */
2742
	if (!blk_poll_stats_enable(q))
2743 2744 2745 2746 2747 2748 2749 2750
		return 0;

	/*
	 * As an optimistic guess, use half of the mean service time
	 * for this type of request. We can (and should) make this smarter.
	 * For instance, if the completion latencies are tight, we can
	 * get closer than just half the mean. This is especially
	 * important on devices where the completion latencies are longer
2751 2752
	 * than ~10 usec. We do use the stats for the relevant IO size
	 * if available which does lead to better estimates.
2753
	 */
2754 2755 2756 2757 2758 2759
	bucket = blk_mq_poll_stats_bkt(rq);
	if (bucket < 0)
		return ret;

	if (q->poll_stat[bucket].nr_samples)
		ret = (q->poll_stat[bucket].mean + 1) / 2;
2760 2761 2762 2763

	return ret;
}

2764
static bool blk_mq_poll_hybrid_sleep(struct request_queue *q,
2765
				     struct blk_mq_hw_ctx *hctx,
2766 2767 2768 2769
				     struct request *rq)
{
	struct hrtimer_sleeper hs;
	enum hrtimer_mode mode;
2770
	unsigned int nsecs;
2771 2772
	ktime_t kt;

2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790
	if (test_bit(REQ_ATOM_POLL_SLEPT, &rq->atomic_flags))
		return false;

	/*
	 * poll_nsec can be:
	 *
	 * -1:	don't ever hybrid sleep
	 *  0:	use half of prev avg
	 * >0:	use this specific value
	 */
	if (q->poll_nsec == -1)
		return false;
	else if (q->poll_nsec > 0)
		nsecs = q->poll_nsec;
	else
		nsecs = blk_mq_poll_nsecs(q, hctx, rq);

	if (!nsecs)
2791 2792 2793 2794 2795 2796 2797 2798
		return false;

	set_bit(REQ_ATOM_POLL_SLEPT, &rq->atomic_flags);

	/*
	 * This will be replaced with the stats tracking code, using
	 * 'avg_completion_time / 2' as the pre-sleep target.
	 */
T
Thomas Gleixner 已提交
2799
	kt = nsecs;
2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821

	mode = HRTIMER_MODE_REL;
	hrtimer_init_on_stack(&hs.timer, CLOCK_MONOTONIC, mode);
	hrtimer_set_expires(&hs.timer, kt);

	hrtimer_init_sleeper(&hs, current);
	do {
		if (test_bit(REQ_ATOM_COMPLETE, &rq->atomic_flags))
			break;
		set_current_state(TASK_UNINTERRUPTIBLE);
		hrtimer_start_expires(&hs.timer, mode);
		if (hs.task)
			io_schedule();
		hrtimer_cancel(&hs.timer);
		mode = HRTIMER_MODE_ABS;
	} while (hs.task && !signal_pending(current));

	__set_current_state(TASK_RUNNING);
	destroy_hrtimer_on_stack(&hs.timer);
	return true;
}

J
Jens Axboe 已提交
2822 2823 2824 2825 2826
static bool __blk_mq_poll(struct blk_mq_hw_ctx *hctx, struct request *rq)
{
	struct request_queue *q = hctx->queue;
	long state;

2827 2828 2829 2830 2831 2832 2833
	/*
	 * If we sleep, have the caller restart the poll loop to reset
	 * the state. Like for the other success return cases, the
	 * caller is responsible for checking if the IO completed. If
	 * the IO isn't complete, we'll get called again and will go
	 * straight to the busy poll loop.
	 */
2834
	if (blk_mq_poll_hybrid_sleep(q, hctx, rq))
2835 2836
		return true;

J
Jens Axboe 已提交
2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879
	hctx->poll_considered++;

	state = current->state;
	while (!need_resched()) {
		int ret;

		hctx->poll_invoked++;

		ret = q->mq_ops->poll(hctx, rq->tag);
		if (ret > 0) {
			hctx->poll_success++;
			set_current_state(TASK_RUNNING);
			return true;
		}

		if (signal_pending_state(state, current))
			set_current_state(TASK_RUNNING);

		if (current->state == TASK_RUNNING)
			return true;
		if (ret < 0)
			break;
		cpu_relax();
	}

	return false;
}

bool blk_mq_poll(struct request_queue *q, blk_qc_t cookie)
{
	struct blk_mq_hw_ctx *hctx;
	struct blk_plug *plug;
	struct request *rq;

	if (!q->mq_ops || !q->mq_ops->poll || !blk_qc_t_valid(cookie) ||
	    !test_bit(QUEUE_FLAG_POLL, &q->queue_flags))
		return false;

	plug = current->plug;
	if (plug)
		blk_flush_plug_list(plug, false);

	hctx = q->queue_hw_ctx[blk_qc_t_to_queue_num(cookie)];
2880 2881
	if (!blk_qc_t_is_internal(cookie))
		rq = blk_mq_tag_to_rq(hctx->tags, blk_qc_t_to_tag(cookie));
2882
	else {
2883
		rq = blk_mq_tag_to_rq(hctx->sched_tags, blk_qc_t_to_tag(cookie));
2884 2885 2886 2887 2888 2889 2890 2891 2892
		/*
		 * With scheduling, if the request has completed, we'll
		 * get a NULL return here, as we clear the sched tag when
		 * that happens. The request still remains valid, like always,
		 * so we should be safe with just the NULL check.
		 */
		if (!rq)
			return false;
	}
J
Jens Axboe 已提交
2893 2894 2895 2896 2897

	return __blk_mq_poll(hctx, rq);
}
EXPORT_SYMBOL_GPL(blk_mq_poll);

2898 2899 2900 2901 2902 2903 2904 2905 2906 2907
void blk_mq_disable_hotplug(void)
{
	mutex_lock(&all_q_mutex);
}

void blk_mq_enable_hotplug(void)
{
	mutex_unlock(&all_q_mutex);
}

2908 2909
static int __init blk_mq_init(void)
{
2910 2911
	cpuhp_setup_state_multi(CPUHP_BLK_MQ_DEAD, "block/mq:dead", NULL,
				blk_mq_hctx_notify_dead);
2912

2913 2914 2915
	cpuhp_setup_state_nocalls(CPUHP_BLK_MQ_PREPARE, "block/mq:prepare",
				  blk_mq_queue_reinit_prepare,
				  blk_mq_queue_reinit_dead);
2916 2917 2918
	return 0;
}
subsys_initcall(blk_mq_init);