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

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

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

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

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

	return bucket;
}

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

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

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

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

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

98 99 100 101 102 103 104 105 106
	/*
	 * 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]++;
	if (mi->part->partno)
		mi->inflight[1]++;
107 108 109 110 111 112 113
}

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

114
	inflight[0] = inflight[1] = 0;
115 116 117
	blk_mq_queue_tag_busy_iter(q, blk_mq_check_inflight, &mi);
}

118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
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);
}

137
void blk_freeze_queue_start(struct request_queue *q)
138
{
139
	int freeze_depth;
140

141 142
	freeze_depth = atomic_inc_return(&q->mq_freeze_depth);
	if (freeze_depth == 1) {
143
		percpu_ref_kill(&q->q_usage_counter);
144 145
		if (q->mq_ops)
			blk_mq_run_hw_queues(q, false);
146
	}
147
}
148
EXPORT_SYMBOL_GPL(blk_freeze_queue_start);
149

150
void blk_mq_freeze_queue_wait(struct request_queue *q)
151
{
152
	wait_event(q->mq_freeze_wq, percpu_ref_is_zero(&q->q_usage_counter));
153
}
154
EXPORT_SYMBOL_GPL(blk_mq_freeze_queue_wait);
155

156 157 158 159 160 161 162 163
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);
164

165 166 167 168
/*
 * Guarantee no request is in use, so we can change any data structure of
 * the queue afterward.
 */
169
void blk_freeze_queue(struct request_queue *q)
170
{
171 172 173 174 175 176 177
	/*
	 * 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.
	 */
178
	blk_freeze_queue_start(q);
179 180
	if (!q->mq_ops)
		blk_drain_queue(q);
181 182
	blk_mq_freeze_queue_wait(q);
}
183 184 185 186 187 188 189 190 191

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);
}
192
EXPORT_SYMBOL_GPL(blk_mq_freeze_queue);
193

194
void blk_mq_unfreeze_queue(struct request_queue *q)
195
{
196
	int freeze_depth;
197

198 199 200
	freeze_depth = atomic_dec_return(&q->mq_freeze_depth);
	WARN_ON_ONCE(freeze_depth < 0);
	if (!freeze_depth) {
201
		percpu_ref_reinit(&q->q_usage_counter);
202
		wake_up_all(&q->mq_freeze_wq);
203
	}
204
}
205
EXPORT_SYMBOL_GPL(blk_mq_unfreeze_queue);
206

207 208 209 210 211 212
/*
 * 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)
{
213
	blk_queue_flag_set(QUEUE_FLAG_QUIESCED, q);
214 215 216
}
EXPORT_SYMBOL_GPL(blk_mq_quiesce_queue_nowait);

217
/**
218
 * blk_mq_quiesce_queue() - wait until all ongoing dispatches have finished
219 220 221
 * @q: request queue.
 *
 * Note: this function does not prevent that the struct request end_io()
222 223 224
 * 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().
225 226 227 228 229 230 231
 */
void blk_mq_quiesce_queue(struct request_queue *q)
{
	struct blk_mq_hw_ctx *hctx;
	unsigned int i;
	bool rcu = false;

232
	blk_mq_quiesce_queue_nowait(q);
233

234 235
	queue_for_each_hw_ctx(q, hctx, i) {
		if (hctx->flags & BLK_MQ_F_BLOCKING)
236
			synchronize_srcu(hctx->srcu);
237 238 239 240 241 242 243 244
		else
			rcu = true;
	}
	if (rcu)
		synchronize_rcu();
}
EXPORT_SYMBOL_GPL(blk_mq_quiesce_queue);

245 246 247 248 249 250 251 252 253
/*
 * 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)
{
254
	blk_queue_flag_clear(QUEUE_FLAG_QUIESCED, q);
255

256 257
	/* dispatch requests which are inserted during quiescing */
	blk_mq_run_hw_queues(q, true);
258 259 260
}
EXPORT_SYMBOL_GPL(blk_mq_unquiesce_queue);

261 262 263 264 265 266 267 268 269 270
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);
}

271 272 273 274 275 276
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);

277
static struct request *blk_mq_rq_ctx_init(struct blk_mq_alloc_data *data,
278
		unsigned int tag, unsigned int op, u64 alloc_time_ns)
279
{
280 281
	struct blk_mq_tags *tags = blk_mq_tags_from_data(data);
	struct request *rq = tags->static_rqs[tag];
282
	req_flags_t rq_flags = 0;
283

284 285 286 287
	if (data->flags & BLK_MQ_REQ_INTERNAL) {
		rq->tag = -1;
		rq->internal_tag = tag;
	} else {
288
		if (data->hctx->flags & BLK_MQ_F_TAG_SHARED) {
289
			rq_flags = RQF_MQ_INFLIGHT;
290 291 292 293 294 295 296
			atomic_inc(&data->hctx->nr_active);
		}
		rq->tag = tag;
		rq->internal_tag = -1;
		data->hctx->tags->rqs[rq->tag] = rq;
	}

297
	/* csd/requeue_work/fifo_time is initialized before use */
298 299
	rq->q = data->q;
	rq->mq_ctx = data->ctx;
300
	rq->rq_flags = rq_flags;
301
	rq->cpu = -1;
302
	rq->cmd_flags = op;
303 304
	if (data->flags & BLK_MQ_REQ_PREEMPT)
		rq->rq_flags |= RQF_PREEMPT;
305
	if (blk_queue_io_stat(data->q))
306
		rq->rq_flags |= RQF_IO_STAT;
307
	INIT_LIST_HEAD(&rq->queuelist);
308 309 310 311
	INIT_HLIST_NODE(&rq->hash);
	RB_CLEAR_NODE(&rq->rb_node);
	rq->rq_disk = NULL;
	rq->part = NULL;
312 313 314
#ifdef CONFIG_BLK_RQ_ALLOC_TIME
	rq->alloc_time_ns = alloc_time_ns;
#endif
315
	rq->start_time_ns = ktime_get_ns();
316
	rq->io_start_time_ns = 0;
317 318 319 320 321 322 323
	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;
324
	rq->__deadline = 0;
325 326

	INIT_LIST_HEAD(&rq->timeout_list);
327 328
	rq->timeout = 0;

329 330 331 332
	rq->end_io = NULL;
	rq->end_io_data = NULL;
	rq->next_rq = NULL;

333 334 335 336
#ifdef CONFIG_BLK_CGROUP
	rq->rl = NULL;
#endif

337
	data->ctx->rq_dispatched[op_is_sync(op)]++;
K
Keith Busch 已提交
338
	refcount_set(&rq->ref, 1);
339
	return rq;
340 341
}

342 343 344 345 346 347
static struct request *blk_mq_get_request(struct request_queue *q,
		struct bio *bio, unsigned int op,
		struct blk_mq_alloc_data *data)
{
	struct elevator_queue *e = q->elevator;
	struct request *rq;
348
	unsigned int tag;
349
	bool put_ctx_on_error = false;
350
	u64 alloc_time_ns = 0;
351 352

	blk_queue_enter_live(q);
353 354 355 356 357

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

358
	data->q = q;
359 360 361 362
	if (likely(!data->ctx)) {
		data->ctx = blk_mq_get_ctx(q);
		put_ctx_on_error = true;
	}
363 364
	if (likely(!data->hctx))
		data->hctx = blk_mq_map_queue(q, data->ctx->cpu);
365 366
	if (op & REQ_NOWAIT)
		data->flags |= BLK_MQ_REQ_NOWAIT;
367 368 369 370 371 372

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

		/*
		 * Flush requests are special and go directly to the
373 374
		 * dispatch list. Don't include reserved tags in the
		 * limiting, as it isn't useful.
375
		 */
376 377
		if (!op_is_flush(op) && e->type->ops.mq.limit_depth &&
		    !(data->flags & BLK_MQ_REQ_RESERVED))
378
			e->type->ops.mq.limit_depth(op, data);
379 380
	} else {
		blk_mq_tag_busy(data->hctx);
381 382
	}

383 384
	tag = blk_mq_get_tag(data);
	if (tag == BLK_MQ_TAG_FAIL) {
385 386
		if (put_ctx_on_error) {
			blk_mq_put_ctx(data->ctx);
387 388
			data->ctx = NULL;
		}
389 390
		blk_queue_exit(q);
		return NULL;
391 392
	}

393
	rq = blk_mq_rq_ctx_init(data, tag, op, alloc_time_ns);
394 395
	if (!op_is_flush(op)) {
		rq->elv.icq = NULL;
396
		if (e && e->type->ops.mq.prepare_request) {
397 398 399
			if (e->type->icq_cache && rq_ioc(bio))
				blk_mq_sched_assign_ioc(rq, bio);

400 401
			e->type->ops.mq.prepare_request(rq, bio);
			rq->rq_flags |= RQF_ELVPRIV;
402
		}
403 404 405
	}
	data->hctx->queued++;
	return rq;
406 407
}

408
struct request *blk_mq_alloc_request(struct request_queue *q, unsigned int op,
409
		blk_mq_req_flags_t flags)
410
{
411
	struct blk_mq_alloc_data alloc_data = { .flags = flags };
412
	struct request *rq;
413
	int ret;
414

415
	ret = blk_queue_enter(q, flags);
416 417
	if (ret)
		return ERR_PTR(ret);
418

419
	rq = blk_mq_get_request(q, NULL, op, &alloc_data);
420
	blk_queue_exit(q);
421

422
	if (!rq)
423
		return ERR_PTR(-EWOULDBLOCK);
424

425 426
	blk_mq_put_ctx(alloc_data.ctx);

427 428 429
	rq->__data_len = 0;
	rq->__sector = (sector_t) -1;
	rq->bio = rq->biotail = NULL;
430 431
	return rq;
}
432
EXPORT_SYMBOL(blk_mq_alloc_request);
433

434
struct request *blk_mq_alloc_request_hctx(struct request_queue *q,
435
	unsigned int op, blk_mq_req_flags_t flags, unsigned int hctx_idx)
M
Ming Lin 已提交
436
{
437
	struct blk_mq_alloc_data alloc_data = { .flags = flags };
M
Ming Lin 已提交
438
	struct request *rq;
439
	unsigned int cpu;
M
Ming Lin 已提交
440 441 442 443 444 445 446 447 448 449 450 451 452 453
	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);

454
	ret = blk_queue_enter(q, flags);
M
Ming Lin 已提交
455 456 457
	if (ret)
		return ERR_PTR(ret);

458 459 460 461
	/*
	 * Check if the hardware context is actually mapped to anything.
	 * If not tell the caller that it should skip this queue.
	 */
462 463 464 465
	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);
466
	}
467
	cpu = cpumask_first_and(alloc_data.hctx->cpumask, cpu_online_mask);
468
	alloc_data.ctx = __blk_mq_get_ctx(q, cpu);
M
Ming Lin 已提交
469

470
	rq = blk_mq_get_request(q, NULL, op, &alloc_data);
471
	blk_queue_exit(q);
472

473 474 475 476
	if (!rq)
		return ERR_PTR(-EWOULDBLOCK);

	return rq;
M
Ming Lin 已提交
477 478 479
}
EXPORT_SYMBOL_GPL(blk_mq_alloc_request_hctx);

