blk-mq.c 83.3 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"
37
#include "blk-mq-sched.h"
38
#include "blk-rq-qos.h"
39

40 41 42
static void blk_mq_poll_stats_start(struct request_queue *q);
static void blk_mq_poll_stats_fn(struct blk_stat_callback *cb);

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

J
Jens Axboe 已提交
47
	ddir = rq_data_dir(rq);
48
	sectors = blk_rq_stats_sectors(rq);
49

50
	bucket = ddir + 2 * ilog2(sectors);
51 52 53 54 55 56 57 58 59

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

	return bucket;
}

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

70 71 72 73 74 75
/*
 * 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)
{
76 77 78 79
	const int bit = ctx->index_hw[hctx->type];

	if (!sbitmap_test_bit(&hctx->ctx_map, bit))
		sbitmap_set_bit(&hctx->ctx_map, bit);
80 81 82 83 84
}

static void blk_mq_hctx_clear_pending(struct blk_mq_hw_ctx *hctx,
				      struct blk_mq_ctx *ctx)
{
85 86 87
	const int bit = ctx->index_hw[hctx->type];

	sbitmap_clear_bit(&hctx->ctx_map, bit);
88 89
}

90 91 92 93 94
struct mq_inflight {
	struct hd_struct *part;
	unsigned int *inflight;
};

95 96 97 98 99
struct mq_hang {
	struct hd_struct *part;
	unsigned int *hang;
};

100 101 102 103 104 105
static void blk_mq_check_inflight(struct blk_mq_hw_ctx *hctx,
				  struct request *rq, void *priv,
				  bool reserved)
{
	struct mq_inflight *mi = priv;

106 107 108 109 110 111 112
	/*
	 * 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.
	 */
	if (rq->part == mi->part)
		mi->inflight[0]++;
113
	if (rq->part && mi->part->partno)
114
		mi->inflight[1]++;
115 116 117 118 119 120 121
}

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

122
	inflight[0] = inflight[1] = 0;
123 124 125
	blk_mq_queue_tag_busy_iter(q, blk_mq_check_inflight, &mi);
}

126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
static void blk_mq_check_inflight_rw(struct blk_mq_hw_ctx *hctx,
				     struct request *rq, void *priv,
				     bool reserved)
{
	struct mq_inflight *mi = priv;

	if (rq->part == mi->part)
		mi->inflight[rq_data_dir(rq)]++;
}

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

	inflight[0] = inflight[1] = 0;
	blk_mq_queue_tag_busy_iter(q, blk_mq_check_inflight_rw, &mi);
}

145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168
static void blk_mq_check_hang_rw(struct blk_mq_hw_ctx *hctx,
		struct request *rq, void *priv, bool reserved)
{
	struct mq_hang *mh = priv;
	u64 now = ktime_get_ns();
	u64 duration;

	duration = div_u64(now - rq->start_time_ns, NSEC_PER_MSEC);
	if (duration < rq->q->rq_hang_threshold)
		return;

	if (!mh->part->partno || rq->part == mh->part)
		mh->hang[rq_data_dir(rq)]++;
}

void blk_mq_in_hang_rw(struct request_queue *q, struct hd_struct *part,
			 unsigned int hang[2])
{
	struct mq_hang mh = { .part = part, .hang = hang, };

	hang[0] = hang[1] = 0;
	blk_mq_queue_tag_busy_iter(q, blk_mq_check_hang_rw, &mh);
}

169
void blk_freeze_queue_start(struct request_queue *q)
170
{
171
	int freeze_depth;
172

173 174
	freeze_depth = atomic_inc_return(&q->mq_freeze_depth);
	if (freeze_depth == 1) {
175
		percpu_ref_kill(&q->q_usage_counter);
176 177
		if (q->mq_ops)
			blk_mq_run_hw_queues(q, false);
178
	}
179
}
180
EXPORT_SYMBOL_GPL(blk_freeze_queue_start);
181

182
void blk_mq_freeze_queue_wait(struct request_queue *q)
183
{
184
	wait_event(q->mq_freeze_wq, percpu_ref_is_zero(&q->q_usage_counter));
185
}
186
EXPORT_SYMBOL_GPL(blk_mq_freeze_queue_wait);
187

188 189 190 191 192 193 194 195
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);
196

197 198 199 200
/*
 * Guarantee no request is in use, so we can change any data structure of
 * the queue afterward.
 */
201
void blk_freeze_queue(struct request_queue *q)
202
{
203 204 205 206 207 208 209
	/*
	 * 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.
	 */
210
	blk_freeze_queue_start(q);
211 212
	if (!q->mq_ops)
		blk_drain_queue(q);
213 214
	blk_mq_freeze_queue_wait(q);
}
215 216 217 218 219 220 221 222 223

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);
}
224
EXPORT_SYMBOL_GPL(blk_mq_freeze_queue);
225

226
void blk_mq_unfreeze_queue(struct request_queue *q)
227
{
228
	int freeze_depth;
229

230 231 232
	freeze_depth = atomic_dec_return(&q->mq_freeze_depth);
	WARN_ON_ONCE(freeze_depth < 0);
	if (!freeze_depth) {
233
		percpu_ref_reinit(&q->q_usage_counter);
234
		wake_up_all(&q->mq_freeze_wq);
235
	}
236
}
237
EXPORT_SYMBOL_GPL(blk_mq_unfreeze_queue);
238

239 240 241 242 243 244
/*
 * 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)
{
245
	blk_queue_flag_set(QUEUE_FLAG_QUIESCED, q);
246 247 248
}
EXPORT_SYMBOL_GPL(blk_mq_quiesce_queue_nowait);

249
/**
250
 * blk_mq_quiesce_queue() - wait until all ongoing dispatches have finished
251 252 253
 * @q: request queue.
 *
 * Note: this function does not prevent that the struct request end_io()
254 255 256
 * 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().
257 258 259 260 261 262 263
 */
void blk_mq_quiesce_queue(struct request_queue *q)
{
	struct blk_mq_hw_ctx *hctx;
	unsigned int i;
	bool rcu = false;

264
	blk_mq_quiesce_queue_nowait(q);
265

266 267
	queue_for_each_hw_ctx(q, hctx, i) {
		if (hctx->flags & BLK_MQ_F_BLOCKING)
268
			synchronize_srcu(hctx->srcu);
269 270 271 272 273 274 275 276
		else
			rcu = true;
	}
	if (rcu)
		synchronize_rcu();
}
EXPORT_SYMBOL_GPL(blk_mq_quiesce_queue);

277 278 279 280 281 282 283 284 285
/*
 * 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)
{
286
	blk_queue_flag_clear(QUEUE_FLAG_QUIESCED, q);
287

288 289
	/* dispatch requests which are inserted during quiescing */
	blk_mq_run_hw_queues(q, true);
290 291 292
}
EXPORT_SYMBOL_GPL(blk_mq_unquiesce_queue);

293 294 295 296 297 298 299 300 301 302
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);
}

303 304 305 306 307 308
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);

309
static struct request *blk_mq_rq_ctx_init(struct blk_mq_alloc_data *data,
310
		unsigned int tag, unsigned int op, u64 alloc_time_ns)
311
{
312 313
	struct blk_mq_tags *tags = blk_mq_tags_from_data(data);
	struct request *rq = tags->static_rqs[tag];
314
	req_flags_t rq_flags = 0;
315

316 317 318 319
	if (data->flags & BLK_MQ_REQ_INTERNAL) {
		rq->tag = -1;
		rq->internal_tag = tag;
	} else {
320
		if (data->hctx->flags & BLK_MQ_F_TAG_SHARED) {
321
			rq_flags = RQF_MQ_INFLIGHT;
322 323 324 325 326 327 328
			atomic_inc(&data->hctx->nr_active);
		}
		rq->tag = tag;
		rq->internal_tag = -1;
		data->hctx->tags->rqs[rq->tag] = rq;
	}

329
	/* csd/requeue_work/fifo_time is initialized before use */
330 331
	rq->q = data->q;
	rq->mq_ctx = data->ctx;
332
	rq->mq_hctx = data->hctx;
333
	rq->rq_flags = rq_flags;
334
	rq->cpu = -1;
335
	rq->cmd_flags = op;
336 337
	if (data->flags & BLK_MQ_REQ_PREEMPT)
		rq->rq_flags |= RQF_PREEMPT;
338
	if (blk_queue_io_stat(data->q))
339
		rq->rq_flags |= RQF_IO_STAT;
340
	INIT_LIST_HEAD(&rq->queuelist);
341 342 343 344
	INIT_HLIST_NODE(&rq->hash);
	RB_CLEAR_NODE(&rq->rb_node);
	rq->rq_disk = NULL;
	rq->part = NULL;
345 346 347
#ifdef CONFIG_BLK_RQ_ALLOC_TIME
	rq->alloc_time_ns = alloc_time_ns;
#endif
348
	rq->start_time_ns = ktime_get_ns();
349
	rq->io_start_time_ns = 0;
350
	rq->stats_sectors = 0;
351 352 353 354 355 356 357
	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;
358
	rq->__deadline = 0;
359 360

	INIT_LIST_HEAD(&rq->timeout_list);
361 362
	rq->timeout = 0;

363 364 365 366
	rq->end_io = NULL;
	rq->end_io_data = NULL;
	rq->next_rq = NULL;

367 368 369 370
#ifdef CONFIG_BLK_CGROUP
	rq->rl = NULL;
#endif

371
	data->ctx->rq_dispatched[op_is_sync(op)]++;
K
Keith Busch 已提交
372
	refcount_set(&rq->ref, 1);
373
	return rq;
374 375
}

376
static struct request *blk_mq_get_request(struct request_queue *q,
377 378
					  struct bio *bio,
					  struct blk_mq_alloc_data *data)
379 380 381
{
	struct elevator_queue *e = q->elevator;
	struct request *rq;
382
	unsigned int tag;
383
	bool put_ctx_on_error = false;
384
	u64 alloc_time_ns = 0;
385 386

	blk_queue_enter_live(q);
387 388 389 390 391

	/* alloc_time includes depth and tag waits */
	if (blk_queue_rq_alloc_time(q))
		alloc_time_ns = ktime_get_ns();

392
	data->q = q;
393 394 395 396
	if (likely(!data->ctx)) {
		data->ctx = blk_mq_get_ctx(q);
		put_ctx_on_error = true;
	}
397
	if (likely(!data->hctx))
398 399 400
		data->hctx = blk_mq_map_queue(q, data->cmd_flags,
						data->ctx->cpu);
	if (data->cmd_flags & REQ_NOWAIT)
401
		data->flags |= BLK_MQ_REQ_NOWAIT;
402 403 404 405 406 407

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

		/*
		 * Flush requests are special and go directly to the
408 409
		 * dispatch list. Don't include reserved tags in the
		 * limiting, as it isn't useful.
410
		 */
411
		if (!op_is_flush(data->cmd_flags) && e->type->ops.mq.limit_depth &&
412
		    !(data->flags & BLK_MQ_REQ_RESERVED))
413
			e->type->ops.mq.limit_depth(data->cmd_flags, data);
414 415
	} else {
		blk_mq_tag_busy(data->hctx);
416 417
	}

418 419
	tag = blk_mq_get_tag(data);
	if (tag == BLK_MQ_TAG_FAIL) {
420 421
		if (put_ctx_on_error) {
			blk_mq_put_ctx(data->ctx);
422 423
			data->ctx = NULL;
		}
424 425
		blk_queue_exit(q);
		return NULL;
426 427
	}

428 429
	rq = blk_mq_rq_ctx_init(data, tag, data->cmd_flags, alloc_time_ns);
	if (!op_is_flush(data->cmd_flags)) {
430
		rq->elv.icq = NULL;
431
		if (e && e->type->ops.mq.prepare_request) {
432 433 434
			if (e->type->icq_cache && rq_ioc(bio))
				blk_mq_sched_assign_ioc(rq, bio);

435 436
			e->type->ops.mq.prepare_request(rq, bio);
			rq->rq_flags |= RQF_ELVPRIV;
437
		}
438 439 440
	}
	data->hctx->queued++;
	return rq;
441 442
}

443
struct request *blk_mq_alloc_request(struct request_queue *q, unsigned int op,
444
		blk_mq_req_flags_t flags)
445
{
446
	struct blk_mq_alloc_data alloc_data = { .flags = flags, .cmd_flags = op };
447
	struct request *rq;
448
	int ret;
449

450
	ret = blk_queue_enter(q, flags);
451 452
	if (ret)
		return ERR_PTR(ret);
453

454
	rq = blk_mq_get_request(q, NULL, &alloc_data);
455
	blk_queue_exit(q);
456

457
	if (!rq)
458
		return ERR_PTR(-EWOULDBLOCK);
459

460 461
	blk_mq_put_ctx(alloc_data.ctx);

462 463 464
	rq->__data_len = 0;
	rq->__sector = (sector_t) -1;
	rq->bio = rq->biotail = NULL;
465 466
	return rq;
}
467
EXPORT_SYMBOL(blk_mq_alloc_request);
468

469
struct request *blk_mq_alloc_request_hctx(struct request_queue *q,
470
	unsigned int op, blk_mq_req_flags_t flags, unsigned int hctx_idx)
M
Ming Lin 已提交
471
{
472
	struct blk_mq_alloc_data alloc_data = { .flags = flags, .cmd_flags = op };
M
Ming Lin 已提交
473
	struct request *rq;
474
	unsigned int cpu;
M
Ming Lin 已提交
475 476 477 478 479 480 481 482 483 484 485 486 487 488
	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);

