“2c46bb119f13a3ebc62461dac498a7057f5b4a94”上不存在“README.md”
blk-mq-debugfs.c 22.0 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
2 3 4 5 6 7 8 9 10
/*
 * Copyright (C) 2017 Facebook
 */

#include <linux/kernel.h>
#include <linux/blkdev.h>
#include <linux/debugfs.h>

#include <linux/blk-mq.h>
11
#include "blk.h"
12
#include "blk-mq.h"
13
#include "blk-mq-debugfs.h"
14
#include "blk-mq-sched.h"
15
#include "blk-mq-tag.h"
16
#include "blk-rq-qos.h"
17

18 19 20
static void print_stat(struct seq_file *m, struct blk_rq_stat *stat)
{
	if (stat->nr_samples) {
21
		seq_printf(m, "samples=%d, mean=%llu, min=%llu, max=%llu",
22 23 24 25 26 27 28 29 30 31 32
			   stat->nr_samples, stat->mean, stat->min, stat->max);
	} else {
		seq_puts(m, "samples=0");
	}
}

static int queue_poll_stat_show(void *data, struct seq_file *m)
{
	struct request_queue *q = data;
	int bucket;

33 34 35
	if (!q->poll_stat)
		return 0;

36 37 38
	for (bucket = 0; bucket < (BLK_MQ_POLL_STATS_BKTS / 2); bucket++) {
		seq_printf(m, "read  (%d Bytes): ", 1 << (9 + bucket));
		print_stat(m, &q->poll_stat[2 * bucket]);
39 40
		seq_puts(m, "\n");

41 42
		seq_printf(m, "write (%d Bytes): ",  1 << (9 + bucket));
		print_stat(m, &q->poll_stat[2 * bucket + 1]);
43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78
		seq_puts(m, "\n");
	}
	return 0;
}

static void *queue_requeue_list_start(struct seq_file *m, loff_t *pos)
	__acquires(&q->requeue_lock)
{
	struct request_queue *q = m->private;

	spin_lock_irq(&q->requeue_lock);
	return seq_list_start(&q->requeue_list, *pos);
}

static void *queue_requeue_list_next(struct seq_file *m, void *v, loff_t *pos)
{
	struct request_queue *q = m->private;

	return seq_list_next(v, &q->requeue_list, pos);
}

static void queue_requeue_list_stop(struct seq_file *m, void *v)
	__releases(&q->requeue_lock)
{
	struct request_queue *q = m->private;

	spin_unlock_irq(&q->requeue_lock);
}

static const struct seq_operations queue_requeue_list_seq_ops = {
	.start	= queue_requeue_list_start,
	.next	= queue_requeue_list_next,
	.stop	= queue_requeue_list_stop,
	.show	= blk_mq_debugfs_rq_show,
};

79 80 81 82 83 84 85 86 87 88
static int blk_flags_show(struct seq_file *m, const unsigned long flags,
			  const char *const *flag_name, int flag_name_count)
{
	bool sep = false;
	int i;

	for (i = 0; i < sizeof(flags) * BITS_PER_BYTE; i++) {
		if (!(flags & BIT(i)))
			continue;
		if (sep)
89
			seq_puts(m, "|");
90 91 92 93 94 95 96 97 98
		sep = true;
		if (i < flag_name_count && flag_name[i])
			seq_puts(m, flag_name[i]);
		else
			seq_printf(m, "%d", i);
	}
	return 0;
}

99 100 101 102 103 104 105 106
static int queue_pm_only_show(void *data, struct seq_file *m)
{
	struct request_queue *q = data;

	seq_printf(m, "%d\n", atomic_read(&q->pm_only));
	return 0;
}

