blk-mq.c 77.5 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
static bool blk_mq_poll(struct request_queue *q, blk_qc_t cookie);
41 42 43
static void blk_mq_poll_stats_start(struct request_queue *q);
static void blk_mq_poll_stats_fn(struct blk_stat_callback *cb);

44 45 46 47
static int blk_mq_poll_stats_bkt(const struct request *rq)
{
	int ddir, bytes, bucket;

J
Jens Axboe 已提交
48
	ddir = rq_data_dir(rq);
49 50 51 52 53 54 55 56 57 58 59 60
	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;
}

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

71 72 73 74 75 76
/*
 * 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)
{
77 78
	if (!sbitmap_test_bit(&hctx->ctx_map, ctx->index_hw))
		sbitmap_set_bit(&hctx->ctx_map, ctx->index_hw);
79 80 81 82 83
}

static void blk_mq_hctx_clear_pending(struct blk_mq_hw_ctx *hctx,
				      struct blk_mq_ctx *ctx)
{
84
	sbitmap_clear_bit(&hctx->ctx_map, ctx->index_hw);
85 86
}

87 88 89 90 91 92 93 94 95 96 97
struct mq_inflight {
	struct hd_struct *part;
	unsigned int *inflight;
};

static void blk_mq_check_inflight(struct blk_mq_hw_ctx *hctx,
				  struct request *rq, void *priv,
				  bool reserved)
{
	struct mq_inflight *mi = priv;

98
	if (blk_mq_rq_state(rq) == MQ_RQ_IN_FLIGHT) {
99
		/*
100 101 102 103
		 * index[0] counts the specific partition that was asked
		 * for. index[1] counts the ones that are active on the
		 * whole device, so increment that if mi->part is indeed
		 * a partition, and not a whole device.
104
		 */
105
		if (rq->part == mi->part)
106
			mi->inflight[0]++;
107 108
		if (mi->part->partno)
			mi->inflight[1]++;
109 110 111 112 113 114 115 116
	}
}

void blk_mq_in_flight(struct request_queue *q, struct hd_struct *part,
		      unsigned int inflight[2])
{
	struct mq_inflight mi = { .part = part, .inflight = inflight, };

117
	inflight[0] = inflight[1] = 0;
118 119 120
	blk_mq_queue_tag_busy_iter(q, blk_mq_check_inflight, &mi);
}

121
void blk_freeze_queue_start(struct request_queue *q)
122
{
123
	int freeze_depth;
124

125 126
	freeze_depth = atomic_inc_return(&q->mq_freeze_depth);
	if (freeze_depth == 1) {
127
		percpu_ref_kill(&q->q_usage_counter);
128 129
		if (q->mq_ops)
			blk_mq_run_hw_queues(q, false);
130
	}
131
}
132
EXPORT_SYMBOL_GPL(blk_freeze_queue_start);
133

134
void blk_mq_freeze_queue_wait(struct request_queue *q)
135
{
136
	wait_event(q->mq_freeze_wq, percpu_ref_is_zero(&q->q_usage_counter));
137
}
138
EXPORT_SYMBOL_GPL(blk_mq_freeze_queue_wait);
139

140 141 142 143 144 145 146 147
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);
148

149 150 151 152
/*
 * Guarantee no request is in use, so we can change any data structure of
 * the queue afterward.
 */
153
void blk_freeze_queue(struct request_queue *q)
154
{
155 156 157 158 159 160 161
	/*
	 * 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.
	 */
162
	blk_freeze_queue_start(q);
163 164
	blk_mq_freeze_queue_wait(q);
}
165 166 167 168 169 170 171 172 173

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);
}
174
EXPORT_SYMBOL_GPL(blk_mq_freeze_queue);
175

176
void blk_mq_unfreeze_queue(struct request_queue *q)
177
{
178
	int freeze_depth;
179

180 181 182
	freeze_depth = atomic_dec_return(&q->mq_freeze_depth);
	WARN_ON_ONCE(freeze_depth < 0);
	if (!freeze_depth) {
183
		percpu_ref_reinit(&q->q_usage_counter);
184
		wake_up_all(&q->mq_freeze_wq);
185
	}
186
}
187
EXPORT_SYMBOL_GPL(blk_mq_unfreeze_queue);
188

189 190 191 192 193 194 195 196 197 198 199 200 201 202
/*
 * FIXME: replace the scsi_internal_device_*block_nowait() calls in the
 * mpt3sas driver such that this function can be removed.
 */
void blk_mq_quiesce_queue_nowait(struct request_queue *q)
{
	unsigned long flags;

	spin_lock_irqsave(q->queue_lock, flags);
	queue_flag_set(QUEUE_FLAG_QUIESCED, q);
	spin_unlock_irqrestore(q->queue_lock, flags);
}
EXPORT_SYMBOL_GPL(blk_mq_quiesce_queue_nowait);

203
/**
204
 * blk_mq_quiesce_queue() - wait until all ongoing dispatches have finished
205 206 207
 * @q: request queue.
 *
 * Note: this function does not prevent that the struct request end_io()
208 209 210
 * callback function is invoked. Once this function is returned, we make
 * sure no dispatch can happen until the queue is unquiesced via
 * blk_mq_unquiesce_queue().
211 212 213 214 215 216 217
 */
void blk_mq_quiesce_queue(struct request_queue *q)
{
	struct blk_mq_hw_ctx *hctx;
	unsigned int i;
	bool rcu = false;

218
	blk_mq_quiesce_queue_nowait(q);
219

220 221
	queue_for_each_hw_ctx(q, hctx, i) {
		if (hctx->flags & BLK_MQ_F_BLOCKING)
222
			synchronize_srcu(hctx->srcu);
223 224 225 226 227 228 229 230
		else
			rcu = true;
	}
	if (rcu)
		synchronize_rcu();
}
EXPORT_SYMBOL_GPL(blk_mq_quiesce_queue);

231 232 233 234 235 236 237 238 239
/*
 * blk_mq_unquiesce_queue() - counterpart of blk_mq_quiesce_queue()
 * @q: request queue.
 *
 * This function recovers queue into the state before quiescing
 * which is done by blk_mq_quiesce_queue.
 */
void blk_mq_unquiesce_queue(struct request_queue *q)
{
240 241 242
	unsigned long flags;

	spin_lock_irqsave(q->queue_lock, flags);
243
	queue_flag_clear(QUEUE_FLAG_QUIESCED, q);
244
	spin_unlock_irqrestore(q->queue_lock, flags);
245

246 247
	/* dispatch requests which are inserted during quiescing */
	blk_mq_run_hw_queues(q, true);
248 249 250
}
EXPORT_SYMBOL_GPL(blk_mq_unquiesce_queue);

251 252 253 254 255 256 257 258 259 260
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);
}

261 262 263 264 265 266
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);

267 268
static struct request *blk_mq_rq_ctx_init(struct blk_mq_alloc_data *data,
		unsigned int tag, unsigned int op)
269
{
270 271
	struct blk_mq_tags *tags = blk_mq_tags_from_data(data);
	struct request *rq = tags->static_rqs[tag];
272
	req_flags_t rq_flags = 0;
273 274 275 276 277 278

	if (data->flags & BLK_MQ_REQ_INTERNAL) {
		rq->tag = -1;
		rq->internal_tag = tag;
	} else {
		if (blk_mq_tag_busy(data->hctx)) {
279
			rq_flags = RQF_MQ_INFLIGHT;
280 281 282 283 284 285 286
			atomic_inc(&data->hctx->nr_active);
		}
		rq->tag = tag;
		rq->internal_tag = -1;
		data->hctx->tags->rqs[rq->tag] = rq;
	}

287
	/* csd/requeue_work/fifo_time is initialized before use */
288 289
	rq->q = data->q;
	rq->mq_ctx = data->ctx;
290
	rq->rq_flags = rq_flags;
291
	rq->cpu = -1;
292
	rq->cmd_flags = op;
293 294
	if (data->flags & BLK_MQ_REQ_PREEMPT)
		rq->rq_flags |= RQF_PREEMPT;
295
	if (blk_queue_io_stat(data->q))
296
		rq->rq_flags |= RQF_IO_STAT;
297
	INIT_LIST_HEAD(&rq->queuelist);
298 299 300 301
	INIT_HLIST_NODE(&rq->hash);
	RB_CLEAR_NODE(&rq->rb_node);
	rq->rq_disk = NULL;
	rq->part = NULL;
302
	rq->start_time = jiffies;
303 304 305 306 307 308 309
	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;
310
	rq->__deadline = 0;
311 312

	INIT_LIST_HEAD(&rq->timeout_list);
313 314
	rq->timeout = 0;

315 316 317 318
	rq->end_io = NULL;
	rq->end_io_data = NULL;
	rq->next_rq = NULL;

319 320 321 322 323 324
#ifdef CONFIG_BLK_CGROUP
	rq->rl = NULL;
	set_start_time_ns(rq);
	rq->io_start_time_ns = 0;
#endif

325 326
	data->ctx->rq_dispatched[op_is_sync(op)]++;
	return rq;
327 328
}

329 330 331 332 333 334
static struct request *blk_mq_get_request(struct request_queue *q,
		struct bio *bio, unsigned int op,
		struct blk_mq_alloc_data *data)
{
	struct elevator_queue *e = q->elevator;
	struct request *rq;
335
	unsigned int tag;
336
	bool put_ctx_on_error = false;
337 338 339

	blk_queue_enter_live(q);
	data->q = q;
340 341 342 343
	if (likely(!data->ctx)) {
		data->ctx = blk_mq_get_ctx(q);
		put_ctx_on_error = true;
	}
344 345
	if (likely(!data->hctx))
		data->hctx = blk_mq_map_queue(q, data->ctx->cpu);
346 347
	if (op & REQ_NOWAIT)
		data->flags |= BLK_MQ_REQ_NOWAIT;
348 349 350 351 352 353 354 355

	if (e) {
		data->flags |= BLK_MQ_REQ_INTERNAL;

		/*
		 * Flush requests are special and go directly to the
		 * dispatch list.
		 */
356 357
		if (!op_is_flush(op) && e->type->ops.mq.limit_depth)
			e->type->ops.mq.limit_depth(op, data);
358 359
	}

360 361
	tag = blk_mq_get_tag(data);
	if (tag == BLK_MQ_TAG_FAIL) {
362 363
		if (put_ctx_on_error) {
			blk_mq_put_ctx(data->ctx);
364 365
			data->ctx = NULL;
		}
366 367
		blk_queue_exit(q);
		return NULL;
368 369
	}

370
	rq = blk_mq_rq_ctx_init(data, tag, op);
371 372
	if (!op_is_flush(op)) {
		rq->elv.icq = NULL;
373
		if (e && e->type->ops.mq.prepare_request) {
374 375 376
			if (e->type->icq_cache && rq_ioc(bio))
				blk_mq_sched_assign_ioc(rq, bio);

377 378
			e->type->ops.mq.prepare_request(rq, bio);
			rq->rq_flags |= RQF_ELVPRIV;
379
		}
380 381 382
	}
	data->hctx->queued++;
	return rq;
383 384
}

385
struct request *blk_mq_alloc_request(struct request_queue *q, unsigned int op,
386
		blk_mq_req_flags_t flags)
387
{
388
	struct blk_mq_alloc_data alloc_data = { .flags = flags };
389
	struct request *rq;
390
	int ret;
391

392
	ret = blk_queue_enter(q, flags);
393 394
	if (ret)
		return ERR_PTR(ret);
395

396
	rq = blk_mq_get_request(q, NULL, op, &alloc_data);
397
	blk_queue_exit(q);
398

399
	if (!rq)
400
		return ERR_PTR(-EWOULDBLOCK);
401

402 403
	blk_mq_put_ctx(alloc_data.ctx);

404 405 406
	rq->__data_len = 0;
	rq->__sector = (sector_t) -1;
	rq->bio = rq->biotail = NULL;
407 408
	return rq;
}
409
EXPORT_SYMBOL(blk_mq_alloc_request);
410

411
struct request *blk_mq_alloc_request_hctx(struct request_queue *q,
412
	unsigned int op, blk_mq_req_flags_t flags, unsigned int hctx_idx)
M
Ming Lin 已提交
413
{
414
	struct blk_mq_alloc_data alloc_data = { .flags = flags };
M
Ming Lin 已提交
415
	struct request *rq;
416
	unsigned int cpu;
M
Ming Lin 已提交
417 418 419 420 421 422 423 424 425 426 427 428 429 430
	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);