K
Keith Busch 已提交
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494
static void __blk_mq_free_request(struct request *rq)
{
	struct request_queue *q = rq->q;
	struct blk_mq_ctx *ctx = rq->mq_ctx;
	struct blk_mq_hw_ctx *hctx = blk_mq_map_queue(q, ctx->cpu);
	const int sched_tag = rq->internal_tag;

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

495
void blk_mq_free_request(struct request *rq)
496 497
{
	struct request_queue *q = rq->q;
498 499 500 501
	struct elevator_queue *e = q->elevator;
	struct blk_mq_ctx *ctx = rq->mq_ctx;
	struct blk_mq_hw_ctx *hctx = blk_mq_map_queue(q, ctx->cpu);

502
	if (rq->rq_flags & RQF_ELVPRIV) {
503 504 505 506 507 508 509
		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;
		}
	}
510

511
	ctx->rq_completed[rq_is_sync(rq)]++;
512
	if (rq->rq_flags & RQF_MQ_INFLIGHT)
513
		atomic_dec(&hctx->nr_active);
J
Jens Axboe 已提交
514

515 516 517
	if (unlikely(laptop_mode && !blk_rq_is_passthrough(rq)))
		laptop_io_completion(q->backing_dev_info);

518
	rq_qos_done(q, rq);
519

S
Shaohua Li 已提交
520 521 522
	if (blk_rq_rl(rq))
		blk_put_rl(blk_rq_rl(rq));

K
Keith Busch 已提交
523 524 525
	WRITE_ONCE(rq->state, MQ_RQ_IDLE);
	if (refcount_dec_and_test(&rq->ref))
		__blk_mq_free_request(rq);
526
}
J
Jens Axboe 已提交
527
EXPORT_SYMBOL_GPL(blk_mq_free_request);
528

529
inline void __blk_mq_end_request(struct request *rq, blk_status_t error)
530
{
531 532
	u64 now = ktime_get_ns();

533 534
	if (rq->rq_flags & RQF_STATS) {
		blk_mq_poll_stats_start(rq->q);
535
		blk_stat_add(rq, now);
536 537
	}

538
	blk_account_io_done(rq, now);
M
Ming Lei 已提交
539

C
Christoph Hellwig 已提交
540
	if (rq->end_io) {
541
		rq_qos_done(rq->q, rq);
542
		rq->end_io(rq, error);
C
Christoph Hellwig 已提交
543 544 545
	} else {
		if (unlikely(blk_bidi_rq(rq)))
			blk_mq_free_request(rq->next_rq);
546
		blk_mq_free_request(rq);
C
Christoph Hellwig 已提交
547
	}
548
}
549
EXPORT_SYMBOL(__blk_mq_end_request);
550

551
void blk_mq_end_request(struct request *rq, blk_status_t error)
552 553 554
{
	if (blk_update_request(rq, error, blk_rq_bytes(rq)))
		BUG();
555
	__blk_mq_end_request(rq, error);
556
}
557
EXPORT_SYMBOL(blk_mq_end_request);
558

559
static void __blk_mq_complete_request_remote(void *data)
560
{
561
	struct request *rq = data;
562

563
	rq->q->softirq_done_fn(rq);
564 565
}

566
static void __blk_mq_complete_request(struct request *rq)
567 568
{
	struct blk_mq_ctx *ctx = rq->mq_ctx;
C
Christoph Hellwig 已提交
569
	bool shared = false;
570 571
	int cpu;

572
	if (!blk_mq_mark_complete(rq))
K
Keith Busch 已提交
573
		return;
574 575 576
	if (rq->internal_tag != -1)
		blk_mq_sched_completed_request(rq);

C
Christoph Hellwig 已提交
577
	if (!test_bit(QUEUE_FLAG_SAME_COMP, &rq->q->queue_flags)) {
578 579 580
		rq->q->softirq_done_fn(rq);
		return;
	}
581 582

	cpu = get_cpu();
C
Christoph Hellwig 已提交
583 584 585 586
	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)) {
587
		rq->csd.func = __blk_mq_complete_request_remote;
588 589
		rq->csd.info = rq;
		rq->csd.flags = 0;
590
		smp_call_function_single_async(ctx->cpu, &rq->csd);
591
	} else {
592
		rq->q->softirq_done_fn(rq);
593
	}
594 595
	put_cpu();
}
596

597
static void hctx_unlock(struct blk_mq_hw_ctx *hctx, int srcu_idx)
598
	__releases(hctx->srcu)
599 600 601 602
{
	if (!(hctx->flags & BLK_MQ_F_BLOCKING))
		rcu_read_unlock();
	else
603
		srcu_read_unlock(hctx->srcu, srcu_idx);
604 605 606
}

static void hctx_lock(struct blk_mq_hw_ctx *hctx, int *srcu_idx)
607
	__acquires(hctx->srcu)
608
{
609 610 611
	if (!(hctx->flags & BLK_MQ_F_BLOCKING)) {
		/* shut up gcc false positive */
		*srcu_idx = 0;
612
		rcu_read_lock();
613
	} else
614
		*srcu_idx = srcu_read_lock(hctx->srcu);
615 616
}

617 618 619 620 621 622 623 624
/**
 * 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.
 **/
625
void blk_mq_complete_request(struct request *rq)
626
{
K
Keith Busch 已提交
627
	if (unlikely(blk_should_fake_timeout(rq->q)))
628
		return;
K
Keith Busch 已提交
629
	__blk_mq_complete_request(rq);
630 631
}
EXPORT_SYMBOL(blk_mq_complete_request);
632

633 634
int blk_mq_request_started(struct request *rq)
{
T
Tejun Heo 已提交
635
	return blk_mq_rq_state(rq) != MQ_RQ_IDLE;
636 637 638
}
EXPORT_SYMBOL_GPL(blk_mq_request_started);

639
void blk_mq_start_request(struct request *rq)
640 641 642
{
	struct request_queue *q = rq->q;

643 644
	blk_mq_sched_started_request(rq);

645 646
	trace_block_rq_issue(q, rq);

647
	if (test_bit(QUEUE_FLAG_STATS, &q->queue_flags)) {
648 649 650 651
		rq->io_start_time_ns = ktime_get_ns();
#ifdef CONFIG_BLK_DEV_THROTTLING_LOW
		rq->throtl_size = blk_rq_sectors(rq);
#endif
652
		rq->rq_flags |= RQF_STATS;
653
		rq_qos_issue(q, rq);
654 655
	}

656
	WARN_ON_ONCE(blk_mq_rq_state(rq) != MQ_RQ_IDLE);
657

658
	blk_add_timer(rq);
K
Keith Busch 已提交
659
	WRITE_ONCE(rq->state, MQ_RQ_IN_FLIGHT);
660 661 662 663 664 665 666 667 668

	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++;
	}
669
}
670
EXPORT_SYMBOL(blk_mq_start_request);
671

672
static void __blk_mq_requeue_request(struct request *rq)
673 674 675
{
	struct request_queue *q = rq->q;

676 677
	blk_mq_put_driver_tag(rq);

678
	trace_block_rq_requeue(q, rq);
679
	rq_qos_requeue(q, rq);
680

K
Keith Busch 已提交
681 682
	if (blk_mq_request_started(rq)) {
		WRITE_ONCE(rq->state, MQ_RQ_IDLE);
683
		rq->rq_flags &= ~RQF_TIMED_OUT;
684 685 686
		if (q->dma_drain_size && blk_rq_bytes(rq))
			rq->nr_phys_segments--;
	}
687 688
}

689
void blk_mq_requeue_request(struct request *rq, bool kick_requeue_list)
690 691 692
{
	__blk_mq_requeue_request(rq);

693 694 695
	/* this request will be re-inserted to io scheduler queue */
	blk_mq_sched_requeue_request(rq);

696
	BUG_ON(blk_queued_rq(rq));
697
	blk_mq_add_to_requeue_list(rq, true, kick_requeue_list);
698 699 700
}
EXPORT_SYMBOL(blk_mq_requeue_request);

701 702 703
static void blk_mq_requeue_work(struct work_struct *work)
{
	struct request_queue *q =
704
		container_of(work, struct request_queue, requeue_work.work);
705 706 707
	LIST_HEAD(rq_list);
	struct request *rq, *next;

708
	spin_lock_irq(&q->requeue_lock);
709
	list_splice_init(&q->requeue_list, &rq_list);
710
	spin_unlock_irq(&q->requeue_lock);
711 712

	list_for_each_entry_safe(rq, next, &rq_list, queuelist) {
713
		if (!(rq->rq_flags & (RQF_SOFTBARRIER | RQF_DONTPREP)))
714 715
			continue;

716
		rq->rq_flags &= ~RQF_SOFTBARRIER;
717
		list_del_init(&rq->queuelist);
718 719 720 721 722 723 724 725 726
		/*
		 * 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);
727 728 729 730 731
	}

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

735
	blk_mq_run_hw_queues(q, false);
736 737
}

738 739
void blk_mq_add_to_requeue_list(struct request *rq, bool at_head,
				bool kick_requeue_list)
740 741 742 743 744 745
{
	struct request_queue *q = rq->q;
	unsigned long flags;

	/*
	 * We abuse this flag that is otherwise used by the I/O scheduler to
746
	 * request head insertion from the workqueue.
747
	 */
748
	BUG_ON(rq->rq_flags & RQF_SOFTBARRIER);
749 750 751

	spin_lock_irqsave(&q->requeue_lock, flags);
	if (at_head) {
752
		rq->rq_flags |= RQF_SOFTBARRIER;
753 754 755 756 757
		list_add(&rq->queuelist, &q->requeue_list);
	} else {
		list_add_tail(&rq->queuelist, &q->requeue_list);
	}
	spin_unlock_irqrestore(&q->requeue_lock, flags);
758 759 760

	if (kick_requeue_list)
		blk_mq_kick_requeue_list(q);
761 762 763 764 765
}
EXPORT_SYMBOL(blk_mq_add_to_requeue_list);

void blk_mq_kick_requeue_list(struct request_queue *q)
{
766
	kblockd_mod_delayed_work_on(WORK_CPU_UNBOUND, &q->requeue_work, 0);
767 768 769
}
EXPORT_SYMBOL(blk_mq_kick_requeue_list);

770 771 772
void blk_mq_delay_kick_requeue_list(struct request_queue *q,
				    unsigned long msecs)
{
773 774
	kblockd_mod_delayed_work_on(WORK_CPU_UNBOUND, &q->requeue_work,
				    msecs_to_jiffies(msecs));
775 776 777
}
EXPORT_SYMBOL(blk_mq_delay_kick_requeue_list);

778 779
struct request *blk_mq_tag_to_rq(struct blk_mq_tags *tags, unsigned int tag)
{
780 781
	if (tag < tags->nr_tags) {
		prefetch(tags->rqs[tag]);
782
		return tags->rqs[tag];
783
	}
784 785

	return NULL;
786 787 788
}
EXPORT_SYMBOL(blk_mq_tag_to_rq);

789
static void blk_mq_rq_timed_out(struct request *req, bool reserved)
790
{
791
	req->rq_flags |= RQF_TIMED_OUT;
792 793 794 795 796 797 798
	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);
799
	}