107
#define QUEUE_FLAG_NAME(name) [QUEUE_FLAG_##name] = #name
108
static const char *const blk_queue_flag_name[] = {
109 110 111 112 113 114 115 116 117 118 119 120 121 122
	QUEUE_FLAG_NAME(STOPPED),
	QUEUE_FLAG_NAME(DYING),
	QUEUE_FLAG_NAME(NOMERGES),
	QUEUE_FLAG_NAME(SAME_COMP),
	QUEUE_FLAG_NAME(FAIL_IO),
	QUEUE_FLAG_NAME(NONROT),
	QUEUE_FLAG_NAME(IO_STAT),
	QUEUE_FLAG_NAME(DISCARD),
	QUEUE_FLAG_NAME(NOXMERGES),
	QUEUE_FLAG_NAME(ADD_RANDOM),
	QUEUE_FLAG_NAME(SECERASE),
	QUEUE_FLAG_NAME(SAME_FORCE),
	QUEUE_FLAG_NAME(DEAD),
	QUEUE_FLAG_NAME(INIT_DONE),
123
	QUEUE_FLAG_NAME(STABLE_WRITES),
124 125 126 127 128 129
	QUEUE_FLAG_NAME(POLL),
	QUEUE_FLAG_NAME(WC),
	QUEUE_FLAG_NAME(FUA),
	QUEUE_FLAG_NAME(DAX),
	QUEUE_FLAG_NAME(STATS),
	QUEUE_FLAG_NAME(REGISTERED),
130
	QUEUE_FLAG_NAME(QUIESCED),
131 132 133
	QUEUE_FLAG_NAME(PCI_P2PDMA),
	QUEUE_FLAG_NAME(ZONE_RESETALL),
	QUEUE_FLAG_NAME(RQ_ALLOC_TIME),
134
	QUEUE_FLAG_NAME(HCTX_ACTIVE),
135
	QUEUE_FLAG_NAME(NOWAIT),
136
};
137
#undef QUEUE_FLAG_NAME
138

139
static int queue_state_show(void *data, struct seq_file *m)
140
{
141
	struct request_queue *q = data;
142 143 144

	blk_flags_show(m, q->queue_flags, blk_queue_flag_name,
		       ARRAY_SIZE(blk_queue_flag_name));
145
	seq_puts(m, "\n");
146 147 148
	return 0;
}

149 150
static ssize_t queue_state_write(void *data, const char __user *buf,
				 size_t count, loff_t *ppos)
151
{
152
	struct request_queue *q = data;
153
	char opbuf[16] = { }, *op;
154

155 156 157 158 159 160 161 162
	/*
	 * The "state" attribute is removed after blk_cleanup_queue() has called
	 * blk_mq_free_queue(). Return if QUEUE_FLAG_DEAD has been set to avoid
	 * triggering a use-after-free.
	 */
	if (blk_queue_dead(q))
		return -ENOENT;

163
	if (count >= sizeof(opbuf)) {
164 165 166 167
		pr_err("%s: operation too long\n", __func__);
		goto inval;
	}

168
	if (copy_from_user(opbuf, buf, count))
169
		return -EFAULT;
170
	op = strstrip(opbuf);
171 172 173 174
	if (strcmp(op, "run") == 0) {
		blk_mq_run_hw_queues(q, true);
	} else if (strcmp(op, "start") == 0) {
		blk_mq_start_stopped_hw_queues(q, true);
175 176
	} else if (strcmp(op, "kick") == 0) {
		blk_mq_kick_requeue_list(q);
177
	} else {
178 179
		pr_err("%s: unsupported operation '%s'\n", __func__, op);
inval:
180
		pr_err("%s: use 'run', 'start' or 'kick'\n", __func__);
181 182
		return -EINVAL;
	}
183
	return count;
184 185
}

186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
static int queue_write_hint_show(void *data, struct seq_file *m)
{
	struct request_queue *q = data;
	int i;

	for (i = 0; i < BLK_MAX_WRITE_HINTS; i++)
		seq_printf(m, "hint%d: %llu\n", i, q->write_hints[i]);

	return 0;
}

static ssize_t queue_write_hint_store(void *data, const char __user *buf,
				      size_t count, loff_t *ppos)
{
	struct request_queue *q = data;
	int i;

	for (i = 0; i < BLK_MAX_WRITE_HINTS; i++)
		q->write_hints[i] = 0;

	return count;
}

209 210 211
static const struct blk_mq_debugfs_attr blk_mq_debugfs_queue_attrs[] = {
	{ "poll_stat", 0400, queue_poll_stat_show },
	{ "requeue_list", 0400, .seq_ops = &queue_requeue_list_seq_ops },
212
	{ "pm_only", 0600, queue_pm_only_show, NULL },
213 214
	{ "state", 0600, queue_state_show, queue_state_write },
	{ "write_hints", 0600, queue_write_hint_show, queue_write_hint_store },
215
	{ "zone_wlock", 0400, queue_zone_wlock_show, NULL },
216 217
	{ },
};
218

219
#define HCTX_STATE_NAME(name) [BLK_MQ_S_##name] = #name
220
static const char *const hctx_state_name[] = {
221 222 223
	HCTX_STATE_NAME(STOPPED),
	HCTX_STATE_NAME(TAG_ACTIVE),
	HCTX_STATE_NAME(SCHED_RESTART),
224
	HCTX_STATE_NAME(INACTIVE),
225
};
226 227
#undef HCTX_STATE_NAME