431
	ret = blk_queue_enter(q, flags);
M
Ming Lin 已提交
432 433 434
	if (ret)
		return ERR_PTR(ret);

435 436 437 438
	/*
	 * Check if the hardware context is actually mapped to anything.
	 * If not tell the caller that it should skip this queue.
	 */
439 440 441 442
	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);
443
	}
444
	cpu = cpumask_first_and(alloc_data.hctx->cpumask, cpu_online_mask);
445
	alloc_data.ctx = __blk_mq_get_ctx(q, cpu);
M
Ming Lin 已提交
446

447
	rq = blk_mq_get_request(q, NULL, op, &alloc_data);
448
	blk_queue_exit(q);
449

450 451 452 453
	if (!rq)
		return ERR_PTR(-EWOULDBLOCK);

	return rq;
M
Ming Lin 已提交
454 455 456
}
EXPORT_SYMBOL_GPL(blk_mq_alloc_request_hctx);

457
void blk_mq_free_request(struct request *rq)
458 459
{
	struct request_queue *q = rq->q;
460 461 462 463 464
	struct elevator_queue *e = q->elevator;
	struct blk_mq_ctx *ctx = rq->mq_ctx;
	struct blk_mq_hw_ctx *hctx = blk_mq_map_queue(q, ctx->cpu);
	const int sched_tag = rq->internal_tag;

465
	if (rq->rq_flags & RQF_ELVPRIV) {
466 467 468 469 470 471 472
		if (e && e->type->ops.mq.finish_request)
			e->type->ops.mq.finish_request(rq);
		if (rq->elv.icq) {
			put_io_context(rq->elv.icq->ioc);
			rq->elv.icq = NULL;
		}
	}
473

474
	ctx->rq_completed[rq_is_sync(rq)]++;
475
	if (rq->rq_flags & RQF_MQ_INFLIGHT)
476
		atomic_dec(&hctx->nr_active);
J
Jens Axboe 已提交
477

478 479 480
	if (unlikely(laptop_mode && !blk_rq_is_passthrough(rq)))
		laptop_io_completion(q->backing_dev_info);

J
Jens Axboe 已提交
481
	wbt_done(q->rq_wb, &rq->issue_stat);
482

S
Shaohua Li 已提交
483 484 485
	if (blk_rq_rl(rq))
		blk_put_rl(blk_rq_rl(rq));

486
	blk_mq_rq_update_state(rq, MQ_RQ_IDLE);
487 488 489
	if (rq->tag != -1)
		blk_mq_put_tag(hctx, hctx->tags, ctx, rq->tag);
	if (sched_tag != -1)
490
		blk_mq_put_tag(hctx, hctx->sched_tags, ctx, sched_tag);
491
	blk_mq_sched_restart(hctx);
492
	blk_queue_exit(q);
493
}
J
Jens Axboe 已提交
494
EXPORT_SYMBOL_GPL(blk_mq_free_request);
495

496
inline void __blk_mq_end_request(struct request *rq, blk_status_t error)
497
{
M
Ming Lei 已提交
498 499
	blk_account_io_done(rq);

C
Christoph Hellwig 已提交
500
	if (rq->end_io) {
J
Jens Axboe 已提交
501
		wbt_done(rq->q->rq_wb, &rq->issue_stat);
502
		rq->end_io(rq, error);
C
Christoph Hellwig 已提交
503 504 505
	} else {
		if (unlikely(blk_bidi_rq(rq)))
			blk_mq_free_request(rq->next_rq);
506
		blk_mq_free_request(rq);
C
Christoph Hellwig 已提交
507
	}
508
}
509
EXPORT_SYMBOL(__blk_mq_end_request);
510

511
void blk_mq_end_request(struct request *rq, blk_status_t error)
512 513 514
{
	if (blk_update_request(rq, error, blk_rq_bytes(rq)))
		BUG();
515
	__blk_mq_end_request(rq, error);
516
}
517
EXPORT_SYMBOL(blk_mq_end_request);
518

519
static void __blk_mq_complete_request_remote(void *data)
520
{
521
	struct request *rq = data;
522

523
	rq->q->softirq_done_fn(rq);
524 525
}

526
static void __blk_mq_complete_request(struct request *rq)
527 528
{
	struct blk_mq_ctx *ctx = rq->mq_ctx;
C
Christoph Hellwig 已提交
529
	bool shared = false;
530 531
	int cpu;

532
	WARN_ON_ONCE(blk_mq_rq_state(rq) != MQ_RQ_IN_FLIGHT);
T
Tejun Heo 已提交
533
	blk_mq_rq_update_state(rq, MQ_RQ_COMPLETE);
534

535 536 537 538 539 540 541
	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 已提交
542
	if (!test_bit(QUEUE_FLAG_SAME_COMP, &rq->q->queue_flags)) {
543 544 545
		rq->q->softirq_done_fn(rq);
		return;
	}
546 547

	cpu = get_cpu();
C
Christoph Hellwig 已提交
548 549 550 551
	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)) {
552
		rq->csd.func = __blk_mq_complete_request_remote;
553 554
		rq->csd.info = rq;
		rq->csd.flags = 0;
555
		smp_call_function_single_async(ctx->cpu, &rq->csd);
556
	} else {
557
		rq->q->softirq_done_fn(rq);
558
	}
559 560
	put_cpu();
}
561

562
static void hctx_unlock(struct blk_mq_hw_ctx *hctx, int srcu_idx)
563
	__releases(hctx->srcu)
564 565 566 567
{
	if (!(hctx->flags & BLK_MQ_F_BLOCKING))
		rcu_read_unlock();
	else
568
		srcu_read_unlock(hctx->srcu, srcu_idx);
569 570 571
}

static void hctx_lock(struct blk_mq_hw_ctx *hctx, int *srcu_idx)
572
	__acquires(hctx->srcu)
573
{
574 575 576
	if (!(hctx->flags & BLK_MQ_F_BLOCKING)) {
		/* shut up gcc false positive */
		*srcu_idx = 0;
577
		rcu_read_lock();
578
	} else
579
		*srcu_idx = srcu_read_lock(hctx->srcu);
580 581
}

582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611
static void blk_mq_rq_update_aborted_gstate(struct request *rq, u64 gstate)
{
	unsigned long flags;

	/*
	 * blk_mq_rq_aborted_gstate() is used from the completion path and
	 * can thus be called from irq context.  u64_stats_fetch in the
	 * middle of update on the same CPU leads to lockup.  Disable irq
	 * while updating.
	 */
	local_irq_save(flags);
	u64_stats_update_begin(&rq->aborted_gstate_sync);
	rq->aborted_gstate = gstate;
	u64_stats_update_end(&rq->aborted_gstate_sync);
	local_irq_restore(flags);
}

static u64 blk_mq_rq_aborted_gstate(struct request *rq)
{
	unsigned int start;
	u64 aborted_gstate;

	do {
		start = u64_stats_fetch_begin(&rq->aborted_gstate_sync);
		aborted_gstate = rq->aborted_gstate;
	} while (u64_stats_fetch_retry(&rq->aborted_gstate_sync, start));

	return aborted_gstate;
}

612 613 614 615 616 617 618 619
/**
 * 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.
 **/
620
void blk_mq_complete_request(struct request *rq)
621
{
622
	struct request_queue *q = rq->q;
623 624
	struct blk_mq_hw_ctx *hctx = blk_mq_map_queue(q, rq->mq_ctx->cpu);
	int srcu_idx;
625 626

	if (unlikely(blk_should_fake_timeout(q)))
627
		return;
628

629 630 631 632 633 634 635 636 637 638 639
	/*
	 * If @rq->aborted_gstate equals the current instance, timeout is
	 * claiming @rq and we lost.  This is synchronized through
	 * hctx_lock().  See blk_mq_timeout_work() for details.
	 *
	 * Completion path never blocks and we can directly use RCU here
	 * instead of hctx_lock() which can be either RCU or SRCU.
	 * However, that would complicate paths which want to synchronize
	 * against us.  Let stay in sync with the issue path so that
	 * hctx_lock() covers both issue and completion paths.
	 */
640
	hctx_lock(hctx, &srcu_idx);
641
	if (blk_mq_rq_aborted_gstate(rq) != rq->gstate)
642
		__blk_mq_complete_request(rq);
643
	hctx_unlock(hctx, srcu_idx);
644 645
}
EXPORT_SYMBOL(blk_mq_complete_request);
646

647 648
int blk_mq_request_started(struct request *rq)
{
T
Tejun Heo 已提交
649
	return blk_mq_rq_state(rq) != MQ_RQ_IDLE;
650 651 652
}
EXPORT_SYMBOL_GPL(blk_mq_request_started);

653
void blk_mq_start_request(struct request *rq)
654 655 656
{
	struct request_queue *q = rq->q;

657 658
	blk_mq_sched_started_request(rq);

659 660
	trace_block_rq_issue(q, rq);

661
	if (test_bit(QUEUE_FLAG_STATS, &q->queue_flags)) {
662
		blk_stat_set_issue(&rq->issue_stat, blk_rq_sectors(rq));
663
		rq->rq_flags |= RQF_STATS;
J
Jens Axboe 已提交
664
		wbt_issue(q->rq_wb, &rq->issue_stat);
665 666
	}

667
	WARN_ON_ONCE(blk_mq_rq_state(rq) != MQ_RQ_IDLE);
668

669
	/*
670 671 672 673
	 * Mark @rq in-flight which also advances the generation number,
	 * and register for timeout.  Protect with a seqcount to allow the
	 * timeout path to read both @rq->gstate and @rq->deadline
	 * coherently.
674
	 *
675 676 677 678
	 * This is the only place where a request is marked in-flight.  If
	 * the timeout path reads an in-flight @rq->gstate, the
	 * @rq->deadline it reads together under @rq->gstate_seq is
	 * guaranteed to be the matching one.
679
	 */
680 681 682 683 684 685 686 687 688
	preempt_disable();
	write_seqcount_begin(&rq->gstate_seq);

	blk_mq_rq_update_state(rq, MQ_RQ_IN_FLIGHT);
	blk_add_timer(rq);

	write_seqcount_end(&rq->gstate_seq);
	preempt_enable();

689 690 691 692 693 694 695 696
	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++;
	}
697
}
698
EXPORT_SYMBOL(blk_mq_start_request);
699

700
/*
T
Tejun Heo 已提交
701 702 703
 * When we reach here because queue is busy, it's safe to change the state
 * to IDLE without checking @rq->aborted_gstate because we should still be
 * holding the RCU read lock and thus protected against timeout.
704
 */
705
static void __blk_mq_requeue_request(struct request *rq)
706 707 708
{
	struct request_queue *q = rq->q;

709 710
	blk_mq_put_driver_tag(rq);

711
	trace_block_rq_requeue(q, rq);
J
Jens Axboe 已提交
712
	wbt_requeue(q->rq_wb, &rq->issue_stat);
713
	blk_mq_sched_requeue_request(rq);
714

T
Tejun Heo 已提交
715
	if (blk_mq_rq_state(rq) != MQ_RQ_IDLE) {
716
		blk_mq_rq_update_state(rq, MQ_RQ_IDLE);
717 718 719
		if (q->dma_drain_size && blk_rq_bytes(rq))
			rq->nr_phys_segments--;
	}
720 721
}

722
void blk_mq_requeue_request(struct request *rq, bool kick_requeue_list)
723 724 725 726
{
	__blk_mq_requeue_request(rq);

	BUG_ON(blk_queued_rq(rq));
727
	blk_mq_add_to_requeue_list(rq, true, kick_requeue_list);
728 729 730
}
EXPORT_SYMBOL(blk_mq_requeue_request);

731 732 733
static void blk_mq_requeue_work(struct work_struct *work)
{
	struct request_queue *q =
734
		container_of(work, struct request_queue, requeue_work.work);
735 736 737
	LIST_HEAD(rq_list);
	struct request *rq, *next;

738
	spin_lock_irq(&q->requeue_lock);
739
	list_splice_init(&q->requeue_list, &rq_list);
740
	spin_unlock_irq(&q->requeue_lock);
741 742

	list_for_each_entry_safe(rq, next, &rq_list, queuelist) {
743
		if (!(rq->rq_flags & RQF_SOFTBARRIER))
744 745
			continue;

746
		rq->rq_flags &= ~RQF_SOFTBARRIER;
747
		list_del_init(&rq->queuelist);
748
		blk_mq_sched_insert_request(rq, true, false, false);
749 750 751 752 753
	}

	while (!list_empty(&rq_list)) {
		rq = list_entry(rq_list.next, struct request, queuelist);
		list_del_init(&rq->queuelist);
754
		blk_mq_sched_insert_request(rq, false, false, false);
755 756
	}

757
	blk_mq_run_hw_queues(q, false);
758 759
}