800 801

	blk_add_timer(req);
802
}
803

K
Keith Busch 已提交
804
static bool blk_mq_req_expired(struct request *rq, unsigned long *next)
805
{
K
Keith Busch 已提交
806
	unsigned long deadline;
807

K
Keith Busch 已提交
808 809
	if (blk_mq_rq_state(rq) != MQ_RQ_IN_FLIGHT)
		return false;
810 811
	if (rq->rq_flags & RQF_TIMED_OUT)
		return false;
812

K
Keith Busch 已提交
813 814 815
	deadline = blk_rq_deadline(rq);
	if (time_after_eq(jiffies, deadline))
		return true;
816

K
Keith Busch 已提交
817 818 819 820 821
	if (*next == 0)
		*next = deadline;
	else if (time_after(*next, deadline))
		*next = deadline;
	return false;
822 823
}

K
Keith Busch 已提交
824
static void blk_mq_check_expired(struct blk_mq_hw_ctx *hctx,
825 826
		struct request *rq, void *priv, bool reserved)
{
K
Keith Busch 已提交
827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847
	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;

848
	/*
K
Keith Busch 已提交
849 850 851 852
	 * 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.
853
	 */
K
Keith Busch 已提交
854
	if (blk_mq_req_expired(rq, next))
855
		blk_mq_rq_timed_out(rq, reserved);
856 857 858 859

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

863
static void blk_mq_timeout_work(struct work_struct *work)
864
{
865 866
	struct request_queue *q =
		container_of(work, struct request_queue, timeout_work);
K
Keith Busch 已提交
867
	unsigned long next = 0;
868
	struct blk_mq_hw_ctx *hctx;
869
	int i;
870

871 872 873 874 875 876 877 878 879
	/* 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
880
	 * blk_freeze_queue_start, and the moment the last request is
881 882 883 884
	 * consumed, marked by the instant q_usage_counter reaches
	 * zero.
	 */
	if (!percpu_ref_tryget(&q->q_usage_counter))
885 886
		return;

K
Keith Busch 已提交
887
	blk_mq_queue_tag_busy_iter(q, blk_mq_check_expired, &next);
888

K
Keith Busch 已提交
889 890
	if (next != 0) {
		mod_timer(&q->timeout, next);
891
	} else {
892 893 894 895 896 897
		/*
		 * 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.
		 */
898 899 900 901 902
		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);
		}
903
	}
904
	blk_queue_exit(q);
905 906
}

907 908 909 910 911 912 913 914 915 916 917 918 919
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);
920
	sbitmap_clear_bit(sb, bitnr);
921 922 923 924
	spin_unlock(&ctx->lock);
	return true;
}

925 926 927 928
/*
 * Process software queues that have been marked busy, splicing them
 * to the for-dispatch
 */
929
void blk_mq_flush_busy_ctxs(struct blk_mq_hw_ctx *hctx, struct list_head *list)
930
{
931 932 933 934
	struct flush_busy_ctx_data data = {
		.hctx = hctx,
		.list = list,
	};
935

936
	sbitmap_for_each_set(&hctx->ctx_map, flush_busy_ctx, &data);
937
}
938
EXPORT_SYMBOL_GPL(blk_mq_flush_busy_ctxs);
939

940 941 942 943 944 945 946 947 948 949 950 951 952
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 已提交
953
	if (!list_empty(&ctx->rq_list)) {
954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978
		dispatch_data->rq = list_entry_rq(ctx->rq_list.next);
		list_del_init(&dispatch_data->rq->queuelist);
		if (list_empty(&ctx->rq_list))
			sbitmap_clear_bit(sb, bitnr);
	}
	spin_unlock(&ctx->lock);

	return !dispatch_data->rq;
}

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

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

	return data.rq;
}

979 980 981 982
static inline unsigned int queued_to_index(unsigned int queued)
{
	if (!queued)
		return 0;
983

984
	return min(BLK_MQ_MAX_DISPATCH_ORDER - 1, ilog2(queued) + 1);
985 986
}

987
bool blk_mq_get_driver_tag(struct request *rq)
988 989 990 991
{
	struct blk_mq_alloc_data data = {
		.q = rq->q,
		.hctx = blk_mq_map_queue(rq->q, rq->mq_ctx->cpu),
992
		.flags = BLK_MQ_REQ_NOWAIT,
993
	};
994
	bool shared;
995

996 997
	if (rq->tag != -1)
		goto done;
998

999 1000 1001
	if (blk_mq_tag_is_reserved(data.hctx->sched_tags, rq->internal_tag))
		data.flags |= BLK_MQ_REQ_RESERVED;

1002
	shared = blk_mq_tag_busy(data.hctx);
1003 1004
	rq->tag = blk_mq_get_tag(&data);
	if (rq->tag >= 0) {
1005
		if (shared) {
1006 1007 1008
			rq->rq_flags |= RQF_MQ_INFLIGHT;
			atomic_inc(&data.hctx->nr_active);
		}
1009 1010 1011
		data.hctx->tags->rqs[rq->tag] = rq;
	}

1012 1013
done:
	return rq->tag != -1;
1014 1015
}

1016 1017
static int blk_mq_dispatch_wake(wait_queue_entry_t *wait, unsigned mode,
				int flags, void *key)
1018 1019 1020 1021 1022
{
	struct blk_mq_hw_ctx *hctx;

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

1023
	spin_lock(&hctx->dispatch_wait_lock);
1024
	list_del_init(&wait->entry);
1025 1026
	spin_unlock(&hctx->dispatch_wait_lock);

1027 1028 1029 1030
	blk_mq_run_hw_queue(hctx, true);
	return 1;
}

1031 1032
/*
 * Mark us waiting for a tag. For shared tags, this involves hooking us into
1033 1034
 * 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
1035 1036
 * marking us as waiting.
 */
1037
static bool blk_mq_mark_tag_wait(struct blk_mq_hw_ctx *hctx,
1038
				 struct request *rq)
1039
{
1040
	struct wait_queue_head *wq;
1041 1042
	wait_queue_entry_t *wait;
	bool ret;
1043

1044 1045 1046
	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);
1047

1048 1049 1050 1051 1052 1053 1054 1055
		/*
		 * 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.
		 */
1056
		return blk_mq_get_driver_tag(rq);
1057 1058
	}

1059
	wait = &hctx->dispatch_wait;
1060 1061 1062
	if (!list_empty_careful(&wait->entry))
		return false;

1063 1064 1065 1066
	wq = &bt_wait_ptr(&hctx->tags->bitmap_tags, hctx)->wait;

	spin_lock_irq(&wq->lock);
	spin_lock(&hctx->dispatch_wait_lock);
1067
	if (!list_empty(&wait->entry)) {
1068 1069
		spin_unlock(&hctx->dispatch_wait_lock);
		spin_unlock_irq(&wq->lock);
1070
		return false;
1071 1072
	}

1073 1074
	wait->flags &= ~WQ_FLAG_EXCLUSIVE;
	__add_wait_queue(wq, wait);
1075

1076
	/*
1077 1078 1079
	 * It's possible that a tag was freed in the window between the
	 * allocation failure and adding the hardware queue to the wait
	 * queue.
1080
	 */
1081
	ret = blk_mq_get_driver_tag(rq);
1082
	if (!ret) {
1083 1084
		spin_unlock(&hctx->dispatch_wait_lock);
		spin_unlock_irq(&wq->lock);
1085
		return false;
1086
	}
1087 1088 1089 1090 1091 1092

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

	return true;
1097 1098
}

1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127
#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;
}

1128 1129
#define BLK_MQ_RESOURCE_DELAY	3		/* ms units */

1130 1131 1132
/*
 * Returns true if we did some work AND can potentially do more.
 */
1133
bool blk_mq_dispatch_rq_list(struct request_queue *q, struct list_head *list,
1134
			     bool got_budget)
1135
{
1136
	struct blk_mq_hw_ctx *hctx;
1137
	struct request *rq, *nxt;
1138
	bool no_tag = false;
1139
	int errors, queued;
1140
	blk_status_t ret = BLK_STS_OK;
1141

1142 1143 1144
	if (list_empty(list))
		return false;

1145 1146
	WARN_ON(!list_is_singular(list) && got_budget);

1147 1148 1149
	/*
	 * Now process all the entries, sending them to the driver.
	 */
1150
	errors = queued = 0;
1151
	do {
1152
		struct blk_mq_queue_data bd;
1153

1154
		rq = list_first_entry(list, struct request, queuelist);
1155 1156 1157 1158 1159

		hctx = blk_mq_map_queue(rq->q, rq->mq_ctx->cpu);
		if (!got_budget && !blk_mq_get_dispatch_budget(hctx))
			break;

1160
		if (!blk_mq_get_driver_tag(rq)) {
1161
			/*
1162
			 * The initial allocation attempt failed, so we need to
1163 1164 1165 1166
			 * 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.
1167
			 */
1168
			if (!blk_mq_mark_tag_wait(hctx, rq)) {
1169
				blk_mq_put_dispatch_budget(hctx);
1170 1171 1172 1173 1174 1175
				/*
				 * For non-shared tags, the RESTART check
				 * will suffice.
				 */
				if (hctx->flags & BLK_MQ_F_TAG_SHARED)
					no_tag = true;
1176 1177 1178 1179
				break;
			}
		}

1180 1181
		list_del_init(&rq->queuelist);

1182
		bd.rq = rq;
1183 1184 1185 1186 1187 1188 1189 1190 1191

		/*
		 * 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);
1192
			bd.last = !blk_mq_get_driver_tag(nxt);
1193
		}
1194 1195

		ret = q->mq_ops->queue_rq(hctx, &bd);
1196
		if (ret == BLK_STS_RESOURCE || ret == BLK_STS_DEV_RESOURCE) {
1197 1198
			/*
			 * If an I/O scheduler has been configured and we got a
1199 1200
			 * driver tag for the next request already, free it
			 * again.
1201 1202 1203 1204 1205
			 */
			if (!list_empty(list)) {
				nxt = list_first_entry(list, struct request, queuelist);
				blk_mq_put_driver_tag(nxt);
			}
1206
			list_add(&rq->queuelist, list);
1207
			__blk_mq_requeue_request(rq);
1208
			break;
1209 1210 1211
		}

		if (unlikely(ret != BLK_STS_OK)) {
1212
			errors++;
1213
			blk_mq_end_request(rq, BLK_STS_IOERR);
1214
			continue;
1215 1216
		}

1217
		queued++;
1218
	} while (!list_empty(list));
1219

1220
	hctx->dispatched[queued_to_index(queued)]++;
1221 1222 1223 1224 1225

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

1229
		spin_lock(&hctx->lock);
1230
		list_splice_init(list, &hctx->dispatch);
1231
		spin_unlock(&hctx->lock);
1232

1233
		/*
1234 1235 1236
		 * 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.
1237
		 *
1238 1239 1240 1241
		 * 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.
1242
		 *
1243 1244 1245 1246 1247 1248 1249
		 * 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
1250
		 *   returning BLK_STS_RESOURCE. Two exceptions are scsi-mq
1251
		 *   and dm-rq.
1252 1253 1254 1255
		 *
		 * 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.
1256
		 */