228
static int hctx_state_show(void *data, struct seq_file *m)
229
{
230
	struct blk_mq_hw_ctx *hctx = data;
231

232 233
	blk_flags_show(m, hctx->state, hctx_state_name,
		       ARRAY_SIZE(hctx_state_name));
234
	seq_puts(m, "\n");
235 236 237
	return 0;
}

238
#define BLK_TAG_ALLOC_NAME(name) [BLK_TAG_ALLOC_##name] = #name
239
static const char *const alloc_policy_name[] = {
240 241
	BLK_TAG_ALLOC_NAME(FIFO),
	BLK_TAG_ALLOC_NAME(RR),
242
};
243
#undef BLK_TAG_ALLOC_NAME
244

245
#define HCTX_FLAG_NAME(name) [ilog2(BLK_MQ_F_##name)] = #name
246
static const char *const hctx_flag_name[] = {
247
	HCTX_FLAG_NAME(SHOULD_MERGE),
248
	HCTX_FLAG_NAME(TAG_QUEUE_SHARED),
249 250
	HCTX_FLAG_NAME(BLOCKING),
	HCTX_FLAG_NAME(NO_SCHED),
251
	HCTX_FLAG_NAME(STACKING),
252
	HCTX_FLAG_NAME(TAG_HCTX_SHARED),
253
};
254
#undef HCTX_FLAG_NAME
255

256
static int hctx_flags_show(void *data, struct seq_file *m)
257
{
258
	struct blk_mq_hw_ctx *hctx = data;
259
	const int alloc_policy = BLK_MQ_FLAG_TO_ALLOC_POLICY(hctx->flags);
260

261 262 263 264 265 266 267 268 269 270
	seq_puts(m, "alloc_policy=");
	if (alloc_policy < ARRAY_SIZE(alloc_policy_name) &&
	    alloc_policy_name[alloc_policy])
		seq_puts(m, alloc_policy_name[alloc_policy]);
	else
		seq_printf(m, "%d", alloc_policy);
	seq_puts(m, " ");
	blk_flags_show(m,
		       hctx->flags ^ BLK_ALLOC_POLICY_TO_MQ_FLAG(alloc_policy),
		       hctx_flag_name, ARRAY_SIZE(hctx_flag_name));
271
	seq_puts(m, "\n");
272 273 274
	return 0;
}

275
#define CMD_FLAG_NAME(name) [__REQ_##name] = #name
276
static const char *const cmd_flag_name[] = {
277 278 279 280 281 282 283 284 285 286 287 288 289
	CMD_FLAG_NAME(FAILFAST_DEV),
	CMD_FLAG_NAME(FAILFAST_TRANSPORT),
	CMD_FLAG_NAME(FAILFAST_DRIVER),
	CMD_FLAG_NAME(SYNC),
	CMD_FLAG_NAME(META),
	CMD_FLAG_NAME(PRIO),
	CMD_FLAG_NAME(NOMERGE),
	CMD_FLAG_NAME(IDLE),
	CMD_FLAG_NAME(INTEGRITY),
	CMD_FLAG_NAME(FUA),
	CMD_FLAG_NAME(PREFLUSH),
	CMD_FLAG_NAME(RAHEAD),
	CMD_FLAG_NAME(BACKGROUND),
290
	CMD_FLAG_NAME(NOWAIT),
291
	CMD_FLAG_NAME(NOUNMAP),
292
	CMD_FLAG_NAME(POLLED),
293
};
294
#undef CMD_FLAG_NAME
295

296
#define RQF_NAME(name) [ilog2((__force u32)RQF_##name)] = #name
297
static const char *const rqf_name[] = {
298
	RQF_NAME(STARTED),
299 300 301 302 303 304 305 306 307 308 309 310 311
	RQF_NAME(SOFTBARRIER),
	RQF_NAME(FLUSH_SEQ),
	RQF_NAME(MIXED_MERGE),
	RQF_NAME(MQ_INFLIGHT),
	RQF_NAME(DONTPREP),
	RQF_NAME(FAILED),
	RQF_NAME(QUIET),
	RQF_NAME(ELVPRIV),
	RQF_NAME(IO_STAT),
	RQF_NAME(PM),
	RQF_NAME(HASHED),
	RQF_NAME(STATS),
	RQF_NAME(SPECIAL_PAYLOAD),
312
	RQF_NAME(ZONE_WRITE_LOCKED),
313
	RQF_NAME(MQ_POLL_SLEPT),
314
	RQF_NAME(ELV),
315
};
316
#undef RQF_NAME
317