760 761
void blk_mq_add_to_requeue_list(struct request *rq, bool at_head,
				bool kick_requeue_list)
762 763 764 765 766 767
{
	struct request_queue *q = rq->q;
	unsigned long flags;

	/*
	 * We abuse this flag that is otherwise used by the I/O scheduler to
768
	 * request head insertion from the workqueue.
769
	 */
770
	BUG_ON(rq->rq_flags & RQF_SOFTBARRIER);
771 772 773

	spin_lock_irqsave(&q->requeue_lock, flags);
	if (at_head) {
774
		rq->rq_flags |= RQF_SOFTBARRIER;
775 776 777 778 779
		list_add(&rq->queuelist, &q->requeue_list);
	} else {
		list_add_tail(&rq->queuelist, &q->requeue_list);
	}
	spin_unlock_irqrestore(&q->requeue_lock, flags);
780 781 782

	if (kick_requeue_list)
		blk_mq_kick_requeue_list(q);
783 784 785 786 787
}
EXPORT_SYMBOL(blk_mq_add_to_requeue_list);

void blk_mq_kick_requeue_list(struct request_queue *q)
{
788
	kblockd_schedule_delayed_work(&q->requeue_work, 0);
789 790 791
}
EXPORT_SYMBOL(blk_mq_kick_requeue_list);

792 793 794
void blk_mq_delay_kick_requeue_list(struct request_queue *q,
				    unsigned long msecs)
{
795 796
	kblockd_mod_delayed_work_on(WORK_CPU_UNBOUND, &q->requeue_work,
				    msecs_to_jiffies(msecs));
797 798 799
}
EXPORT_SYMBOL(blk_mq_delay_kick_requeue_list);

800 801
struct request *blk_mq_tag_to_rq(struct blk_mq_tags *tags, unsigned int tag)
{
802 803
	if (tag < tags->nr_tags) {
		prefetch(tags->rqs[tag]);
804
		return tags->rqs[tag];
805
	}
806 807

	return NULL;
808 809 810
}
EXPORT_SYMBOL(blk_mq_tag_to_rq);

811
struct blk_mq_timeout_data {
812 813
	unsigned long next;
	unsigned int next_set;
814
	unsigned int nr_expired;
815 816
};

817
static void blk_mq_rq_timed_out(struct request *req, bool reserved)
818
{
J
Jens Axboe 已提交
819
	const struct blk_mq_ops *ops = req->q->mq_ops;
820
	enum blk_eh_timer_return ret = BLK_EH_RESET_TIMER;
821

822 823
	req->rq_flags |= RQF_MQ_TIMEOUT_EXPIRED;

824
	if (ops->timeout)
825
		ret = ops->timeout(req, reserved);
826 827 828 829 830 831

	switch (ret) {
	case BLK_EH_HANDLED:
		__blk_mq_complete_request(req);
		break;
	case BLK_EH_RESET_TIMER:
832 833 834 835 836 837
		/*
		 * As nothing prevents from completion happening while
		 * ->aborted_gstate is set, this may lead to ignored
		 * completions and further spurious timeouts.
		 */
		blk_mq_rq_update_aborted_gstate(req, 0);
838 839 840 841 842 843 844 845
		blk_add_timer(req);
		break;
	case BLK_EH_NOT_HANDLED:
		break;
	default:
		printk(KERN_ERR "block: bad eh return: %d\n", ret);
		break;
	}
846
}
847

848 849 850 851
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;
852 853 854 855
	unsigned long gstate, deadline;
	int start;

	might_sleep();
856

T
Tejun Heo 已提交
857
	if (rq->rq_flags & RQF_MQ_TIMEOUT_EXPIRED)
858
		return;
859

860 861 862 863
	/* read coherent snapshots of @rq->state_gen and @rq->deadline */
	while (true) {
		start = read_seqcount_begin(&rq->gstate_seq);
		gstate = READ_ONCE(rq->gstate);
864
		deadline = blk_rq_deadline(rq);
865 866 867 868
		if (!read_seqcount_retry(&rq->gstate_seq, start))
			break;
		cond_resched();
	}
869

870 871 872 873 874 875
	/* if in-flight && overdue, mark for abortion */
	if ((gstate & MQ_RQ_STATE_MASK) == MQ_RQ_IN_FLIGHT &&
	    time_after_eq(jiffies, deadline)) {
		blk_mq_rq_update_aborted_gstate(rq, gstate);
		data->nr_expired++;
		hctx->nr_expired++;
876 877
	} else if (!data->next_set || time_after(data->next, deadline)) {
		data->next = deadline;
878 879
		data->next_set = 1;
	}
880 881
}

882 883 884 885 886 887 888 889 890 891
static void blk_mq_terminate_expired(struct blk_mq_hw_ctx *hctx,
		struct request *rq, void *priv, bool reserved)
{
	/*
	 * We marked @rq->aborted_gstate and waited for RCU.  If there were
	 * completions that we lost to, they would have finished and
	 * updated @rq->gstate by now; otherwise, the completion path is
	 * now guaranteed to see @rq->aborted_gstate and yield.  If
	 * @rq->aborted_gstate still matches @rq->gstate, @rq is ours.
	 */
892 893
	if (!(rq->rq_flags & RQF_MQ_TIMEOUT_EXPIRED) &&
	    READ_ONCE(rq->gstate) == rq->aborted_gstate)
894 895 896
		blk_mq_rq_timed_out(rq, reserved);
}

897
static void blk_mq_timeout_work(struct work_struct *work)
898
{
899 900
	struct request_queue *q =
		container_of(work, struct request_queue, timeout_work);
901 902 903
	struct blk_mq_timeout_data data = {
		.next		= 0,
		.next_set	= 0,
904
		.nr_expired	= 0,
905
	};
906
	struct blk_mq_hw_ctx *hctx;
907
	int i;
908

909 910 911 912 913 914 915 916 917
	/* 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
918
	 * blk_freeze_queue_start, and the moment the last request is
919 920 921 922
	 * consumed, marked by the instant q_usage_counter reaches
	 * zero.
	 */
	if (!percpu_ref_tryget(&q->q_usage_counter))
923 924
		return;

925
	/* scan for the expired ones and set their ->aborted_gstate */
926
	blk_mq_queue_tag_busy_iter(q, blk_mq_check_expired, &data);
927

928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943
	if (data.nr_expired) {
		bool has_rcu = false;

		/*
		 * Wait till everyone sees ->aborted_gstate.  The
		 * sequential waits for SRCUs aren't ideal.  If this ever
		 * becomes a problem, we can add per-hw_ctx rcu_head and
		 * wait in parallel.
		 */
		queue_for_each_hw_ctx(q, hctx, i) {
			if (!hctx->nr_expired)
				continue;

			if (!(hctx->flags & BLK_MQ_F_BLOCKING))
				has_rcu = true;
			else
944
				synchronize_srcu(hctx->srcu);
945 946 947 948 949 950 951 952 953 954

			hctx->nr_expired = 0;
		}
		if (has_rcu)
			synchronize_rcu();

		/* terminate the ones we won */
		blk_mq_queue_tag_busy_iter(q, blk_mq_terminate_expired, NULL);
	}

955 956 957
	if (data.next_set) {
		data.next = blk_rq_timeout(round_jiffies_up(data.next));
		mod_timer(&q->timeout, data.next);
958
	} else {
959 960 961 962 963 964
		/*
		 * Request timeouts are handled as a forward rolling timer. If
		 * we end up here it means that no requests are pending and
		 * also that no request has been pending for a while. Mark
		 * each hctx as idle.
		 */
965 966 967 968 969
		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);
		}
970
	}
971
	blk_queue_exit(q);
972 973
}

974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991
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;
}

992 993 994 995
/*
 * Process software queues that have been marked busy, splicing them
 * to the for-dispatch
 */
996
void blk_mq_flush_busy_ctxs(struct blk_mq_hw_ctx *hctx, struct list_head *list)
997
{
998 999 1000 1001
	struct flush_busy_ctx_data data = {
		.hctx = hctx,
		.list = list,
	};
1002

1003
	sbitmap_for_each_set(&hctx->ctx_map, flush_busy_ctx, &data);
1004
}
1005
EXPORT_SYMBOL_GPL(blk_mq_flush_busy_ctxs);
1006

1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045
struct dispatch_rq_data {
	struct blk_mq_hw_ctx *hctx;
	struct request *rq;
};

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

	spin_lock(&ctx->lock);
	if (unlikely(!list_empty(&ctx->rq_list))) {
		dispatch_data->rq = list_entry_rq(ctx->rq_list.next);
		list_del_init(&dispatch_data->rq->queuelist);
		if (list_empty(&ctx->rq_list))
			sbitmap_clear_bit(sb, bitnr);
	}
	spin_unlock(&ctx->lock);

	return !dispatch_data->rq;
}

struct request *blk_mq_dequeue_from_ctx(struct blk_mq_hw_ctx *hctx,
					struct blk_mq_ctx *start)
{
	unsigned off = start ? start->index_hw : 0;
	struct dispatch_rq_data data = {
		.hctx = hctx,
		.rq   = NULL,
	};

	__sbitmap_for_each_set(&hctx->ctx_map, off,
			       dispatch_rq_from_ctx, &data);

	return data.rq;
}

1046 1047 1048 1049
static inline unsigned int queued_to_index(unsigned int queued)
{
	if (!queued)
		return 0;
1050

1051
	return min(BLK_MQ_MAX_DISPATCH_ORDER - 1, ilog2(queued) + 1);
1052 1053
}

1054 1055
bool blk_mq_get_driver_tag(struct request *rq, struct blk_mq_hw_ctx **hctx,
			   bool wait)
1056 1057 1058 1059 1060 1061 1062
{
	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,
	};

1063 1064
	might_sleep_if(wait);

1065 1066
	if (rq->tag != -1)
		goto done;
1067

1068 1069 1070
	if (blk_mq_tag_is_reserved(data.hctx->sched_tags, rq->internal_tag))
		data.flags |= BLK_MQ_REQ_RESERVED;

1071 1072
	rq->tag = blk_mq_get_tag(&data);
	if (rq->tag >= 0) {
1073 1074 1075 1076
		if (blk_mq_tag_busy(data.hctx)) {
			rq->rq_flags |= RQF_MQ_INFLIGHT;
			atomic_inc(&data.hctx->nr_active);
		}
1077 1078 1079
		data.hctx->tags->rqs[rq->tag] = rq;
	}

1080 1081 1082 1083
done:
	if (hctx)
		*hctx = data.hctx;
	return rq->tag != -1;
1084 1085
}

1086 1087
static int blk_mq_dispatch_wake(wait_queue_entry_t *wait, unsigned mode,
				int flags, void *key)
1088 1089 1090 1091 1092
{
	struct blk_mq_hw_ctx *hctx;

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

1093
	list_del_init(&wait->entry);
1094 1095 1096 1097
	blk_mq_run_hw_queue(hctx, true);
	return 1;
}

1098 1099
/*
 * Mark us waiting for a tag. For shared tags, this involves hooking us into
1100 1101
 * the tag wakeups. For non-shared tags, we can simply mark us needing a
 * restart. For both cases, take care to check the condition again after
1102 1103 1104 1105
 * marking us as waiting.
 */
static bool blk_mq_mark_tag_wait(struct blk_mq_hw_ctx **hctx,
				 struct request *rq)