489
	ret = blk_queue_enter(q, flags);
M
Ming Lin 已提交
490 491 492
	if (ret)
		return ERR_PTR(ret);

493 494 495 496
	/*
	 * Check if the hardware context is actually mapped to anything.
	 * If not tell the caller that it should skip this queue.
	 */
497 498 499 500
	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);
501
	}
502
	cpu = cpumask_first_and(alloc_data.hctx->cpumask, cpu_online_mask);
503
	alloc_data.ctx = __blk_mq_get_ctx(q, cpu);
M
Ming Lin 已提交
504

505
	rq = blk_mq_get_request(q, NULL, &alloc_data);
506
	blk_queue_exit(q);
507

508 509 510 511
	if (!rq)
		return ERR_PTR(-EWOULDBLOCK);

	return rq;
M
Ming Lin 已提交
512 513 514
}
EXPORT_SYMBOL_GPL(blk_mq_alloc_request_hctx);

515
void __blk_mq_free_request(struct request *rq)
K
Keith Busch 已提交
516 517 518
{
	struct request_queue *q = rq->q;
	struct blk_mq_ctx *ctx = rq->mq_ctx;
519
	struct blk_mq_hw_ctx *hctx = rq->mq_hctx;
K
Keith Busch 已提交
520 521
	const int sched_tag = rq->internal_tag;

522
	rq->mq_hctx = NULL;
K
Keith Busch 已提交
523 524 525 526 527 528 529 530
	if (rq->tag != -1)
		blk_mq_put_tag(hctx, hctx->tags, ctx, rq->tag);
	if (sched_tag != -1)
		blk_mq_put_tag(hctx, hctx->sched_tags, ctx, sched_tag);
	blk_mq_sched_restart(hctx);
	blk_queue_exit(q);
}

531
void blk_mq_free_request(struct request *rq)
532 533
{
	struct request_queue *q = rq->q;
534 535
	struct elevator_queue *e = q->elevator;
	struct blk_mq_ctx *ctx = rq->mq_ctx;
536
	struct blk_mq_hw_ctx *hctx = rq->mq_hctx;
537

538
	if (rq->rq_flags & RQF_ELVPRIV) {
539 540 541 542 543 544 545
		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;
		}
	}
546

547
	ctx->rq_completed[rq_is_sync(rq)]++;
548
	if (rq->rq_flags & RQF_MQ_INFLIGHT)
549
		atomic_dec(&hctx->nr_active);
J
Jens Axboe 已提交
550

551 552 553
	if (unlikely(laptop_mode && !blk_rq_is_passthrough(rq)))
		laptop_io_completion(q->backing_dev_info);

554
	rq_qos_done(q, rq);
555

S
Shaohua Li 已提交
556 557 558
	if (blk_rq_rl(rq))
		blk_put_rl(blk_rq_rl(rq));

K
Keith Busch 已提交
559 560 561
	WRITE_ONCE(rq->state, MQ_RQ_IDLE);
	if (refcount_dec_and_test(&rq->ref))
		__blk_mq_free_request(rq);
562
}
J
Jens Axboe 已提交
563
EXPORT_SYMBOL_GPL(blk_mq_free_request);
564

565
inline void __blk_mq_end_request(struct request *rq, blk_status_t error)
566
{
567 568
	u64 now = ktime_get_ns();

569 570
	if (rq->rq_flags & RQF_STATS) {
		blk_mq_poll_stats_start(rq->q);
571
		blk_stat_add(rq, now);
572 573
	}

574
	blk_account_io_done(rq, now);
M
Ming Lei 已提交
575

C
Christoph Hellwig 已提交
576
	if (rq->end_io) {
577
		rq_qos_done(rq->q, rq);
578
		rq->end_io(rq, error);
C
Christoph Hellwig 已提交
579 580 581
	} else {
		if (unlikely(blk_bidi_rq(rq)))
			blk_mq_free_request(rq->next_rq);
582
		blk_mq_free_request(rq);
C
Christoph Hellwig 已提交
583
	}
584
}
585
EXPORT_SYMBOL(__blk_mq_end_request);
586

587
void blk_mq_end_request(struct request *rq, blk_status_t error)
588 589 590
{
	if (blk_update_request(rq, error, blk_rq_bytes(rq)))
		BUG();
591
	__blk_mq_end_request(rq, error);
592
}
593
EXPORT_SYMBOL(blk_mq_end_request);
594

595
static void __blk_mq_complete_request_remote(void *data)
596
{
597
	struct request *rq = data;
598

599
	rq->q->softirq_done_fn(rq);
600 601
}

602
static void __blk_mq_complete_request(struct request *rq)
603 604
{
	struct blk_mq_ctx *ctx = rq->mq_ctx;
C
Christoph Hellwig 已提交
605
	bool shared = false;
606 607
	int cpu;

608
	if (!blk_mq_mark_complete(rq))
K
Keith Busch 已提交
609
		return;
610 611 612
	if (rq->internal_tag != -1)
		blk_mq_sched_completed_request(rq);

C
Christoph Hellwig 已提交
613
	if (!test_bit(QUEUE_FLAG_SAME_COMP, &rq->q->queue_flags)) {
614 615 616
		rq->q->softirq_done_fn(rq);
		return;
	}
617 618

	cpu = get_cpu();
C
Christoph Hellwig 已提交
619 620 621 622
	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)) {
623
		rq->csd.func = __blk_mq_complete_request_remote;
624 625
		rq->csd.info = rq;
		rq->csd.flags = 0;
626
		smp_call_function_single_async(ctx->cpu, &rq->csd);
627
	} else {
628
		rq->q->softirq_done_fn(rq);
629
	}
630 631
	put_cpu();
}
632

633
static void hctx_unlock(struct blk_mq_hw_ctx *hctx, int srcu_idx)
634
	__releases(hctx->srcu)
635 636 637 638
{
	if (!(hctx->flags & BLK_MQ_F_BLOCKING))
		rcu_read_unlock();
	else
639
		srcu_read_unlock(hctx->srcu, srcu_idx);
640 641 642
}

static void hctx_lock(struct blk_mq_hw_ctx *hctx, int *srcu_idx)
643
	__acquires(hctx->srcu)
644
{
645 646 647
	if (!(hctx->flags & BLK_MQ_F_BLOCKING)) {
		/* shut up gcc false positive */
		*srcu_idx = 0;
648
		rcu_read_lock();
649
	} else
650
		*srcu_idx = srcu_read_lock(hctx->srcu);
651 652
}

653 654 655 656 657 658 659 660
/**
 * 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.
 **/
661
void blk_mq_complete_request(struct request *rq)
662
{
K
Keith Busch 已提交
663
	if (unlikely(blk_should_fake_timeout(rq->q)))
664
		return;
K
Keith Busch 已提交
665
	__blk_mq_complete_request(rq);
666 667
}
EXPORT_SYMBOL(blk_mq_complete_request);
668

669 670
int blk_mq_request_started(struct request *rq)
{
T
Tejun Heo 已提交
671
	return blk_mq_rq_state(rq) != MQ_RQ_IDLE;
672 673 674
}
EXPORT_SYMBOL_GPL(blk_mq_request_started);

675
void blk_mq_start_request(struct request *rq)
676 677 678
{
	struct request_queue *q = rq->q;

679 680
	blk_mq_sched_started_request(rq);

681 682
	trace_block_rq_issue(q, rq);

683
	if (test_bit(QUEUE_FLAG_STATS, &q->queue_flags)) {
684
		rq->io_start_time_ns = ktime_get_ns();
685
		rq->stats_sectors = blk_rq_sectors(rq);
686
		rq->rq_flags |= RQF_STATS;
687
		rq_qos_issue(q, rq);
688 689
	}

690
	WARN_ON_ONCE(blk_mq_rq_state(rq) != MQ_RQ_IDLE);
691

692
	blk_add_timer(rq);
K
Keith Busch 已提交
693
	WRITE_ONCE(rq->state, MQ_RQ_IN_FLIGHT);
694 695 696 697 698 699 700 701 702

	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++;
	}
703
}
704
EXPORT_SYMBOL(blk_mq_start_request);
705

706
static void __blk_mq_requeue_request(struct request *rq)
707 708 709
{
	struct request_queue *q = rq->q;

710 711
	blk_mq_put_driver_tag(rq);

712
	trace_block_rq_requeue(q, rq);
713
	rq_qos_requeue(q, rq);
714

K
Keith Busch 已提交
715 716
	if (blk_mq_request_started(rq)) {
		WRITE_ONCE(rq->state, MQ_RQ_IDLE);
717
		rq->rq_flags &= ~RQF_TIMED_OUT;
718 719 720
		if (q->dma_drain_size && blk_rq_bytes(rq))
			rq->nr_phys_segments--;
	}
721 722
}

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

727 728 729
	/* this request will be re-inserted to io scheduler queue */
	blk_mq_sched_requeue_request(rq);

730
	BUG_ON(blk_queued_rq(rq));
731
	blk_mq_add_to_requeue_list(rq, true, kick_requeue_list);
732 733 734
}
EXPORT_SYMBOL(blk_mq_requeue_request);

735 736 737
static void blk_mq_requeue_work(struct work_struct *work)
{
	struct request_queue *q =
738
		container_of(work, struct request_queue, requeue_work.work);
739 740 741
	LIST_HEAD(rq_list);
	struct request *rq, *next;

742
	spin_lock_irq(&q->requeue_lock);
743
	list_splice_init(&q->requeue_list, &rq_list);
744
	spin_unlock_irq(&q->requeue_lock);
745 746

	list_for_each_entry_safe(rq, next, &rq_list, queuelist) {
747
		if (!(rq->rq_flags & (RQF_SOFTBARRIER | RQF_DONTPREP)))
748 749
			continue;

750
		rq->rq_flags &= ~RQF_SOFTBARRIER;
751
		list_del_init(&rq->queuelist);
752 753 754 755 756 757 758 759 760
		/*
		 * If RQF_DONTPREP, rq has contained some driver specific
		 * data, so insert it to hctx dispatch list to avoid any
		 * merge.
		 */
		if (rq->rq_flags & RQF_DONTPREP)
			blk_mq_request_bypass_insert(rq, false);
		else
			blk_mq_sched_insert_request(rq, true, false, false);
761 762 763 764 765
	}

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

769
	blk_mq_run_hw_queues(q, false);
770 771
}

772 773
void blk_mq_add_to_requeue_list(struct request *rq, bool at_head,
				bool kick_requeue_list)
774 775 776 777 778 779
{
	struct request_queue *q = rq->q;
	unsigned long flags;

	/*
	 * We abuse this flag that is otherwise used by the I/O scheduler to
780
	 * request head insertion from the workqueue.
781
	 */
782
	BUG_ON(rq->rq_flags & RQF_SOFTBARRIER);
783 784 785

	spin_lock_irqsave(&q->requeue_lock, flags);
	if (at_head) {
786
		rq->rq_flags |= RQF_SOFTBARRIER;
787 788 789 790 791
		list_add(&rq->queuelist, &q->requeue_list);
	} else {
		list_add_tail(&rq->queuelist, &q->requeue_list);
	}
	spin_unlock_irqrestore(&q->requeue_lock, flags);
792 793 794

	if (kick_requeue_list)
		blk_mq_kick_requeue_list(q);
795 796 797 798 799
}
EXPORT_SYMBOL(blk_mq_add_to_requeue_list);

void blk_mq_kick_requeue_list(struct request_queue *q)
{
800
	kblockd_mod_delayed_work_on(WORK_CPU_UNBOUND, &q->requeue_work, 0);
801 802 803
}
EXPORT_SYMBOL(blk_mq_kick_requeue_list);

804 805 806
void blk_mq_delay_kick_requeue_list(struct request_queue *q,
				    unsigned long msecs)
{
807 808
	kblockd_mod_delayed_work_on(WORK_CPU_UNBOUND, &q->requeue_work,
				    msecs_to_jiffies(msecs));
809 810 811
}
EXPORT_SYMBOL(blk_mq_delay_kick_requeue_list);

812 813
struct request *blk_mq_tag_to_rq(struct blk_mq_tags *tags, unsigned int tag)
{
814 815
	if (tag < tags->nr_tags) {
		prefetch(tags->rqs[tag]);
816
		return tags->rqs[tag];
817
	}
818 819

	return NULL;
820 821 822
}
EXPORT_SYMBOL(blk_mq_tag_to_rq);

823
static void blk_mq_rq_timed_out(struct request *req, bool reserved)
824
{
825
	req->rq_flags |= RQF_TIMED_OUT;
826 827 828 829 830 831 832
	if (req->q->mq_ops->timeout) {
		enum blk_eh_timer_return ret;

		ret = req->q->mq_ops->timeout(req, reserved);
		if (ret == BLK_EH_DONE)
			return;
		WARN_ON_ONCE(ret != BLK_EH_RESET_TIMER);
833
	}
834 835

	blk_add_timer(req);
836
}
837

K
Keith Busch 已提交
838
static bool blk_mq_req_expired(struct request *rq, unsigned long *next)
839
{
K
Keith Busch 已提交
840
	unsigned long deadline;
841

K
Keith Busch 已提交
842 843
	if (blk_mq_rq_state(rq) != MQ_RQ_IN_FLIGHT)
		return false;
844 845
	if (rq->rq_flags & RQF_TIMED_OUT)
		return false;
846

K
Keith Busch 已提交
847 848 849
	deadline = blk_rq_deadline(rq);
	if (time_after_eq(jiffies, deadline))
		return true;
850

K
Keith Busch 已提交
851 852 853 854 855
	if (*next == 0)
		*next = deadline;
	else if (time_after(*next, deadline))
		*next = deadline;
	return false;
856 857
}