318 319 320 321 322 323 324 325
static const char *const blk_mq_rq_state_name_array[] = {
	[MQ_RQ_IDLE]		= "idle",
	[MQ_RQ_IN_FLIGHT]	= "in_flight",
	[MQ_RQ_COMPLETE]	= "complete",
};

static const char *blk_mq_rq_state_name(enum mq_rq_state rq_state)
{
326
	if (WARN_ON_ONCE((unsigned int)rq_state >=
327 328 329 330 331
			 ARRAY_SIZE(blk_mq_rq_state_name_array)))
		return "(?)";
	return blk_mq_rq_state_name_array[rq_state];
}

332
int __blk_mq_debugfs_rq_show(struct seq_file *m, struct request *rq)
333
{
334
	const struct blk_mq_ops *const mq_ops = rq->q->mq_ops;
335
	const unsigned int op = req_op(rq);
336
	const char *op_str = blk_op_str(op);
337

338
	seq_printf(m, "%p {.op=", rq);
339
	if (strcmp(op_str, "UNKNOWN") == 0)
340
		seq_printf(m, "%u", op);
341
	else
342
		seq_printf(m, "%s", op_str);
343 344 345 346 347 348
	seq_puts(m, ", .cmd_flags=");
	blk_flags_show(m, rq->cmd_flags & ~REQ_OP_MASK, cmd_flag_name,
		       ARRAY_SIZE(cmd_flag_name));
	seq_puts(m, ", .rq_flags=");
	blk_flags_show(m, (__force unsigned int)rq->rq_flags, rqf_name,
		       ARRAY_SIZE(rqf_name));
349
	seq_printf(m, ", .state=%s", blk_mq_rq_state_name(blk_mq_rq_state(rq)));
350
	seq_printf(m, ", .tag=%d, .internal_tag=%d", rq->tag,
351
		   rq->internal_tag);
352 353 354
	if (mq_ops->show_rq)
		mq_ops->show_rq(m, rq);
	seq_puts(m, "}\n");
355 356
	return 0;
}
357 358 359 360 361 362
EXPORT_SYMBOL_GPL(__blk_mq_debugfs_rq_show);

int blk_mq_debugfs_rq_show(struct seq_file *m, void *v)
{
	return __blk_mq_debugfs_rq_show(m, list_entry_rq(v));
}
363
EXPORT_SYMBOL_GPL(blk_mq_debugfs_rq_show);
364 365

static void *hctx_dispatch_start(struct seq_file *m, loff_t *pos)
366
	__acquires(&hctx->lock)
367 368 369 370 371 372 373 374 375 376 377 378 379 380 381
{
	struct blk_mq_hw_ctx *hctx = m->private;

	spin_lock(&hctx->lock);
	return seq_list_start(&hctx->dispatch, *pos);
}

static void *hctx_dispatch_next(struct seq_file *m, void *v, loff_t *pos)
{
	struct blk_mq_hw_ctx *hctx = m->private;

	return seq_list_next(v, &hctx->dispatch, pos);
}

static void hctx_dispatch_stop(struct seq_file *m, void *v)
382
	__releases(&hctx->lock)
383 384 385 386 387 388 389 390 391 392 393 394 395
{
	struct blk_mq_hw_ctx *hctx = m->private;

	spin_unlock(&hctx->lock);
}

static const struct seq_operations hctx_dispatch_seq_ops = {
	.start	= hctx_dispatch_start,
	.next	= hctx_dispatch_next,
	.stop	= hctx_dispatch_stop,
	.show	= blk_mq_debugfs_rq_show,
};

396 397 398 399 400 401 402
struct show_busy_params {
	struct seq_file		*m;
	struct blk_mq_hw_ctx	*hctx;
};

/*
 * Note: the state of a request may change while this function is in progress,
403 404
 * e.g. due to a concurrent blk_mq_finish_request() call. Returns true to
 * keep iterating requests.
405
 */
406
static bool hctx_show_busy_rq(struct request *rq, void *data, bool reserved)
407 408 409
{
	const struct show_busy_params *params = data;

410
	if (rq->mq_hctx == params->hctx)
411
		__blk_mq_debugfs_rq_show(params->m, rq);
412 413

	return true;
414 415 416 417 418 419 420 421 422 423 424 425 426
}

static int hctx_busy_show(void *data, struct seq_file *m)
{
	struct blk_mq_hw_ctx *hctx = data;
	struct show_busy_params params = { .m = m, .hctx = hctx };

	blk_mq_tagset_busy_iter(hctx->queue->tag_set, hctx_show_busy_rq,
				&params);

	return 0;
}