1257 1258
		needs_restart = blk_mq_sched_needs_restart(hctx);
		if (!needs_restart ||
1259
		    (no_tag && list_empty_careful(&hctx->dispatch_wait.entry)))
1260
			blk_mq_run_hw_queue(hctx, true);
1261 1262
		else if (needs_restart && (ret == BLK_STS_RESOURCE))
			blk_mq_delay_run_hw_queue(hctx, BLK_MQ_RESOURCE_DELAY);
1263

1264
		blk_mq_update_dispatch_busy(hctx, true);
1265
		return false;
1266 1267
	} else
		blk_mq_update_dispatch_busy(hctx, false);
1268

1269 1270 1271 1272 1273 1274 1275
	/*
	 * 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;

1276
	return (queued + errors) != 0;
1277 1278
}

1279 1280 1281 1282
static void __blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx)
{
	int srcu_idx;

1283 1284 1285
	/*
	 * We should be running this queue from one of the CPUs that
	 * are mapped to it.
1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298
	 *
	 * 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
1299
	 */
1300 1301 1302 1303 1304 1305 1306
	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();
	}
1307

1308 1309 1310 1311 1312 1313
	/*
	 * We can't run the queue inline with ints disabled. Ensure that
	 * we catch bad users of this early.
	 */
	WARN_ON_ONCE(in_interrupt());

1314
	might_sleep_if(hctx->flags & BLK_MQ_F_BLOCKING);
1315

1316 1317 1318
	hctx_lock(hctx, &srcu_idx);
	blk_mq_sched_dispatch_requests(hctx);
	hctx_unlock(hctx, srcu_idx);
1319 1320
}

1321 1322 1323 1324 1325 1326 1327 1328 1329
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;
}

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

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

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

1353 1354 1355 1356
	/*
	 * 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.
	 */
1357
	if (!cpu_online(next_cpu)) {
1358 1359 1360 1361 1362 1363 1364 1365 1366
		if (!tried) {
			tried = true;
			goto select_cpu;
		}

		/*
		 * Make sure to re-select CPU next time once after CPUs
		 * in hctx->cpumask become online again.
		 */
1367
		hctx->next_cpu = next_cpu;
1368 1369 1370
		hctx->next_cpu_batch = 1;
		return WORK_CPU_UNBOUND;
	}
1371 1372 1373

	hctx->next_cpu = next_cpu;
	return next_cpu;
1374 1375
}

1376 1377
static void __blk_mq_delay_run_hw_queue(struct blk_mq_hw_ctx *hctx, bool async,
					unsigned long msecs)
1378
{
1379
	if (unlikely(blk_mq_hctx_stopped(hctx)))
1380 1381
		return;

1382
	if (!async && !(hctx->flags & BLK_MQ_F_BLOCKING)) {
1383 1384
		int cpu = get_cpu();
		if (cpumask_test_cpu(cpu, hctx->cpumask)) {
1385
			__blk_mq_run_hw_queue(hctx);
1386
			put_cpu();
1387 1388
			return;
		}
1389

1390
		put_cpu();
1391
	}
1392

1393 1394
	kblockd_mod_delayed_work_on(blk_mq_hctx_next_cpu(hctx), &hctx->run_work,
				    msecs_to_jiffies(msecs));
1395 1396 1397 1398 1399 1400 1401 1402
}

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

1403
bool blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx, bool async)
1404
{
1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415
	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.
	 */
1416 1417 1418 1419
	hctx_lock(hctx, &srcu_idx);
	need_run = !blk_queue_quiesced(hctx->queue) &&
		blk_mq_hctx_has_pending(hctx);
	hctx_unlock(hctx, srcu_idx);
1420 1421

	if (need_run) {
1422 1423 1424 1425 1426
		__blk_mq_delay_run_hw_queue(hctx, async, 0);
		return true;
	}

	return false;
1427
}
O
Omar Sandoval 已提交
1428
EXPORT_SYMBOL(blk_mq_run_hw_queue);
1429

1430
void blk_mq_run_hw_queues(struct request_queue *q, bool async)
1431 1432 1433 1434 1435
{
	struct blk_mq_hw_ctx *hctx;
	int i;

	queue_for_each_hw_ctx(q, hctx, i) {
1436
		if (blk_mq_hctx_stopped(hctx))
1437 1438
			continue;

1439
		blk_mq_run_hw_queue(hctx, async);
1440 1441
	}
}
1442
EXPORT_SYMBOL(blk_mq_run_hw_queues);
1443

1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463
/**
 * 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);

1464 1465 1466
/*
 * This function is often used for pausing .queue_rq() by driver when
 * there isn't enough resource or some conditions aren't satisfied, and
1467
 * BLK_STS_RESOURCE is usually returned.
1468 1469 1470 1471 1472
 *
 * 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.
 */
1473 1474
void blk_mq_stop_hw_queue(struct blk_mq_hw_ctx *hctx)
{
1475
	cancel_delayed_work(&hctx->run_work);
1476

1477
	set_bit(BLK_MQ_S_STOPPED, &hctx->state);
1478
}
1479
EXPORT_SYMBOL(blk_mq_stop_hw_queue);
1480

1481 1482 1483
/*
 * This function is often used for pausing .queue_rq() by driver when
 * there isn't enough resource or some conditions aren't satisfied, and
1484
 * BLK_STS_RESOURCE is usually returned.
1485 1486 1487 1488 1489
 *
 * 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.
 */
1490 1491
void blk_mq_stop_hw_queues(struct request_queue *q)
{
1492 1493 1494 1495 1496
	struct blk_mq_hw_ctx *hctx;
	int i;

	queue_for_each_hw_ctx(q, hctx, i)
		blk_mq_stop_hw_queue(hctx);
1497 1498 1499
}
EXPORT_SYMBOL(blk_mq_stop_hw_queues);

1500 1501 1502
void blk_mq_start_hw_queue(struct blk_mq_hw_ctx *hctx)
{
	clear_bit(BLK_MQ_S_STOPPED, &hctx->state);
1503

1504
	blk_mq_run_hw_queue(hctx, false);
1505 1506 1507
}
EXPORT_SYMBOL(blk_mq_start_hw_queue);

1508 1509 1510 1511 1512 1513 1514 1515 1516 1517
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);

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

1528
void blk_mq_start_stopped_hw_queues(struct request_queue *q, bool async)
1529 1530 1531 1532
{
	struct blk_mq_hw_ctx *hctx;
	int i;

1533 1534
	queue_for_each_hw_ctx(q, hctx, i)
		blk_mq_start_stopped_hw_queue(hctx, async);
1535 1536 1537
}
EXPORT_SYMBOL(blk_mq_start_stopped_hw_queues);

1538
static void blk_mq_run_work_fn(struct work_struct *work)
1539 1540 1541
{
	struct blk_mq_hw_ctx *hctx;

1542
	hctx = container_of(work, struct blk_mq_hw_ctx, run_work.work);
1543

1544
	/*
M
Ming Lei 已提交
1545
	 * If we are stopped, don't run the queue.
1546
	 */
M
Ming Lei 已提交
1547
	if (test_bit(BLK_MQ_S_STOPPED, &hctx->state))
1548
		return;
1549 1550 1551 1552

	__blk_mq_run_hw_queue(hctx);
}

1553 1554 1555
static inline void __blk_mq_insert_req_list(struct blk_mq_hw_ctx *hctx,
					    struct request *rq,
					    bool at_head)
1556
{
J
Jens Axboe 已提交
1557 1558
	struct blk_mq_ctx *ctx = rq->mq_ctx;

1559 1560
	lockdep_assert_held(&ctx->lock);

1561 1562
	trace_block_rq_insert(hctx->queue, rq);

1563 1564 1565 1566
	if (at_head)
		list_add(&rq->queuelist, &ctx->rq_list);
	else
		list_add_tail(&rq->queuelist, &ctx->rq_list);
1567
}
1568

1569 1570
void __blk_mq_insert_request(struct blk_mq_hw_ctx *hctx, struct request *rq,
			     bool at_head)
1571 1572 1573
{
	struct blk_mq_ctx *ctx = rq->mq_ctx;

1574 1575
	lockdep_assert_held(&ctx->lock);

J
Jens Axboe 已提交
1576
	__blk_mq_insert_req_list(hctx, rq, at_head);
1577 1578 1579
	blk_mq_hctx_mark_pending(hctx, ctx);
}

1580 1581 1582 1583
/*
 * Should only be used carefully, when the caller knows we want to
 * bypass a potential IO scheduler on the target device.
 */
1584
void blk_mq_request_bypass_insert(struct request *rq, bool run_queue)
1585 1586 1587 1588 1589 1590 1591 1592
{
	struct blk_mq_ctx *ctx = rq->mq_ctx;
	struct blk_mq_hw_ctx *hctx = blk_mq_map_queue(rq->q, ctx->cpu);

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

1593 1594
	if (run_queue)
		blk_mq_run_hw_queue(hctx, false);
1595 1596
}

1597 1598
void blk_mq_insert_requests(struct blk_mq_hw_ctx *hctx, struct blk_mq_ctx *ctx,
			    struct list_head *list)
1599 1600

{
1601 1602
	struct request *rq;

1603 1604 1605 1606
	/*
	 * preemption doesn't flush plug list, so it's possible ctx->cpu is
	 * offline now
	 */
1607
	list_for_each_entry(rq, list, queuelist) {
J
Jens Axboe 已提交
1608
		BUG_ON(rq->mq_ctx != ctx);
1609
		trace_block_rq_insert(hctx->queue, rq);
1610
	}
1611 1612 1613

	spin_lock(&ctx->lock);
	list_splice_tail_init(list, &ctx->rq_list);
1614
	blk_mq_hctx_mark_pending(hctx, ctx);
1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650
	spin_unlock(&ctx->lock);
}

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

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

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

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

	list_sort(NULL, &list, plug_ctx_cmp);

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

	while (!list_empty(&list)) {
		rq = list_entry_rq(list.next);
		list_del_init(&rq->queuelist);
		BUG_ON(!rq->q);
		if (rq->mq_ctx != this_ctx) {
			if (this_ctx) {
1651
				trace_block_unplug(this_q, depth, !from_schedule);
1652 1653 1654
				blk_mq_sched_insert_requests(this_q, this_ctx,
								&ctx_list,
								from_schedule);
1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670
			}

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

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

	/*
	 * If 'this_ctx' is set, we know we have entries to complete
	 * on 'ctx_list'. Do those.
	 */
	if (this_ctx) {
1671
		trace_block_unplug(this_q, depth, !from_schedule);
1672 1673
		blk_mq_sched_insert_requests(this_q, this_ctx, &ctx_list,
						from_schedule);
1674 1675 1676 1677 1678
	}
}

static void blk_mq_bio_to_request(struct request *rq, struct bio *bio)
{
1679
	blk_init_request_from_bio(rq, bio);
1680

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

1683
	blk_account_io_start(rq, true);
1684 1685
}

1686 1687
static blk_qc_t request_to_qc_t(struct blk_mq_hw_ctx *hctx, struct request *rq)
{
1688 1689 1690 1691
	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);
1692 1693
}

1694 1695 1696
static blk_status_t __blk_mq_issue_directly(struct blk_mq_hw_ctx *hctx,
					    struct request *rq,
					    blk_qc_t *cookie)