K
Keith Busch 已提交
858
static void blk_mq_check_expired(struct blk_mq_hw_ctx *hctx,
859 860
		struct request *rq, void *priv, bool reserved)
{
K
Keith Busch 已提交
861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881
	unsigned long *next = priv;

	/*
	 * Just do a quick check if it is expired before locking the request in
	 * so we're not unnecessarilly synchronizing across CPUs.
	 */
	if (!blk_mq_req_expired(rq, next))
		return;

	/*
	 * We have reason to believe the request may be expired. Take a
	 * reference on the request to lock this request lifetime into its
	 * currently allocated context to prevent it from being reallocated in
	 * the event the completion by-passes this timeout handler.
	 *
	 * If the reference was already released, then the driver beat the
	 * timeout handler to posting a natural completion.
	 */
	if (!refcount_inc_not_zero(&rq->ref))
		return;

882
	/*
K
Keith Busch 已提交
883 884 885 886
	 * The request is now locked and cannot be reallocated underneath the
	 * timeout handler's processing. Re-verify this exact request is truly
	 * expired; if it is not expired, then the request was completed and
	 * reallocated as a new request.
887
	 */
K
Keith Busch 已提交
888
	if (blk_mq_req_expired(rq, next))
889
		blk_mq_rq_timed_out(rq, reserved);
890 891 892 893

	if (is_flush_rq(rq, hctx))
		rq->end_io(rq, 0);
	else if (refcount_dec_and_test(&rq->ref))
K
Keith Busch 已提交
894
		__blk_mq_free_request(rq);
895 896
}

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);
K
Keith Busch 已提交
901
	unsigned long next = 0;
902
	struct blk_mq_hw_ctx *hctx;
903
	int i;
904

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

K
Keith Busch 已提交
921
	blk_mq_queue_tag_busy_iter(q, blk_mq_check_expired, &next);
922

K
Keith Busch 已提交
923 924
	if (next != 0) {
		mod_timer(&q->timeout, next);
925
	} else {
926 927 928 929 930 931
		/*
		 * 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.
		 */
932 933 934 935 936
		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);
		}
937
	}
938
	blk_queue_exit(q);
939 940
}

941 942 943 944 945 946 947 948 949 950 951 952 953
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];

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

959 960 961 962
/*
 * Process software queues that have been marked busy, splicing them
 * to the for-dispatch
 */
963
void blk_mq_flush_busy_ctxs(struct blk_mq_hw_ctx *hctx, struct list_head *list)
964
{
965 966 967 968
	struct flush_busy_ctx_data data = {
		.hctx = hctx,
		.list = list,
	};
969

970
	sbitmap_for_each_set(&hctx->ctx_map, flush_busy_ctx, &data);
971
}
972
EXPORT_SYMBOL_GPL(blk_mq_flush_busy_ctxs);
973

974 975 976 977 978 979 980 981 982 983 984 985 986
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);
H
huhai 已提交
987
	if (!list_empty(&ctx->rq_list)) {
988 989 990 991 992 993 994 995 996 997 998 999 1000
		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)
{
1001
	unsigned off = start ? start->index_hw[hctx->type] : 0;
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
	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;
}

1013 1014 1015 1016
static inline unsigned int queued_to_index(unsigned int queued)
{
	if (!queued)
		return 0;
1017

1018
	return min(BLK_MQ_MAX_DISPATCH_ORDER - 1, ilog2(queued) + 1);
1019 1020
}

1021
bool blk_mq_get_driver_tag(struct request *rq)
1022 1023 1024
{
	struct blk_mq_alloc_data data = {
		.q = rq->q,
1025
		.hctx = rq->mq_hctx,
1026
		.flags = BLK_MQ_REQ_NOWAIT,
1027
		.cmd_flags = rq->cmd_flags,
1028
	};
1029
	bool shared;
1030

1031 1032
	if (rq->tag != -1)
		goto done;
1033

1034 1035 1036
	if (blk_mq_tag_is_reserved(data.hctx->sched_tags, rq->internal_tag))
		data.flags |= BLK_MQ_REQ_RESERVED;

1037
	shared = blk_mq_tag_busy(data.hctx);
1038 1039
	rq->tag = blk_mq_get_tag(&data);
	if (rq->tag >= 0) {
1040
		if (shared) {
1041 1042 1043
			rq->rq_flags |= RQF_MQ_INFLIGHT;
			atomic_inc(&data.hctx->nr_active);
		}
1044 1045 1046
		data.hctx->tags->rqs[rq->tag] = rq;
	}

1047 1048
done:
	return rq->tag != -1;
1049 1050
}

1051 1052
static int blk_mq_dispatch_wake(wait_queue_entry_t *wait, unsigned mode,
				int flags, void *key)
1053 1054 1055 1056 1057
{
	struct blk_mq_hw_ctx *hctx;

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

1058
	spin_lock(&hctx->dispatch_wait_lock);
1059
	list_del_init(&wait->entry);
1060 1061
	spin_unlock(&hctx->dispatch_wait_lock);

1062 1063 1064 1065
	blk_mq_run_hw_queue(hctx, true);
	return 1;
}

1066 1067
/*
 * Mark us waiting for a tag. For shared tags, this involves hooking us into
1068 1069
 * 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
1070 1071
 * marking us as waiting.
 */
1072
static bool blk_mq_mark_tag_wait(struct blk_mq_hw_ctx *hctx,
1073
				 struct request *rq)
1074
{
1075
	struct wait_queue_head *wq;
1076 1077
	wait_queue_entry_t *wait;
	bool ret;
1078

1079 1080 1081
	if (!(hctx->flags & BLK_MQ_F_TAG_SHARED)) {
		if (!test_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state))
			set_bit(BLK_MQ_S_SCHED_RESTART, &hctx->state);
1082

1083 1084 1085 1086 1087 1088 1089 1090
		/*
		 * 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.
		 */
1091
		return blk_mq_get_driver_tag(rq);
1092 1093
	}

1094
	wait = &hctx->dispatch_wait;
1095 1096 1097
	if (!list_empty_careful(&wait->entry))
		return false;

1098 1099 1100 1101
	wq = &bt_wait_ptr(&hctx->tags->bitmap_tags, hctx)->wait;

	spin_lock_irq(&wq->lock);
	spin_lock(&hctx->dispatch_wait_lock);
1102
	if (!list_empty(&wait->entry)) {
1103 1104
		spin_unlock(&hctx->dispatch_wait_lock);
		spin_unlock_irq(&wq->lock);
1105
		return false;
1106 1107
	}

1108 1109
	wait->flags &= ~WQ_FLAG_EXCLUSIVE;
	__add_wait_queue(wq, wait);
1110

1111
	/*
1112 1113 1114
	 * It's possible that a tag was freed in the window between the
	 * allocation failure and adding the hardware queue to the wait
	 * queue.
1115
	 */
1116
	ret = blk_mq_get_driver_tag(rq);
1117
	if (!ret) {
1118 1119
		spin_unlock(&hctx->dispatch_wait_lock);
		spin_unlock_irq(&wq->lock);
1120
		return false;
1121
	}
1122 1123 1124 1125 1126 1127

	/*
	 * We got a tag, remove ourselves from the wait queue to ensure
	 * someone else gets the wakeup.
	 */
	list_del_init(&wait->entry);
1128 1129
	spin_unlock(&hctx->dispatch_wait_lock);
	spin_unlock_irq(&wq->lock);
1130 1131

	return true;
1132 1133
}

1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
#define BLK_MQ_DISPATCH_BUSY_EWMA_WEIGHT  8
#define BLK_MQ_DISPATCH_BUSY_EWMA_FACTOR  4
/*
 * Update dispatch busy with the Exponential Weighted Moving Average(EWMA):
 * - EWMA is one simple way to compute running average value
 * - weight(7/8 and 1/8) is applied so that it can decrease exponentially
 * - take 4 as factor for avoiding to get too small(0) result, and this
 *   factor doesn't matter because EWMA decreases exponentially
 */
static void blk_mq_update_dispatch_busy(struct blk_mq_hw_ctx *hctx, bool busy)
{
	unsigned int ewma;

	if (hctx->queue->elevator)
		return;

	ewma = hctx->dispatch_busy;

	if (!ewma && !busy)
		return;

	ewma *= BLK_MQ_DISPATCH_BUSY_EWMA_WEIGHT - 1;
	if (busy)
		ewma += 1 << BLK_MQ_DISPATCH_BUSY_EWMA_FACTOR;
	ewma /= BLK_MQ_DISPATCH_BUSY_EWMA_WEIGHT;

	hctx->dispatch_busy = ewma;
}

1163 1164
#define BLK_MQ_RESOURCE_DELAY	3		/* ms units */

1165 1166 1167
/*
 * Returns true if we did some work AND can potentially do more.
 */
1168
bool blk_mq_dispatch_rq_list(struct request_queue *q, struct list_head *list,
1169
			     bool got_budget)
1170
{
1171
	struct blk_mq_hw_ctx *hctx;
1172
	struct request *rq, *nxt;
1173
	bool no_tag = false;
1174
	int errors, queued;
1175
	blk_status_t ret = BLK_STS_OK;
1176

1177 1178 1179
	if (list_empty(list))
		return false;

1180 1181
	WARN_ON(!list_is_singular(list) && got_budget);

1182 1183 1184
	/*
	 * Now process all the entries, sending them to the driver.
	 */
1185
	errors = queued = 0;
1186
	do {
1187
		struct blk_mq_queue_data bd;
1188

1189
		rq = list_first_entry(list, struct request, queuelist);
1190

1191
		hctx = rq->mq_hctx;
1192 1193 1194
		if (!got_budget && !blk_mq_get_dispatch_budget(hctx))
			break;

1195
		if (!blk_mq_get_driver_tag(rq)) {
1196
			/*
1197
			 * The initial allocation attempt failed, so we need to
1198 1199 1200 1201
			 * 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.
1202
			 */
1203
			if (!blk_mq_mark_tag_wait(hctx, rq)) {
1204
				blk_mq_put_dispatch_budget(hctx);
1205 1206 1207 1208 1209 1210
				/*
				 * For non-shared tags, the RESTART check
				 * will suffice.
				 */
				if (hctx->flags & BLK_MQ_F_TAG_SHARED)
					no_tag = true;
1211 1212 1213 1214
				break;
			}
		}

1215 1216
		list_del_init(&rq->queuelist);

1217
		bd.rq = rq;
1218 1219 1220 1221 1222 1223 1224 1225 1226

		/*
		 * 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);
1227
			bd.last = !blk_mq_get_driver_tag(nxt);
1228
		}
1229 1230

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

		if (unlikely(ret != BLK_STS_OK)) {
1247
			errors++;
1248
			blk_mq_end_request(rq, BLK_STS_IOERR);
1249
			continue;
1250 1251
		}

1252
		queued++;
1253
	} while (!list_empty(list));
1254

1255
	hctx->dispatched[queued_to_index(queued)]++;
1256 1257 1258 1259 1260

	/*
	 * Any items that need requeuing? Stuff them into hctx->dispatch,
	 * that is where we will continue on next queue run.
	 */
1261
	if (!list_empty(list)) {
1262 1263
		bool needs_restart;

J
Jens Axboe 已提交
1264 1265 1266 1267 1268 1269 1270 1271
		/*
		 * If we didn't flush the entire list, we could have told
		 * the driver there was more coming, but that turned out to
		 * be a lie.
		 */
		if (q->mq_ops->commit_rqs)
			q->mq_ops->commit_rqs(hctx);

1272
		spin_lock(&hctx->lock);
1273
		list_splice_init(list, &hctx->dispatch);
1274
		spin_unlock(&hctx->lock);
1275

1276
		/*
1277 1278 1279
		 * 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.
1280
		 *
1281 1282 1283 1284
		 * 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.
1285
		 *
1286 1287 1288 1289 1290 1291 1292
		 * 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
1293
		 *   returning BLK_STS_RESOURCE. Two exceptions are scsi-mq
1294
		 *   and dm-rq.
1295 1296 1297 1298
		 *
		 * If driver returns BLK_STS_RESOURCE and SCHED_RESTART
		 * bit is set, run queue after a delay to avoid IO stalls
		 * that could otherwise occur if the queue is idle.
1299
		 */
1300 1301
		needs_restart = blk_mq_sched_needs_restart(hctx);
		if (!needs_restart ||
1302
		    (no_tag && list_empty_careful(&hctx->dispatch_wait.entry)))
1303
			blk_mq_run_hw_queue(hctx, true);
1304 1305
		else if (needs_restart && (ret == BLK_STS_RESOURCE))
			blk_mq_delay_run_hw_queue(hctx, BLK_MQ_RESOURCE_DELAY);
1306

1307
		blk_mq_update_dispatch_busy(hctx, true);
1308
		return false;
1309 1310
	} else
		blk_mq_update_dispatch_busy(hctx, false);
1311

1312 1313 1314 1315 1316 1317 1318
	/*
	 * If the host/device is unable to accept more work, inform the
	 * caller of that.
	 */
	if (ret == BLK_STS_RESOURCE || ret == BLK_STS_DEV_RESOURCE)
		return false;

1319
	return (queued + errors) != 0;
1320 1321
}

1322 1323 1324 1325
static void __blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx)
{
	int srcu_idx;

1326 1327 1328
	/*
	 * We should be running this queue from one of the CPUs that
	 * are mapped to it.
1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341
	 *
	 * 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
1342
	 */
1343 1344 1345 1346 1347 1348 1349
	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();
	}