427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
static const char *const hctx_types[] = {
	[HCTX_TYPE_DEFAULT]	= "default",
	[HCTX_TYPE_READ]	= "read",
	[HCTX_TYPE_POLL]	= "poll",
};

static int hctx_type_show(void *data, struct seq_file *m)
{
	struct blk_mq_hw_ctx *hctx = data;

	BUILD_BUG_ON(ARRAY_SIZE(hctx_types) != HCTX_MAX_TYPES);
	seq_printf(m, "%s\n", hctx_types[hctx->type]);
	return 0;
}

442
static int hctx_ctx_map_show(void *data, struct seq_file *m)
443
{
444
	struct blk_mq_hw_ctx *hctx = data;
445 446 447 448 449

	sbitmap_bitmap_show(&hctx->ctx_map, m);
	return 0;
}

450 451 452 453 454 455 456 457 458
static void blk_mq_debugfs_tags_show(struct seq_file *m,
				     struct blk_mq_tags *tags)
{
	seq_printf(m, "nr_tags=%u\n", tags->nr_tags);
	seq_printf(m, "nr_reserved_tags=%u\n", tags->nr_reserved_tags);
	seq_printf(m, "active_queues=%d\n",
		   atomic_read(&tags->active_queues));

	seq_puts(m, "\nbitmap_tags:\n");
459
	sbitmap_queue_show(&tags->bitmap_tags, m);
460 461 462

	if (tags->nr_reserved_tags) {
		seq_puts(m, "\nbreserved_tags:\n");
463
		sbitmap_queue_show(&tags->breserved_tags, m);
464 465 466
	}
}

467
static int hctx_tags_show(void *data, struct seq_file *m)
468
{
469
	struct blk_mq_hw_ctx *hctx = data;
470
	struct request_queue *q = hctx->queue;
471
	int res;
472

473 474 475
	res = mutex_lock_interruptible(&q->sysfs_lock);
	if (res)
		goto out;
476 477 478 479
	if (hctx->tags)
		blk_mq_debugfs_tags_show(m, hctx->tags);
	mutex_unlock(&q->sysfs_lock);

480 481
out:
	return res;
482 483
}

484
static int hctx_tags_bitmap_show(void *data, struct seq_file *m)
485
{
486
	struct blk_mq_hw_ctx *hctx = data;
487
	struct request_queue *q = hctx->queue;
488
	int res;
489

490 491 492
	res = mutex_lock_interruptible(&q->sysfs_lock);
	if (res)
		goto out;
493
	if (hctx->tags)
494
		sbitmap_bitmap_show(&hctx->tags->bitmap_tags.sb, m);
495
	mutex_unlock(&q->sysfs_lock);
496 497 498

out:
	return res;
499 500
}

501
static int hctx_sched_tags_show(void *data, struct seq_file *m)
502
{
503
	struct blk_mq_hw_ctx *hctx = data;
504
	struct request_queue *q = hctx->queue;
505
	int res;
506

507 508 509
	res = mutex_lock_interruptible(&q->sysfs_lock);
	if (res)
		goto out;
510 511 512 513
	if (hctx->sched_tags)
		blk_mq_debugfs_tags_show(m, hctx->sched_tags);
	mutex_unlock(&q->sysfs_lock);

514 515
out:
	return res;
516 517
}

518
static int hctx_sched_tags_bitmap_show(void *data, struct seq_file *m)
519
{
520
	struct blk_mq_hw_ctx *hctx = data;
521
	struct request_queue *q = hctx->queue;
522
	int res;
523

524 525 526
	res = mutex_lock_interruptible(&q->sysfs_lock);
	if (res)
		goto out;
527
	if (hctx->sched_tags)
528
		sbitmap_bitmap_show(&hctx->sched_tags->bitmap_tags.sb, m);
529
	mutex_unlock(&q->sysfs_lock);
530 531 532

out:
	return res;
533 534
}

535
static int hctx_run_show(void *data, struct seq_file *m)
536
{
537
	struct blk_mq_hw_ctx *hctx = data;
538 539 540 541 542

	seq_printf(m, "%lu\n", hctx->run);
	return 0;
}

543 544
static ssize_t hctx_run_write(void *data, const char __user *buf, size_t count,
			      loff_t *ppos)
545
{
546
	struct blk_mq_hw_ctx *hctx = data;
547 548 549 550 551

	hctx->run = 0;
	return count;
}