1106
{
1107
	struct blk_mq_hw_ctx *this_hctx = *hctx;
1108
	struct sbq_wait_state *ws;
1109 1110
	wait_queue_entry_t *wait;
	bool ret;
1111

1112
	if (!(this_hctx->flags & BLK_MQ_F_TAG_SHARED)) {
1113 1114
		if (!test_bit(BLK_MQ_S_SCHED_RESTART, &this_hctx->state))
			set_bit(BLK_MQ_S_SCHED_RESTART, &this_hctx->state);
1115

1116 1117 1118 1119 1120 1121 1122 1123 1124
		/*
		 * It's possible that a tag was freed in the window between the
		 * allocation failure and adding the hardware queue to the wait
		 * queue.
		 *
		 * Don't clear RESTART here, someone else could have set it.
		 * At most this will cost an extra queue run.
		 */
		return blk_mq_get_driver_tag(rq, hctx, false);
1125 1126
	}

1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
	wait = &this_hctx->dispatch_wait;
	if (!list_empty_careful(&wait->entry))
		return false;

	spin_lock(&this_hctx->lock);
	if (!list_empty(&wait->entry)) {
		spin_unlock(&this_hctx->lock);
		return false;
	}

	ws = bt_wait_ptr(&this_hctx->tags->bitmap_tags, this_hctx);
	add_wait_queue(&ws->wait, wait);

1140
	/*
1141 1142 1143
	 * It's possible that a tag was freed in the window between the
	 * allocation failure and adding the hardware queue to the wait
	 * queue.
1144
	 */
1145
	ret = blk_mq_get_driver_tag(rq, hctx, false);
1146
	if (!ret) {
1147
		spin_unlock(&this_hctx->lock);
1148
		return false;
1149
	}
1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160

	/*
	 * We got a tag, remove ourselves from the wait queue to ensure
	 * someone else gets the wakeup.
	 */
	spin_lock_irq(&ws->wait.lock);
	list_del_init(&wait->entry);
	spin_unlock_irq(&ws->wait.lock);
	spin_unlock(&this_hctx->lock);

	return true;
1161 1162
}

1163
bool blk_mq_dispatch_rq_list(struct request_queue *q, struct list_head *list,
1164
			     bool got_budget)
1165
{
1166
	struct blk_mq_hw_ctx *hctx;
1167
	struct request *rq, *nxt;
1168
	bool no_tag = false;
1169
	int errors, queued;
1170

1171 1172 1173
	if (list_empty(list))
		return false;

1174 1175
	WARN_ON(!list_is_singular(list) && got_budget);

1176 1177 1178
	/*
	 * Now process all the entries, sending them to the driver.
	 */
1179
	errors = queued = 0;
1180
	do {
1181
		struct blk_mq_queue_data bd;
1182
		blk_status_t ret;
1183

1184
		rq = list_first_entry(list, struct request, queuelist);
1185
		if (!blk_mq_get_driver_tag(rq, &hctx, false)) {
1186
			/*
1187
			 * The initial allocation attempt failed, so we need to
1188 1189 1190 1191
			 * rerun the hardware queue when a tag is freed. The
			 * waitqueue takes care of that. If the queue is run
			 * before we add this entry back on the dispatch list,
			 * we'll re-run it below.
1192
			 */
1193
			if (!blk_mq_mark_tag_wait(&hctx, rq)) {
1194 1195
				if (got_budget)
					blk_mq_put_dispatch_budget(hctx);
1196 1197 1198 1199 1200 1201
				/*
				 * For non-shared tags, the RESTART check
				 * will suffice.
				 */
				if (hctx->flags & BLK_MQ_F_TAG_SHARED)
					no_tag = true;
1202 1203 1204 1205
				break;
			}
		}

1206 1207
		if (!got_budget && !blk_mq_get_dispatch_budget(hctx)) {
			blk_mq_put_driver_tag(rq);
1208
			break;
1209
		}
1210

1211 1212
		list_del_init(&rq->queuelist);

1213
		bd.rq = rq;
1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224

		/*
		 * 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 {
			nxt = list_first_entry(list, struct request, queuelist);
			bd.last = !blk_mq_get_driver_tag(nxt, NULL, false);
		}
1225 1226

		ret = q->mq_ops->queue_rq(hctx, &bd);
1227
		if (ret == BLK_STS_RESOURCE) {
1228 1229
			/*
			 * If an I/O scheduler has been configured and we got a
1230 1231
			 * driver tag for the next request already, free it
			 * again.
1232 1233 1234 1235 1236
			 */
			if (!list_empty(list)) {
				nxt = list_first_entry(list, struct request, queuelist);
				blk_mq_put_driver_tag(nxt);
			}
1237
			list_add(&rq->queuelist, list);
1238
			__blk_mq_requeue_request(rq);
1239
			break;
1240 1241 1242
		}

		if (unlikely(ret != BLK_STS_OK)) {
1243
			errors++;
1244
			blk_mq_end_request(rq, BLK_STS_IOERR);
1245
			continue;
1246 1247
		}

1248
		queued++;
1249
	} while (!list_empty(list));
1250

1251
	hctx->dispatched[queued_to_index(queued)]++;
1252 1253 1254 1255 1256

	/*
	 * Any items that need requeuing? Stuff them into hctx->dispatch,
	 * that is where we will continue on next queue run.
	 */
1257
	if (!list_empty(list)) {
1258
		spin_lock(&hctx->lock);
1259
		list_splice_init(list, &hctx->dispatch);
1260
		spin_unlock(&hctx->lock);
1261

1262
		/*
1263 1264 1265
		 * 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.
1266
		 *
1267 1268 1269 1270
		 * If 'no_tag' is set, that means that we failed getting
		 * a driver tag with an I/O scheduler attached. If our dispatch
		 * waitqueue is no longer active, ensure that we run the queue
		 * AFTER adding our entries back to the list.
1271
		 *
1272 1273 1274 1275 1276 1277 1278
		 * 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
1279
		 *   returning BLK_STS_RESOURCE. Two exceptions are scsi-mq
1280
		 *   and dm-rq.
1281
		 */
1282 1283
		if (!blk_mq_sched_needs_restart(hctx) ||
		    (no_tag && list_empty_careful(&hctx->dispatch_wait.entry)))
1284
			blk_mq_run_hw_queue(hctx, true);
1285
	}
1286

1287
	return (queued + errors) != 0;
1288 1289
}

1290 1291 1292 1293
static void __blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx)
{
	int srcu_idx;

1294 1295 1296
	/*
	 * We should be running this queue from one of the CPUs that
	 * are mapped to it.
1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309
	 *
	 * There are at least two related races now between setting
	 * hctx->next_cpu from blk_mq_hctx_next_cpu() and running
	 * __blk_mq_run_hw_queue():
	 *
	 * - hctx->next_cpu is found offline in blk_mq_hctx_next_cpu(),
	 *   but later it becomes online, then this warning is harmless
	 *   at all
	 *
	 * - hctx->next_cpu is found online in blk_mq_hctx_next_cpu(),
	 *   but later it becomes offline, then the warning can't be
	 *   triggered, and we depend on blk-mq timeout handler to
	 *   handle dispatched requests to this hctx
1310
	 */
1311 1312 1313 1314 1315 1316 1317
	if (!cpumask_test_cpu(raw_smp_processor_id(), hctx->cpumask) &&
		cpu_online(hctx->next_cpu)) {
		printk(KERN_WARNING "run queue from wrong CPU %d, hctx %s\n",
			raw_smp_processor_id(),
			cpumask_empty(hctx->cpumask) ? "inactive": "active");
		dump_stack();
	}
1318

1319 1320 1321 1322 1323 1324
	/*
	 * We can't run the queue inline with ints disabled. Ensure that
	 * we catch bad users of this early.
	 */
	WARN_ON_ONCE(in_interrupt());

1325
	might_sleep_if(hctx->flags & BLK_MQ_F_BLOCKING);
1326

1327 1328 1329
	hctx_lock(hctx, &srcu_idx);
	blk_mq_sched_dispatch_requests(hctx);
	hctx_unlock(hctx, srcu_idx);
1330 1331
}

1332 1333 1334 1335 1336 1337 1338 1339
/*
 * 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)
{
1340 1341
	bool tried = false;

1342 1343
	if (hctx->queue->nr_hw_queues == 1)
		return WORK_CPU_UNBOUND;
1344 1345

	if (--hctx->next_cpu_batch <= 0) {
1346
		int next_cpu;
1347
select_cpu:
1348 1349
		next_cpu = cpumask_next_and(hctx->next_cpu, hctx->cpumask,
				cpu_online_mask);
1350
		if (next_cpu >= nr_cpu_ids)
1351
			next_cpu = cpumask_first_and(hctx->cpumask,cpu_online_mask);
1352

1353 1354 1355 1356 1357 1358 1359 1360
		/*
		 * No online CPU is found, so have to make sure hctx->next_cpu
		 * is set correctly for not breaking workqueue.
		 */
		if (next_cpu >= nr_cpu_ids)
			hctx->next_cpu = cpumask_first(hctx->cpumask);
		else
			hctx->next_cpu = next_cpu;
1361 1362 1363
		hctx->next_cpu_batch = BLK_MQ_CPU_WORK_BATCH;
	}

1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380
	/*
	 * Do unbound schedule if we can't find a online CPU for this hctx,
	 * and it should only happen in the path of handling CPU DEAD.
	 */
	if (!cpu_online(hctx->next_cpu)) {
		if (!tried) {
			tried = true;
			goto select_cpu;
		}

		/*
		 * Make sure to re-select CPU next time once after CPUs
		 * in hctx->cpumask become online again.
		 */
		hctx->next_cpu_batch = 1;
		return WORK_CPU_UNBOUND;
	}
1381
	return hctx->next_cpu;
1382 1383
}

1384 1385
static void __blk_mq_delay_run_hw_queue(struct blk_mq_hw_ctx *hctx, bool async,
					unsigned long msecs)
1386
{
1387 1388 1389 1390
	if (WARN_ON_ONCE(!blk_mq_hw_queue_mapped(hctx)))
		return;

	if (unlikely(blk_mq_hctx_stopped(hctx)))
1391 1392
		return;

1393
	if (!async && !(hctx->flags & BLK_MQ_F_BLOCKING)) {
1394 1395
		int cpu = get_cpu();
		if (cpumask_test_cpu(cpu, hctx->cpumask)) {
1396
			__blk_mq_run_hw_queue(hctx);
1397
			put_cpu();
1398 1399
			return;
		}
1400

1401
		put_cpu();
1402
	}
1403

1404 1405 1406
	kblockd_schedule_delayed_work_on(blk_mq_hctx_next_cpu(hctx),
					 &hctx->run_work,
					 msecs_to_jiffies(msecs));
1407 1408 1409 1410 1411 1412 1413 1414
}

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);

1415
bool blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx, bool async)
1416
{
1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427
	int srcu_idx;
	bool need_run;

	/*
	 * When queue is quiesced, we may be switching io scheduler, or
	 * updating nr_hw_queues, or other things, and we can't run queue
	 * any more, even __blk_mq_hctx_has_pending() can't be called safely.
	 *
	 * And queue will be rerun in blk_mq_unquiesce_queue() if it is
	 * quiesced.
	 */
1428 1429 1430 1431
	hctx_lock(hctx, &srcu_idx);
	need_run = !blk_queue_quiesced(hctx->queue) &&
		blk_mq_hctx_has_pending(hctx);
	hctx_unlock(hctx, srcu_idx);
1432 1433

	if (need_run) {
1434 1435 1436 1437 1438
		__blk_mq_delay_run_hw_queue(hctx, async, 0);
		return true;
	}

	return false;
1439
}
O
Omar Sandoval 已提交
1440
EXPORT_SYMBOL(blk_mq_run_hw_queue);
1441

1442
void blk_mq_run_hw_queues(struct request_queue *q, bool async)
1443 1444 1445 1446 1447
{
	struct blk_mq_hw_ctx *hctx;
	int i;

	queue_for_each_hw_ctx(q, hctx, i) {
1448
		if (blk_mq_hctx_stopped(hctx))
1449 1450
			continue;

1451
		blk_mq_run_hw_queue(hctx, async);
1452 1453
	}
}
1454
EXPORT_SYMBOL(blk_mq_run_hw_queues);
1455

1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475
/**
 * 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);

1476 1477 1478
/*
 * This function is often used for pausing .queue_rq() by driver when
 * there isn't enough resource or some conditions aren't satisfied, and
1479
 * BLK_STS_RESOURCE is usually returned.
1480 1481 1482 1483 1484
 *
 * We do not guarantee that dispatch can be drained or blocked
 * after blk_mq_stop_hw_queue() returns. Please use
 * blk_mq_quiesce_queue() for that requirement.
 */
1485 1486
void blk_mq_stop_hw_queue(struct blk_mq_hw_ctx *hctx)
{
1487
	cancel_delayed_work(&hctx->run_work);
1488

1489
	set_bit(BLK_MQ_S_STOPPED, &hctx->state);
1490
}
1491
EXPORT_SYMBOL(blk_mq_stop_hw_queue);
1492