1697 1698 1699 1700
{
	struct request_queue *q = rq->q;
	struct blk_mq_queue_data bd = {
		.rq = rq,
1701
		.last = true,
1702
	};
1703
	blk_qc_t new_cookie;
1704
	blk_status_t ret;
1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715

	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:
1716
		blk_mq_update_dispatch_busy(hctx, false);
1717 1718 1719
		*cookie = new_cookie;
		break;
	case BLK_STS_RESOURCE:
1720
	case BLK_STS_DEV_RESOURCE:
1721
		blk_mq_update_dispatch_busy(hctx, true);
1722 1723 1724
		__blk_mq_requeue_request(rq);
		break;
	default:
1725
		blk_mq_update_dispatch_busy(hctx, false);
1726 1727 1728 1729 1730 1731 1732 1733 1734
		*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,
1735 1736
						blk_qc_t *cookie,
						bool bypass_insert)
1737 1738
{
	struct request_queue *q = rq->q;
M
Ming Lei 已提交
1739 1740
	bool run_queue = true;

1741 1742 1743 1744
	/*
	 * RCU or SRCU read lock is needed before checking quiesced flag.
	 *
	 * When queue is stopped or quiesced, ignore 'bypass_insert' from
1745
	 * blk_mq_request_issue_directly(), and return BLK_STS_OK to caller,
1746 1747
	 * and avoid driver to try to dispatch again.
	 */
1748
	if (blk_mq_hctx_stopped(hctx) || blk_queue_quiesced(q)) {
M
Ming Lei 已提交
1749
		run_queue = false;
1750
		bypass_insert = false;
M
Ming Lei 已提交
1751 1752
		goto insert;
	}
1753

1754
	if (q->elevator && !bypass_insert)
1755 1756
		goto insert;

1757
	if (!blk_mq_get_dispatch_budget(hctx))
1758 1759
		goto insert;

1760
	if (!blk_mq_get_driver_tag(rq)) {
1761
		blk_mq_put_dispatch_budget(hctx);
1762
		goto insert;
1763
	}
1764

1765
	return __blk_mq_issue_directly(hctx, rq, cookie);
1766
insert:
1767 1768
	if (bypass_insert)
		return BLK_STS_RESOURCE;
1769

1770
	blk_mq_request_bypass_insert(rq, run_queue);
1771
	return BLK_STS_OK;
1772 1773
}

1774 1775 1776
static void blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx,
		struct request *rq, blk_qc_t *cookie)
{
1777
	blk_status_t ret;
1778
	int srcu_idx;
1779

1780
	might_sleep_if(hctx->flags & BLK_MQ_F_BLOCKING);
1781

1782
	hctx_lock(hctx, &srcu_idx);
1783

1784
	ret = __blk_mq_try_issue_directly(hctx, rq, cookie, false);
1785
	if (ret == BLK_STS_RESOURCE || ret == BLK_STS_DEV_RESOURCE)
1786
		blk_mq_request_bypass_insert(rq, true);
1787 1788 1789
	else if (ret != BLK_STS_OK)
		blk_mq_end_request(rq, ret);

1790
	hctx_unlock(hctx, srcu_idx);
1791 1792
}

1793
blk_status_t blk_mq_request_issue_directly(struct request *rq)
1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805
{
	blk_status_t ret;
	int srcu_idx;
	blk_qc_t unused_cookie;
	struct blk_mq_ctx *ctx = rq->mq_ctx;
	struct blk_mq_hw_ctx *hctx = blk_mq_map_queue(rq->q, ctx->cpu);

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

	return ret;
1806 1807
}

1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818
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);
		ret = blk_mq_request_issue_directly(rq);
		if (ret != BLK_STS_OK) {
1819 1820
			if (ret == BLK_STS_RESOURCE ||
					ret == BLK_STS_DEV_RESOURCE) {
1821 1822
				blk_mq_request_bypass_insert(rq,
							list_empty(list));
1823 1824 1825
				break;
			}
			blk_mq_end_request(rq, ret);
1826 1827 1828 1829
		}
	}
}

1830
static blk_qc_t blk_mq_make_request(struct request_queue *q, struct bio *bio)
1831
{
1832
	const int is_sync = op_is_sync(bio->bi_opf);
1833
	const int is_flush_fua = op_is_flush(bio->bi_opf);
1834
	struct blk_mq_alloc_data data = { .flags = 0 };
1835
	struct request *rq;
1836
	unsigned int request_count = 0;
1837
	struct blk_plug *plug;
1838
	struct request *same_queue_rq = NULL;
1839
	blk_qc_t cookie;
1840 1841 1842

	blk_queue_bounce(q, &bio);

1843
	blk_queue_split(q, &bio);
1844

1845
	if (!bio_integrity_prep(bio))
1846
		return BLK_QC_T_NONE;
1847

1848 1849 1850
	if (!is_flush_fua && !blk_queue_nomerges(q) &&
	    blk_attempt_plug_merge(q, bio, &request_count, &same_queue_rq))
		return BLK_QC_T_NONE;
1851

1852 1853 1854
	if (blk_mq_sched_bio_merge(q, bio))
		return BLK_QC_T_NONE;

1855
	rq_qos_throttle(q, bio, NULL);
J
Jens Axboe 已提交
1856

1857 1858
	trace_block_getrq(q, bio, bio->bi_opf);

1859
	rq = blk_mq_get_request(q, bio, bio->bi_opf, &data);
J
Jens Axboe 已提交
1860
	if (unlikely(!rq)) {
1861
		rq_qos_cleanup(q, bio);
1862 1863
		if (bio->bi_opf & REQ_NOWAIT)
			bio_wouldblock_error(bio);
1864
		return BLK_QC_T_NONE;
J
Jens Axboe 已提交
1865 1866
	}

1867
	rq_qos_track(q, rq, bio);
1868

1869
	cookie = request_to_qc_t(data.hctx, rq);
1870

1871
	plug = current->plug;
1872
	if (unlikely(is_flush_fua)) {
1873
		blk_mq_put_ctx(data.ctx);
1874
		blk_mq_bio_to_request(rq, bio);
1875 1876 1877 1878

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

1882
		blk_mq_put_ctx(data.ctx);
1883
		blk_mq_bio_to_request(rq, bio);
1884 1885 1886 1887 1888 1889 1890

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

M
Ming Lei 已提交
1894
		if (!request_count)
1895
			trace_block_plug(q);
1896 1897
		else
			last = list_entry_rq(plug->mq_list.prev);
1898

1899 1900
		if (request_count >= BLK_MAX_REQUEST_COUNT || (last &&
		    blk_rq_bytes(last) >= BLK_PLUG_FLUSH_SIZE)) {
1901 1902
			blk_flush_plug_list(plug, false);
			trace_block_plug(q);
1903
		}
1904

1905
		list_add_tail(&rq->queuelist, &plug->mq_list);
1906
	} else if (plug && !blk_queue_nomerges(q)) {
1907
		blk_mq_bio_to_request(rq, bio);
1908 1909

		/*
1910
		 * We do limited plugging. If the bio can be merged, do that.
1911 1912
		 * Otherwise the existing request in the plug list will be
		 * issued. So the plug list will have one request at most
1913 1914
		 * The plug list might get flushed before this. If that happens,
		 * the plug list is empty, and same_queue_rq is invalid.
1915
		 */
1916 1917 1918 1919 1920 1921
		if (list_empty(&plug->mq_list))
			same_queue_rq = NULL;
		if (same_queue_rq)
			list_del_init(&same_queue_rq->queuelist);
		list_add_tail(&rq->queuelist, &plug->mq_list);

1922 1923
		blk_mq_put_ctx(data.ctx);

1924 1925 1926
		if (same_queue_rq) {
			data.hctx = blk_mq_map_queue(q,
					same_queue_rq->mq_ctx->cpu);
1927 1928
			blk_mq_try_issue_directly(data.hctx, same_queue_rq,
					&cookie);
1929
		}
1930 1931
	} else if ((q->nr_hw_queues > 1 && is_sync) || (!q->elevator &&
			!data.hctx->dispatch_busy)) {
1932
		blk_mq_put_ctx(data.ctx);
1933 1934
		blk_mq_bio_to_request(rq, bio);
		blk_mq_try_issue_directly(data.hctx, rq, &cookie);
1935
	} else {
1936
		blk_mq_put_ctx(data.ctx);
1937
		blk_mq_bio_to_request(rq, bio);
1938
		blk_mq_sched_insert_request(rq, false, true, true);
1939
	}
1940

1941
	return cookie;
1942 1943
}

1944 1945
void blk_mq_free_rqs(struct blk_mq_tag_set *set, struct blk_mq_tags *tags,
		     unsigned int hctx_idx)
1946
{
1947
	struct page *page;
1948

1949
	if (tags->rqs && set->ops->exit_request) {
1950
		int i;
1951

1952
		for (i = 0; i < tags->nr_tags; i++) {
J
Jens Axboe 已提交
1953 1954 1955
			struct request *rq = tags->static_rqs[i];

			if (!rq)
1956
				continue;
1957
			set->ops->exit_request(set, rq, hctx_idx);
J
Jens Axboe 已提交
1958
			tags->static_rqs[i] = NULL;
1959
		}
1960 1961
	}

1962 1963
	while (!list_empty(&tags->page_list)) {
		page = list_first_entry(&tags->page_list, struct page, lru);
1964
		list_del_init(&page->lru);
1965 1966 1967 1968 1969
		/*
		 * Remove kmemleak object previously allocated in
		 * blk_mq_init_rq_map().
		 */
		kmemleak_free(page_address(page));
1970 1971
		__free_pages(page, page->private);
	}
1972
}
1973

1974 1975
void blk_mq_free_rq_map(struct blk_mq_tags *tags)
{
1976
	kfree(tags->rqs);
1977
	tags->rqs = NULL;
J
Jens Axboe 已提交
1978 1979
	kfree(tags->static_rqs);
	tags->static_rqs = NULL;
1980

1981
	blk_mq_free_tags(tags);
1982 1983
}

1984 1985 1986 1987
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)
1988
{
1989
	struct blk_mq_tags *tags;
1990
	int node;
1991

1992 1993 1994 1995 1996
	node = blk_mq_hw_queue_to_node(set->mq_map, hctx_idx);
	if (node == NUMA_NO_NODE)
		node = set->numa_node;

	tags = blk_mq_init_tags(nr_tags, reserved_tags, node,
S
Shaohua Li 已提交
1997
				BLK_MQ_FLAG_TO_ALLOC_POLICY(set->flags));
1998 1999
	if (!tags)
		return NULL;
2000

2001
	tags->rqs = kcalloc_node(nr_tags, sizeof(struct request *),
2002
				 GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY,
2003
				 node);
2004 2005 2006 2007
	if (!tags->rqs) {
		blk_mq_free_tags(tags);
		return NULL;
	}
2008

2009 2010 2011
	tags->static_rqs = kcalloc_node(nr_tags, sizeof(struct request *),
					GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY,
					node);
J
Jens Axboe 已提交
2012 2013 2014 2015 2016 2017
	if (!tags->static_rqs) {
		kfree(tags->rqs);
		blk_mq_free_tags(tags);
		return NULL;
	}

2018 2019 2020 2021 2022 2023 2024 2025
	return tags;
}

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