552
static int hctx_active_show(void *data, struct seq_file *m)
553
{
554
	struct blk_mq_hw_ctx *hctx = data;
555

556
	seq_printf(m, "%d\n", __blk_mq_active_requests(hctx));
557 558 559
	return 0;
}

560 561 562 563 564 565 566 567
static int hctx_dispatch_busy_show(void *data, struct seq_file *m)
{
	struct blk_mq_hw_ctx *hctx = data;

	seq_printf(m, "%u\n", hctx->dispatch_busy);
	return 0;
}

568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
#define CTX_RQ_SEQ_OPS(name, type)					\
static void *ctx_##name##_rq_list_start(struct seq_file *m, loff_t *pos) \
	__acquires(&ctx->lock)						\
{									\
	struct blk_mq_ctx *ctx = m->private;				\
									\
	spin_lock(&ctx->lock);						\
	return seq_list_start(&ctx->rq_lists[type], *pos);		\
}									\
									\
static void *ctx_##name##_rq_list_next(struct seq_file *m, void *v,	\
				     loff_t *pos)			\
{									\
	struct blk_mq_ctx *ctx = m->private;				\
									\
	return seq_list_next(v, &ctx->rq_lists[type], pos);		\
}									\
									\
static void ctx_##name##_rq_list_stop(struct seq_file *m, void *v)	\
	__releases(&ctx->lock)						\
{									\
	struct blk_mq_ctx *ctx = m->private;				\
									\
	spin_unlock(&ctx->lock);					\
}									\
									\
static const struct seq_operations ctx_##name##_rq_list_seq_ops = {	\
	.start	= ctx_##name##_rq_list_start,				\
	.next	= ctx_##name##_rq_list_next,				\
	.stop	= ctx_##name##_rq_list_stop,				\
	.show	= blk_mq_debugfs_rq_show,				\
}

CTX_RQ_SEQ_OPS(default, HCTX_TYPE_DEFAULT);
CTX_RQ_SEQ_OPS(read, HCTX_TYPE_READ);
CTX_RQ_SEQ_OPS(poll, HCTX_TYPE_POLL);
604

605 606 607 608 609 610 611 612 613 614
static int blk_mq_debugfs_show(struct seq_file *m, void *v)
{
	const struct blk_mq_debugfs_attr *attr = m->private;
	void *data = d_inode(m->file->f_path.dentry->d_parent)->i_private;

	return attr->show(data, m);
}

static ssize_t blk_mq_debugfs_write(struct file *file, const char __user *buf,
				    size_t count, loff_t *ppos)
615 616
{
	struct seq_file *m = file->private_data;
617 618
	const struct blk_mq_debugfs_attr *attr = m->private;
	void *data = d_inode(file->f_path.dentry->d_parent)->i_private;
619

620 621 622 623 624
	/*
	 * Attributes that only implement .seq_ops are read-only and 'attr' is
	 * the same with 'data' in this case.
	 */
	if (attr == data || !attr->write)
625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649
		return -EPERM;

	return attr->write(data, buf, count, ppos);
}

static int blk_mq_debugfs_open(struct inode *inode, struct file *file)
{
	const struct blk_mq_debugfs_attr *attr = inode->i_private;
	void *data = d_inode(file->f_path.dentry->d_parent)->i_private;
	struct seq_file *m;
	int ret;

	if (attr->seq_ops) {
		ret = seq_open(file, attr->seq_ops);
		if (!ret) {
			m = file->private_data;
			m->private = data;
		}
		return ret;
	}

	if (WARN_ON_ONCE(!attr->show))
		return -EPERM;

	return single_open(file, blk_mq_debugfs_show, inode->i_private);
650 651
}

652 653 654 655 656 657
static int blk_mq_debugfs_release(struct inode *inode, struct file *file)
{
	const struct blk_mq_debugfs_attr *attr = inode->i_private;

	if (attr->show)
		return single_release(inode, file);
658 659

	return seq_release(inode, file);
660 661
}

662
static const struct file_operations blk_mq_debugfs_fops = {
663
	.open		= blk_mq_debugfs_open,
664
	.read		= seq_read,
665
	.write		= blk_mq_debugfs_write,
666
	.llseek		= seq_lseek,
667
	.release	= blk_mq_debugfs_release,
668 669
};