1493 1494 1495
/*
 * This function is often used for pausing .queue_rq() by driver when
 * there isn't enough resource or some conditions aren't satisfied, and
1496
 * BLK_STS_RESOURCE is usually returned.
1497 1498 1499 1500 1501
 *
 * We do not guarantee that dispatch can be drained or blocked
 * after blk_mq_stop_hw_queues() returns. Please use
 * blk_mq_quiesce_queue() for that requirement.
 */
1502 1503
void blk_mq_stop_hw_queues(struct request_queue *q)
{
1504 1505 1506 1507 1508
	struct blk_mq_hw_ctx *hctx;
	int i;

	queue_for_each_hw_ctx(q, hctx, i)
		blk_mq_stop_hw_queue(hctx);
1509 1510 1511
}
EXPORT_SYMBOL(blk_mq_stop_hw_queues);

1512 1513 1514
void blk_mq_start_hw_queue(struct blk_mq_hw_ctx *hctx)
{
	clear_bit(BLK_MQ_S_STOPPED, &hctx->state);
1515

1516
	blk_mq_run_hw_queue(hctx, false);
1517 1518 1519
}
EXPORT_SYMBOL(blk_mq_start_hw_queue);

1520 1521 1522 1523 1524 1525 1526 1527 1528 1529
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);

1530 1531 1532 1533 1534 1535 1536 1537 1538 1539
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);

1540
void blk_mq_start_stopped_hw_queues(struct request_queue *q, bool async)
1541 1542 1543 1544
{
	struct blk_mq_hw_ctx *hctx;
	int i;

1545 1546
	queue_for_each_hw_ctx(q, hctx, i)
		blk_mq_start_stopped_hw_queue(hctx, async);
1547 1548 1549
}
EXPORT_SYMBOL(blk_mq_start_stopped_hw_queues);

1550
static void blk_mq_run_work_fn(struct work_struct *work)
1551 1552 1553
{
	struct blk_mq_hw_ctx *hctx;

1554
	hctx = container_of(work, struct blk_mq_hw_ctx, run_work.work);
1555

1556 1557 1558 1559 1560 1561 1562 1563
	/*
	 * 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;
1564

1565 1566 1567
		clear_bit(BLK_MQ_S_START_ON_RUN, &hctx->state);
		clear_bit(BLK_MQ_S_STOPPED, &hctx->state);
	}
1568 1569 1570 1571

	__blk_mq_run_hw_queue(hctx);
}

1572 1573 1574

void blk_mq_delay_queue(struct blk_mq_hw_ctx *hctx, unsigned long msecs)
{
1575
	if (WARN_ON_ONCE(!blk_mq_hw_queue_mapped(hctx)))
1576
		return;
1577

1578 1579 1580 1581 1582
	/*
	 * 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.
	 */
1583
	blk_mq_stop_hw_queue(hctx);
1584 1585 1586 1587
	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));
1588 1589 1590
}
EXPORT_SYMBOL(blk_mq_delay_queue);

1591 1592 1593
static inline void __blk_mq_insert_req_list(struct blk_mq_hw_ctx *hctx,
					    struct request *rq,
					    bool at_head)
1594
{
J
Jens Axboe 已提交
1595 1596
	struct blk_mq_ctx *ctx = rq->mq_ctx;

1597 1598
	lockdep_assert_held(&ctx->lock);

1599 1600
	trace_block_rq_insert(hctx->queue, rq);

1601 1602 1603 1604
	if (at_head)
		list_add(&rq->queuelist, &ctx->rq_list);
	else
		list_add_tail(&rq->queuelist, &ctx->rq_list);
1605
}
1606

1607 1608
void __blk_mq_insert_request(struct blk_mq_hw_ctx *hctx, struct request *rq,
			     bool at_head)
1609 1610 1611
{
	struct blk_mq_ctx *ctx = rq->mq_ctx;

1612 1613
	lockdep_assert_held(&ctx->lock);

J
Jens Axboe 已提交
1614
	__blk_mq_insert_req_list(hctx, rq, at_head);
1615 1616 1617
	blk_mq_hctx_mark_pending(hctx, ctx);
}

1618 1619 1620 1621
/*
 * Should only be used carefully, when the caller knows we want to
 * bypass a potential IO scheduler on the target device.
 */
1622
void blk_mq_request_bypass_insert(struct request *rq, bool run_queue)
1623 1624 1625 1626 1627 1628 1629 1630
{
	struct blk_mq_ctx *ctx = rq->mq_ctx;
	struct blk_mq_hw_ctx *hctx = blk_mq_map_queue(rq->q, ctx->cpu);

	spin_lock(&hctx->lock);
	list_add_tail(&rq->queuelist, &hctx->dispatch);
	spin_unlock(&hctx->lock);

1631 1632
	if (run_queue)
		blk_mq_run_hw_queue(hctx, false);
1633 1634
}

1635 1636
void blk_mq_insert_requests(struct blk_mq_hw_ctx *hctx, struct blk_mq_ctx *ctx,
			    struct list_head *list)
1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647

{
	/*
	 * 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 已提交
1648
		BUG_ON(rq->mq_ctx != ctx);
1649
		list_del_init(&rq->queuelist);
J
Jens Axboe 已提交
1650
		__blk_mq_insert_req_list(hctx, rq, false);
1651
	}
1652
	blk_mq_hctx_mark_pending(hctx, ctx);
1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688
	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) {
1689 1690 1691 1692
				trace_block_unplug(this_q, depth, from_schedule);
				blk_mq_sched_insert_requests(this_q, this_ctx,
								&ctx_list,
								from_schedule);
1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708
			}

			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) {
1709 1710 1711
		trace_block_unplug(this_q, depth, from_schedule);
		blk_mq_sched_insert_requests(this_q, this_ctx, &ctx_list,
						from_schedule);
1712 1713 1714 1715 1716
	}
}

static void blk_mq_bio_to_request(struct request *rq, struct bio *bio)
{
1717
	blk_init_request_from_bio(rq, bio);
1718

S
Shaohua Li 已提交
1719 1720
	blk_rq_set_rl(rq, blk_get_rl(rq->q, bio));

1721
	blk_account_io_start(rq, true);
1722 1723
}

1724 1725 1726 1727 1728 1729 1730
static inline void blk_mq_queue_io(struct blk_mq_hw_ctx *hctx,
				   struct blk_mq_ctx *ctx,
				   struct request *rq)
{
	spin_lock(&ctx->lock);
	__blk_mq_insert_request(hctx, rq, false);
	spin_unlock(&ctx->lock);
1731
}
1732

1733 1734
static blk_qc_t request_to_qc_t(struct blk_mq_hw_ctx *hctx, struct request *rq)
{
1735 1736 1737 1738
	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);
1739 1740
}

1741 1742 1743
static blk_status_t __blk_mq_issue_directly(struct blk_mq_hw_ctx *hctx,
					    struct request *rq,
					    blk_qc_t *cookie)
1744 1745 1746 1747
{
	struct request_queue *q = rq->q;
	struct blk_mq_queue_data bd = {
		.rq = rq,
1748
		.last = true,
1749
	};
1750
	blk_qc_t new_cookie;
1751
	blk_status_t ret;
1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775

	new_cookie = request_to_qc_t(hctx, rq);

	/*
	 * For OK queue, we are done. For error, caller may 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);
	switch (ret) {
	case BLK_STS_OK:
		*cookie = new_cookie;
		break;
	case BLK_STS_RESOURCE:
		__blk_mq_requeue_request(rq);
		break;
	default:
		*cookie = BLK_QC_T_NONE;
		break;
	}

	return ret;
}

1776
static void __blk_mq_fallback_to_insert(struct request *rq,
1777
					bool run_queue, bool bypass_insert)
1778
{
1779
	if (!bypass_insert)
1780
		blk_mq_sched_insert_request(rq, false, run_queue, false);
1781 1782
	else
		blk_mq_request_bypass_insert(rq, run_queue);
1783 1784 1785 1786
}

static blk_status_t __blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx,
						struct request *rq,
1787 1788
						blk_qc_t *cookie,
						bool bypass_insert)
1789 1790
{
	struct request_queue *q = rq->q;
M
Ming Lei 已提交
1791 1792
	bool run_queue = true;

1793 1794
	/* RCU or SRCU read lock is needed before checking quiesced flag */
	if (blk_mq_hctx_stopped(hctx) || blk_queue_quiesced(q)) {
M
Ming Lei 已提交
1795 1796 1797
		run_queue = false;
		goto insert;
	}
1798

1799
	if (q->elevator && !bypass_insert)
1800 1801
		goto insert;

M
Ming Lei 已提交
1802
	if (!blk_mq_get_driver_tag(rq, NULL, false))
1803 1804
		goto insert;

1805
	if (!blk_mq_get_dispatch_budget(hctx)) {
1806 1807
		blk_mq_put_driver_tag(rq);
		goto insert;
1808
	}
1809

1810
	return __blk_mq_issue_directly(hctx, rq, cookie);
1811
insert:
1812
	__blk_mq_fallback_to_insert(rq, run_queue, bypass_insert);
1813 1814
	if (bypass_insert)
		return BLK_STS_RESOURCE;
1815 1816

	return BLK_STS_OK;
1817 1818
}

1819 1820 1821
static void blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx,
		struct request *rq, blk_qc_t *cookie)
{
1822
	blk_status_t ret;
1823
	int srcu_idx;
1824

1825
	might_sleep_if(hctx->flags & BLK_MQ_F_BLOCKING);
1826

1827
	hctx_lock(hctx, &srcu_idx);
1828

1829
	ret = __blk_mq_try_issue_directly(hctx, rq, cookie, false);
1830
	if (ret == BLK_STS_RESOURCE)
1831
		__blk_mq_fallback_to_insert(rq, true, false);
1832 1833 1834
	else if (ret != BLK_STS_OK)
		blk_mq_end_request(rq, ret);

1835
	hctx_unlock(hctx, srcu_idx);
1836 1837
}

1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852
blk_status_t blk_mq_request_direct_issue(struct request *rq)
{
	blk_status_t ret;
	int srcu_idx;
	blk_qc_t unused_cookie;
	struct blk_mq_ctx *ctx = rq->mq_ctx;
	struct blk_mq_hw_ctx *hctx = blk_mq_map_queue(rq->q, ctx->cpu);

	hctx_lock(hctx, &srcu_idx);
	ret = __blk_mq_try_issue_directly(hctx, rq, &unused_cookie, true);
	hctx_unlock(hctx, srcu_idx);

	return ret;
}