2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036
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 已提交
2037
	WRITE_ONCE(rq->state, MQ_RQ_IDLE);
2038 2039 2040
	return 0;
}

2041 2042 2043 2044 2045
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;
2046 2047 2048 2049 2050
	int node;

	node = blk_mq_hw_queue_to_node(set->mq_map, hctx_idx);
	if (node == NUMA_NO_NODE)
		node = set->numa_node;
2051 2052 2053

	INIT_LIST_HEAD(&tags->page_list);

2054 2055 2056 2057
	/*
	 * rq_size is the size of the request plus driver payload, rounded
	 * to the cacheline size
	 */
2058
	rq_size = round_up(sizeof(struct request) + set->cmd_size,
2059
				cache_line_size());
2060
	left = rq_size * depth;
2061

2062
	for (i = 0; i < depth; ) {
2063 2064 2065 2066 2067
		int this_order = max_order;
		struct page *page;
		int to_do;
		void *p;

2068
		while (this_order && left < order_to_size(this_order - 1))
2069 2070 2071
			this_order--;

		do {
2072
			page = alloc_pages_node(node,
2073
				GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY | __GFP_ZERO,
2074
				this_order);
2075 2076 2077 2078 2079 2080 2081 2082 2083
			if (page)
				break;
			if (!this_order--)
				break;
			if (order_to_size(this_order) < rq_size)
				break;
		} while (1);

		if (!page)
2084
			goto fail;
2085 2086

		page->private = this_order;
2087
		list_add_tail(&page->lru, &tags->page_list);
2088 2089

		p = page_address(page);
2090 2091 2092 2093
		/*
		 * Allow kmemleak to scan these pages as they contain pointers
		 * to additional allocations like via ops->init_request().
		 */
2094
		kmemleak_alloc(p, order_to_size(this_order), 1, GFP_NOIO);
2095
		entries_per_page = order_to_size(this_order) / rq_size;
2096
		to_do = min(entries_per_page, depth - i);
2097 2098
		left -= to_do * rq_size;
		for (j = 0; j < to_do; j++) {
J
Jens Axboe 已提交
2099 2100 2101
			struct request *rq = p;

			tags->static_rqs[i] = rq;
2102 2103 2104
			if (blk_mq_init_request(set, rq, hctx_idx, node)) {
				tags->static_rqs[i] = NULL;
				goto fail;
2105 2106
			}

2107 2108 2109 2110
			p += rq_size;
			i++;
		}
	}
2111
	return 0;
2112

2113
fail:
2114 2115
	blk_mq_free_rqs(set, tags, hctx_idx);
	return -ENOMEM;
2116 2117
}

J
Jens Axboe 已提交
2118 2119 2120 2121 2122
/*
 * '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.
 */
2123
static int blk_mq_hctx_notify_dead(unsigned int cpu, struct hlist_node *node)
2124
{
2125
	struct blk_mq_hw_ctx *hctx;
2126 2127 2128
	struct blk_mq_ctx *ctx;
	LIST_HEAD(tmp);

2129
	hctx = hlist_entry_safe(node, struct blk_mq_hw_ctx, cpuhp_dead);
J
Jens Axboe 已提交
2130
	ctx = __blk_mq_get_ctx(hctx->queue, cpu);
2131 2132 2133 2134 2135 2136 2137 2138 2139

	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))
2140
		return 0;
2141

J
Jens Axboe 已提交
2142 2143 2144
	spin_lock(&hctx->lock);
	list_splice_tail_init(&tmp, &hctx->dispatch);
	spin_unlock(&hctx->lock);
2145 2146

	blk_mq_run_hw_queue(hctx, true);
2147
	return 0;
2148 2149
}

2150
static void blk_mq_remove_cpuhp(struct blk_mq_hw_ctx *hctx)
2151
{
2152 2153
	cpuhp_state_remove_instance_nocalls(CPUHP_BLK_MQ_DEAD,
					    &hctx->cpuhp_dead);
2154 2155
}

2156
/* hctx->ctxs will be freed in queue's release handler */
2157 2158 2159 2160
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)
{
2161 2162
	blk_mq_debugfs_unregister_hctx(hctx);

2163 2164
	if (blk_mq_hw_queue_mapped(hctx))
		blk_mq_tag_idle(hctx);
2165

2166
	if (set->ops->exit_request)
2167
		set->ops->exit_request(set, hctx->fq->flush_rq, hctx_idx);
2168

2169 2170 2171
	if (set->ops->exit_hctx)
		set->ops->exit_hctx(hctx, hctx_idx);

2172
	blk_mq_remove_cpuhp(hctx);
2173 2174
}

M
Ming Lei 已提交
2175 2176 2177 2178 2179 2180 2181 2182 2183
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;
2184
		blk_mq_exit_hctx(q, set, hctx, i);
M
Ming Lei 已提交
2185 2186 2187
	}
}

2188 2189 2190
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)
2191
{
2192 2193 2194 2195 2196 2197
	int node;

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

2198
	INIT_DELAYED_WORK(&hctx->run_work, blk_mq_run_work_fn);
2199 2200 2201
	spin_lock_init(&hctx->lock);
	INIT_LIST_HEAD(&hctx->dispatch);
	hctx->queue = q;
2202
	hctx->flags = set->flags & ~BLK_MQ_F_TAG_SHARED;
2203

2204
	cpuhp_state_add_instance_nocalls(CPUHP_BLK_MQ_DEAD, &hctx->cpuhp_dead);
2205 2206

	hctx->tags = set->tags[hctx_idx];
2207 2208

	/*
2209 2210
	 * Allocate space for all possible cpus to avoid allocation at
	 * runtime
2211
	 */
2212
	hctx->ctxs = kmalloc_array_node(nr_cpu_ids, sizeof(void *),
2213
			GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY, node);
2214 2215
	if (!hctx->ctxs)
		goto unregister_cpu_notifier;
2216

2217 2218
	if (sbitmap_init_node(&hctx->ctx_map, nr_cpu_ids, ilog2(8),
				GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY, node))
2219
		goto free_ctxs;
2220

2221
	hctx->nr_ctx = 0;
2222

2223
	spin_lock_init(&hctx->dispatch_wait_lock);
2224 2225 2226
	init_waitqueue_func_entry(&hctx->dispatch_wait, blk_mq_dispatch_wake);
	INIT_LIST_HEAD(&hctx->dispatch_wait.entry);

2227 2228 2229
	if (set->ops->init_hctx &&
	    set->ops->init_hctx(hctx, set->driver_data, hctx_idx))
		goto free_bitmap;
2230

2231 2232
	hctx->fq = blk_alloc_flush_queue(q, hctx->numa_node, set->cmd_size,
			GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY);
2233
	if (!hctx->fq)
2234
		goto exit_hctx;
2235

2236
	if (blk_mq_init_request(set, hctx->fq->flush_rq, hctx_idx, node))
2237
		goto free_fq;
2238

2239
	if (hctx->flags & BLK_MQ_F_BLOCKING)
2240
		init_srcu_struct(hctx->srcu);
2241

2242 2243
	blk_mq_debugfs_register_hctx(q, hctx);

2244
	return 0;
2245

2246
 free_fq:
2247
	blk_free_flush_queue(hctx->fq);
2248 2249 2250
 exit_hctx:
	if (set->ops->exit_hctx)
		set->ops->exit_hctx(hctx, hctx_idx);
2251
 free_bitmap:
2252
	sbitmap_free(&hctx->ctx_map);
2253 2254 2255
 free_ctxs:
	kfree(hctx->ctxs);
 unregister_cpu_notifier:
2256
	blk_mq_remove_cpuhp(hctx);
2257 2258
	return -1;
}
2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277

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

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

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

		/*
		 * Set local node, IFF we have more than one hw queue. If
		 * not, we remain on the home node of the device
		 */
2278
		hctx = blk_mq_map_queue(q, i);
2279
		if (nr_hw_queues > 1 && hctx->numa_node == NUMA_NO_NODE)
2280
			hctx->numa_node = local_memory_node(cpu_to_node(i));
2281 2282 2283
	}
}

2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305
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)
{
2306 2307 2308 2309 2310
	if (set->tags[hctx_idx]) {
		blk_mq_free_rqs(set, set->tags[hctx_idx], hctx_idx);
		blk_mq_free_rq_map(set->tags[hctx_idx]);
		set->tags[hctx_idx] = NULL;
	}
2311 2312
}

2313
static void blk_mq_map_swqueue(struct request_queue *q)
2314
{
2315
	unsigned int i, hctx_idx;
2316 2317
	struct blk_mq_hw_ctx *hctx;
	struct blk_mq_ctx *ctx;
M
Ming Lei 已提交
2318
	struct blk_mq_tag_set *set = q->tag_set;
2319

2320 2321 2322 2323 2324
	/*
	 * Avoid others reading imcomplete hctx->cpumask through sysfs
	 */
	mutex_lock(&q->sysfs_lock);

2325
	queue_for_each_hw_ctx(q, hctx, i) {
2326
		cpumask_clear(hctx->cpumask);
2327
		hctx->nr_ctx = 0;
2328
		hctx->dispatch_from = NULL;
2329 2330 2331
	}

	/*
2332
	 * Map software to hardware queues.
2333 2334
	 *
	 * If the cpu isn't present, the cpu is mapped to first hctx.
2335
	 */
2336
	for_each_possible_cpu(i) {
2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349
		hctx_idx = q->mq_map[i];
		/* 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
			 */
			q->mq_map[i] = 0;
		}

2350
		ctx = per_cpu_ptr(q->queue_ctx, i);
C
Christoph Hellwig 已提交
2351
		hctx = blk_mq_map_queue(q, i);
K
Keith Busch 已提交
2352

2353
		cpumask_set_cpu(i, hctx->cpumask);
2354 2355 2356
		ctx->index_hw = hctx->nr_ctx;
		hctx->ctxs[hctx->nr_ctx++] = ctx;
	}
2357

2358 2359
	mutex_unlock(&q->sysfs_lock);

2360
	queue_for_each_hw_ctx(q, hctx, i) {
2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375
		/*
		 * 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;
		}
2376

M
Ming Lei 已提交
2377 2378 2379
		hctx->tags = set->tags[i];
		WARN_ON(!hctx->tags);

2380 2381 2382 2383 2384
		/*
		 * 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.
		 */
2385
		sbitmap_resize(&hctx->ctx_map, hctx->nr_ctx);
2386

2387 2388 2389
		/*
		 * Initialize batch roundrobin counts
		 */
2390
		hctx->next_cpu = blk_mq_first_mapped_cpu(hctx);
2391 2392
		hctx->next_cpu_batch = BLK_MQ_CPU_WORK_BATCH;
	}
2393 2394
}

2395 2396 2397 2398
/*
 * Caller needs to ensure that we're either frozen/quiesced, or that
 * the queue isn't live yet.
 */