1350

1351 1352 1353 1354 1355 1356
	/*
	 * We can't run the queue inline with ints disabled. Ensure that
	 * we catch bad users of this early.
	 */
	WARN_ON_ONCE(in_interrupt());

1357
	might_sleep_if(hctx->flags & BLK_MQ_F_BLOCKING);
1358

1359 1360 1361
	hctx_lock(hctx, &srcu_idx);
	blk_mq_sched_dispatch_requests(hctx);
	hctx_unlock(hctx, srcu_idx);
1362 1363
}

1364 1365 1366 1367 1368 1369 1370 1371 1372
static inline int blk_mq_first_mapped_cpu(struct blk_mq_hw_ctx *hctx)
{
	int cpu = cpumask_first_and(hctx->cpumask, cpu_online_mask);

	if (cpu >= nr_cpu_ids)
		cpu = cpumask_first(hctx->cpumask);
	return cpu;
}

1373 1374 1375 1376 1377 1378 1379 1380
/*
 * 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)
{
1381
	bool tried = false;
1382
	int next_cpu = hctx->next_cpu;
1383

1384 1385
	if (hctx->queue->nr_hw_queues == 1)
		return WORK_CPU_UNBOUND;
1386 1387

	if (--hctx->next_cpu_batch <= 0) {
1388
select_cpu:
1389
		next_cpu = cpumask_next_and(next_cpu, hctx->cpumask,
1390
				cpu_online_mask);
1391
		if (next_cpu >= nr_cpu_ids)
1392
			next_cpu = blk_mq_first_mapped_cpu(hctx);
1393 1394 1395
		hctx->next_cpu_batch = BLK_MQ_CPU_WORK_BATCH;
	}

1396 1397 1398 1399
	/*
	 * 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.
	 */
1400
	if (!cpu_online(next_cpu)) {
1401 1402 1403 1404 1405 1406 1407 1408 1409
		if (!tried) {
			tried = true;
			goto select_cpu;
		}

		/*
		 * Make sure to re-select CPU next time once after CPUs
		 * in hctx->cpumask become online again.
		 */
1410
		hctx->next_cpu = next_cpu;
1411 1412 1413
		hctx->next_cpu_batch = 1;
		return WORK_CPU_UNBOUND;
	}
1414 1415 1416

	hctx->next_cpu = next_cpu;
	return next_cpu;
1417 1418
}

1419 1420
static void __blk_mq_delay_run_hw_queue(struct blk_mq_hw_ctx *hctx, bool async,
					unsigned long msecs)
1421
{
1422
	if (unlikely(blk_mq_hctx_stopped(hctx)))
1423 1424
		return;

1425
	if (!async && !(hctx->flags & BLK_MQ_F_BLOCKING)) {
1426 1427
		int cpu = get_cpu();
		if (cpumask_test_cpu(cpu, hctx->cpumask)) {
1428
			__blk_mq_run_hw_queue(hctx);
1429
			put_cpu();
1430 1431
			return;
		}
1432

1433
		put_cpu();
1434
	}
1435

1436 1437
	kblockd_mod_delayed_work_on(blk_mq_hctx_next_cpu(hctx), &hctx->run_work,
				    msecs_to_jiffies(msecs));
1438 1439 1440 1441 1442 1443 1444 1445
}

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

1446
bool blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx, bool async)
1447
{
1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458
	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.
	 */
1459 1460 1461 1462
	hctx_lock(hctx, &srcu_idx);
	need_run = !blk_queue_quiesced(hctx->queue) &&
		blk_mq_hctx_has_pending(hctx);
	hctx_unlock(hctx, srcu_idx);
1463 1464

	if (need_run) {
1465 1466 1467 1468 1469
		__blk_mq_delay_run_hw_queue(hctx, async, 0);
		return true;
	}

	return false;
1470
}
O
Omar Sandoval 已提交
1471
EXPORT_SYMBOL(blk_mq_run_hw_queue);
1472

1473
void blk_mq_run_hw_queues(struct request_queue *q, bool async)
1474 1475 1476 1477 1478
{
	struct blk_mq_hw_ctx *hctx;
	int i;

	queue_for_each_hw_ctx(q, hctx, i) {
1479
		if (blk_mq_hctx_stopped(hctx))
1480 1481
			continue;

1482
		blk_mq_run_hw_queue(hctx, async);
1483 1484
	}
}
1485
EXPORT_SYMBOL(blk_mq_run_hw_queues);
1486

1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506
/**
 * 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);

1507 1508 1509
/*
 * This function is often used for pausing .queue_rq() by driver when
 * there isn't enough resource or some conditions aren't satisfied, and
1510
 * BLK_STS_RESOURCE is usually returned.
1511 1512 1513 1514 1515
 *
 * 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.
 */
1516 1517
void blk_mq_stop_hw_queue(struct blk_mq_hw_ctx *hctx)
{
1518
	cancel_delayed_work(&hctx->run_work);
1519

1520
	set_bit(BLK_MQ_S_STOPPED, &hctx->state);
1521
}
1522
EXPORT_SYMBOL(blk_mq_stop_hw_queue);
1523

1524 1525 1526
/*
 * This function is often used for pausing .queue_rq() by driver when
 * there isn't enough resource or some conditions aren't satisfied, and
1527
 * BLK_STS_RESOURCE is usually returned.
1528 1529 1530 1531 1532
 *
 * 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.
 */
1533 1534
void blk_mq_stop_hw_queues(struct request_queue *q)
{
1535 1536 1537 1538 1539
	struct blk_mq_hw_ctx *hctx;
	int i;

	queue_for_each_hw_ctx(q, hctx, i)
		blk_mq_stop_hw_queue(hctx);
1540 1541 1542
}
EXPORT_SYMBOL(blk_mq_stop_hw_queues);

1543 1544 1545
void blk_mq_start_hw_queue(struct blk_mq_hw_ctx *hctx)
{
	clear_bit(BLK_MQ_S_STOPPED, &hctx->state);
1546

1547
	blk_mq_run_hw_queue(hctx, false);
1548 1549 1550
}
EXPORT_SYMBOL(blk_mq_start_hw_queue);

1551 1552 1553 1554 1555 1556 1557 1558 1559 1560
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);

1561 1562 1563 1564 1565 1566 1567 1568 1569 1570
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);

1571
void blk_mq_start_stopped_hw_queues(struct request_queue *q, bool async)
1572 1573 1574 1575
{
	struct blk_mq_hw_ctx *hctx;
	int i;

1576 1577
	queue_for_each_hw_ctx(q, hctx, i)
		blk_mq_start_stopped_hw_queue(hctx, async);
1578 1579 1580
}
EXPORT_SYMBOL(blk_mq_start_stopped_hw_queues);

1581
static void blk_mq_run_work_fn(struct work_struct *work)
1582 1583 1584
{
	struct blk_mq_hw_ctx *hctx;

1585
	hctx = container_of(work, struct blk_mq_hw_ctx, run_work.work);
1586

1587
	/*
M
Ming Lei 已提交
1588
	 * If we are stopped, don't run the queue.
1589
	 */
M
Ming Lei 已提交
1590
	if (test_bit(BLK_MQ_S_STOPPED, &hctx->state))
1591
		return;
1592 1593 1594 1595

	__blk_mq_run_hw_queue(hctx);
}

1596 1597 1598
static inline void __blk_mq_insert_req_list(struct blk_mq_hw_ctx *hctx,
					    struct request *rq,
					    bool at_head)
1599
{
J
Jens Axboe 已提交
1600 1601
	struct blk_mq_ctx *ctx = rq->mq_ctx;

1602 1603
	lockdep_assert_held(&ctx->lock);

1604 1605
	trace_block_rq_insert(hctx->queue, rq);

1606 1607 1608 1609
	if (at_head)
		list_add(&rq->queuelist, &ctx->rq_list);
	else
		list_add_tail(&rq->queuelist, &ctx->rq_list);
1610
}
1611

1612 1613
void __blk_mq_insert_request(struct blk_mq_hw_ctx *hctx, struct request *rq,
			     bool at_head)
1614 1615 1616
{
	struct blk_mq_ctx *ctx = rq->mq_ctx;

1617 1618
	lockdep_assert_held(&ctx->lock);

J
Jens Axboe 已提交
1619
	__blk_mq_insert_req_list(hctx, rq, at_head);
1620 1621 1622
	blk_mq_hctx_mark_pending(hctx, ctx);
}

1623 1624 1625 1626
/*
 * Should only be used carefully, when the caller knows we want to
 * bypass a potential IO scheduler on the target device.
 */
1627
void blk_mq_request_bypass_insert(struct request *rq, bool run_queue)
1628
{
1629
	struct blk_mq_hw_ctx *hctx = rq->mq_hctx;
1630 1631 1632 1633 1634

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

1635 1636
	if (run_queue)
		blk_mq_run_hw_queue(hctx, false);
1637 1638
}

1639 1640
void blk_mq_insert_requests(struct blk_mq_hw_ctx *hctx, struct blk_mq_ctx *ctx,
			    struct list_head *list)
1641 1642

{
1643 1644
	struct request *rq;

1645 1646 1647 1648
	/*
	 * preemption doesn't flush plug list, so it's possible ctx->cpu is
	 * offline now
	 */
1649
	list_for_each_entry(rq, list, queuelist) {
J
Jens Axboe 已提交
1650
		BUG_ON(rq->mq_ctx != ctx);
1651
		trace_block_rq_insert(hctx->queue, rq);
1652
	}
1653 1654 1655

	spin_lock(&ctx->lock);
	list_splice_tail_init(list, &ctx->rq_list);
1656
	blk_mq_hctx_mark_pending(hctx, ctx);
1657 1658 1659
	spin_unlock(&ctx->lock);
}

J
Jens Axboe 已提交
1660
static int plug_rq_cmp(void *priv, struct list_head *a, struct list_head *b)
1661 1662 1663 1664
{
	struct request *rqa = container_of(a, struct request, queuelist);
	struct request *rqb = container_of(b, struct request, queuelist);

J
Jens Axboe 已提交
1665 1666 1667 1668 1669 1670 1671 1672 1673 1674
	if (rqa->mq_ctx < rqb->mq_ctx)
		return -1;
	else if (rqa->mq_ctx > rqb->mq_ctx)
		return 1;
	else if (rqa->mq_hctx < rqb->mq_hctx)
		return -1;
	else if (rqa->mq_hctx > rqb->mq_hctx)
		return 1;

	return blk_rq_pos(rqa) > blk_rq_pos(rqb);
1675 1676 1677 1678
}

void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule)
{
1679
	struct blk_mq_hw_ctx *this_hctx;
1680 1681 1682 1683
	struct blk_mq_ctx *this_ctx;
	struct request_queue *this_q;
	struct request *rq;
	LIST_HEAD(list);
1684
	LIST_HEAD(rq_list);
1685 1686 1687 1688
	unsigned int depth;

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

1689
	if (plug->multiple_queues)
J
Jens Axboe 已提交
1690
		list_sort(NULL, &list, plug_rq_cmp);
1691 1692

	this_q = NULL;
1693
	this_hctx = NULL;
1694 1695 1696 1697 1698 1699 1700
	this_ctx = NULL;
	depth = 0;

	while (!list_empty(&list)) {
		rq = list_entry_rq(list.next);
		list_del_init(&rq->queuelist);
		BUG_ON(!rq->q);
1701 1702
		if (rq->mq_hctx != this_hctx || rq->mq_ctx != this_ctx) {
			if (this_hctx) {
1703
				trace_block_unplug(this_q, depth, !from_schedule);
1704 1705
				blk_mq_sched_insert_requests(this_hctx, this_ctx,
								&rq_list,
1706
								from_schedule);
1707 1708 1709
			}

			this_q = rq->q;
1710 1711
			this_ctx = rq->mq_ctx;
			this_hctx = rq->mq_hctx;
1712 1713 1714 1715
			depth = 0;
		}

		depth++;
1716
		list_add_tail(&rq->queuelist, &rq_list);
1717 1718 1719
	}

	/*
1720 1721
	 * If 'this_hctx' is set, we know we have entries to complete
	 * on 'rq_list'. Do those.
1722
	 */
1723
	if (this_hctx) {
1724
		trace_block_unplug(this_q, depth, !from_schedule);
1725
		blk_mq_sched_insert_requests(this_hctx, this_ctx, &rq_list,
1726
						from_schedule);
1727 1728 1729 1730 1731
	}
}

static void blk_mq_bio_to_request(struct request *rq, struct bio *bio)
{
1732
	blk_init_request_from_bio(rq, bio);
1733

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

1736
	blk_account_io_start(rq, true);
1737 1738
}

1739 1740
static blk_qc_t request_to_qc_t(struct blk_mq_hw_ctx *hctx, struct request *rq)
{
1741 1742 1743 1744
	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);
1745 1746
}

1747 1748
static blk_status_t __blk_mq_issue_directly(struct blk_mq_hw_ctx *hctx,
					    struct request *rq,
1749
					    blk_qc_t *cookie, bool last)
1750 1751 1752 1753
{
	struct request_queue *q = rq->q;
	struct blk_mq_queue_data bd = {
		.rq = rq,
1754
		.last = last,
1755
	};
1756
	blk_qc_t new_cookie;
1757
	blk_status_t ret;
1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768

	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:
1769
		blk_mq_update_dispatch_busy(hctx, false);
1770 1771 1772
		*cookie = new_cookie;
		break;
	case BLK_STS_RESOURCE:
1773
	case BLK_STS_DEV_RESOURCE:
1774
		blk_mq_update_dispatch_busy(hctx, true);
1775 1776 1777
		__blk_mq_requeue_request(rq);
		break;
	default:
1778
		blk_mq_update_dispatch_busy(hctx, false);
1779 1780 1781 1782 1783 1784 1785 1786 1787
		*cookie = BLK_QC_T_NONE;
		break;
	}

	return ret;
}

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