1853
static blk_qc_t blk_mq_make_request(struct request_queue *q, struct bio *bio)
1854
{
1855
	const int is_sync = op_is_sync(bio->bi_opf);
1856
	const int is_flush_fua = op_is_flush(bio->bi_opf);
1857
	struct blk_mq_alloc_data data = { .flags = 0 };
1858
	struct request *rq;
1859
	unsigned int request_count = 0;
1860
	struct blk_plug *plug;
1861
	struct request *same_queue_rq = NULL;
1862
	blk_qc_t cookie;
J
Jens Axboe 已提交
1863
	unsigned int wb_acct;
1864 1865 1866

	blk_queue_bounce(q, &bio);

1867
	blk_queue_split(q, &bio);
1868

1869
	if (!bio_integrity_prep(bio))
1870
		return BLK_QC_T_NONE;
1871

1872 1873 1874
	if (!is_flush_fua && !blk_queue_nomerges(q) &&
	    blk_attempt_plug_merge(q, bio, &request_count, &same_queue_rq))
		return BLK_QC_T_NONE;
1875

1876 1877 1878
	if (blk_mq_sched_bio_merge(q, bio))
		return BLK_QC_T_NONE;

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

1881 1882
	trace_block_getrq(q, bio, bio->bi_opf);

1883
	rq = blk_mq_get_request(q, bio, bio->bi_opf, &data);
J
Jens Axboe 已提交
1884 1885
	if (unlikely(!rq)) {
		__wbt_done(q->rq_wb, wb_acct);
1886 1887
		if (bio->bi_opf & REQ_NOWAIT)
			bio_wouldblock_error(bio);
1888
		return BLK_QC_T_NONE;
J
Jens Axboe 已提交
1889 1890 1891
	}

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

1893
	cookie = request_to_qc_t(data.hctx, rq);
1894

1895
	plug = current->plug;
1896
	if (unlikely(is_flush_fua)) {
1897
		blk_mq_put_ctx(data.ctx);
1898
		blk_mq_bio_to_request(rq, bio);
1899 1900 1901 1902

		/* bypass scheduler for flush rq */
		blk_insert_flush(rq);
		blk_mq_run_hw_queue(data.hctx, true);
1903
	} else if (plug && q->nr_hw_queues == 1) {
1904 1905
		struct request *last = NULL;

1906
		blk_mq_put_ctx(data.ctx);
1907
		blk_mq_bio_to_request(rq, bio);
1908 1909 1910 1911 1912 1913 1914

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

M
Ming Lei 已提交
1918
		if (!request_count)
1919
			trace_block_plug(q);
1920 1921
		else
			last = list_entry_rq(plug->mq_list.prev);
1922

1923 1924
		if (request_count >= BLK_MAX_REQUEST_COUNT || (last &&
		    blk_rq_bytes(last) >= BLK_PLUG_FLUSH_SIZE)) {
1925 1926
			blk_flush_plug_list(plug, false);
			trace_block_plug(q);
1927
		}
1928

1929
		list_add_tail(&rq->queuelist, &plug->mq_list);
1930
	} else if (plug && !blk_queue_nomerges(q)) {
1931
		blk_mq_bio_to_request(rq, bio);
1932 1933

		/*
1934
		 * We do limited plugging. If the bio can be merged, do that.
1935 1936
		 * Otherwise the existing request in the plug list will be
		 * issued. So the plug list will have one request at most
1937 1938
		 * The plug list might get flushed before this. If that happens,
		 * the plug list is empty, and same_queue_rq is invalid.
1939
		 */
1940 1941 1942 1943 1944 1945
		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);

1946 1947
		blk_mq_put_ctx(data.ctx);

1948 1949 1950
		if (same_queue_rq) {
			data.hctx = blk_mq_map_queue(q,
					same_queue_rq->mq_ctx->cpu);
1951 1952
			blk_mq_try_issue_directly(data.hctx, same_queue_rq,
					&cookie);
1953
		}
1954
	} else if (q->nr_hw_queues > 1 && is_sync) {
1955
		blk_mq_put_ctx(data.ctx);
1956 1957
		blk_mq_bio_to_request(rq, bio);
		blk_mq_try_issue_directly(data.hctx, rq, &cookie);
1958
	} else if (q->elevator) {
1959
		blk_mq_put_ctx(data.ctx);
1960
		blk_mq_bio_to_request(rq, bio);
1961
		blk_mq_sched_insert_request(rq, false, true, true);
1962
	} else {
1963
		blk_mq_put_ctx(data.ctx);
1964 1965
		blk_mq_bio_to_request(rq, bio);
		blk_mq_queue_io(data.hctx, data.ctx, rq);
1966
		blk_mq_run_hw_queue(data.hctx, true);
1967
	}
1968

1969
	return cookie;
1970 1971
}

1972 1973
void blk_mq_free_rqs(struct blk_mq_tag_set *set, struct blk_mq_tags *tags,
		     unsigned int hctx_idx)
1974
{
1975
	struct page *page;
1976

1977
	if (tags->rqs && set->ops->exit_request) {
1978
		int i;
1979

1980
		for (i = 0; i < tags->nr_tags; i++) {
J
Jens Axboe 已提交
1981 1982 1983
			struct request *rq = tags->static_rqs[i];

			if (!rq)
1984
				continue;
1985
			set->ops->exit_request(set, rq, hctx_idx);
J
Jens Axboe 已提交
1986
			tags->static_rqs[i] = NULL;
1987
		}
1988 1989
	}

1990 1991
	while (!list_empty(&tags->page_list)) {
		page = list_first_entry(&tags->page_list, struct page, lru);
1992
		list_del_init(&page->lru);
1993 1994 1995 1996 1997
		/*
		 * Remove kmemleak object previously allocated in
		 * blk_mq_init_rq_map().
		 */
		kmemleak_free(page_address(page));
1998 1999
		__free_pages(page, page->private);
	}
2000
}
2001

2002 2003
void blk_mq_free_rq_map(struct blk_mq_tags *tags)
{
2004
	kfree(tags->rqs);
2005
	tags->rqs = NULL;
J
Jens Axboe 已提交
2006 2007
	kfree(tags->static_rqs);
	tags->static_rqs = NULL;
2008

2009
	blk_mq_free_tags(tags);
2010 2011
}

2012 2013 2014 2015
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)
2016
{
2017
	struct blk_mq_tags *tags;
2018
	int node;
2019

2020 2021 2022 2023 2024
	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 已提交
2025
				BLK_MQ_FLAG_TO_ALLOC_POLICY(set->flags));
2026 2027
	if (!tags)
		return NULL;
2028

2029
	tags->rqs = kzalloc_node(nr_tags * sizeof(struct request *),
2030
				 GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY,
2031
				 node);
2032 2033 2034 2035
	if (!tags->rqs) {
		blk_mq_free_tags(tags);
		return NULL;
	}
2036

J
Jens Axboe 已提交
2037 2038
	tags->static_rqs = kzalloc_node(nr_tags * sizeof(struct request *),
				 GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY,
2039
				 node);
J
Jens Axboe 已提交
2040 2041 2042 2043 2044 2045
	if (!tags->static_rqs) {
		kfree(tags->rqs);
		blk_mq_free_tags(tags);
		return NULL;
	}

2046 2047 2048 2049 2050 2051 2052 2053
	return tags;
}

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

2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069
static int blk_mq_init_request(struct blk_mq_tag_set *set, struct request *rq,
			       unsigned int hctx_idx, int node)
{
	int ret;

	if (set->ops->init_request) {
		ret = set->ops->init_request(set, rq, hctx_idx, node);
		if (ret)
			return ret;
	}

	seqcount_init(&rq->gstate_seq);
	u64_stats_init(&rq->aborted_gstate_sync);
	return 0;
}

2070 2071 2072 2073 2074
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;
2075 2076 2077 2078 2079
	int node;

	node = blk_mq_hw_queue_to_node(set->mq_map, hctx_idx);
	if (node == NUMA_NO_NODE)
		node = set->numa_node;
2080 2081 2082

	INIT_LIST_HEAD(&tags->page_list);

2083 2084 2085 2086
	/*
	 * rq_size is the size of the request plus driver payload, rounded
	 * to the cacheline size
	 */
2087
	rq_size = round_up(sizeof(struct request) + set->cmd_size,
2088
				cache_line_size());
2089
	left = rq_size * depth;
2090

2091
	for (i = 0; i < depth; ) {
2092 2093 2094 2095 2096
		int this_order = max_order;
		struct page *page;
		int to_do;
		void *p;

2097
		while (this_order && left < order_to_size(this_order - 1))
2098 2099 2100
			this_order--;

		do {
2101
			page = alloc_pages_node(node,
2102
				GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY | __GFP_ZERO,
2103
				this_order);
2104 2105 2106 2107 2108 2109 2110 2111 2112
			if (page)
				break;
			if (!this_order--)
				break;
			if (order_to_size(this_order) < rq_size)
				break;
		} while (1);

		if (!page)
2113
			goto fail;
2114 2115

		page->private = this_order;
2116
		list_add_tail(&page->lru, &tags->page_list);
2117 2118

		p = page_address(page);
2119 2120 2121 2122
		/*
		 * Allow kmemleak to scan these pages as they contain pointers
		 * to additional allocations like via ops->init_request().
		 */
2123
		kmemleak_alloc(p, order_to_size(this_order), 1, GFP_NOIO);
2124
		entries_per_page = order_to_size(this_order) / rq_size;
2125
		to_do = min(entries_per_page, depth - i);
2126 2127
		left -= to_do * rq_size;
		for (j = 0; j < to_do; j++) {
J
Jens Axboe 已提交
2128 2129 2130
			struct request *rq = p;

			tags->static_rqs[i] = rq;
2131 2132 2133
			if (blk_mq_init_request(set, rq, hctx_idx, node)) {
				tags->static_rqs[i] = NULL;
				goto fail;
2134 2135
			}

2136 2137 2138 2139
			p += rq_size;
			i++;
		}
	}
2140
	return 0;
2141

2142
fail:
2143 2144
	blk_mq_free_rqs(set, tags, hctx_idx);
	return -ENOMEM;
2145 2146
}

J
Jens Axboe 已提交
2147 2148 2149 2150 2151
/*
 * '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.
 */
2152
static int blk_mq_hctx_notify_dead(unsigned int cpu, struct hlist_node *node)
2153
{
2154
	struct blk_mq_hw_ctx *hctx;
2155 2156 2157
	struct blk_mq_ctx *ctx;
	LIST_HEAD(tmp);

2158
	hctx = hlist_entry_safe(node, struct blk_mq_hw_ctx, cpuhp_dead);
J
Jens Axboe 已提交
2159
	ctx = __blk_mq_get_ctx(hctx->queue, cpu);
2160 2161 2162 2163 2164 2165 2166 2167 2168

	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))
2169
		return 0;
2170

J
Jens Axboe 已提交
2171 2172 2173
	spin_lock(&hctx->lock);
	list_splice_tail_init(&tmp, &hctx->dispatch);
	spin_unlock(&hctx->lock);
2174 2175

	blk_mq_run_hw_queue(hctx, true);
2176
	return 0;
2177 2178
}

2179
static void blk_mq_remove_cpuhp(struct blk_mq_hw_ctx *hctx)
2180
{
2181 2182
	cpuhp_state_remove_instance_nocalls(CPUHP_BLK_MQ_DEAD,
					    &hctx->cpuhp_dead);
2183 2184
}

2185
/* hctx->ctxs will be freed in queue's release handler */
2186 2187 2188 2189
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)
{
2190 2191
	blk_mq_debugfs_unregister_hctx(hctx);

2192 2193
	if (blk_mq_hw_queue_mapped(hctx))
		blk_mq_tag_idle(hctx);
2194

2195
	if (set->ops->exit_request)
2196
		set->ops->exit_request(set, hctx->fq->flush_rq, hctx_idx);
2197

2198 2199
	blk_mq_sched_exit_hctx(q, hctx, hctx_idx);

2200 2201 2202
	if (set->ops->exit_hctx)
		set->ops->exit_hctx(hctx, hctx_idx);

2203
	if (hctx->flags & BLK_MQ_F_BLOCKING)
2204
		cleanup_srcu_struct(hctx->srcu);
2205

2206
	blk_mq_remove_cpuhp(hctx);
2207
	blk_free_flush_queue(hctx->fq);
2208
	sbitmap_free(&hctx->ctx_map);
2209 2210
}

M
Ming Lei 已提交
2211 2212 2213 2214 2215 2216 2217 2218 2219
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;
2220
		blk_mq_exit_hctx(q, set, hctx, i);
M
Ming Lei 已提交
2221 2222 2223
	}
}

2224 2225 2226
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)
2227
{
2228 2229 2230 2231 2232 2233
	int node;

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

2234
	INIT_DELAYED_WORK(&hctx->run_work, blk_mq_run_work_fn);
2235 2236 2237
	spin_lock_init(&hctx->lock);
	INIT_LIST_HEAD(&hctx->dispatch);
	hctx->queue = q;
2238
	hctx->flags = set->flags & ~BLK_MQ_F_TAG_SHARED;
2239

2240
	cpuhp_state_add_instance_nocalls(CPUHP_BLK_MQ_DEAD, &hctx->cpuhp_dead);
2241 2242

	hctx->tags = set->tags[hctx_idx];
2243 2244

	/*
2245 2246
	 * Allocate space for all possible cpus to avoid allocation at
	 * runtime
2247
	 */
2248
	hctx->ctxs = kmalloc_array_node(nr_cpu_ids, sizeof(void *),
2249 2250 2251
					GFP_KERNEL, node);
	if (!hctx->ctxs)
		goto unregister_cpu_notifier;
2252

2253 2254
	if (sbitmap_init_node(&hctx->ctx_map, nr_cpu_ids, ilog2(8), GFP_KERNEL,
			      node))
2255
		goto free_ctxs;
2256

2257
	hctx->nr_ctx = 0;
2258

2259 2260 2261
	init_waitqueue_func_entry(&hctx->dispatch_wait, blk_mq_dispatch_wake);
	INIT_LIST_HEAD(&hctx->dispatch_wait.entry);

2262 2263 2264
	if (set->ops->init_hctx &&
	    set->ops->init_hctx(hctx, set->driver_data, hctx_idx))
		goto free_bitmap;
2265

2266 2267 2268
	if (blk_mq_sched_init_hctx(q, hctx, hctx_idx))
		goto exit_hctx;

2269 2270
	hctx->fq = blk_alloc_flush_queue(q, hctx->numa_node, set->cmd_size);
	if (!hctx->fq)
2271
		goto sched_exit_hctx;
2272

2273
	if (blk_mq_init_request(set, hctx->fq->flush_rq, hctx_idx, node))
2274
		goto free_fq;
2275

2276
	if (hctx->flags & BLK_MQ_F_BLOCKING)
2277
		init_srcu_struct(hctx->srcu);
2278

2279 2280
	blk_mq_debugfs_register_hctx(q, hctx);

2281
	return 0;
2282

2283 2284
 free_fq:
	kfree(hctx->fq);
2285 2286
 sched_exit_hctx:
	blk_mq_sched_exit_hctx(q, hctx, hctx_idx);
2287 2288 2289
 exit_hctx:
	if (set->ops->exit_hctx)
		set->ops->exit_hctx(hctx, hctx_idx);
2290
 free_bitmap:
2291
	sbitmap_free(&hctx->ctx_map);
2292 2293 2294
 free_ctxs:
	kfree(hctx->ctxs);
 unregister_cpu_notifier:
2295
	blk_mq_remove_cpuhp(hctx);
2296 2297
	return -1;
}
2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316

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;

		/*
		 * Set local node, IFF we have more than one hw queue. If
		 * not, we remain on the home node of the device
		 */