670
static const struct blk_mq_debugfs_attr blk_mq_debugfs_hctx_attrs[] = {
671 672 673
	{"state", 0400, hctx_state_show},
	{"flags", 0400, hctx_flags_show},
	{"dispatch", 0400, .seq_ops = &hctx_dispatch_seq_ops},
674
	{"busy", 0400, hctx_busy_show},
675 676 677 678 679 680 681
	{"ctx_map", 0400, hctx_ctx_map_show},
	{"tags", 0400, hctx_tags_show},
	{"tags_bitmap", 0400, hctx_tags_bitmap_show},
	{"sched_tags", 0400, hctx_sched_tags_show},
	{"sched_tags_bitmap", 0400, hctx_sched_tags_bitmap_show},
	{"run", 0600, hctx_run_show, hctx_run_write},
	{"active", 0400, hctx_active_show},
682
	{"dispatch_busy", 0400, hctx_dispatch_busy_show},
683
	{"type", 0400, hctx_type_show},
684
	{},
685 686 687
};

static const struct blk_mq_debugfs_attr blk_mq_debugfs_ctx_attrs[] = {
688 689 690
	{"default_rq_list", 0400, .seq_ops = &ctx_default_rq_list_seq_ops},
	{"read_rq_list", 0400, .seq_ops = &ctx_read_rq_list_seq_ops},
	{"poll_rq_list", 0400, .seq_ops = &ctx_poll_rq_list_seq_ops},
691
	{},
692 693
};

694
static void debugfs_create_files(struct dentry *parent, void *data,
695 696
				 const struct blk_mq_debugfs_attr *attr)
{
697
	if (IS_ERR_OR_NULL(parent))
698
		return;
699

700 701
	d_inode(parent)->i_private = data;

702 703 704
	for (; attr->name; attr++)
		debugfs_create_file(attr->name, attr->mode, parent,
				    (void *)attr, &blk_mq_debugfs_fops);
705 706
}

707
void blk_mq_debugfs_register(struct request_queue *q)
708
{
709 710 711
	struct blk_mq_hw_ctx *hctx;
	int i;

712
	debugfs_create_files(q->debugfs_dir, q, blk_mq_debugfs_queue_attrs);
713

714
	/*
715
	 * blk_mq_init_sched() attempted to do this already, but q->debugfs_dir
716 717 718
	 * didn't exist yet (because we don't know what to name the directory
	 * until the queue is registered to a gendisk).
	 */
719 720 721 722
	if (q->elevator && !q->sched_debugfs_dir)
		blk_mq_debugfs_register_sched(q);

	/* Similarly, blk_mq_init_hctx() couldn't do this previously. */
723
	queue_for_each_hw_ctx(q, hctx, i) {
724 725 726 727
		if (!hctx->debugfs_dir)
			blk_mq_debugfs_register_hctx(q, hctx);
		if (q->elevator && !hctx->sched_debugfs_dir)
			blk_mq_debugfs_register_sched_hctx(q, hctx);
728 729
	}

730 731 732 733 734 735 736 737
	if (q->rq_qos) {
		struct rq_qos *rqos = q->rq_qos;

		while (rqos) {
			blk_mq_debugfs_register_rqos(rqos);
			rqos = rqos->next;
		}
	}
738 739 740 741
}

void blk_mq_debugfs_unregister(struct request_queue *q)
{
742
	q->sched_debugfs_dir = NULL;
743 744
}

745 746
static void blk_mq_debugfs_register_ctx(struct blk_mq_hw_ctx *hctx,
					struct blk_mq_ctx *ctx)
747 748 749 750 751
{
	struct dentry *ctx_dir;
	char name[20];

	snprintf(name, sizeof(name), "cpu%u", ctx->cpu);
752
	ctx_dir = debugfs_create_dir(name, hctx->debugfs_dir);
753

754
	debugfs_create_files(ctx_dir, ctx, blk_mq_debugfs_ctx_attrs);
755 756
}

757 758
void blk_mq_debugfs_register_hctx(struct request_queue *q,
				  struct blk_mq_hw_ctx *hctx)
759 760 761 762 763
{
	struct blk_mq_ctx *ctx;
	char name[20];
	int i;

764
	snprintf(name, sizeof(name), "hctx%u", hctx->queue_num);
765
	hctx->debugfs_dir = debugfs_create_dir(name, q->debugfs_dir);
766

767
	debugfs_create_files(hctx->debugfs_dir, hctx, blk_mq_debugfs_hctx_attrs);
768

769 770
	hctx_for_each_ctx(hctx, ctx, i)
		blk_mq_debugfs_register_ctx(hctx, ctx);
771 772 773 774 775
}