2399
static void queue_set_hctx_shared(struct request_queue *q, bool shared)
2400 2401 2402 2403
{
	struct blk_mq_hw_ctx *hctx;
	int i;

2404
	queue_for_each_hw_ctx(q, hctx, i) {
2405
		if (shared)
2406
			hctx->flags |= BLK_MQ_F_TAG_SHARED;
2407
		else
2408 2409 2410 2411
			hctx->flags &= ~BLK_MQ_F_TAG_SHARED;
	}
}

2412 2413
static void blk_mq_update_tag_set_depth(struct blk_mq_tag_set *set,
					bool shared)
2414 2415
{
	struct request_queue *q;
2416

2417 2418
	lockdep_assert_held(&set->tag_list_lock);

2419 2420
	list_for_each_entry(q, &set->tag_list, tag_set_list) {
		blk_mq_freeze_queue(q);
2421
		queue_set_hctx_shared(q, shared);
2422 2423 2424 2425 2426 2427 2428 2429 2430
		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);
2431
	list_del_rcu(&q->tag_set_list);
2432 2433 2434 2435 2436 2437
	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);
	}
2438
	mutex_unlock(&set->tag_list_lock);
2439
	INIT_LIST_HEAD(&q->tag_set_list);
2440 2441 2442 2443 2444 2445 2446 2447
}

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

	mutex_lock(&set->tag_list_lock);
2448

2449 2450 2451 2452 2453
	/*
	 * 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)) {
2454 2455 2456 2457 2458 2459
		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);
2460
	list_add_tail_rcu(&q->tag_set_list, &set->tag_list);
2461

2462 2463 2464
	mutex_unlock(&set->tag_list_lock);
}

2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476
/*
 * 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 */
2477 2478 2479
	queue_for_each_hw_ctx(q, hctx, i) {
		if (!hctx)
			continue;
2480
		kobject_put(&hctx->kobj);
2481
	}
2482

2483 2484
	q->mq_map = NULL;

2485 2486
	kfree(q->queue_hw_ctx);

2487 2488 2489 2490 2491 2492
	/*
	 * release .mq_kobj and sw queue's kobject now because
	 * both share lifetime with request queue.
	 */
	blk_mq_sysfs_deinit(q);

2493 2494 2495
	free_percpu(q->queue_ctx);
}

2496
struct request_queue *blk_mq_init_queue(struct blk_mq_tag_set *set)
2497 2498 2499
{
	struct request_queue *uninit_q, *q;

2500
	uninit_q = blk_alloc_queue_node(GFP_KERNEL, set->numa_node, NULL);
2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511
	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);

2512 2513 2514 2515
static int blk_mq_hw_ctx_size(struct blk_mq_tag_set *tag_set)
{
	int hw_ctx_size = sizeof(struct blk_mq_hw_ctx);

2516
	BUILD_BUG_ON(ALIGN(offsetof(struct blk_mq_hw_ctx, srcu),
2517 2518 2519 2520 2521 2522 2523 2524 2525
			   __alignof__(struct blk_mq_hw_ctx)) !=
		     sizeof(struct blk_mq_hw_ctx));

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

	return hw_ctx_size;
}

K
Keith Busch 已提交
2526 2527
static void blk_mq_realloc_hw_ctxs(struct blk_mq_tag_set *set,
						struct request_queue *q)
2528
{
K
Keith Busch 已提交
2529 2530
	int i, j;
	struct blk_mq_hw_ctx **hctxs = q->queue_hw_ctx;
2531

K
Keith Busch 已提交
2532
	blk_mq_sysfs_unregister(q);
2533 2534 2535

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

K
Keith Busch 已提交
2539 2540 2541 2542
		if (hctxs[i])
			continue;

		node = blk_mq_hw_queue_to_node(q->mq_map, i);
2543
		hctxs[i] = kzalloc_node(blk_mq_hw_ctx_size(set),
2544 2545
				GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY,
				node);
2546
		if (!hctxs[i])
K
Keith Busch 已提交
2547
			break;
2548

2549 2550 2551
		if (!zalloc_cpumask_var_node(&hctxs[i]->cpumask,
					GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY,
					node)) {
K
Keith Busch 已提交
2552 2553 2554 2555
			kfree(hctxs[i]);
			hctxs[i] = NULL;
			break;
		}
2556

2557
		atomic_set(&hctxs[i]->nr_active, 0);
2558
		hctxs[i]->numa_node = node;
2559
		hctxs[i]->queue_num = i;
K
Keith Busch 已提交
2560 2561 2562 2563 2564 2565 2566 2567

		if (blk_mq_init_hctx(q, set, hctxs[i], i)) {
			free_cpumask_var(hctxs[i]->cpumask);
			kfree(hctxs[i]);
			hctxs[i] = NULL;
			break;
		}
		blk_mq_hctx_kobj_init(hctxs[i]);
2568
	}
K
Keith Busch 已提交
2569 2570 2571 2572
	for (j = i; j < q->nr_hw_queues; j++) {
		struct blk_mq_hw_ctx *hctx = hctxs[j];

		if (hctx) {
2573 2574
			if (hctx->tags)
				blk_mq_free_map_and_requests(set, j);
K
Keith Busch 已提交
2575 2576 2577 2578 2579 2580 2581
			blk_mq_exit_hctx(q, set, hctx, j);
			kobject_put(&hctx->kobj);
			hctxs[j] = NULL;

		}
	}
	q->nr_hw_queues = i;
2582
	mutex_unlock(&q->sysfs_lock);
K
Keith Busch 已提交
2583 2584 2585 2586 2587 2588
	blk_mq_sysfs_register(q);
}

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

2592
	q->poll_cb = blk_stat_alloc_callback(blk_mq_poll_stats_fn,
2593 2594
					     blk_mq_poll_stats_bkt,
					     BLK_MQ_POLL_STATS_BKTS, q);
2595 2596 2597
	if (!q->poll_cb)
		goto err_exit;

K
Keith Busch 已提交
2598 2599
	q->queue_ctx = alloc_percpu(struct blk_mq_ctx);
	if (!q->queue_ctx)
M
Ming Lin 已提交
2600
		goto err_exit;
K
Keith Busch 已提交
2601

2602 2603 2604
	/* init q->mq_kobj and sw queues' kobjects */
	blk_mq_sysfs_init(q);

2605
	q->queue_hw_ctx = kcalloc_node(nr_cpu_ids, sizeof(*(q->queue_hw_ctx)),
K
Keith Busch 已提交
2606 2607 2608 2609
						GFP_KERNEL, set->numa_node);
	if (!q->queue_hw_ctx)
		goto err_percpu;

2610
	q->mq_map = set->mq_map;
K
Keith Busch 已提交
2611 2612 2613 2614

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

2616
	INIT_WORK(&q->timeout_work, blk_mq_timeout_work);
2617
	blk_queue_rq_timeout(q, set->timeout ? set->timeout : 30 * HZ);
2618 2619 2620

	q->nr_queues = nr_cpu_ids;

2621
	q->queue_flags |= QUEUE_FLAG_MQ_DEFAULT;
2622

2623
	if (!(set->flags & BLK_MQ_F_SG_MERGE))
2624
		queue_flag_set_unlocked(QUEUE_FLAG_NO_SG_MERGE, q);
2625

2626 2627
	q->sg_reserved_size = INT_MAX;

2628
	INIT_DELAYED_WORK(&q->requeue_work, blk_mq_requeue_work);
2629 2630 2631
	INIT_LIST_HEAD(&q->requeue_list);
	spin_lock_init(&q->requeue_lock);

2632
	blk_queue_make_request(q, blk_mq_make_request);
2633 2634
	if (q->mq_ops->poll)
		q->poll_fn = blk_mq_poll;
2635

2636 2637 2638 2639 2640
	/*
	 * Do this after blk_queue_make_request() overrides it...
	 */
	q->nr_requests = set->queue_depth;

2641 2642 2643 2644 2645
	/*
	 * Default to classic polling
	 */
	q->poll_nsec = -1;

2646 2647
	if (set->ops->complete)
		blk_queue_softirq_done(q, set->ops->complete);
2648

2649
	blk_mq_init_cpu_queues(q, set->nr_hw_queues);
2650
	blk_mq_add_queue_tag_set(set, q);
2651
	blk_mq_map_swqueue(q);
2652

2653 2654 2655
	if (!(set->flags & BLK_MQ_F_NO_SCHED)) {
		int ret;

2656
		ret = elevator_init_mq(q);
2657 2658 2659 2660
		if (ret)
			return ERR_PTR(ret);
	}

2661
	return q;
2662

2663
err_hctxs:
K
Keith Busch 已提交
2664
	kfree(q->queue_hw_ctx);
2665
err_percpu:
K
Keith Busch 已提交
2666
	free_percpu(q->queue_ctx);
M
Ming Lin 已提交
2667 2668
err_exit:
	q->mq_ops = NULL;
2669 2670
	return ERR_PTR(-ENOMEM);
}
2671
EXPORT_SYMBOL(blk_mq_init_allocated_queue);
2672

2673 2674
/* tags can _not_ be used after returning from blk_mq_exit_queue */
void blk_mq_exit_queue(struct request_queue *q)
2675
{
M
Ming Lei 已提交
2676
	struct blk_mq_tag_set	*set = q->tag_set;
2677

2678
	blk_mq_del_queue_tag_set(q);
M
Ming Lei 已提交
2679
	blk_mq_exit_hw_queues(q, set, set->nr_hw_queues);
2680 2681 2682
}

/* Basically redo blk_mq_init_queue with queue frozen */
2683
static void blk_mq_queue_reinit(struct request_queue *q)
2684
{
2685
	WARN_ON_ONCE(!atomic_read(&q->mq_freeze_depth));
2686

2687
	blk_mq_debugfs_unregister_hctxs(q);
2688 2689
	blk_mq_sysfs_unregister(q);

2690 2691
	/*
	 * redo blk_mq_init_cpu_queues and blk_mq_init_hw_queues. FIXME: maybe
2692 2693
	 * we should change hctx numa_node according to the new topology (this
	 * involves freeing and re-allocating memory, worth doing?)
2694
	 */
2695
	blk_mq_map_swqueue(q);
2696

2697
	blk_mq_sysfs_register(q);
2698
	blk_mq_debugfs_register_hctxs(q);
2699 2700
}