2317
		hctx = blk_mq_map_queue(q, i);
2318
		if (nr_hw_queues > 1 && hctx->numa_node == NUMA_NO_NODE)
2319
			hctx->numa_node = local_memory_node(cpu_to_node(i));
2320 2321 2322
	}
}

2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344
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)
{
2345 2346 2347 2348 2349
	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;
	}
2350 2351
}

2352
static void blk_mq_map_swqueue(struct request_queue *q)
2353
{
2354
	unsigned int i, hctx_idx;
2355 2356
	struct blk_mq_hw_ctx *hctx;
	struct blk_mq_ctx *ctx;
M
Ming Lei 已提交
2357
	struct blk_mq_tag_set *set = q->tag_set;
2358

2359 2360 2361 2362 2363
	/*
	 * Avoid others reading imcomplete hctx->cpumask through sysfs
	 */
	mutex_lock(&q->sysfs_lock);

2364
	queue_for_each_hw_ctx(q, hctx, i) {
2365
		cpumask_clear(hctx->cpumask);
2366 2367 2368 2369
		hctx->nr_ctx = 0;
	}

	/*
2370 2371 2372
	 * Map software to hardware queues.
	 *
	 * If the cpu isn't present, the cpu is mapped to first hctx.
2373
	 */
2374
	for_each_possible_cpu(i) {
2375 2376
		hctx_idx = q->mq_map[i];
		/* unmapped hw queue can be remapped after CPU topo changed */
2377 2378
		if (!set->tags[hctx_idx] &&
		    !__blk_mq_alloc_rq_map(set, hctx_idx)) {
2379 2380 2381 2382 2383 2384
			/*
			 * 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
			 */
2385
			q->mq_map[i] = 0;
2386 2387
		}

2388
		ctx = per_cpu_ptr(q->queue_ctx, i);
C
Christoph Hellwig 已提交
2389
		hctx = blk_mq_map_queue(q, i);
K
Keith Busch 已提交
2390

2391
		cpumask_set_cpu(i, hctx->cpumask);
2392 2393 2394
		ctx->index_hw = hctx->nr_ctx;
		hctx->ctxs[hctx->nr_ctx++] = ctx;
	}
2395

2396 2397
	mutex_unlock(&q->sysfs_lock);

2398
	queue_for_each_hw_ctx(q, hctx, i) {
2399
		/*
2400 2401
		 * If no software queues are mapped to this hardware queue,
		 * disable it and free the request entries.
2402 2403
		 */
		if (!hctx->nr_ctx) {
2404 2405 2406 2407
			/* Never unmap queue 0.  We need it as a
			 * fallback in case of a new remap fails
			 * allocation
			 */
2408 2409 2410
			if (i && set->tags[i])
				blk_mq_free_map_and_requests(set, i);

M
Ming Lei 已提交
2411
			hctx->tags = NULL;
2412 2413 2414
			continue;
		}

M
Ming Lei 已提交
2415 2416 2417
		hctx->tags = set->tags[i];
		WARN_ON(!hctx->tags);

2418 2419 2420 2421 2422
		/*
		 * 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.
		 */
2423
		sbitmap_resize(&hctx->ctx_map, hctx->nr_ctx);
2424

2425 2426 2427
		/*
		 * Initialize batch roundrobin counts
		 */
2428 2429
		hctx->next_cpu = cpumask_first_and(hctx->cpumask,
				cpu_online_mask);
2430 2431
		hctx->next_cpu_batch = BLK_MQ_CPU_WORK_BATCH;
	}
2432 2433
}

2434 2435 2436 2437
/*
 * Caller needs to ensure that we're either frozen/quiesced, or that
 * the queue isn't live yet.
 */
2438
static void queue_set_hctx_shared(struct request_queue *q, bool shared)
2439 2440 2441 2442
{
	struct blk_mq_hw_ctx *hctx;
	int i;

2443
	queue_for_each_hw_ctx(q, hctx, i) {
2444 2445 2446
		if (shared) {
			if (test_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state))
				atomic_inc(&q->shared_hctx_restart);
2447
			hctx->flags |= BLK_MQ_F_TAG_SHARED;
2448 2449 2450
		} else {
			if (test_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state))
				atomic_dec(&q->shared_hctx_restart);
2451
			hctx->flags &= ~BLK_MQ_F_TAG_SHARED;
2452
		}
2453 2454 2455
	}
}

2456 2457
static void blk_mq_update_tag_set_depth(struct blk_mq_tag_set *set,
					bool shared)
2458 2459
{
	struct request_queue *q;
2460

2461 2462
	lockdep_assert_held(&set->tag_list_lock);

2463 2464
	list_for_each_entry(q, &set->tag_list, tag_set_list) {
		blk_mq_freeze_queue(q);
2465
		queue_set_hctx_shared(q, shared);
2466 2467 2468 2469 2470 2471 2472 2473 2474
		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);
2475 2476
	list_del_rcu(&q->tag_set_list);
	INIT_LIST_HEAD(&q->tag_set_list);
2477 2478 2479 2480 2481 2482
	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);
	}
2483
	mutex_unlock(&set->tag_list_lock);
2484 2485

	synchronize_rcu();
2486 2487 2488 2489 2490 2491 2492 2493
}

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);
2494

2495 2496 2497 2498 2499
	/*
	 * 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)) {
2500 2501 2502 2503 2504 2505
		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);
2506
	list_add_tail_rcu(&q->tag_set_list, &set->tag_list);
2507

2508 2509 2510
	mutex_unlock(&set->tag_list_lock);
}

2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522
/*
 * 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 */
2523 2524 2525
	queue_for_each_hw_ctx(q, hctx, i) {
		if (!hctx)
			continue;
2526
		kobject_put(&hctx->kobj);
2527
	}
2528

2529 2530
	q->mq_map = NULL;

2531 2532
	kfree(q->queue_hw_ctx);

2533 2534 2535 2536 2537 2538
	/*
	 * release .mq_kobj and sw queue's kobject now because
	 * both share lifetime with request queue.
	 */
	blk_mq_sysfs_deinit(q);

2539 2540 2541
	free_percpu(q->queue_ctx);
}

2542
struct request_queue *blk_mq_init_queue(struct blk_mq_tag_set *set)
2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557
{
	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);

2558 2559 2560 2561
static int blk_mq_hw_ctx_size(struct blk_mq_tag_set *tag_set)
{
	int hw_ctx_size = sizeof(struct blk_mq_hw_ctx);

2562
	BUILD_BUG_ON(ALIGN(offsetof(struct blk_mq_hw_ctx, srcu),
2563 2564 2565 2566 2567 2568 2569 2570 2571
			   __alignof__(struct blk_mq_hw_ctx)) !=
		     sizeof(struct blk_mq_hw_ctx));

	if (tag_set->flags & BLK_MQ_F_BLOCKING)
		hw_ctx_size += sizeof(struct srcu_struct);

	return hw_ctx_size;
}

K
Keith Busch 已提交
2572 2573
static void blk_mq_realloc_hw_ctxs(struct blk_mq_tag_set *set,
						struct request_queue *q)
2574
{
K
Keith Busch 已提交
2575 2576
	int i, j;
	struct blk_mq_hw_ctx **hctxs = q->queue_hw_ctx;
2577

K
Keith Busch 已提交
2578
	blk_mq_sysfs_unregister(q);
2579 2580 2581

	/* protect against switching io scheduler  */
	mutex_lock(&q->sysfs_lock);
2582
	for (i = 0; i < set->nr_hw_queues; i++) {
K
Keith Busch 已提交
2583
		int node;
2584

K
Keith Busch 已提交
2585 2586 2587 2588
		if (hctxs[i])
			continue;

		node = blk_mq_hw_queue_to_node(q->mq_map, i);
2589
		hctxs[i] = kzalloc_node(blk_mq_hw_ctx_size(set),
2590
					GFP_KERNEL, node);
2591
		if (!hctxs[i])
K
Keith Busch 已提交
2592
			break;
2593

2594
		if (!zalloc_cpumask_var_node(&hctxs[i]->cpumask, GFP_KERNEL,
K
Keith Busch 已提交
2595 2596 2597 2598 2599
						node)) {
			kfree(hctxs[i]);
			hctxs[i] = NULL;
			break;
		}
2600

2601
		atomic_set(&hctxs[i]->nr_active, 0);
2602
		hctxs[i]->numa_node = node;
2603
		hctxs[i]->queue_num = i;
K
Keith Busch 已提交
2604 2605 2606 2607 2608 2609 2610 2611

		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]);
2612
	}
K
Keith Busch 已提交
2613 2614 2615 2616
	for (j = i; j < q->nr_hw_queues; j++) {
		struct blk_mq_hw_ctx *hctx = hctxs[j];

		if (hctx) {
2617 2618
			if (hctx->tags)
				blk_mq_free_map_and_requests(set, j);
K
Keith Busch 已提交
2619 2620 2621 2622 2623 2624 2625
			blk_mq_exit_hctx(q, set, hctx, j);
			kobject_put(&hctx->kobj);
			hctxs[j] = NULL;

		}
	}
	q->nr_hw_queues = i;
2626
	mutex_unlock(&q->sysfs_lock);
K
Keith Busch 已提交
2627 2628 2629 2630 2631 2632
	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 已提交
2633 2634 2635
	/* mark the queue as mq asap */
	q->mq_ops = set->ops;

2636
	q->poll_cb = blk_stat_alloc_callback(blk_mq_poll_stats_fn,
2637 2638
					     blk_mq_poll_stats_bkt,
					     BLK_MQ_POLL_STATS_BKTS, q);
2639 2640 2641
	if (!q->poll_cb)
		goto err_exit;

K
Keith Busch 已提交
2642 2643
	q->queue_ctx = alloc_percpu(struct blk_mq_ctx);
	if (!q->queue_ctx)
M
Ming Lin 已提交
2644
		goto err_exit;
K
Keith Busch 已提交
2645

2646 2647 2648
	/* init q->mq_kobj and sw queues' kobjects */
	blk_mq_sysfs_init(q);

K
Keith Busch 已提交
2649 2650 2651 2652 2653
	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;

2654
	q->mq_map = set->mq_map;
K
Keith Busch 已提交
2655 2656 2657 2658

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

2660
	INIT_WORK(&q->timeout_work, blk_mq_timeout_work);
2661
	blk_queue_rq_timeout(q, set->timeout ? set->timeout : 30 * HZ);
2662 2663 2664

	q->nr_queues = nr_cpu_ids;

2665
	q->queue_flags |= QUEUE_FLAG_MQ_DEFAULT;
2666

2667 2668 2669
	if (!(set->flags & BLK_MQ_F_SG_MERGE))
		q->queue_flags |= 1 << QUEUE_FLAG_NO_SG_MERGE;

2670 2671
	q->sg_reserved_size = INT_MAX;

2672
	INIT_DELAYED_WORK(&q->requeue_work, blk_mq_requeue_work);
2673 2674 2675
	INIT_LIST_HEAD(&q->requeue_list);
	spin_lock_init(&q->requeue_lock);

2676
	blk_queue_make_request(q, blk_mq_make_request);
2677 2678
	if (q->mq_ops->poll)
		q->poll_fn = blk_mq_poll;