void blk_mq_debugfs_unregister_hctx(struct blk_mq_hw_ctx *hctx)
{
	debugfs_remove_recursive(hctx->debugfs_dir);
776
	hctx->sched_debugfs_dir = NULL;
777
	hctx->debugfs_dir = NULL;
778 779
}

780
void blk_mq_debugfs_register_hctxs(struct request_queue *q)
781 782 783 784
{
	struct blk_mq_hw_ctx *hctx;
	int i;

785 786
	queue_for_each_hw_ctx(q, hctx, i)
		blk_mq_debugfs_register_hctx(q, hctx);
787 788
}

789
void blk_mq_debugfs_unregister_hctxs(struct request_queue *q)
790
{
791 792 793 794 795
	struct blk_mq_hw_ctx *hctx;
	int i;

	queue_for_each_hw_ctx(q, hctx, i)
		blk_mq_debugfs_unregister_hctx(hctx);
796
}
797

798
void blk_mq_debugfs_register_sched(struct request_queue *q)
799 800 801
{
	struct elevator_type *e = q->elevator->type;

802 803 804 805 806 807 808
	/*
	 * If the parent directory has not been created yet, return, we will be
	 * called again later on and the directory/files will be created then.
	 */
	if (!q->debugfs_dir)
		return;

809
	if (!e->queue_debugfs_attrs)
810
		return;
811 812 813

	q->sched_debugfs_dir = debugfs_create_dir("sched", q->debugfs_dir);

814
	debugfs_create_files(q->sched_debugfs_dir, q, e->queue_debugfs_attrs);
815 816 817 818 819 820 821 822
}

void blk_mq_debugfs_unregister_sched(struct request_queue *q)
{
	debugfs_remove_recursive(q->sched_debugfs_dir);
	q->sched_debugfs_dir = NULL;
}

823 824 825 826 827 828 829 830 831
static const char *rq_qos_id_to_name(enum rq_qos_id id)
{
	switch (id) {
	case RQ_QOS_WBT:
		return "wbt";
	case RQ_QOS_LATENCY:
		return "latency";
	case RQ_QOS_COST:
		return "cost";
832 833
	case RQ_QOS_IOPRIO:
		return "ioprio";
834 835 836 837
	}
	return "unknown";
}

838 839 840 841 842 843
void blk_mq_debugfs_unregister_rqos(struct rq_qos *rqos)
{
	debugfs_remove_recursive(rqos->debugfs_dir);
	rqos->debugfs_dir = NULL;
}

844
void blk_mq_debugfs_register_rqos(struct rq_qos *rqos)
845 846 847 848 849
{
	struct request_queue *q = rqos->q;
	const char *dir_name = rq_qos_id_to_name(rqos->id);

	if (rqos->debugfs_dir || !rqos->ops->debugfs_attrs)
850
		return;
851

852
	if (!q->rqos_debugfs_dir)
853 854 855 856 857 858
		q->rqos_debugfs_dir = debugfs_create_dir("rqos",
							 q->debugfs_dir);

	rqos->debugfs_dir = debugfs_create_dir(dir_name,
					       rqos->q->rqos_debugfs_dir);

859
	debugfs_create_files(rqos->debugfs_dir, rqos, rqos->ops->debugfs_attrs);
860 861 862 863 864 865 866 867
}

void blk_mq_debugfs_unregister_queue_rqos(struct request_queue *q)
{
	debugfs_remove_recursive(q->rqos_debugfs_dir);
	q->rqos_debugfs_dir = NULL;
}

868 869
void blk_mq_debugfs_register_sched_hctx(struct request_queue *q,
					struct blk_mq_hw_ctx *hctx)
870 871 872
{
	struct elevator_type *e = q->elevator->type;

873 874 875 876 877 878 879 880
	/*
	 * If the parent debugfs directory has not been created yet, return;
	 * We will be called again later on with appropriate parent debugfs
	 * directory from blk_register_queue()
	 */
	if (!hctx->debugfs_dir)
		return;

881
	if (!e->hctx_debugfs_attrs)
882
		return;
883 884 885

	hctx->sched_debugfs_dir = debugfs_create_dir("sched",
						     hctx->debugfs_dir);
886 887
	debugfs_create_files(hctx->sched_debugfs_dir, hctx,
			     e->hctx_debugfs_attrs);
888 889 890 891 892 893 894
}

void blk_mq_debugfs_unregister_sched_hctx(struct blk_mq_hw_ctx *hctx)
{
	debugfs_remove_recursive(hctx->sched_debugfs_dir);
	hctx->sched_debugfs_dir = NULL;
}
新手
引导
客服 返回
顶部