2701 2702 2703 2704
static int __blk_mq_alloc_rq_maps(struct blk_mq_tag_set *set)
{
	int i;

2705 2706
	for (i = 0; i < set->nr_hw_queues; i++)
		if (!__blk_mq_alloc_rq_map(set, i))
2707 2708 2709 2710 2711 2712
			goto out_unwind;

	return 0;

out_unwind:
	while (--i >= 0)
2713
		blk_mq_free_rq_map(set->tags[i]);
2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752

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

2753 2754
static int blk_mq_update_queue_map(struct blk_mq_tag_set *set)
{
2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769
	if (set->ops->map_queues) {
		/*
		 * transport .map_queues is usually done in the following
		 * way:
		 *
		 * for (queue = 0; queue < set->nr_hw_queues; queue++) {
		 * 	mask = get_cpu_mask(queue)
		 * 	for_each_cpu(cpu, mask)
		 * 		set->mq_map[cpu] = queue;
		 * }
		 *
		 * When we need to remap, the table has to be cleared for
		 * killing stale mapping since one CPU may not be mapped
		 * to any hw queue.
		 */
2770
		blk_mq_clear_mq_map(set);
2771

2772
		return set->ops->map_queues(set);
2773
	} else
2774 2775 2776
		return blk_mq_map_queues(set);
}

2777 2778 2779
/*
 * Alloc a tag set to be associated with one or more request queues.
 * May fail with EINVAL for various error conditions. May adjust the
2780
 * requested depth down, if it's too large. In that case, the set
2781 2782
 * value will be stored in set->queue_depth.
 */
2783 2784
int blk_mq_alloc_tag_set(struct blk_mq_tag_set *set)
{
2785 2786
	int ret;

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

2789 2790
	if (!set->nr_hw_queues)
		return -EINVAL;
2791
	if (!set->queue_depth)
2792 2793 2794 2795
		return -EINVAL;
	if (set->queue_depth < set->reserved_tags + BLK_MQ_TAG_MIN)
		return -EINVAL;

C
Christoph Hellwig 已提交
2796
	if (!set->ops->queue_rq)
2797 2798
		return -EINVAL;

2799 2800 2801
	if (!set->ops->get_budget ^ !set->ops->put_budget)
		return -EINVAL;

2802 2803 2804 2805 2806
	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;
	}
2807

2808 2809 2810 2811 2812 2813 2814 2815 2816
	/*
	 * 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 已提交
2817 2818 2819 2820 2821
	/*
	 * There is no use for more h/w queues than cpus.
	 */
	if (set->nr_hw_queues > nr_cpu_ids)
		set->nr_hw_queues = nr_cpu_ids;
2822

2823
	set->tags = kcalloc_node(nr_cpu_ids, sizeof(struct blk_mq_tags *),
2824 2825
				 GFP_KERNEL, set->numa_node);
	if (!set->tags)
2826
		return -ENOMEM;
2827

2828
	ret = -ENOMEM;
2829 2830
	set->mq_map = kcalloc_node(nr_cpu_ids, sizeof(*set->mq_map),
				   GFP_KERNEL, set->numa_node);
2831 2832 2833
	if (!set->mq_map)
		goto out_free_tags;

2834
	ret = blk_mq_update_queue_map(set);
2835 2836 2837 2838 2839
	if (ret)
		goto out_free_mq_map;

	ret = blk_mq_alloc_rq_maps(set);
	if (ret)
2840
		goto out_free_mq_map;
2841

2842 2843 2844
	mutex_init(&set->tag_list_lock);
	INIT_LIST_HEAD(&set->tag_list);

2845
	return 0;
2846 2847 2848 2849 2850

out_free_mq_map:
	kfree(set->mq_map);
	set->mq_map = NULL;
out_free_tags:
2851 2852
	kfree(set->tags);
	set->tags = NULL;
2853
	return ret;
2854 2855 2856 2857 2858 2859 2860
}
EXPORT_SYMBOL(blk_mq_alloc_tag_set);

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

2861 2862
	for (i = 0; i < nr_cpu_ids; i++)
		blk_mq_free_map_and_requests(set, i);
2863

2864 2865 2866
	kfree(set->mq_map);
	set->mq_map = NULL;

M
Ming Lei 已提交
2867
	kfree(set->tags);
2868
	set->tags = NULL;
2869 2870 2871
}
EXPORT_SYMBOL(blk_mq_free_tag_set);

2872 2873 2874 2875 2876 2877
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;

2878
	if (!set)
2879 2880
		return -EINVAL;

2881
	blk_mq_freeze_queue(q);
2882
	blk_mq_quiesce_queue(q);
2883

2884 2885
	ret = 0;
	queue_for_each_hw_ctx(q, hctx, i) {
2886 2887
		if (!hctx->tags)
			continue;
2888 2889 2890 2891
		/*
		 * If we're using an MQ scheduler, just update the scheduler
		 * queue depth. This is similar to what the old code would do.
		 */
2892
		if (!hctx->sched_tags) {
2893
			ret = blk_mq_tag_update_depth(hctx, &hctx->tags, nr,
2894 2895 2896 2897 2898
							false);
		} else {
			ret = blk_mq_tag_update_depth(hctx, &hctx->sched_tags,
							nr, true);
		}
2899 2900
		if (ret)
			break;
2901 2902
		if (q->elevator && q->elevator->type->ops.mq.depth_updated)
			q->elevator->type->ops.mq.depth_updated(hctx);
2903 2904 2905 2906 2907
	}

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

2908
	blk_mq_unquiesce_queue(q);
2909 2910
	blk_mq_unfreeze_queue(q);

2911 2912 2913
	return ret;
}

2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983
/*
 * 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);
}

2984 2985
static void __blk_mq_update_nr_hw_queues(struct blk_mq_tag_set *set,
							int nr_hw_queues)
K
Keith Busch 已提交
2986 2987
{
	struct request_queue *q;
2988
	LIST_HEAD(head);
K
Keith Busch 已提交
2989

2990 2991
	lockdep_assert_held(&set->tag_list_lock);

K
Keith Busch 已提交
2992 2993 2994 2995 2996 2997 2998
	if (nr_hw_queues > nr_cpu_ids)
		nr_hw_queues = nr_cpu_ids;
	if (nr_hw_queues < 1 || nr_hw_queues == set->nr_hw_queues)
		return;

	list_for_each_entry(q, &set->tag_list, tag_set_list)
		blk_mq_freeze_queue(q);
2999 3000 3001 3002
	/*
	 * Sync with blk_mq_queue_tag_busy_iter.
	 */
	synchronize_rcu();
3003 3004 3005 3006 3007 3008 3009 3010
	/*
	 * 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 已提交
3011 3012

	set->nr_hw_queues = nr_hw_queues;
3013
	blk_mq_update_queue_map(set);
K
Keith Busch 已提交
3014 3015
	list_for_each_entry(q, &set->tag_list, tag_set_list) {
		blk_mq_realloc_hw_ctxs(set, q);
3016
		blk_mq_queue_reinit(q);
K
Keith Busch 已提交
3017 3018
	}

3019 3020 3021 3022
switch_back:
	list_for_each_entry(q, &set->tag_list, tag_set_list)
		blk_mq_elv_switch_back(&head, q);

K
Keith Busch 已提交
3023 3024 3025
	list_for_each_entry(q, &set->tag_list, tag_set_list)
		blk_mq_unfreeze_queue(q);
}
3026 3027 3028 3029 3030 3031 3032

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

3035 3036 3037 3038
/* 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) ||
3039
	    blk_queue_flag_test_and_set(QUEUE_FLAG_POLL_STATS, q))
3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060
		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;
3061
	int bucket;
3062

3063 3064 3065 3066
	for (bucket = 0; bucket < BLK_MQ_POLL_STATS_BKTS; bucket++) {
		if (cb->stat[bucket].nr_samples)
			q->poll_stat[bucket] = cb->stat[bucket];
	}
3067 3068
}

3069 3070 3071 3072 3073
static unsigned long blk_mq_poll_nsecs(struct request_queue *q,
				       struct blk_mq_hw_ctx *hctx,
				       struct request *rq)
{
	unsigned long ret = 0;
3074
	int bucket;
3075 3076 3077 3078 3079

	/*
	 * If stats collection isn't on, don't sleep but turn it on for
	 * future users
	 */
3080
	if (!blk_poll_stats_enable(q))
3081 3082 3083 3084 3085 3086 3087 3088
		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
3089 3090
	 * than ~10 usec. We do use the stats for the relevant IO size
	 * if available which does lead to better estimates.
3091
	 */
3092 3093 3094 3095 3096 3097
	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;
3098 3099 3100 3101

	return ret;
}

3102
static bool blk_mq_poll_hybrid_sleep(struct request_queue *q,
3103
				     struct blk_mq_hw_ctx *hctx,
3104 3105 3106 3107
				     struct request *rq)
{
	struct hrtimer_sleeper hs;
	enum hrtimer_mode mode;
3108
	unsigned int nsecs;
3109 3110
	ktime_t kt;

J
Jens Axboe 已提交
3111
	if (rq->rq_flags & RQF_MQ_POLL_SLEPT)
3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128
		return false;

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

	if (!nsecs)
3129 3130
		return false;

J
Jens Axboe 已提交
3131
	rq->rq_flags |= RQF_MQ_POLL_SLEPT;
3132 3133 3134 3135 3136

	/*
	 * This will be replaced with the stats tracking code, using
	 * 'avg_completion_time / 2' as the pre-sleep target.
	 */
T
Thomas Gleixner 已提交
3137
	kt = nsecs;
3138 3139 3140 3141 3142 3143 3144

	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 已提交
3145
		if (blk_mq_rq_state(rq) == MQ_RQ_COMPLETE)
3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159
			break;
		set_current_state(TASK_UNINTERRUPTIBLE);
		hrtimer_start_expires(&hs.timer, mode);
		if (hs.task)
			io_schedule();
		hrtimer_cancel(&hs.timer);
		mode = HRTIMER_MODE_ABS;
	} while (hs.task && !signal_pending(current));

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

J
Jens Axboe 已提交
3160 3161 3162 3163 3164
static bool __blk_mq_poll(struct blk_mq_hw_ctx *hctx, struct request *rq)
{
	struct request_queue *q = hctx->queue;
	long state;

3165 3166 3167 3168 3169 3170 3171
	/*
	 * 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.
	 */
3172
	if (blk_mq_poll_hybrid_sleep(q, hctx, rq))
3173 3174
		return true;

J
Jens Axboe 已提交
3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199
	hctx->poll_considered++;

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

		hctx->poll_invoked++;

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

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

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

3200
	__set_current_state(TASK_RUNNING);
J
Jens Axboe 已提交
3201 3202 3203
	return false;
}

3204
static bool blk_mq_poll(struct request_queue *q, blk_qc_t cookie)
J
Jens Axboe 已提交
3205 3206 3207 3208
{
	struct blk_mq_hw_ctx *hctx;
	struct request *rq;

3209
	if (!test_bit(QUEUE_FLAG_POLL, &q->queue_flags))
J
Jens Axboe 已提交
3210 3211 3212
		return false;

	hctx = q->queue_hw_ctx[blk_qc_t_to_queue_num(cookie)];
3213 3214
	if (!blk_qc_t_is_internal(cookie))
		rq = blk_mq_tag_to_rq(hctx->tags, blk_qc_t_to_tag(cookie));
3215
	else {
3216
		rq = blk_mq_tag_to_rq(hctx->sched_tags, blk_qc_t_to_tag(cookie));
3217 3218 3219 3220 3221 3222 3223 3224 3225
		/*
		 * With scheduling, if the request has completed, we'll
		 * get a NULL return here, as we clear the sched tag when
		 * that happens. The request still remains valid, like always,
		 * so we should be safe with just the NULL check.
		 */
		if (!rq)
			return false;
	}
J
Jens Axboe 已提交
3226 3227 3228 3229

	return __blk_mq_poll(hctx, rq);
}

3230 3231
static int __init blk_mq_init(void)
{
3232 3233
	cpuhp_setup_state_multi(CPUHP_BLK_MQ_DEAD, "block/mq:dead", NULL,
				blk_mq_hctx_notify_dead);
3234 3235 3236
	return 0;
}
subsys_initcall(blk_mq_init);