1794 1795 1796 1797
	/*
	 * RCU or SRCU read lock is needed before checking quiesced flag.
	 *
	 * When queue is stopped or quiesced, ignore 'bypass_insert' from
1798
	 * blk_mq_request_issue_directly(), and return BLK_STS_OK to caller,
1799 1800
	 * and avoid driver to try to dispatch again.
	 */
1801
	if (blk_mq_hctx_stopped(hctx) || blk_queue_quiesced(q)) {
M
Ming Lei 已提交
1802
		run_queue = false;
1803
		bypass_insert = false;
M
Ming Lei 已提交
1804 1805
		goto insert;
	}
1806

1807
	if (q->elevator && !bypass_insert)
1808 1809
		goto insert;

1810
	if (!blk_mq_get_dispatch_budget(hctx))
1811 1812
		goto insert;

1813
	if (!blk_mq_get_driver_tag(rq)) {
1814
		blk_mq_put_dispatch_budget(hctx);
1815
		goto insert;
1816
	}
1817

1818
	return __blk_mq_issue_directly(hctx, rq, cookie, last);
1819
insert:
1820 1821
	if (bypass_insert)
		return BLK_STS_RESOURCE;
1822

1823
	blk_mq_request_bypass_insert(rq, run_queue);
1824
	return BLK_STS_OK;
1825 1826
}

1827 1828 1829
static void blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx,
		struct request *rq, blk_qc_t *cookie)
{
1830
	blk_status_t ret;
1831
	int srcu_idx;
1832

1833
	might_sleep_if(hctx->flags & BLK_MQ_F_BLOCKING);
1834

1835
	hctx_lock(hctx, &srcu_idx);
1836

1837
	ret = __blk_mq_try_issue_directly(hctx, rq, cookie, false, true);
1838
	if (ret == BLK_STS_RESOURCE || ret == BLK_STS_DEV_RESOURCE)
1839
		blk_mq_request_bypass_insert(rq, true);
1840 1841 1842
	else if (ret != BLK_STS_OK)
		blk_mq_end_request(rq, ret);

1843
	hctx_unlock(hctx, srcu_idx);
1844 1845
}

1846
blk_status_t blk_mq_request_issue_directly(struct request *rq, bool last)
1847 1848 1849 1850
{
	blk_status_t ret;
	int srcu_idx;
	blk_qc_t unused_cookie;
1851
	struct blk_mq_hw_ctx *hctx = rq->mq_hctx;
1852 1853

	hctx_lock(hctx, &srcu_idx);
1854
	ret = __blk_mq_try_issue_directly(hctx, rq, &unused_cookie, true, last);
1855 1856 1857
	hctx_unlock(hctx, srcu_idx);

	return ret;
1858 1859
}

1860 1861 1862 1863 1864 1865 1866 1867 1868
void blk_mq_try_issue_list_directly(struct blk_mq_hw_ctx *hctx,
		struct list_head *list)
{
	while (!list_empty(list)) {
		blk_status_t ret;
		struct request *rq = list_first_entry(list, struct request,
				queuelist);

		list_del_init(&rq->queuelist);
1869
		ret = blk_mq_request_issue_directly(rq, list_empty(list));
1870
		if (ret != BLK_STS_OK) {
1871 1872
			if (ret == BLK_STS_RESOURCE ||
					ret == BLK_STS_DEV_RESOURCE) {
1873 1874
				blk_mq_request_bypass_insert(rq,
							list_empty(list));
1875 1876 1877
				break;
			}
			blk_mq_end_request(rq, ret);
1878 1879
		}
	}
J
Jens Axboe 已提交
1880 1881 1882 1883 1884 1885 1886 1887

	/*
	 * If we didn't flush the entire list, we could have told
	 * the driver there was more coming, but that turned out to
	 * be a lie.
	 */
	if (!list_empty(list) && hctx->queue->mq_ops->commit_rqs)
		hctx->queue->mq_ops->commit_rqs(hctx);
1888 1889
}

1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902
static void blk_add_rq_to_plug(struct blk_plug *plug, struct request *rq)
{
	list_add_tail(&rq->queuelist, &plug->mq_list);
	if (!plug->multiple_queues && !list_is_singular(&plug->mq_list)) {
		struct request *tmp;

		tmp = list_first_entry(&plug->mq_list, struct request,
						queuelist);
		if (tmp->q != rq->q)
			plug->multiple_queues = true;
	}
}

1903
static blk_qc_t blk_mq_make_request(struct request_queue *q, struct bio *bio)
1904
{
1905
	const int is_sync = op_is_sync(bio->bi_opf);
1906
	const int is_flush_fua = op_is_flush(bio->bi_opf);
1907
	struct blk_mq_alloc_data data = { .flags = 0};
1908
	struct request *rq;
1909
	unsigned int request_count = 0;
1910
	struct blk_plug *plug;
1911
	struct request *same_queue_rq = NULL;
1912
	blk_qc_t cookie;
1913 1914 1915

	blk_queue_bounce(q, &bio);

1916
	blk_queue_split(q, &bio);
1917

1918
	if (!bio_integrity_prep(bio))
1919
		return BLK_QC_T_NONE;
1920

1921 1922 1923
	if (!is_flush_fua && !blk_queue_nomerges(q) &&
	    blk_attempt_plug_merge(q, bio, &request_count, &same_queue_rq))
		return BLK_QC_T_NONE;
1924

1925 1926 1927
	if (blk_mq_sched_bio_merge(q, bio))
		return BLK_QC_T_NONE;

1928
	rq_qos_throttle(q, bio, NULL);
J
Jens Axboe 已提交
1929

1930
	data.cmd_flags = bio->bi_opf;
1931
	rq = blk_mq_get_request(q, bio, &data);
J
Jens Axboe 已提交
1932
	if (unlikely(!rq)) {
1933
		rq_qos_cleanup(q, bio);
1934 1935
		if (bio->bi_opf & REQ_NOWAIT)
			bio_wouldblock_error(bio);
1936
		return BLK_QC_T_NONE;
J
Jens Axboe 已提交
1937 1938
	}

1939 1940
	trace_block_getrq(q, bio, bio->bi_opf);

1941
	rq_qos_track(q, rq, bio);
1942

1943
	cookie = request_to_qc_t(data.hctx, rq);
1944

1945
	plug = current->plug;
1946
	if (unlikely(is_flush_fua)) {
1947
		blk_mq_put_ctx(data.ctx);
1948
		blk_mq_bio_to_request(rq, bio);
1949 1950 1951 1952

		/* bypass scheduler for flush rq */
		blk_insert_flush(rq);
		blk_mq_run_hw_queue(data.hctx, true);
1953 1954 1955 1956 1957
	} else if (plug && (q->nr_hw_queues == 1 || q->mq_ops->commit_rqs)) {
		/*
		 * Use plugging if we have a ->commit_rqs() hook as well, as
		 * we know the driver uses bd->last in a smart fashion.
		 */
1958 1959
		struct request *last = NULL;

1960
		blk_mq_put_ctx(data.ctx);
1961
		blk_mq_bio_to_request(rq, bio);
1962 1963 1964 1965 1966 1967 1968

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

M
Ming Lei 已提交
1972
		if (!request_count)
1973
			trace_block_plug(q);
1974 1975
		else
			last = list_entry_rq(plug->mq_list.prev);
1976

1977 1978
		if (request_count >= BLK_MAX_REQUEST_COUNT || (last &&
		    blk_rq_bytes(last) >= BLK_PLUG_FLUSH_SIZE)) {
1979 1980
			blk_flush_plug_list(plug, false);
			trace_block_plug(q);
1981
		}
1982

1983
		blk_add_rq_to_plug(plug, rq);
1984
	} else if (plug && !blk_queue_nomerges(q)) {
1985
		blk_mq_bio_to_request(rq, bio);
1986 1987

		/*
1988
		 * We do limited plugging. If the bio can be merged, do that.
1989 1990
		 * Otherwise the existing request in the plug list will be
		 * issued. So the plug list will have one request at most
1991 1992
		 * The plug list might get flushed before this. If that happens,
		 * the plug list is empty, and same_queue_rq is invalid.
1993
		 */
1994 1995 1996 1997
		if (list_empty(&plug->mq_list))
			same_queue_rq = NULL;
		if (same_queue_rq)
			list_del_init(&same_queue_rq->queuelist);
1998
		blk_add_rq_to_plug(plug, rq);
1999

2000 2001
		blk_mq_put_ctx(data.ctx);

2002
		if (same_queue_rq) {
2003
			data.hctx = same_queue_rq->mq_hctx;
2004 2005
			blk_mq_try_issue_directly(data.hctx, same_queue_rq,
					&cookie);
2006
		}
2007 2008
	} else if ((q->nr_hw_queues > 1 && is_sync) || (!q->elevator &&
			!data.hctx->dispatch_busy)) {
2009
		blk_mq_put_ctx(data.ctx);
2010 2011
		blk_mq_bio_to_request(rq, bio);
		blk_mq_try_issue_directly(data.hctx, rq, &cookie);
2012
	} else {
2013
		blk_mq_put_ctx(data.ctx);
2014
		blk_mq_bio_to_request(rq, bio);
2015
		blk_mq_sched_insert_request(rq, false, true, true);
2016
	}
2017

2018
	return cookie;
2019 2020
}

2021 2022
void blk_mq_free_rqs(struct blk_mq_tag_set *set, struct blk_mq_tags *tags,
		     unsigned int hctx_idx)
2023
{
2024
	struct page *page;
2025

2026
	if (tags->rqs && set->ops->exit_request) {
2027
		int i;
2028

2029
		for (i = 0; i < tags->nr_tags; i++) {
J
Jens Axboe 已提交
2030 2031 2032
			struct request *rq = tags->static_rqs[i];

			if (!rq)
2033
				continue;
2034
			set->ops->exit_request(set, rq, hctx_idx);
J
Jens Axboe 已提交
2035
			tags->static_rqs[i] = NULL;
2036
		}
2037 2038
	}

2039 2040
	while (!list_empty(&tags->page_list)) {
		page = list_first_entry(&tags->page_list, struct page, lru);
2041
		list_del_init(&page->lru);
2042 2043 2044 2045 2046
		/*
		 * Remove kmemleak object previously allocated in
		 * blk_mq_init_rq_map().
		 */
		kmemleak_free(page_address(page));
2047 2048
		__free_pages(page, page->private);
	}
2049
}
2050

2051 2052
void blk_mq_free_rq_map(struct blk_mq_tags *tags)
{
2053
	kfree(tags->rqs);
2054
	tags->rqs = NULL;
J
Jens Axboe 已提交
2055 2056
	kfree(tags->static_rqs);
	tags->static_rqs = NULL;
2057

2058
	blk_mq_free_tags(tags);
2059 2060
}

2061 2062 2063 2064
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)
2065
{
2066
	struct blk_mq_tags *tags;
2067
	int node;
2068

J
Jens Axboe 已提交
2069
	node = blk_mq_hw_queue_to_node(&set->map[0], hctx_idx);
2070 2071 2072 2073
	if (node == NUMA_NO_NODE)
		node = set->numa_node;

	tags = blk_mq_init_tags(nr_tags, reserved_tags, node,
S
Shaohua Li 已提交
2074
				BLK_MQ_FLAG_TO_ALLOC_POLICY(set->flags));
2075 2076
	if (!tags)
		return NULL;
2077

2078
	tags->rqs = kcalloc_node(nr_tags, sizeof(struct request *),
2079
				 GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY,
2080
				 node);
2081 2082 2083 2084
	if (!tags->rqs) {
		blk_mq_free_tags(tags);
		return NULL;
	}
2085

2086 2087 2088
	tags->static_rqs = kcalloc_node(nr_tags, sizeof(struct request *),
					GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY,
					node);
J
Jens Axboe 已提交
2089 2090 2091 2092 2093 2094
	if (!tags->static_rqs) {
		kfree(tags->rqs);
		blk_mq_free_tags(tags);
		return NULL;
	}

2095 2096 2097 2098 2099 2100 2101 2102
	return tags;
}

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

2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113
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;
	}

K
Keith Busch 已提交
2114
	WRITE_ONCE(rq->state, MQ_RQ_IDLE);
2115 2116 2117
	return 0;
}

2118 2119 2120 2121 2122
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;
2123 2124
	int node;

J
Jens Axboe 已提交
2125
	node = blk_mq_hw_queue_to_node(&set->map[0], hctx_idx);
2126 2127
	if (node == NUMA_NO_NODE)
		node = set->numa_node;
2128 2129 2130

	INIT_LIST_HEAD(&tags->page_list);

2131 2132 2133 2134
	/*
	 * rq_size is the size of the request plus driver payload, rounded
	 * to the cacheline size
	 */
2135
	rq_size = round_up(sizeof(struct request) + set->cmd_size,
2136
				cache_line_size());
2137
	left = rq_size * depth;
2138

