1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2017 Facebook
6 #include <linux/kernel.h>
7 #include <linux/blkdev.h>
8 #include <linux/debugfs.h>
10 #include <linux/blk-mq.h>
13 #include "blk-mq-debugfs.h"
14 #include "blk-mq-tag.h"
15 #include "blk-rq-qos.h"
17 static void print_stat(struct seq_file
*m
, struct blk_rq_stat
*stat
)
19 if (stat
->nr_samples
) {
20 seq_printf(m
, "samples=%d, mean=%llu, min=%llu, max=%llu",
21 stat
->nr_samples
, stat
->mean
, stat
->min
, stat
->max
);
23 seq_puts(m
, "samples=0");
27 static int queue_poll_stat_show(void *data
, struct seq_file
*m
)
29 struct request_queue
*q
= data
;
32 for (bucket
= 0; bucket
< (BLK_MQ_POLL_STATS_BKTS
/ 2); bucket
++) {
33 seq_printf(m
, "read (%d Bytes): ", 1 << (9 + bucket
));
34 print_stat(m
, &q
->poll_stat
[2 * bucket
]);
37 seq_printf(m
, "write (%d Bytes): ", 1 << (9 + bucket
));
38 print_stat(m
, &q
->poll_stat
[2 * bucket
+ 1]);
44 static void *queue_requeue_list_start(struct seq_file
*m
, loff_t
*pos
)
45 __acquires(&q
->requeue_lock
)
47 struct request_queue
*q
= m
->private;
49 spin_lock_irq(&q
->requeue_lock
);
50 return seq_list_start(&q
->requeue_list
, *pos
);
53 static void *queue_requeue_list_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
55 struct request_queue
*q
= m
->private;
57 return seq_list_next(v
, &q
->requeue_list
, pos
);
60 static void queue_requeue_list_stop(struct seq_file
*m
, void *v
)
61 __releases(&q
->requeue_lock
)
63 struct request_queue
*q
= m
->private;
65 spin_unlock_irq(&q
->requeue_lock
);
68 static const struct seq_operations queue_requeue_list_seq_ops
= {
69 .start
= queue_requeue_list_start
,
70 .next
= queue_requeue_list_next
,
71 .stop
= queue_requeue_list_stop
,
72 .show
= blk_mq_debugfs_rq_show
,
75 static int blk_flags_show(struct seq_file
*m
, const unsigned long flags
,
76 const char *const *flag_name
, int flag_name_count
)
81 for (i
= 0; i
< sizeof(flags
) * BITS_PER_BYTE
; i
++) {
82 if (!(flags
& BIT(i
)))
87 if (i
< flag_name_count
&& flag_name
[i
])
88 seq_puts(m
, flag_name
[i
]);
90 seq_printf(m
, "%d", i
);
95 static int queue_pm_only_show(void *data
, struct seq_file
*m
)
97 struct request_queue
*q
= data
;
99 seq_printf(m
, "%d\n", atomic_read(&q
->pm_only
));
103 #define QUEUE_FLAG_NAME(name) [QUEUE_FLAG_##name] = #name
104 static const char *const blk_queue_flag_name
[] = {
105 QUEUE_FLAG_NAME(STOPPED
),
106 QUEUE_FLAG_NAME(DYING
),
107 QUEUE_FLAG_NAME(NOMERGES
),
108 QUEUE_FLAG_NAME(SAME_COMP
),
109 QUEUE_FLAG_NAME(FAIL_IO
),
110 QUEUE_FLAG_NAME(NONROT
),
111 QUEUE_FLAG_NAME(IO_STAT
),
112 QUEUE_FLAG_NAME(DISCARD
),
113 QUEUE_FLAG_NAME(NOXMERGES
),
114 QUEUE_FLAG_NAME(ADD_RANDOM
),
115 QUEUE_FLAG_NAME(SECERASE
),
116 QUEUE_FLAG_NAME(SAME_FORCE
),
117 QUEUE_FLAG_NAME(DEAD
),
118 QUEUE_FLAG_NAME(INIT_DONE
),
119 QUEUE_FLAG_NAME(STABLE_WRITES
),
120 QUEUE_FLAG_NAME(POLL
),
122 QUEUE_FLAG_NAME(FUA
),
123 QUEUE_FLAG_NAME(DAX
),
124 QUEUE_FLAG_NAME(STATS
),
125 QUEUE_FLAG_NAME(POLL_STATS
),
126 QUEUE_FLAG_NAME(REGISTERED
),
127 QUEUE_FLAG_NAME(SCSI_PASSTHROUGH
),
128 QUEUE_FLAG_NAME(QUIESCED
),
129 QUEUE_FLAG_NAME(PCI_P2PDMA
),
130 QUEUE_FLAG_NAME(ZONE_RESETALL
),
131 QUEUE_FLAG_NAME(RQ_ALLOC_TIME
),
132 QUEUE_FLAG_NAME(NOWAIT
),
134 #undef QUEUE_FLAG_NAME
136 static int queue_state_show(void *data
, struct seq_file
*m
)
138 struct request_queue
*q
= data
;
140 blk_flags_show(m
, q
->queue_flags
, blk_queue_flag_name
,
141 ARRAY_SIZE(blk_queue_flag_name
));
146 static ssize_t
queue_state_write(void *data
, const char __user
*buf
,
147 size_t count
, loff_t
*ppos
)
149 struct request_queue
*q
= data
;
150 char opbuf
[16] = { }, *op
;
153 * The "state" attribute is removed after blk_cleanup_queue() has called
154 * blk_mq_free_queue(). Return if QUEUE_FLAG_DEAD has been set to avoid
155 * triggering a use-after-free.
157 if (blk_queue_dead(q
))
160 if (count
>= sizeof(opbuf
)) {
161 pr_err("%s: operation too long\n", __func__
);
165 if (copy_from_user(opbuf
, buf
, count
))
167 op
= strstrip(opbuf
);
168 if (strcmp(op
, "run") == 0) {
169 blk_mq_run_hw_queues(q
, true);
170 } else if (strcmp(op
, "start") == 0) {
171 blk_mq_start_stopped_hw_queues(q
, true);
172 } else if (strcmp(op
, "kick") == 0) {
173 blk_mq_kick_requeue_list(q
);
175 pr_err("%s: unsupported operation '%s'\n", __func__
, op
);
177 pr_err("%s: use 'run', 'start' or 'kick'\n", __func__
);
183 static int queue_write_hint_show(void *data
, struct seq_file
*m
)
185 struct request_queue
*q
= data
;
188 for (i
= 0; i
< BLK_MAX_WRITE_HINTS
; i
++)
189 seq_printf(m
, "hint%d: %llu\n", i
, q
->write_hints
[i
]);
194 static ssize_t
queue_write_hint_store(void *data
, const char __user
*buf
,
195 size_t count
, loff_t
*ppos
)
197 struct request_queue
*q
= data
;
200 for (i
= 0; i
< BLK_MAX_WRITE_HINTS
; i
++)
201 q
->write_hints
[i
] = 0;
206 static const struct blk_mq_debugfs_attr blk_mq_debugfs_queue_attrs
[] = {
207 { "poll_stat", 0400, queue_poll_stat_show
},
208 { "requeue_list", 0400, .seq_ops
= &queue_requeue_list_seq_ops
},
209 { "pm_only", 0600, queue_pm_only_show
, NULL
},
210 { "state", 0600, queue_state_show
, queue_state_write
},
211 { "write_hints", 0600, queue_write_hint_show
, queue_write_hint_store
},
212 { "zone_wlock", 0400, queue_zone_wlock_show
, NULL
},
216 #define HCTX_STATE_NAME(name) [BLK_MQ_S_##name] = #name
217 static const char *const hctx_state_name
[] = {
218 HCTX_STATE_NAME(STOPPED
),
219 HCTX_STATE_NAME(TAG_ACTIVE
),
220 HCTX_STATE_NAME(SCHED_RESTART
),
221 HCTX_STATE_NAME(INACTIVE
),
223 #undef HCTX_STATE_NAME
225 static int hctx_state_show(void *data
, struct seq_file
*m
)
227 struct blk_mq_hw_ctx
*hctx
= data
;
229 blk_flags_show(m
, hctx
->state
, hctx_state_name
,
230 ARRAY_SIZE(hctx_state_name
));
235 #define BLK_TAG_ALLOC_NAME(name) [BLK_TAG_ALLOC_##name] = #name
236 static const char *const alloc_policy_name
[] = {
237 BLK_TAG_ALLOC_NAME(FIFO
),
238 BLK_TAG_ALLOC_NAME(RR
),
240 #undef BLK_TAG_ALLOC_NAME
242 #define HCTX_FLAG_NAME(name) [ilog2(BLK_MQ_F_##name)] = #name
243 static const char *const hctx_flag_name
[] = {
244 HCTX_FLAG_NAME(SHOULD_MERGE
),
245 HCTX_FLAG_NAME(TAG_QUEUE_SHARED
),
246 HCTX_FLAG_NAME(BLOCKING
),
247 HCTX_FLAG_NAME(NO_SCHED
),
248 HCTX_FLAG_NAME(STACKING
),
249 HCTX_FLAG_NAME(TAG_HCTX_SHARED
),
251 #undef HCTX_FLAG_NAME
253 static int hctx_flags_show(void *data
, struct seq_file
*m
)
255 struct blk_mq_hw_ctx
*hctx
= data
;
256 const int alloc_policy
= BLK_MQ_FLAG_TO_ALLOC_POLICY(hctx
->flags
);
258 seq_puts(m
, "alloc_policy=");
259 if (alloc_policy
< ARRAY_SIZE(alloc_policy_name
) &&
260 alloc_policy_name
[alloc_policy
])
261 seq_puts(m
, alloc_policy_name
[alloc_policy
]);
263 seq_printf(m
, "%d", alloc_policy
);
266 hctx
->flags
^ BLK_ALLOC_POLICY_TO_MQ_FLAG(alloc_policy
),
267 hctx_flag_name
, ARRAY_SIZE(hctx_flag_name
));
272 #define CMD_FLAG_NAME(name) [__REQ_##name] = #name
273 static const char *const cmd_flag_name
[] = {
274 CMD_FLAG_NAME(FAILFAST_DEV
),
275 CMD_FLAG_NAME(FAILFAST_TRANSPORT
),
276 CMD_FLAG_NAME(FAILFAST_DRIVER
),
280 CMD_FLAG_NAME(NOMERGE
),
282 CMD_FLAG_NAME(INTEGRITY
),
284 CMD_FLAG_NAME(PREFLUSH
),
285 CMD_FLAG_NAME(RAHEAD
),
286 CMD_FLAG_NAME(BACKGROUND
),
287 CMD_FLAG_NAME(NOWAIT
),
288 CMD_FLAG_NAME(NOUNMAP
),
289 CMD_FLAG_NAME(HIPRI
),
293 #define RQF_NAME(name) [ilog2((__force u32)RQF_##name)] = #name
294 static const char *const rqf_name
[] = {
296 RQF_NAME(SOFTBARRIER
),
298 RQF_NAME(MIXED_MERGE
),
299 RQF_NAME(MQ_INFLIGHT
),
308 RQF_NAME(SPECIAL_PAYLOAD
),
309 RQF_NAME(ZONE_WRITE_LOCKED
),
310 RQF_NAME(MQ_POLL_SLEPT
),
314 static const char *const blk_mq_rq_state_name_array
[] = {
315 [MQ_RQ_IDLE
] = "idle",
316 [MQ_RQ_IN_FLIGHT
] = "in_flight",
317 [MQ_RQ_COMPLETE
] = "complete",
320 static const char *blk_mq_rq_state_name(enum mq_rq_state rq_state
)
322 if (WARN_ON_ONCE((unsigned int)rq_state
>=
323 ARRAY_SIZE(blk_mq_rq_state_name_array
)))
325 return blk_mq_rq_state_name_array
[rq_state
];
328 int __blk_mq_debugfs_rq_show(struct seq_file
*m
, struct request
*rq
)
330 const struct blk_mq_ops
*const mq_ops
= rq
->q
->mq_ops
;
331 const unsigned int op
= req_op(rq
);
332 const char *op_str
= blk_op_str(op
);
334 seq_printf(m
, "%p {.op=", rq
);
335 if (strcmp(op_str
, "UNKNOWN") == 0)
336 seq_printf(m
, "%u", op
);
338 seq_printf(m
, "%s", op_str
);
339 seq_puts(m
, ", .cmd_flags=");
340 blk_flags_show(m
, rq
->cmd_flags
& ~REQ_OP_MASK
, cmd_flag_name
,
341 ARRAY_SIZE(cmd_flag_name
));
342 seq_puts(m
, ", .rq_flags=");
343 blk_flags_show(m
, (__force
unsigned int)rq
->rq_flags
, rqf_name
,
344 ARRAY_SIZE(rqf_name
));
345 seq_printf(m
, ", .state=%s", blk_mq_rq_state_name(blk_mq_rq_state(rq
)));
346 seq_printf(m
, ", .tag=%d, .internal_tag=%d", rq
->tag
,
349 mq_ops
->show_rq(m
, rq
);
353 EXPORT_SYMBOL_GPL(__blk_mq_debugfs_rq_show
);
355 int blk_mq_debugfs_rq_show(struct seq_file
*m
, void *v
)
357 return __blk_mq_debugfs_rq_show(m
, list_entry_rq(v
));
359 EXPORT_SYMBOL_GPL(blk_mq_debugfs_rq_show
);
361 static void *hctx_dispatch_start(struct seq_file
*m
, loff_t
*pos
)
362 __acquires(&hctx
->lock
)
364 struct blk_mq_hw_ctx
*hctx
= m
->private;
366 spin_lock(&hctx
->lock
);
367 return seq_list_start(&hctx
->dispatch
, *pos
);
370 static void *hctx_dispatch_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
372 struct blk_mq_hw_ctx
*hctx
= m
->private;
374 return seq_list_next(v
, &hctx
->dispatch
, pos
);
377 static void hctx_dispatch_stop(struct seq_file
*m
, void *v
)
378 __releases(&hctx
->lock
)
380 struct blk_mq_hw_ctx
*hctx
= m
->private;
382 spin_unlock(&hctx
->lock
);
385 static const struct seq_operations hctx_dispatch_seq_ops
= {
386 .start
= hctx_dispatch_start
,
387 .next
= hctx_dispatch_next
,
388 .stop
= hctx_dispatch_stop
,
389 .show
= blk_mq_debugfs_rq_show
,
392 struct show_busy_params
{
394 struct blk_mq_hw_ctx
*hctx
;
398 * Note: the state of a request may change while this function is in progress,
399 * e.g. due to a concurrent blk_mq_finish_request() call. Returns true to
400 * keep iterating requests.
402 static bool hctx_show_busy_rq(struct request
*rq
, void *data
, bool reserved
)
404 const struct show_busy_params
*params
= data
;
406 if (rq
->mq_hctx
== params
->hctx
)
407 __blk_mq_debugfs_rq_show(params
->m
, rq
);
412 static int hctx_busy_show(void *data
, struct seq_file
*m
)
414 struct blk_mq_hw_ctx
*hctx
= data
;
415 struct show_busy_params params
= { .m
= m
, .hctx
= hctx
};
417 blk_mq_tagset_busy_iter(hctx
->queue
->tag_set
, hctx_show_busy_rq
,
423 static const char *const hctx_types
[] = {
424 [HCTX_TYPE_DEFAULT
] = "default",
425 [HCTX_TYPE_READ
] = "read",
426 [HCTX_TYPE_POLL
] = "poll",
429 static int hctx_type_show(void *data
, struct seq_file
*m
)
431 struct blk_mq_hw_ctx
*hctx
= data
;
433 BUILD_BUG_ON(ARRAY_SIZE(hctx_types
) != HCTX_MAX_TYPES
);
434 seq_printf(m
, "%s\n", hctx_types
[hctx
->type
]);
438 static int hctx_ctx_map_show(void *data
, struct seq_file
*m
)
440 struct blk_mq_hw_ctx
*hctx
= data
;
442 sbitmap_bitmap_show(&hctx
->ctx_map
, m
);
446 static void blk_mq_debugfs_tags_show(struct seq_file
*m
,
447 struct blk_mq_tags
*tags
)
449 seq_printf(m
, "nr_tags=%u\n", tags
->nr_tags
);
450 seq_printf(m
, "nr_reserved_tags=%u\n", tags
->nr_reserved_tags
);
451 seq_printf(m
, "active_queues=%d\n",
452 atomic_read(&tags
->active_queues
));
454 seq_puts(m
, "\nbitmap_tags:\n");
455 sbitmap_queue_show(tags
->bitmap_tags
, m
);
457 if (tags
->nr_reserved_tags
) {
458 seq_puts(m
, "\nbreserved_tags:\n");
459 sbitmap_queue_show(tags
->breserved_tags
, m
);
463 static int hctx_tags_show(void *data
, struct seq_file
*m
)
465 struct blk_mq_hw_ctx
*hctx
= data
;
466 struct request_queue
*q
= hctx
->queue
;
469 res
= mutex_lock_interruptible(&q
->sysfs_lock
);
473 blk_mq_debugfs_tags_show(m
, hctx
->tags
);
474 mutex_unlock(&q
->sysfs_lock
);
480 static int hctx_tags_bitmap_show(void *data
, struct seq_file
*m
)
482 struct blk_mq_hw_ctx
*hctx
= data
;
483 struct request_queue
*q
= hctx
->queue
;
486 res
= mutex_lock_interruptible(&q
->sysfs_lock
);
490 sbitmap_bitmap_show(&hctx
->tags
->bitmap_tags
->sb
, m
);
491 mutex_unlock(&q
->sysfs_lock
);
497 static int hctx_sched_tags_show(void *data
, struct seq_file
*m
)
499 struct blk_mq_hw_ctx
*hctx
= data
;
500 struct request_queue
*q
= hctx
->queue
;
503 res
= mutex_lock_interruptible(&q
->sysfs_lock
);
506 if (hctx
->sched_tags
)
507 blk_mq_debugfs_tags_show(m
, hctx
->sched_tags
);
508 mutex_unlock(&q
->sysfs_lock
);
514 static int hctx_sched_tags_bitmap_show(void *data
, struct seq_file
*m
)
516 struct blk_mq_hw_ctx
*hctx
= data
;
517 struct request_queue
*q
= hctx
->queue
;
520 res
= mutex_lock_interruptible(&q
->sysfs_lock
);
523 if (hctx
->sched_tags
)
524 sbitmap_bitmap_show(&hctx
->sched_tags
->bitmap_tags
->sb
, m
);
525 mutex_unlock(&q
->sysfs_lock
);
531 static int hctx_io_poll_show(void *data
, struct seq_file
*m
)
533 struct blk_mq_hw_ctx
*hctx
= data
;
535 seq_printf(m
, "considered=%lu\n", hctx
->poll_considered
);
536 seq_printf(m
, "invoked=%lu\n", hctx
->poll_invoked
);
537 seq_printf(m
, "success=%lu\n", hctx
->poll_success
);
541 static ssize_t
hctx_io_poll_write(void *data
, const char __user
*buf
,
542 size_t count
, loff_t
*ppos
)
544 struct blk_mq_hw_ctx
*hctx
= data
;
546 hctx
->poll_considered
= hctx
->poll_invoked
= hctx
->poll_success
= 0;
550 static int hctx_dispatched_show(void *data
, struct seq_file
*m
)
552 struct blk_mq_hw_ctx
*hctx
= data
;
555 seq_printf(m
, "%8u\t%lu\n", 0U, hctx
->dispatched
[0]);
557 for (i
= 1; i
< BLK_MQ_MAX_DISPATCH_ORDER
- 1; i
++) {
558 unsigned int d
= 1U << (i
- 1);
560 seq_printf(m
, "%8u\t%lu\n", d
, hctx
->dispatched
[i
]);
563 seq_printf(m
, "%8u+\t%lu\n", 1U << (i
- 1), hctx
->dispatched
[i
]);
567 static ssize_t
hctx_dispatched_write(void *data
, const char __user
*buf
,
568 size_t count
, loff_t
*ppos
)
570 struct blk_mq_hw_ctx
*hctx
= data
;
573 for (i
= 0; i
< BLK_MQ_MAX_DISPATCH_ORDER
; i
++)
574 hctx
->dispatched
[i
] = 0;
578 static int hctx_queued_show(void *data
, struct seq_file
*m
)
580 struct blk_mq_hw_ctx
*hctx
= data
;
582 seq_printf(m
, "%lu\n", hctx
->queued
);
586 static ssize_t
hctx_queued_write(void *data
, const char __user
*buf
,
587 size_t count
, loff_t
*ppos
)
589 struct blk_mq_hw_ctx
*hctx
= data
;
595 static int hctx_run_show(void *data
, struct seq_file
*m
)
597 struct blk_mq_hw_ctx
*hctx
= data
;
599 seq_printf(m
, "%lu\n", hctx
->run
);
603 static ssize_t
hctx_run_write(void *data
, const char __user
*buf
, size_t count
,
606 struct blk_mq_hw_ctx
*hctx
= data
;
612 static int hctx_active_show(void *data
, struct seq_file
*m
)
614 struct blk_mq_hw_ctx
*hctx
= data
;
616 seq_printf(m
, "%d\n", atomic_read(&hctx
->nr_active
));
620 static int hctx_dispatch_busy_show(void *data
, struct seq_file
*m
)
622 struct blk_mq_hw_ctx
*hctx
= data
;
624 seq_printf(m
, "%u\n", hctx
->dispatch_busy
);
628 #define CTX_RQ_SEQ_OPS(name, type) \
629 static void *ctx_##name##_rq_list_start(struct seq_file *m, loff_t *pos) \
630 __acquires(&ctx->lock) \
632 struct blk_mq_ctx *ctx = m->private; \
634 spin_lock(&ctx->lock); \
635 return seq_list_start(&ctx->rq_lists[type], *pos); \
638 static void *ctx_##name##_rq_list_next(struct seq_file *m, void *v, \
641 struct blk_mq_ctx *ctx = m->private; \
643 return seq_list_next(v, &ctx->rq_lists[type], pos); \
646 static void ctx_##name##_rq_list_stop(struct seq_file *m, void *v) \
647 __releases(&ctx->lock) \
649 struct blk_mq_ctx *ctx = m->private; \
651 spin_unlock(&ctx->lock); \
654 static const struct seq_operations ctx_##name##_rq_list_seq_ops = { \
655 .start = ctx_##name##_rq_list_start, \
656 .next = ctx_##name##_rq_list_next, \
657 .stop = ctx_##name##_rq_list_stop, \
658 .show = blk_mq_debugfs_rq_show, \
661 CTX_RQ_SEQ_OPS(default, HCTX_TYPE_DEFAULT
);
662 CTX_RQ_SEQ_OPS(read
, HCTX_TYPE_READ
);
663 CTX_RQ_SEQ_OPS(poll
, HCTX_TYPE_POLL
);
665 static int ctx_dispatched_show(void *data
, struct seq_file
*m
)
667 struct blk_mq_ctx
*ctx
= data
;
669 seq_printf(m
, "%lu %lu\n", ctx
->rq_dispatched
[1], ctx
->rq_dispatched
[0]);
673 static ssize_t
ctx_dispatched_write(void *data
, const char __user
*buf
,
674 size_t count
, loff_t
*ppos
)
676 struct blk_mq_ctx
*ctx
= data
;
678 ctx
->rq_dispatched
[0] = ctx
->rq_dispatched
[1] = 0;
682 static int ctx_merged_show(void *data
, struct seq_file
*m
)
684 struct blk_mq_ctx
*ctx
= data
;
686 seq_printf(m
, "%lu\n", ctx
->rq_merged
);
690 static ssize_t
ctx_merged_write(void *data
, const char __user
*buf
,
691 size_t count
, loff_t
*ppos
)
693 struct blk_mq_ctx
*ctx
= data
;
699 static int ctx_completed_show(void *data
, struct seq_file
*m
)
701 struct blk_mq_ctx
*ctx
= data
;
703 seq_printf(m
, "%lu %lu\n", ctx
->rq_completed
[1], ctx
->rq_completed
[0]);
707 static ssize_t
ctx_completed_write(void *data
, const char __user
*buf
,
708 size_t count
, loff_t
*ppos
)
710 struct blk_mq_ctx
*ctx
= data
;
712 ctx
->rq_completed
[0] = ctx
->rq_completed
[1] = 0;
716 static int blk_mq_debugfs_show(struct seq_file
*m
, void *v
)
718 const struct blk_mq_debugfs_attr
*attr
= m
->private;
719 void *data
= d_inode(m
->file
->f_path
.dentry
->d_parent
)->i_private
;
721 return attr
->show(data
, m
);
724 static ssize_t
blk_mq_debugfs_write(struct file
*file
, const char __user
*buf
,
725 size_t count
, loff_t
*ppos
)
727 struct seq_file
*m
= file
->private_data
;
728 const struct blk_mq_debugfs_attr
*attr
= m
->private;
729 void *data
= d_inode(file
->f_path
.dentry
->d_parent
)->i_private
;
732 * Attributes that only implement .seq_ops are read-only and 'attr' is
733 * the same with 'data' in this case.
735 if (attr
== data
|| !attr
->write
)
738 return attr
->write(data
, buf
, count
, ppos
);
741 static int blk_mq_debugfs_open(struct inode
*inode
, struct file
*file
)
743 const struct blk_mq_debugfs_attr
*attr
= inode
->i_private
;
744 void *data
= d_inode(file
->f_path
.dentry
->d_parent
)->i_private
;
749 ret
= seq_open(file
, attr
->seq_ops
);
751 m
= file
->private_data
;
757 if (WARN_ON_ONCE(!attr
->show
))
760 return single_open(file
, blk_mq_debugfs_show
, inode
->i_private
);
763 static int blk_mq_debugfs_release(struct inode
*inode
, struct file
*file
)
765 const struct blk_mq_debugfs_attr
*attr
= inode
->i_private
;
768 return single_release(inode
, file
);
770 return seq_release(inode
, file
);
773 static const struct file_operations blk_mq_debugfs_fops
= {
774 .open
= blk_mq_debugfs_open
,
776 .write
= blk_mq_debugfs_write
,
778 .release
= blk_mq_debugfs_release
,
781 static const struct blk_mq_debugfs_attr blk_mq_debugfs_hctx_attrs
[] = {
782 {"state", 0400, hctx_state_show
},
783 {"flags", 0400, hctx_flags_show
},
784 {"dispatch", 0400, .seq_ops
= &hctx_dispatch_seq_ops
},
785 {"busy", 0400, hctx_busy_show
},
786 {"ctx_map", 0400, hctx_ctx_map_show
},
787 {"tags", 0400, hctx_tags_show
},
788 {"tags_bitmap", 0400, hctx_tags_bitmap_show
},
789 {"sched_tags", 0400, hctx_sched_tags_show
},
790 {"sched_tags_bitmap", 0400, hctx_sched_tags_bitmap_show
},
791 {"io_poll", 0600, hctx_io_poll_show
, hctx_io_poll_write
},
792 {"dispatched", 0600, hctx_dispatched_show
, hctx_dispatched_write
},
793 {"queued", 0600, hctx_queued_show
, hctx_queued_write
},
794 {"run", 0600, hctx_run_show
, hctx_run_write
},
795 {"active", 0400, hctx_active_show
},
796 {"dispatch_busy", 0400, hctx_dispatch_busy_show
},
797 {"type", 0400, hctx_type_show
},
801 static const struct blk_mq_debugfs_attr blk_mq_debugfs_ctx_attrs
[] = {
802 {"default_rq_list", 0400, .seq_ops
= &ctx_default_rq_list_seq_ops
},
803 {"read_rq_list", 0400, .seq_ops
= &ctx_read_rq_list_seq_ops
},
804 {"poll_rq_list", 0400, .seq_ops
= &ctx_poll_rq_list_seq_ops
},
805 {"dispatched", 0600, ctx_dispatched_show
, ctx_dispatched_write
},
806 {"merged", 0600, ctx_merged_show
, ctx_merged_write
},
807 {"completed", 0600, ctx_completed_show
, ctx_completed_write
},
811 static void debugfs_create_files(struct dentry
*parent
, void *data
,
812 const struct blk_mq_debugfs_attr
*attr
)
814 if (IS_ERR_OR_NULL(parent
))
817 d_inode(parent
)->i_private
= data
;
819 for (; attr
->name
; attr
++)
820 debugfs_create_file(attr
->name
, attr
->mode
, parent
,
821 (void *)attr
, &blk_mq_debugfs_fops
);
824 void blk_mq_debugfs_register(struct request_queue
*q
)
826 struct blk_mq_hw_ctx
*hctx
;
829 debugfs_create_files(q
->debugfs_dir
, q
, blk_mq_debugfs_queue_attrs
);
832 * blk_mq_init_sched() attempted to do this already, but q->debugfs_dir
833 * didn't exist yet (because we don't know what to name the directory
834 * until the queue is registered to a gendisk).
836 if (q
->elevator
&& !q
->sched_debugfs_dir
)
837 blk_mq_debugfs_register_sched(q
);
839 /* Similarly, blk_mq_init_hctx() couldn't do this previously. */
840 queue_for_each_hw_ctx(q
, hctx
, i
) {
841 if (!hctx
->debugfs_dir
)
842 blk_mq_debugfs_register_hctx(q
, hctx
);
843 if (q
->elevator
&& !hctx
->sched_debugfs_dir
)
844 blk_mq_debugfs_register_sched_hctx(q
, hctx
);
848 struct rq_qos
*rqos
= q
->rq_qos
;
851 blk_mq_debugfs_register_rqos(rqos
);
857 void blk_mq_debugfs_unregister(struct request_queue
*q
)
859 q
->sched_debugfs_dir
= NULL
;
862 static void blk_mq_debugfs_register_ctx(struct blk_mq_hw_ctx
*hctx
,
863 struct blk_mq_ctx
*ctx
)
865 struct dentry
*ctx_dir
;
868 snprintf(name
, sizeof(name
), "cpu%u", ctx
->cpu
);
869 ctx_dir
= debugfs_create_dir(name
, hctx
->debugfs_dir
);
871 debugfs_create_files(ctx_dir
, ctx
, blk_mq_debugfs_ctx_attrs
);
874 void blk_mq_debugfs_register_hctx(struct request_queue
*q
,
875 struct blk_mq_hw_ctx
*hctx
)
877 struct blk_mq_ctx
*ctx
;
881 snprintf(name
, sizeof(name
), "hctx%u", hctx
->queue_num
);
882 hctx
->debugfs_dir
= debugfs_create_dir(name
, q
->debugfs_dir
);
884 debugfs_create_files(hctx
->debugfs_dir
, hctx
, blk_mq_debugfs_hctx_attrs
);
886 hctx_for_each_ctx(hctx
, ctx
, i
)
887 blk_mq_debugfs_register_ctx(hctx
, ctx
);
890 void blk_mq_debugfs_unregister_hctx(struct blk_mq_hw_ctx
*hctx
)
892 debugfs_remove_recursive(hctx
->debugfs_dir
);
893 hctx
->sched_debugfs_dir
= NULL
;
894 hctx
->debugfs_dir
= NULL
;
897 void blk_mq_debugfs_register_hctxs(struct request_queue
*q
)
899 struct blk_mq_hw_ctx
*hctx
;
902 queue_for_each_hw_ctx(q
, hctx
, i
)
903 blk_mq_debugfs_register_hctx(q
, hctx
);
906 void blk_mq_debugfs_unregister_hctxs(struct request_queue
*q
)
908 struct blk_mq_hw_ctx
*hctx
;
911 queue_for_each_hw_ctx(q
, hctx
, i
)
912 blk_mq_debugfs_unregister_hctx(hctx
);
915 void blk_mq_debugfs_register_sched(struct request_queue
*q
)
917 struct elevator_type
*e
= q
->elevator
->type
;
920 * If the parent directory has not been created yet, return, we will be
921 * called again later on and the directory/files will be created then.
926 if (!e
->queue_debugfs_attrs
)
929 q
->sched_debugfs_dir
= debugfs_create_dir("sched", q
->debugfs_dir
);
931 debugfs_create_files(q
->sched_debugfs_dir
, q
, e
->queue_debugfs_attrs
);
934 void blk_mq_debugfs_unregister_sched(struct request_queue
*q
)
936 debugfs_remove_recursive(q
->sched_debugfs_dir
);
937 q
->sched_debugfs_dir
= NULL
;
940 static const char *rq_qos_id_to_name(enum rq_qos_id id
)
955 void blk_mq_debugfs_unregister_rqos(struct rq_qos
*rqos
)
957 debugfs_remove_recursive(rqos
->debugfs_dir
);
958 rqos
->debugfs_dir
= NULL
;
961 void blk_mq_debugfs_register_rqos(struct rq_qos
*rqos
)
963 struct request_queue
*q
= rqos
->q
;
964 const char *dir_name
= rq_qos_id_to_name(rqos
->id
);
966 if (rqos
->debugfs_dir
|| !rqos
->ops
->debugfs_attrs
)
969 if (!q
->rqos_debugfs_dir
)
970 q
->rqos_debugfs_dir
= debugfs_create_dir("rqos",
973 rqos
->debugfs_dir
= debugfs_create_dir(dir_name
,
974 rqos
->q
->rqos_debugfs_dir
);
976 debugfs_create_files(rqos
->debugfs_dir
, rqos
, rqos
->ops
->debugfs_attrs
);
979 void blk_mq_debugfs_unregister_queue_rqos(struct request_queue
*q
)
981 debugfs_remove_recursive(q
->rqos_debugfs_dir
);
982 q
->rqos_debugfs_dir
= NULL
;
985 void blk_mq_debugfs_register_sched_hctx(struct request_queue
*q
,
986 struct blk_mq_hw_ctx
*hctx
)
988 struct elevator_type
*e
= q
->elevator
->type
;
991 * If the parent debugfs directory has not been created yet, return;
992 * We will be called again later on with appropriate parent debugfs
993 * directory from blk_register_queue()
995 if (!hctx
->debugfs_dir
)
998 if (!e
->hctx_debugfs_attrs
)
1001 hctx
->sched_debugfs_dir
= debugfs_create_dir("sched",
1003 debugfs_create_files(hctx
->sched_debugfs_dir
, hctx
,
1004 e
->hctx_debugfs_attrs
);
1007 void blk_mq_debugfs_unregister_sched_hctx(struct blk_mq_hw_ctx
*hctx
)
1009 debugfs_remove_recursive(hctx
->sched_debugfs_dir
);
1010 hctx
->sched_debugfs_dir
= NULL
;