2679

2680 2681 2682 2683 2684
	/*
	 * Do this after blk_queue_make_request() overrides it...
	 */
	q->nr_requests = set->queue_depth;

2685 2686 2687 2688 2689
	/*
	 * Default to classic polling
	 */
	q->poll_nsec = -1;

2690 2691
	if (set->ops->complete)
		blk_queue_softirq_done(q, set->ops->complete);
2692

2693
	blk_mq_init_cpu_queues(q, set->nr_hw_queues);
2694
	blk_mq_add_queue_tag_set(set, q);
2695
	blk_mq_map_swqueue(q);
2696

2697 2698 2699 2700 2701 2702 2703 2704
	if (!(set->flags & BLK_MQ_F_NO_SCHED)) {
		int ret;

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

2705
	return q;
2706

2707
err_hctxs:
K
Keith Busch 已提交
2708
	kfree(q->queue_hw_ctx);
2709
err_percpu:
K
Keith Busch 已提交
2710
	free_percpu(q->queue_ctx);
M
Ming Lin 已提交
2711 2712
err_exit:
	q->mq_ops = NULL;
2713 2714
	return ERR_PTR(-ENOMEM);
}
2715
EXPORT_SYMBOL(blk_mq_init_allocated_queue);
2716 2717 2718

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

2721
	blk_mq_del_queue_tag_set(q);
M
Ming Lei 已提交
2722
	blk_mq_exit_hw_queues(q, set, set->nr_hw_queues);
2723 2724 2725
}

/* Basically redo blk_mq_init_queue with queue frozen */
2726
static void blk_mq_queue_reinit(struct request_queue *q)
2727
{
2728
	WARN_ON_ONCE(!atomic_read(&q->mq_freeze_depth));
2729

2730
	blk_mq_debugfs_unregister_hctxs(q);
2731 2732
	blk_mq_sysfs_unregister(q);

2733 2734
	/*
	 * redo blk_mq_init_cpu_queues and blk_mq_init_hw_queues. FIXME: maybe
2735 2736
	 * we should change hctx numa_node according to the new topology (this
	 * involves freeing and re-allocating memory, worth doing?)
2737
	 */
2738
	blk_mq_map_swqueue(q);
2739

2740
	blk_mq_sysfs_register(q);
2741
	blk_mq_debugfs_register_hctxs(q);
2742 2743
}

2744 2745 2746 2747
static int __blk_mq_alloc_rq_maps(struct blk_mq_tag_set *set)
{
	int i;

2748 2749
	for (i = 0; i < set->nr_hw_queues; i++)
		if (!__blk_mq_alloc_rq_map(set, i))
2750 2751 2752 2753 2754 2755
			goto out_unwind;

	return 0;

out_unwind:
	while (--i >= 0)
2756
		blk_mq_free_rq_map(set->tags[i]);
2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795

	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;
}

2796 2797
static int blk_mq_update_queue_map(struct blk_mq_tag_set *set)
{
2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816
	if (set->ops->map_queues) {
		int cpu;
		/*
		 * transport .map_queues is usually done in the following
		 * way:
		 *
		 * for (queue = 0; queue < set->nr_hw_queues; queue++) {
		 * 	mask = get_cpu_mask(queue)
		 * 	for_each_cpu(cpu, mask)
		 * 		set->mq_map[cpu] = queue;
		 * }
		 *
		 * When we need to remap, the table has to be cleared for
		 * killing stale mapping since one CPU may not be mapped
		 * to any hw queue.
		 */
		for_each_possible_cpu(cpu)
			set->mq_map[cpu] = 0;

2817
		return set->ops->map_queues(set);
2818
	} else
2819 2820 2821
		return blk_mq_map_queues(set);
}

2822 2823 2824 2825 2826 2827
/*
 * 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.
 */
2828 2829
int blk_mq_alloc_tag_set(struct blk_mq_tag_set *set)
{
2830 2831
	int ret;

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

2834 2835
	if (!set->nr_hw_queues)
		return -EINVAL;
2836
	if (!set->queue_depth)
2837 2838 2839 2840
		return -EINVAL;
	if (set->queue_depth < set->reserved_tags + BLK_MQ_TAG_MIN)
		return -EINVAL;

C
Christoph Hellwig 已提交
2841
	if (!set->ops->queue_rq)
2842 2843
		return -EINVAL;

2844 2845 2846
	if (!set->ops->get_budget ^ !set->ops->put_budget)
		return -EINVAL;

2847 2848 2849 2850 2851
	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;
	}
2852

2853 2854 2855 2856 2857 2858 2859 2860 2861
	/*
	 * 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 已提交
2862 2863 2864 2865 2866
	/*
	 * 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;
2867

K
Keith Busch 已提交
2868
	set->tags = kzalloc_node(nr_cpu_ids * sizeof(struct blk_mq_tags *),
2869 2870
				 GFP_KERNEL, set->numa_node);
	if (!set->tags)
2871
		return -ENOMEM;
2872

2873 2874 2875
	ret = -ENOMEM;
	set->mq_map = kzalloc_node(sizeof(*set->mq_map) * nr_cpu_ids,
			GFP_KERNEL, set->numa_node);
2876 2877 2878
	if (!set->mq_map)
		goto out_free_tags;

2879
	ret = blk_mq_update_queue_map(set);
2880 2881 2882 2883 2884
	if (ret)
		goto out_free_mq_map;

	ret = blk_mq_alloc_rq_maps(set);
	if (ret)
2885
		goto out_free_mq_map;
2886

2887 2888 2889
	mutex_init(&set->tag_list_lock);
	INIT_LIST_HEAD(&set->tag_list);

2890
	return 0;
2891 2892 2893 2894 2895

out_free_mq_map:
	kfree(set->mq_map);
	set->mq_map = NULL;
out_free_tags:
2896 2897
	kfree(set->tags);
	set->tags = NULL;
2898
	return ret;
2899 2900 2901 2902 2903 2904 2905
}
EXPORT_SYMBOL(blk_mq_alloc_tag_set);

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

2906 2907
	for (i = 0; i < nr_cpu_ids; i++)
		blk_mq_free_map_and_requests(set, i);
2908

2909 2910 2911
	kfree(set->mq_map);
	set->mq_map = NULL;

M
Ming Lei 已提交
2912
	kfree(set->tags);
2913
	set->tags = NULL;
2914 2915 2916
}
EXPORT_SYMBOL(blk_mq_free_tag_set);

2917 2918 2919 2920 2921 2922
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;

2923
	if (!set)
2924 2925
		return -EINVAL;

2926
	blk_mq_freeze_queue(q);
2927
	blk_mq_quiesce_queue(q);
2928

2929 2930
	ret = 0;
	queue_for_each_hw_ctx(q, hctx, i) {
2931 2932
		if (!hctx->tags)
			continue;
2933 2934 2935 2936
		/*
		 * If we're using an MQ scheduler, just update the scheduler
		 * queue depth. This is similar to what the old code would do.
		 */
2937
		if (!hctx->sched_tags) {
2938
			ret = blk_mq_tag_update_depth(hctx, &hctx->tags, nr,
2939 2940 2941 2942 2943
							false);
		} else {
			ret = blk_mq_tag_update_depth(hctx, &hctx->sched_tags,
							nr, true);
		}
2944 2945 2946 2947 2948 2949 2950
		if (ret)
			break;
	}

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

2951
	blk_mq_unquiesce_queue(q);
2952 2953
	blk_mq_unfreeze_queue(q);

2954 2955 2956
	return ret;
}

2957 2958
static void __blk_mq_update_nr_hw_queues(struct blk_mq_tag_set *set,
							int nr_hw_queues)
K
Keith Busch 已提交
2959 2960 2961
{
	struct request_queue *q;

2962 2963
	lockdep_assert_held(&set->tag_list_lock);

K
Keith Busch 已提交
2964 2965 2966 2967 2968 2969 2970 2971 2972
	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;
2973
	blk_mq_update_queue_map(set);
K
Keith Busch 已提交
2974 2975
	list_for_each_entry(q, &set->tag_list, tag_set_list) {
		blk_mq_realloc_hw_ctxs(set, q);
2976
		blk_mq_queue_reinit(q);
K
Keith Busch 已提交
2977 2978 2979 2980 2981
	}

	list_for_each_entry(q, &set->tag_list, tag_set_list)
		blk_mq_unfreeze_queue(q);
}
2982 2983 2984 2985 2986 2987 2988

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 已提交
2989 2990
EXPORT_SYMBOL_GPL(blk_mq_update_nr_hw_queues);

2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016
/* 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;
3017
	int bucket;
3018

3019 3020 3021 3022
	for (bucket = 0; bucket < BLK_MQ_POLL_STATS_BKTS; bucket++) {
		if (cb->stat[bucket].nr_samples)
			q->poll_stat[bucket] = cb->stat[bucket];
	}
3023 3024
}

3025 3026 3027 3028 3029
static unsigned long blk_mq_poll_nsecs(struct request_queue *q,
				       struct blk_mq_hw_ctx *hctx,
				       struct request *rq)
{
	unsigned long ret = 0;
3030
	int bucket;
3031 3032 3033 3034 3035

	/*
	 * If stats collection isn't on, don't sleep but turn it on for
	 * future users
	 */
3036
	if (!blk_poll_stats_enable(q))
3037 3038 3039 3040 3041 3042 3043 3044
		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
3045 3046
	 * than ~10 usec. We do use the stats for the relevant IO size
	 * if available which does lead to better estimates.
3047
	 */
3048 3049 3050 3051 3052 3053
	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;
3054 3055 3056 3057

	return ret;
}

3058
static bool blk_mq_poll_hybrid_sleep(struct request_queue *q,
3059
				     struct blk_mq_hw_ctx *hctx,
3060 3061 3062 3063
				     struct request *rq)
{
	struct hrtimer_sleeper hs;
	enum hrtimer_mode mode;
3064
	unsigned int nsecs;
3065 3066
	ktime_t kt;

J
Jens Axboe 已提交
3067
	if (rq->rq_flags & RQF_MQ_POLL_SLEPT)
3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084
		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)
3085 3086
		return false;

J
Jens Axboe 已提交
3087
	rq->rq_flags |= RQF_MQ_POLL_SLEPT;
3088 3089 3090 3091 3092

	/*
	 * This will be replaced with the stats tracking code, using
	 * 'avg_completion_time / 2' as the pre-sleep target.
	 */
T
Thomas Gleixner 已提交
3093
	kt = nsecs;
3094 3095 3096 3097 3098 3099 3100

	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 {
T
Tejun Heo 已提交
3101
		if (blk_mq_rq_state(rq) == MQ_RQ_COMPLETE)
3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115
			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 已提交
3116 3117 3118 3119 3120
static bool __blk_mq_poll(struct blk_mq_hw_ctx *hctx, struct request *rq)
{
	struct request_queue *q = hctx->queue;
	long state;

3121 3122 3123 3124 3125 3126 3127
	/*
	 * 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.
	 */
3128
	if (blk_mq_poll_hybrid_sleep(q, hctx, rq))
3129 3130
		return true;

J
Jens Axboe 已提交
3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158
	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;
}

3159
static bool blk_mq_poll(struct request_queue *q, blk_qc_t cookie)
J
Jens Axboe 已提交
3160 3161 3162 3163
{
	struct blk_mq_hw_ctx *hctx;
	struct request *rq;

3164
	if (!test_bit(QUEUE_FLAG_POLL, &q->queue_flags))
J
Jens Axboe 已提交
3165 3166 3167
		return false;

	hctx = q->queue_hw_ctx[blk_qc_t_to_queue_num(cookie)];
3168 3169
	if (!blk_qc_t_is_internal(cookie))
		rq = blk_mq_tag_to_rq(hctx->tags, blk_qc_t_to_tag(cookie));
3170
	else {
3171
		rq = blk_mq_tag_to_rq(hctx->sched_tags, blk_qc_t_to_tag(cookie));
3172 3173 3174 3175 3176 3177 3178 3179 3180
		/*
		 * 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 已提交
3181 3182 3183 3184

	return __blk_mq_poll(hctx, rq);
}

3185 3186
static int __init blk_mq_init(void)
{
3187 3188
	cpuhp_setup_state_multi(CPUHP_BLK_MQ_DEAD, "block/mq:dead", NULL,
				blk_mq_hctx_notify_dead);
3189 3190 3191
	return 0;
}
subsys_initcall(blk_mq_init);