2139
	for (i = 0; i < depth; ) {
2140 2141 2142 2143 2144
		int this_order = max_order;
		struct page *page;
		int to_do;
		void *p;

2145
		while (this_order && left < order_to_size(this_order - 1))
2146 2147 2148
			this_order--;

		do {
2149
			page = alloc_pages_node(node,
2150
				GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY | __GFP_ZERO,
2151
				this_order);
2152 2153 2154 2155 2156 2157 2158 2159 2160
			if (page)
				break;
			if (!this_order--)
				break;
			if (order_to_size(this_order) < rq_size)
				break;
		} while (1);

		if (!page)
2161
			goto fail;
2162 2163

		page->private = this_order;
2164
		list_add_tail(&page->lru, &tags->page_list);
2165 2166

		p = page_address(page);
2167 2168 2169 2170
		/*
		 * Allow kmemleak to scan these pages as they contain pointers
		 * to additional allocations like via ops->init_request().
		 */
2171
		kmemleak_alloc(p, order_to_size(this_order), 1, GFP_NOIO);
2172
		entries_per_page = order_to_size(this_order) / rq_size;
2173
		to_do = min(entries_per_page, depth - i);
2174 2175
		left -= to_do * rq_size;
		for (j = 0; j < to_do; j++) {
J
Jens Axboe 已提交
2176 2177 2178
			struct request *rq = p;

			tags->static_rqs[i] = rq;
2179 2180 2181
			if (blk_mq_init_request(set, rq, hctx_idx, node)) {
				tags->static_rqs[i] = NULL;
				goto fail;
2182 2183
			}

2184 2185 2186 2187
			p += rq_size;
			i++;
		}
	}
2188
	return 0;
2189

2190
fail:
2191 2192
	blk_mq_free_rqs(set, tags, hctx_idx);
	return -ENOMEM;
2193 2194
}

J
Jens Axboe 已提交
2195 2196 2197 2198 2199
/*
 * '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.
 */
2200
static int blk_mq_hctx_notify_dead(unsigned int cpu, struct hlist_node *node)
2201
{
2202
	struct blk_mq_hw_ctx *hctx;
2203 2204 2205
	struct blk_mq_ctx *ctx;
	LIST_HEAD(tmp);

2206
	hctx = hlist_entry_safe(node, struct blk_mq_hw_ctx, cpuhp_dead);
J
Jens Axboe 已提交
2207
	ctx = __blk_mq_get_ctx(hctx->queue, cpu);
2208 2209 2210 2211 2212 2213 2214 2215 2216

	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))
2217
		return 0;
2218

J
Jens Axboe 已提交
2219 2220 2221
	spin_lock(&hctx->lock);
	list_splice_tail_init(&tmp, &hctx->dispatch);
	spin_unlock(&hctx->lock);
2222 2223

	blk_mq_run_hw_queue(hctx, true);
2224
	return 0;
2225 2226
}

2227
static void blk_mq_remove_cpuhp(struct blk_mq_hw_ctx *hctx)
2228
{
2229 2230
	cpuhp_state_remove_instance_nocalls(CPUHP_BLK_MQ_DEAD,
					    &hctx->cpuhp_dead);
2231 2232
}

2233
/* hctx->ctxs will be freed in queue's release handler */
2234 2235 2236 2237
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)
{
2238 2239
	if (blk_mq_hw_queue_mapped(hctx))
		blk_mq_tag_idle(hctx);
2240

2241
	if (set->ops->exit_request)
2242
		set->ops->exit_request(set, hctx->fq->flush_rq, hctx_idx);
2243

2244 2245 2246
	if (set->ops->exit_hctx)
		set->ops->exit_hctx(hctx, hctx_idx);

2247
	blk_mq_remove_cpuhp(hctx);
2248 2249
}

M
Ming Lei 已提交
2250 2251 2252 2253 2254 2255 2256 2257 2258
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;
2259
		blk_mq_debugfs_unregister_hctx(hctx);
2260
		blk_mq_exit_hctx(q, set, hctx, i);
M
Ming Lei 已提交
2261 2262 2263
	}
}

2264 2265 2266
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)
2267
{
2268 2269 2270 2271 2272 2273
	int node;

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

2274
	INIT_DELAYED_WORK(&hctx->run_work, blk_mq_run_work_fn);
2275 2276 2277
	spin_lock_init(&hctx->lock);
	INIT_LIST_HEAD(&hctx->dispatch);
	hctx->queue = q;
2278
	hctx->flags = set->flags & ~BLK_MQ_F_TAG_SHARED;
2279

2280
	cpuhp_state_add_instance_nocalls(CPUHP_BLK_MQ_DEAD, &hctx->cpuhp_dead);
2281 2282

	hctx->tags = set->tags[hctx_idx];
2283 2284

	/*
2285 2286
	 * Allocate space for all possible cpus to avoid allocation at
	 * runtime
2287
	 */
2288
	hctx->ctxs = kmalloc_array_node(nr_cpu_ids, sizeof(void *),
2289
			GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY, node);
2290 2291
	if (!hctx->ctxs)
		goto unregister_cpu_notifier;
2292

2293 2294
	if (sbitmap_init_node(&hctx->ctx_map, nr_cpu_ids, ilog2(8),
				GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY, node))
2295
		goto free_ctxs;
2296

2297
	hctx->nr_ctx = 0;
2298

2299
	spin_lock_init(&hctx->dispatch_wait_lock);
2300 2301 2302
	init_waitqueue_func_entry(&hctx->dispatch_wait, blk_mq_dispatch_wake);
	INIT_LIST_HEAD(&hctx->dispatch_wait.entry);

2303 2304 2305
	if (set->ops->init_hctx &&
	    set->ops->init_hctx(hctx, set->driver_data, hctx_idx))
		goto free_bitmap;
2306

2307 2308
	hctx->fq = blk_alloc_flush_queue(q, hctx->numa_node, set->cmd_size,
			GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY);
2309
	if (!hctx->fq)
2310
		goto exit_hctx;
2311

2312
	if (blk_mq_init_request(set, hctx->fq->flush_rq, hctx_idx, node))
2313
		goto free_fq;
2314

2315
	if (hctx->flags & BLK_MQ_F_BLOCKING)
2316
		init_srcu_struct(hctx->srcu);
2317

2318
	return 0;
2319

2320
 free_fq:
2321
	blk_free_flush_queue(hctx->fq);
2322 2323 2324
 exit_hctx:
	if (set->ops->exit_hctx)
		set->ops->exit_hctx(hctx, hctx_idx);
2325
 free_bitmap:
2326
	sbitmap_free(&hctx->ctx_map);
2327 2328 2329
 free_ctxs:
	kfree(hctx->ctxs);
 unregister_cpu_notifier:
2330
	blk_mq_remove_cpuhp(hctx);
2331 2332
	return -1;
}
2333 2334 2335 2336

static void blk_mq_init_cpu_queues(struct request_queue *q,
				   unsigned int nr_hw_queues)
{
J
Jens Axboe 已提交
2337 2338
	struct blk_mq_tag_set *set = q->tag_set;
	unsigned int i, j;
2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352

	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
		 */
J
Jens Axboe 已提交
2353 2354 2355 2356 2357
		for (j = 0; j < set->nr_maps; j++) {
			hctx = blk_mq_map_queue_type(q, j, i);
			if (nr_hw_queues > 1 && hctx->numa_node == NUMA_NO_NODE)
				hctx->numa_node = local_memory_node(cpu_to_node(i));
		}
2358 2359 2360
	}
}

2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382
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)
{
2383
	if (set->tags && set->tags[hctx_idx]) {
2384 2385 2386 2387
		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;
	}
2388 2389
}

2390
static void blk_mq_map_swqueue(struct request_queue *q)
2391
{
J
Jens Axboe 已提交
2392
	unsigned int i, j, hctx_idx;
2393 2394
	struct blk_mq_hw_ctx *hctx;
	struct blk_mq_ctx *ctx;
M
Ming Lei 已提交
2395
	struct blk_mq_tag_set *set = q->tag_set;
2396

2397 2398 2399 2400 2401
	/*
	 * Avoid others reading imcomplete hctx->cpumask through sysfs
	 */
	mutex_lock(&q->sysfs_lock);

2402
	queue_for_each_hw_ctx(q, hctx, i) {
2403
		cpumask_clear(hctx->cpumask);
2404
		hctx->nr_ctx = 0;
2405
		hctx->dispatch_from = NULL;
2406 2407 2408
	}

	/*
2409
	 * Map software to hardware queues.
2410 2411
	 *
	 * If the cpu isn't present, the cpu is mapped to first hctx.
2412
	 */
2413
	for_each_possible_cpu(i) {
J
Jens Axboe 已提交
2414
		hctx_idx = set->map[0].mq_map[i];
2415 2416 2417 2418 2419 2420 2421 2422 2423
		/* unmapped hw queue can be remapped after CPU topo changed */
		if (!set->tags[hctx_idx] &&
		    !__blk_mq_alloc_rq_map(set, hctx_idx)) {
			/*
			 * 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
			 */
J
Jens Axboe 已提交
2424
			set->map[0].mq_map[i] = 0;
2425 2426
		}

2427
		ctx = per_cpu_ptr(q->queue_ctx, i);
J
Jens Axboe 已提交
2428 2429
		for (j = 0; j < set->nr_maps; j++) {
			hctx = blk_mq_map_queue_type(q, j, i);
2430

J
Jens Axboe 已提交
2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449
			/*
			 * If the CPU is already set in the mask, then we've
			 * mapped this one already. This can happen if
			 * devices share queues across queue maps.
			 */
			if (cpumask_test_cpu(i, hctx->cpumask))
				continue;

			cpumask_set_cpu(i, hctx->cpumask);
			hctx->type = j;
			ctx->index_hw[hctx->type] = hctx->nr_ctx;
			hctx->ctxs[hctx->nr_ctx++] = ctx;

			/*
			 * If the nr_ctx type overflows, we have exceeded the
			 * amount of sw queues we can support.
			 */
			BUG_ON(!hctx->nr_ctx);
		}
2450
	}
2451

2452 2453
	mutex_unlock(&q->sysfs_lock);

2454
	queue_for_each_hw_ctx(q, hctx, i) {
2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469
		/*
		 * If no software queues are mapped to this hardware queue,
		 * disable it and free the request entries.
		 */
		if (!hctx->nr_ctx) {
			/* Never unmap queue 0.  We need it as a
			 * fallback in case of a new remap fails
			 * allocation
			 */
			if (i && set->tags[i])
				blk_mq_free_map_and_requests(set, i);

			hctx->tags = NULL;
			continue;
		}
2470

M
Ming Lei 已提交
2471 2472 2473
		hctx->tags = set->tags[i];
		WARN_ON(!hctx->tags);

2474 2475 2476 2477 2478
		/*
		 * 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.
		 */
2479
		sbitmap_resize(&hctx->ctx_map, hctx->nr_ctx);
2480

2481 2482 2483
		/*
		 * Initialize batch roundrobin counts
		 */
2484
		hctx->next_cpu = blk_mq_first_mapped_cpu(hctx);
2485 2486
		hctx->next_cpu_batch = BLK_MQ_CPU_WORK_BATCH;
	}
2487 2488
}

2489 2490 2491 2492
/*
 * Caller needs to ensure that we're either frozen/quiesced, or that
 * the queue isn't live yet.
 */
2493
static void queue_set_hctx_shared(struct request_queue *q, bool shared)
2494 2495 2496 2497
{
	struct blk_mq_hw_ctx *hctx;
	int i;

2498
	queue_for_each_hw_ctx(q, hctx, i) {
2499
		if (shared)
2500
			hctx->flags |= BLK_MQ_F_TAG_SHARED;
2501
		else
2502 2503 2504 2505
			hctx->flags &= ~BLK_MQ_F_TAG_SHARED;
	}
}

2506 2507
static void blk_mq_update_tag_set_depth(struct blk_mq_tag_set *set,
					bool shared)
2508 2509
{
	struct request_queue *q;
2510

2511 2512
	lockdep_assert_held(&set->tag_list_lock);

2513 2514
	list_for_each_entry(q, &set->tag_list, tag_set_list) {
		blk_mq_freeze_queue(q);
2515
		queue_set_hctx_shared(q, shared);
2516 2517 2518 2519 2520 2521 2522 2523 2524
		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);
2525
	list_del_rcu(&q->tag_set_list);
2526 2527 2528 2529 2530 2531
	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);
	}
2532
	mutex_unlock(&set->tag_list_lock);
2533
	INIT_LIST_HEAD(&q->tag_set_list);
2534 2535 2536 2537 2538 2539
}

static void blk_mq_add_queue_tag_set(struct blk_mq_tag_set *set,
				     struct request_queue *q)
{
	mutex_lock(&set->tag_list_lock);
2540

2541 2542 2543 2544 2545
	/*
	 * 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)) {
2546 2547 2548 2549 2550 2551
		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);
2552
	list_add_tail_rcu(&q->tag_set_list, &set->tag_list);
2553

2554 2555 2556
	mutex_unlock(&set->tag_list_lock);
}

2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584
/* All allocations will be freed in release handler of q->mq_kobj */
static int blk_mq_alloc_ctxs(struct request_queue *q)
{
	struct blk_mq_ctxs *ctxs;
	int cpu;

	ctxs = kzalloc(sizeof(*ctxs), GFP_KERNEL);
	if (!ctxs)
		return -ENOMEM;

	ctxs->queue_ctx = alloc_percpu(struct blk_mq_ctx);
	if (!ctxs->queue_ctx)
		goto fail;

	for_each_possible_cpu(cpu) {
		struct blk_mq_ctx *ctx = per_cpu_ptr(ctxs->queue_ctx, cpu);
		ctx->ctxs = ctxs;
	}

	q->mq_kobj = &ctxs->kobj;
	q->queue_ctx = ctxs->queue_ctx;

	return 0;
 fail:
	kfree(ctxs);
	return -ENOMEM;
}

2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596
/*
 * 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 */
2597 2598 2599
	queue_for_each_hw_ctx(q, hctx, i) {
		if (!hctx)
			continue;
2600
		kobject_put(&hctx->kobj);
2601
	}
2602 2603 2604

	kfree(q->queue_hw_ctx);

2605 2606 2607 2608 2609
	/*
	 * release .mq_kobj and sw queue's kobject now because
	 * both share lifetime with request queue.
	 */
	blk_mq_sysfs_deinit(q);
2610 2611
}

2612
struct request_queue *blk_mq_init_queue(struct blk_mq_tag_set *set)
2613 2614 2615
{
	struct request_queue *uninit_q, *q;

2616
	uninit_q = blk_alloc_queue_node(GFP_KERNEL, set->numa_node, NULL);
2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627
	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);

2628 2629 2630 2631
static int blk_mq_hw_ctx_size(struct blk_mq_tag_set *tag_set)
{
	int hw_ctx_size = sizeof(struct blk_mq_hw_ctx);

2632
	BUILD_BUG_ON(ALIGN(offsetof(struct blk_mq_hw_ctx, srcu),
2633 2634 2635 2636 2637 2638 2639 2640 2641
			   __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;
}

2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674
static struct blk_mq_hw_ctx *blk_mq_alloc_and_init_hctx(
		struct blk_mq_tag_set *set, struct request_queue *q,
		int hctx_idx, int node)
{
	struct blk_mq_hw_ctx *hctx;

	hctx = kzalloc_node(blk_mq_hw_ctx_size(set),
			GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY,
			node);
	if (!hctx)
		return NULL;

	if (!zalloc_cpumask_var_node(&hctx->cpumask,
				GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY,
				node)) {
		kfree(hctx);
		return NULL;
	}

	atomic_set(&hctx->nr_active, 0);
	hctx->numa_node = node;
	hctx->queue_num = hctx_idx;

	if (blk_mq_init_hctx(q, set, hctx, hctx_idx)) {
		free_cpumask_var(hctx->cpumask);
		kfree(hctx);
		return NULL;
	}
	blk_mq_hctx_kobj_init(hctx);

	return hctx;
}

K
Keith Busch 已提交
2675 2676
static void blk_mq_realloc_hw_ctxs(struct blk_mq_tag_set *set,
						struct request_queue *q)
2677
{
2678
	int i, j, end;
K
Keith Busch 已提交
2679
	struct blk_mq_hw_ctx **hctxs = q->queue_hw_ctx;
2680

2681 2682
	/* protect against switching io scheduler  */
	mutex_lock(&q->sysfs_lock);
2683
	for (i = 0; i < set->nr_hw_queues; i++) {
K
Keith Busch 已提交
2684
		int node;
2685
		struct blk_mq_hw_ctx *hctx;
K
Keith Busch 已提交
2686

J
Jens Axboe 已提交
2687
		node = blk_mq_hw_queue_to_node(&set->map[0], i);
2688 2689 2690 2691 2692 2693 2694
		/*
		 * If the hw queue has been mapped to another numa node,
		 * we need to realloc the hctx. If allocation fails, fallback
		 * to use the previous one.
		 */
		if (hctxs[i] && (hctxs[i]->numa_node == node))
			continue;
K
Keith Busch 已提交
2695

2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709
		hctx = blk_mq_alloc_and_init_hctx(set, q, i, node);
		if (hctx) {
			if (hctxs[i]) {
				blk_mq_exit_hctx(q, set, hctxs[i], i);
				kobject_put(&hctxs[i]->kobj);
			}
			hctxs[i] = hctx;
		} else {
			if (hctxs[i])
				pr_warn("Allocate new hctx on node %d fails,\
						fallback to previous one on node %d\n",
						node, hctxs[i]->numa_node);
			else
				break;
K
Keith Busch 已提交
2710
		}
2711
	}
2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723
	/*
	 * Increasing nr_hw_queues fails. Free the newly allocated
	 * hctxs and keep the previous q->nr_hw_queues.
	 */
	if (i != set->nr_hw_queues) {
		j = q->nr_hw_queues;
		end = i;
	} else {
		j = i;
		end = q->nr_hw_queues;
		q->nr_hw_queues = set->nr_hw_queues;
	}
2724

2725
	for (; j < end; j++) {
K
Keith Busch 已提交
2726 2727 2728
		struct blk_mq_hw_ctx *hctx = hctxs[j];

		if (hctx) {
2729 2730
			if (hctx->tags)
				blk_mq_free_map_and_requests(set, j);
K
Keith Busch 已提交
2731 2732 2733 2734 2735 2736
			blk_mq_exit_hctx(q, set, hctx, j);
			kobject_put(&hctx->kobj);
			hctxs[j] = NULL;

		}
	}
2737
	mutex_unlock(&q->sysfs_lock);
K
Keith Busch 已提交
2738 2739
}

2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752
/*
 * Maximum number of hardware queues we support. For single sets, we'll never
 * have more than the CPUs (software queues). For multiple sets, the tag_set
 * user may have set ->nr_hw_queues larger.
 */
static unsigned int nr_hw_queues(struct blk_mq_tag_set *set)
{
	if (set->nr_maps == 1)
		return nr_cpu_ids;

	return max(set->nr_hw_queues, nr_cpu_ids);
}

K
Keith Busch 已提交
2753 2754 2755
struct request_queue *blk_mq_init_allocated_queue(struct blk_mq_tag_set *set,
						  struct request_queue *q)
{
M
Ming Lei 已提交
2756 2757 2758
	/* mark the queue as mq asap */
	q->mq_ops = set->ops;

2759
	q->poll_cb = blk_stat_alloc_callback(blk_mq_poll_stats_fn,
2760 2761
					     blk_mq_poll_stats_bkt,
					     BLK_MQ_POLL_STATS_BKTS, q);
2762 2763 2764
	if (!q->poll_cb)
		goto err_exit;

2765
	if (blk_mq_alloc_ctxs(q))
M
Ming Lin 已提交
2766
		goto err_exit;
K
Keith Busch 已提交
2767

2768 2769 2770
	/* init q->mq_kobj and sw queues' kobjects */
	blk_mq_sysfs_init(q);

2771 2772
	q->nr_queues = nr_hw_queues(set);
	q->queue_hw_ctx = kcalloc_node(q->nr_queues, sizeof(*(q->queue_hw_ctx)),
K
Keith Busch 已提交
2773 2774
						GFP_KERNEL, set->numa_node);
	if (!q->queue_hw_ctx)
2775
		goto err_sys_init;
K
Keith Busch 已提交
2776 2777 2778 2779

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

2781
	INIT_WORK(&q->timeout_work, blk_mq_timeout_work);
2782
	blk_queue_rq_timeout(q, set->timeout ? set->timeout : 30 * HZ);
2783

J
Jens Axboe 已提交
2784
	q->tag_set = set;
2785

2786
	q->queue_flags |= QUEUE_FLAG_MQ_DEFAULT;
2787 2788
	if (q->mq_ops->poll)
		queue_flag_set_unlocked(QUEUE_FLAG_POLL, q);
2789

2790
	if (!(set->flags & BLK_MQ_F_SG_MERGE))
2791
		queue_flag_set_unlocked(QUEUE_FLAG_NO_SG_MERGE, q);
2792

2793 2794
	q->sg_reserved_size = INT_MAX;

2795
	INIT_DELAYED_WORK(&q->requeue_work, blk_mq_requeue_work);
2796 2797 2798
	INIT_LIST_HEAD(&q->requeue_list);
	spin_lock_init(&q->requeue_lock);

2799
	blk_queue_make_request(q, blk_mq_make_request);
2800

2801 2802 2803 2804 2805
	/*
	 * Do this after blk_queue_make_request() overrides it...
	 */
	q->nr_requests = set->queue_depth;

2806 2807 2808 2809 2810
	/*
	 * Default to classic polling
	 */
	q->poll_nsec = -1;

2811 2812
	if (set->ops->complete)
		blk_queue_softirq_done(q, set->ops->complete);
2813

2814
	blk_mq_init_cpu_queues(q, set->nr_hw_queues);
2815
	blk_mq_add_queue_tag_set(set, q);
2816
	blk_mq_map_swqueue(q);
2817

2818 2819 2820
	if (!(set->flags & BLK_MQ_F_NO_SCHED)) {
		int ret;

2821
		ret = elevator_init_mq(q);
2822 2823 2824 2825
		if (ret)
			return ERR_PTR(ret);
	}

2826
	return q;
2827

2828
err_hctxs:
K
Keith Busch 已提交
2829
	kfree(q->queue_hw_ctx);
2830 2831
err_sys_init:
	blk_mq_sysfs_deinit(q);
M
Ming Lin 已提交
2832 2833
err_exit:
	q->mq_ops = NULL;
2834 2835
	return ERR_PTR(-ENOMEM);
}
2836
EXPORT_SYMBOL(blk_mq_init_allocated_queue);
2837

2838 2839
/* tags can _not_ be used after returning from blk_mq_exit_queue */
void blk_mq_exit_queue(struct request_queue *q)
2840
{
M
Ming Lei 已提交
2841
	struct blk_mq_tag_set	*set = q->tag_set;
2842

2843
	blk_mq_del_queue_tag_set(q);
M
Ming Lei 已提交
2844
	blk_mq_exit_hw_queues(q, set, set->nr_hw_queues);
2845 2846
}

2847 2848 2849 2850
static int __blk_mq_alloc_rq_maps(struct blk_mq_tag_set *set)
{
	int i;

2851 2852
	for (i = 0; i < set->nr_hw_queues; i++)
		if (!__blk_mq_alloc_rq_map(set, i))
2853 2854 2855 2856 2857 2858
			goto out_unwind;

	return 0;

out_unwind:
	while (--i >= 0)
2859
		blk_mq_free_rq_map(set->tags[i]);
2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898

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

2899 2900
static int blk_mq_update_queue_map(struct blk_mq_tag_set *set)
{
2901
	if (set->ops->map_queues) {
J
Jens Axboe 已提交
2902 2903
		int i;

2904 2905 2906 2907 2908 2909 2910
		/*
		 * 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)
J
Jens Axboe 已提交
2911
		 * 		set->map[x].mq_map[cpu] = queue;
2912 2913 2914 2915 2916 2917
		 * }
		 *
		 * 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.
		 */
J
Jens Axboe 已提交
2918 2919
		for (i = 0; i < set->nr_maps; i++)
			blk_mq_clear_mq_map(&set->map[i]);
2920

2921
		return set->ops->map_queues(set);
J
Jens Axboe 已提交
2922 2923
	} else {
		BUG_ON(set->nr_maps > 1);
J
Jens Axboe 已提交
2924
		return blk_mq_map_queues(&set->map[0]);
J
Jens Axboe 已提交
2925
	}
2926 2927
}

2928 2929 2930
/*
 * Alloc a tag set to be associated with one or more request queues.
 * May fail with EINVAL for various error conditions. May adjust the
2931
 * requested depth down, if it's too large. In that case, the set
2932 2933
 * value will be stored in set->queue_depth.
 */
2934 2935
int blk_mq_alloc_tag_set(struct blk_mq_tag_set *set)
{
J
Jens Axboe 已提交
2936
	int i, ret;
2937

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

2940 2941
	if (!set->nr_hw_queues)
		return -EINVAL;
2942
	if (!set->queue_depth)
2943 2944 2945 2946
		return -EINVAL;
	if (set->queue_depth < set->reserved_tags + BLK_MQ_TAG_MIN)
		return -EINVAL;

C
Christoph Hellwig 已提交
2947
	if (!set->ops->queue_rq)
2948 2949
		return -EINVAL;

2950 2951 2952
	if (!set->ops->get_budget ^ !set->ops->put_budget)
		return -EINVAL;

2953 2954 2955 2956 2957
	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;
	}
2958

J
Jens Axboe 已提交
2959 2960 2961 2962 2963
	if (!set->nr_maps)
		set->nr_maps = 1;
	else if (set->nr_maps > HCTX_MAX_TYPES)
		return -EINVAL;

2964 2965 2966 2967 2968 2969 2970 2971 2972
	/*
	 * 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 已提交
2973
	/*
2974 2975
	 * There is no use for more h/w queues than cpus if we just have
	 * a single map
K
Keith Busch 已提交
2976
	 */
2977
	if (set->nr_maps == 1 && set->nr_hw_queues > nr_cpu_ids)
K
Keith Busch 已提交
2978
		set->nr_hw_queues = nr_cpu_ids;
2979

2980
	set->tags = kcalloc_node(nr_hw_queues(set), sizeof(struct blk_mq_tags *),
2981 2982
				 GFP_KERNEL, set->numa_node);
	if (!set->tags)
2983
		return -ENOMEM;
2984

2985
	ret = -ENOMEM;
J
Jens Axboe 已提交
2986 2987 2988 2989 2990 2991 2992 2993
	for (i = 0; i < set->nr_maps; i++) {
		set->map[i].mq_map = kcalloc_node(nr_cpu_ids,
						  sizeof(struct blk_mq_queue_map),
						  GFP_KERNEL, set->numa_node);
		if (!set->map[i].mq_map)
			goto out_free_mq_map;
		set->map[i].nr_queues = set->nr_hw_queues;
	}
2994

2995
	ret = blk_mq_update_queue_map(set);
2996 2997 2998 2999 3000
	if (ret)
		goto out_free_mq_map;

	ret = blk_mq_alloc_rq_maps(set);
	if (ret)
3001
		goto out_free_mq_map;
3002

3003 3004 3005
	mutex_init(&set->tag_list_lock);
	INIT_LIST_HEAD(&set->tag_list);

3006
	return 0;
3007 3008

out_free_mq_map:
J
Jens Axboe 已提交
3009 3010 3011 3012
	for (i = 0; i < set->nr_maps; i++) {
		kfree(set->map[i].mq_map);
		set->map[i].mq_map = NULL;
	}
3013 3014
	kfree(set->tags);
	set->tags = NULL;
3015
	return ret;
3016 3017 3018 3019 3020
}
EXPORT_SYMBOL(blk_mq_alloc_tag_set);

void blk_mq_free_tag_set(struct blk_mq_tag_set *set)
{
J
Jens Axboe 已提交
3021
	int i, j;
3022

3023
	for (i = 0; i < nr_hw_queues(set); i++)
3024
		blk_mq_free_map_and_requests(set, i);
3025

J
Jens Axboe 已提交
3026 3027 3028 3029
	for (j = 0; j < set->nr_maps; j++) {
		kfree(set->map[j].mq_map);
		set->map[j].mq_map = NULL;
	}
3030

M
Ming Lei 已提交
3031
	kfree(set->tags);
3032
	set->tags = NULL;
3033 3034 3035
}
EXPORT_SYMBOL(blk_mq_free_tag_set);

3036 3037 3038 3039 3040 3041
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;

3042
	if (!set)
3043 3044
		return -EINVAL;

3045
	blk_mq_freeze_queue(q);
3046
	blk_mq_quiesce_queue(q);
3047

3048 3049
	ret = 0;
	queue_for_each_hw_ctx(q, hctx, i) {
3050 3051
		if (!hctx->tags)
			continue;
3052 3053 3054 3055
		/*
		 * If we're using an MQ scheduler, just update the scheduler
		 * queue depth. This is similar to what the old code would do.
		 */
3056
		if (!hctx->sched_tags) {
3057
			ret = blk_mq_tag_update_depth(hctx, &hctx->tags, nr,
3058 3059 3060 3061 3062
							false);
		} else {
			ret = blk_mq_tag_update_depth(hctx, &hctx->sched_tags,
							nr, true);
		}
3063 3064
		if (ret)
			break;
3065 3066
		if (q->elevator && q->elevator->type->ops.mq.depth_updated)
			q->elevator->type->ops.mq.depth_updated(hctx);
3067 3068 3069 3070 3071
	}

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

3072
	blk_mq_unquiesce_queue(q);
3073 3074
	blk_mq_unfreeze_queue(q);

3075 3076 3077
	return ret;
}

3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147
/*
 * request_queue and elevator_type pair.
 * It is just used by __blk_mq_update_nr_hw_queues to cache
 * the elevator_type associated with a request_queue.
 */
struct blk_mq_qe_pair {
	struct list_head node;
	struct request_queue *q;
	struct elevator_type *type;
};

/*
 * Cache the elevator_type in qe pair list and switch the
 * io scheduler to 'none'
 */
static bool blk_mq_elv_switch_none(struct list_head *head,
		struct request_queue *q)
{
	struct blk_mq_qe_pair *qe;

	if (!q->elevator)
		return true;

	qe = kmalloc(sizeof(*qe), GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY);
	if (!qe)
		return false;

	INIT_LIST_HEAD(&qe->node);
	qe->q = q;
	qe->type = q->elevator->type;
	list_add(&qe->node, head);

	mutex_lock(&q->sysfs_lock);
	/*
	 * After elevator_switch_mq, the previous elevator_queue will be
	 * released by elevator_release. The reference of the io scheduler
	 * module get by elevator_get will also be put. So we need to get
	 * a reference of the io scheduler module here to prevent it to be
	 * removed.
	 */
	__module_get(qe->type->elevator_owner);
	elevator_switch_mq(q, NULL);
	mutex_unlock(&q->sysfs_lock);

	return true;
}

static void blk_mq_elv_switch_back(struct list_head *head,
		struct request_queue *q)
{
	struct blk_mq_qe_pair *qe;
	struct elevator_type *t = NULL;

	list_for_each_entry(qe, head, node)
		if (qe->q == q) {
			t = qe->type;
			break;
		}

	if (!t)
		return;

	list_del(&qe->node);
	kfree(qe);

	mutex_lock(&q->sysfs_lock);
	elevator_switch_mq(q, t);
	mutex_unlock(&q->sysfs_lock);
}

3148 3149
static void __blk_mq_update_nr_hw_queues(struct blk_mq_tag_set *set,
							int nr_hw_queues)
K
Keith Busch 已提交
3150 3151
{
	struct request_queue *q;
3152
	LIST_HEAD(head);
3153
	int prev_nr_hw_queues;
K
Keith Busch 已提交
3154

3155 3156
	lockdep_assert_held(&set->tag_list_lock);

3157
	if (set->nr_maps == 1 && nr_hw_queues > nr_cpu_ids)
K
Keith Busch 已提交
3158 3159 3160 3161 3162 3163
		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);
3164 3165 3166 3167
	/*
	 * Sync with blk_mq_queue_tag_busy_iter.
	 */
	synchronize_rcu();
3168 3169 3170 3171 3172 3173 3174 3175
	/*
	 * Switch IO scheduler to 'none', cleaning up the data associated
	 * with the previous scheduler. We will switch back once we are done
	 * updating the new sw to hw queue mappings.
	 */
	list_for_each_entry(q, &set->tag_list, tag_set_list)
		if (!blk_mq_elv_switch_none(&head, q))
			goto switch_back;
K
Keith Busch 已提交
3176

3177 3178 3179 3180 3181
	list_for_each_entry(q, &set->tag_list, tag_set_list) {
		blk_mq_debugfs_unregister_hctxs(q);
		blk_mq_sysfs_unregister(q);
	}

3182
	prev_nr_hw_queues = set->nr_hw_queues;
K
Keith Busch 已提交
3183
	set->nr_hw_queues = nr_hw_queues;
3184
	blk_mq_update_queue_map(set);
3185
fallback:
K
Keith Busch 已提交
3186 3187
	list_for_each_entry(q, &set->tag_list, tag_set_list) {
		blk_mq_realloc_hw_ctxs(set, q);
3188 3189 3190 3191
		if (q->nr_hw_queues != set->nr_hw_queues) {
			pr_warn("Increasing nr_hw_queues to %d fails, fallback to %d\n",
					nr_hw_queues, prev_nr_hw_queues);
			set->nr_hw_queues = prev_nr_hw_queues;
J
Jens Axboe 已提交
3192
			blk_mq_map_queues(&set->map[0]);
3193 3194
			goto fallback;
		}
3195 3196 3197 3198 3199 3200
		blk_mq_map_swqueue(q);
	}

	list_for_each_entry(q, &set->tag_list, tag_set_list) {
		blk_mq_sysfs_register(q);
		blk_mq_debugfs_register_hctxs(q);
K
Keith Busch 已提交
3201 3202
	}

3203 3204 3205 3206
switch_back:
	list_for_each_entry(q, &set->tag_list, tag_set_list)
		blk_mq_elv_switch_back(&head, q);

K
Keith Busch 已提交
3207 3208 3209
	list_for_each_entry(q, &set->tag_list, tag_set_list)
		blk_mq_unfreeze_queue(q);
}
3210 3211 3212 3213 3214 3215 3216

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

3219 3220 3221 3222
/* 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) ||
3223
	    blk_queue_flag_test_and_set(QUEUE_FLAG_POLL_STATS, q))
3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244
		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;
3245
	int bucket;
3246

3247 3248 3249 3250
	for (bucket = 0; bucket < BLK_MQ_POLL_STATS_BKTS; bucket++) {
		if (cb->stat[bucket].nr_samples)
			q->poll_stat[bucket] = cb->stat[bucket];
	}
3251 3252
}

3253 3254 3255 3256 3257
static unsigned long blk_mq_poll_nsecs(struct request_queue *q,
				       struct blk_mq_hw_ctx *hctx,
				       struct request *rq)
{
	unsigned long ret = 0;
3258
	int bucket;
3259 3260 3261 3262 3263

	/*
	 * If stats collection isn't on, don't sleep but turn it on for
	 * future users
	 */
3264
	if (!blk_poll_stats_enable(q))
3265 3266 3267 3268 3269 3270 3271 3272
		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
3273 3274
	 * than ~10 usec. We do use the stats for the relevant IO size
	 * if available which does lead to better estimates.
3275
	 */
3276 3277 3278 3279 3280 3281
	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;
3282 3283 3284 3285

	return ret;
}

3286
static bool blk_mq_poll_hybrid_sleep(struct request_queue *q,
3287
				     struct blk_mq_hw_ctx *hctx,
3288 3289 3290 3291
				     struct request *rq)
{
	struct hrtimer_sleeper hs;
	enum hrtimer_mode mode;
3292
	unsigned int nsecs;
3293 3294
	ktime_t kt;

J
Jens Axboe 已提交
3295
	if (rq->rq_flags & RQF_MQ_POLL_SLEPT)
3296 3297 3298
		return false;

	/*
3299
	 * If we get here, hybrid polling is enabled. Hence poll_nsec can be:
3300 3301 3302 3303
	 *
	 *  0:	use half of prev avg
	 * >0:	use this specific value
	 */
3304
	if (q->poll_nsec > 0)
3305 3306 3307 3308 3309
		nsecs = q->poll_nsec;
	else
		nsecs = blk_mq_poll_nsecs(q, hctx, rq);

	if (!nsecs)
3310 3311
		return false;

J
Jens Axboe 已提交
3312
	rq->rq_flags |= RQF_MQ_POLL_SLEPT;
3313 3314 3315 3316 3317

	/*
	 * This will be replaced with the stats tracking code, using
	 * 'avg_completion_time / 2' as the pre-sleep target.
	 */
T
Thomas Gleixner 已提交
3318
	kt = nsecs;
3319 3320 3321 3322 3323 3324 3325

	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 已提交
3326
		if (blk_mq_rq_state(rq) == MQ_RQ_COMPLETE)
3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340
			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;
}

3341 3342
static bool blk_mq_poll_hybrid(struct request_queue *q,
			       struct blk_mq_hw_ctx *hctx, blk_qc_t cookie)
J
Jens Axboe 已提交
3343
{
3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365
	struct request *rq;

	if (q->poll_nsec == -1)
		return false;

	if (!blk_qc_t_is_internal(cookie))
		rq = blk_mq_tag_to_rq(hctx->tags, blk_qc_t_to_tag(cookie));
	else {
		rq = blk_mq_tag_to_rq(hctx->sched_tags, blk_qc_t_to_tag(cookie));
		/*
		 * 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;
	}

	return blk_mq_poll_hybrid_sleep(q, hctx, rq);
}

C
Christoph Hellwig 已提交
3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378
/**
 * blk_poll - poll for IO completions
 * @q:  the queue
 * @cookie: cookie passed back at IO submission time
 * @spin: whether to spin for completions
 *
 * Description:
 *    Poll for completions on the passed in queue. Returns number of
 *    completed entries found. If @spin is true, then blk_poll will continue
 *    looping until at least one completion is found, unless the task is
 *    otherwise marked running (or we need to reschedule).
 */
int blk_poll(struct request_queue *q, blk_qc_t cookie, bool spin)
3379 3380
{
	struct blk_mq_hw_ctx *hctx;
J
Jens Axboe 已提交
3381 3382
	long state;

3383
	if (!blk_qc_t_valid(cookie) || !q->mq_ops->poll ||
C
Christoph Hellwig 已提交
3384
	    !test_bit(QUEUE_FLAG_POLL, &q->queue_flags))
3385 3386
		return 0;

C
Christoph Hellwig 已提交
3387 3388 3389
	if (current->plug)
		blk_flush_plug_list(current->plug, false);

3390 3391
	hctx = q->queue_hw_ctx[blk_qc_t_to_queue_num(cookie)];

3392 3393 3394 3395 3396 3397 3398
	/*
	 * 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.
	 */
3399
	if (blk_mq_poll_hybrid(q, hctx, cookie))
3400
		return 1;
3401

J
Jens Axboe 已提交
3402 3403 3404 3405 3406 3407 3408 3409
	hctx->poll_considered++;

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

		hctx->poll_invoked++;

3410
		ret = q->mq_ops->poll(hctx, -1U);
J
Jens Axboe 已提交
3411 3412 3413
		if (ret > 0) {
			hctx->poll_success++;
			set_current_state(TASK_RUNNING);
3414
			return ret;
J
Jens Axboe 已提交
3415 3416 3417 3418 3419 3420
		}

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

		if (current->state == TASK_RUNNING)
3421
			return 1;
3422
		if (ret < 0 || !spin)
J
Jens Axboe 已提交
3423 3424 3425 3426
			break;
		cpu_relax();
	}

3427
	__set_current_state(TASK_RUNNING);
3428
	return 0;
J
Jens Axboe 已提交
3429
}
C
Christoph Hellwig 已提交
3430
EXPORT_SYMBOL_GPL(blk_poll);
J
Jens Axboe 已提交
3431

3432 3433
static int __init blk_mq_init(void)
{
3434 3435
	cpuhp_setup_state_multi(CPUHP_BLK_MQ_DEAD, "block/mq:dead", NULL,
				blk_mq_hctx_notify_dead);
3436 3437 3438
	return 0;
}
subsys_initcall(blk_mq_init);