blob: 90c454bbaf925d9cc203ac984e5edb700219c97a [file] [log] [blame]
Omar Sandoval07e4fea2017-01-25 08:06:40 -08001/*
2 * Copyright (C) 2017 Facebook
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program. If not, see <https://www.gnu.org/licenses/>.
15 */
16
17#include <linux/kernel.h>
18#include <linux/blkdev.h>
19#include <linux/debugfs.h>
20
21#include <linux/blk-mq.h>
Omar Sandoval18fbda92017-01-31 14:53:20 -080022#include "blk.h"
Omar Sandoval07e4fea2017-01-25 08:06:40 -080023#include "blk-mq.h"
Omar Sandovald173a252017-05-04 00:31:30 -070024#include "blk-mq-debugfs.h"
Omar Sandovald96b37c2017-01-25 08:06:46 -080025#include "blk-mq-tag.h"
Omar Sandoval07e4fea2017-01-25 08:06:40 -080026
Bart Van Assche91d68902017-04-10 16:13:15 -060027static int blk_flags_show(struct seq_file *m, const unsigned long flags,
28 const char *const *flag_name, int flag_name_count)
29{
30 bool sep = false;
31 int i;
32
33 for (i = 0; i < sizeof(flags) * BITS_PER_BYTE; i++) {
34 if (!(flags & BIT(i)))
35 continue;
36 if (sep)
Omar Sandovalbec03d62017-05-04 00:31:23 -070037 seq_puts(m, "|");
Bart Van Assche91d68902017-04-10 16:13:15 -060038 sep = true;
39 if (i < flag_name_count && flag_name[i])
40 seq_puts(m, flag_name[i]);
41 else
42 seq_printf(m, "%d", i);
43 }
Bart Van Assche91d68902017-04-10 16:13:15 -060044 return 0;
45}
46
Omar Sandoval1a435112017-05-04 00:31:24 -070047#define QUEUE_FLAG_NAME(name) [QUEUE_FLAG_##name] = #name
Bart Van Assche91d68902017-04-10 16:13:15 -060048static const char *const blk_queue_flag_name[] = {
Omar Sandoval1a435112017-05-04 00:31:24 -070049 QUEUE_FLAG_NAME(QUEUED),
50 QUEUE_FLAG_NAME(STOPPED),
51 QUEUE_FLAG_NAME(SYNCFULL),
52 QUEUE_FLAG_NAME(ASYNCFULL),
53 QUEUE_FLAG_NAME(DYING),
54 QUEUE_FLAG_NAME(BYPASS),
55 QUEUE_FLAG_NAME(BIDI),
56 QUEUE_FLAG_NAME(NOMERGES),
57 QUEUE_FLAG_NAME(SAME_COMP),
58 QUEUE_FLAG_NAME(FAIL_IO),
59 QUEUE_FLAG_NAME(STACKABLE),
60 QUEUE_FLAG_NAME(NONROT),
61 QUEUE_FLAG_NAME(IO_STAT),
62 QUEUE_FLAG_NAME(DISCARD),
63 QUEUE_FLAG_NAME(NOXMERGES),
64 QUEUE_FLAG_NAME(ADD_RANDOM),
65 QUEUE_FLAG_NAME(SECERASE),
66 QUEUE_FLAG_NAME(SAME_FORCE),
67 QUEUE_FLAG_NAME(DEAD),
68 QUEUE_FLAG_NAME(INIT_DONE),
69 QUEUE_FLAG_NAME(NO_SG_MERGE),
70 QUEUE_FLAG_NAME(POLL),
71 QUEUE_FLAG_NAME(WC),
72 QUEUE_FLAG_NAME(FUA),
73 QUEUE_FLAG_NAME(FLUSH_NQ),
74 QUEUE_FLAG_NAME(DAX),
75 QUEUE_FLAG_NAME(STATS),
76 QUEUE_FLAG_NAME(POLL_STATS),
77 QUEUE_FLAG_NAME(REGISTERED),
Bart Van Assche91d68902017-04-10 16:13:15 -060078};
Omar Sandoval1a435112017-05-04 00:31:24 -070079#undef QUEUE_FLAG_NAME
Bart Van Assche91d68902017-04-10 16:13:15 -060080
Omar Sandovalf57de232017-05-04 00:31:28 -070081static int queue_state_show(void *data, struct seq_file *m)
Bart Van Assche91d68902017-04-10 16:13:15 -060082{
Omar Sandovalf57de232017-05-04 00:31:28 -070083 struct request_queue *q = data;
Bart Van Assche91d68902017-04-10 16:13:15 -060084
85 blk_flags_show(m, q->queue_flags, blk_queue_flag_name,
86 ARRAY_SIZE(blk_queue_flag_name));
Bart Van Asschefd07dc82017-04-26 13:47:54 -070087 seq_puts(m, "\n");
Bart Van Assche91d68902017-04-10 16:13:15 -060088 return 0;
89}
90
Omar Sandovalf57de232017-05-04 00:31:28 -070091static ssize_t queue_state_write(void *data, const char __user *buf,
92 size_t count, loff_t *ppos)
Bart Van Assche91d68902017-04-10 16:13:15 -060093{
Omar Sandovalf57de232017-05-04 00:31:28 -070094 struct request_queue *q = data;
Omar Sandoval71b90512017-05-04 00:31:26 -070095 char opbuf[16] = { }, *op;
Bart Van Assche91d68902017-04-10 16:13:15 -060096
Bart Van Assche18d4d7d2017-05-04 00:31:29 -070097 /*
98 * The "state" attribute is removed after blk_cleanup_queue() has called
99 * blk_mq_free_queue(). Return if QUEUE_FLAG_DEAD has been set to avoid
100 * triggering a use-after-free.
101 */
102 if (blk_queue_dead(q))
103 return -ENOENT;
104
Omar Sandoval71b90512017-05-04 00:31:26 -0700105 if (count >= sizeof(opbuf)) {
Omar Sandovalc7e41452017-05-04 00:31:25 -0700106 pr_err("%s: operation too long\n", __func__);
107 goto inval;
108 }
109
Omar Sandoval71b90512017-05-04 00:31:26 -0700110 if (copy_from_user(opbuf, buf, count))
Bart Van Assche91d68902017-04-10 16:13:15 -0600111 return -EFAULT;
Omar Sandoval71b90512017-05-04 00:31:26 -0700112 op = strstrip(opbuf);
Bart Van Assche91d68902017-04-10 16:13:15 -0600113 if (strcmp(op, "run") == 0) {
114 blk_mq_run_hw_queues(q, true);
115 } else if (strcmp(op, "start") == 0) {
116 blk_mq_start_stopped_hw_queues(q, true);
117 } else {
Omar Sandovalc7e41452017-05-04 00:31:25 -0700118 pr_err("%s: unsupported operation '%s'\n", __func__, op);
119inval:
120 pr_err("%s: use either 'run' or 'start'\n", __func__);
Bart Van Assche91d68902017-04-10 16:13:15 -0600121 return -EINVAL;
122 }
Omar Sandovalc7e41452017-05-04 00:31:25 -0700123 return count;
Bart Van Assche91d68902017-04-10 16:13:15 -0600124}
125
Omar Sandoval34dbad52017-03-21 08:56:08 -0700126static void print_stat(struct seq_file *m, struct blk_rq_stat *stat)
127{
128 if (stat->nr_samples) {
129 seq_printf(m, "samples=%d, mean=%lld, min=%llu, max=%llu",
130 stat->nr_samples, stat->mean, stat->min, stat->max);
131 } else {
132 seq_puts(m, "samples=0");
133 }
134}
135
Omar Sandovalf57de232017-05-04 00:31:28 -0700136static int queue_poll_stat_show(void *data, struct seq_file *m)
Omar Sandoval34dbad52017-03-21 08:56:08 -0700137{
Omar Sandovalf57de232017-05-04 00:31:28 -0700138 struct request_queue *q = data;
Stephen Bates02063192017-04-20 16:59:11 -0600139 int bucket;
Omar Sandoval34dbad52017-03-21 08:56:08 -0700140
Stephen Bates02063192017-04-20 16:59:11 -0600141 for (bucket = 0; bucket < BLK_MQ_POLL_STATS_BKTS/2; bucket++) {
142 seq_printf(m, "read (%d Bytes): ", 1 << (9+bucket));
143 print_stat(m, &q->poll_stat[2*bucket]);
144 seq_puts(m, "\n");
Omar Sandoval34dbad52017-03-21 08:56:08 -0700145
Stephen Bates02063192017-04-20 16:59:11 -0600146 seq_printf(m, "write (%d Bytes): ", 1 << (9+bucket));
147 print_stat(m, &q->poll_stat[2*bucket+1]);
148 seq_puts(m, "\n");
149 }
Omar Sandoval34dbad52017-03-21 08:56:08 -0700150 return 0;
151}
152
Omar Sandoval1a435112017-05-04 00:31:24 -0700153#define HCTX_STATE_NAME(name) [BLK_MQ_S_##name] = #name
Bart Van Asschef5c0b0912017-03-30 11:21:27 -0700154static const char *const hctx_state_name[] = {
Omar Sandoval1a435112017-05-04 00:31:24 -0700155 HCTX_STATE_NAME(STOPPED),
156 HCTX_STATE_NAME(TAG_ACTIVE),
157 HCTX_STATE_NAME(SCHED_RESTART),
158 HCTX_STATE_NAME(TAG_WAITING),
159 HCTX_STATE_NAME(START_ON_RUN),
Bart Van Asschef5c0b0912017-03-30 11:21:27 -0700160};
Omar Sandoval1a435112017-05-04 00:31:24 -0700161#undef HCTX_STATE_NAME
162
Omar Sandovalf57de232017-05-04 00:31:28 -0700163static int hctx_state_show(void *data, struct seq_file *m)
Omar Sandoval9abb2ad2017-01-25 08:06:41 -0800164{
Omar Sandovalf57de232017-05-04 00:31:28 -0700165 struct blk_mq_hw_ctx *hctx = data;
Omar Sandoval9abb2ad2017-01-25 08:06:41 -0800166
Bart Van Asschef5c0b0912017-03-30 11:21:27 -0700167 blk_flags_show(m, hctx->state, hctx_state_name,
168 ARRAY_SIZE(hctx_state_name));
Bart Van Asschefd07dc82017-04-26 13:47:54 -0700169 seq_puts(m, "\n");
Omar Sandoval9abb2ad2017-01-25 08:06:41 -0800170 return 0;
171}
172
Omar Sandoval1a435112017-05-04 00:31:24 -0700173#define BLK_TAG_ALLOC_NAME(name) [BLK_TAG_ALLOC_##name] = #name
Bart Van Asschef5c0b0912017-03-30 11:21:27 -0700174static const char *const alloc_policy_name[] = {
Omar Sandoval1a435112017-05-04 00:31:24 -0700175 BLK_TAG_ALLOC_NAME(FIFO),
176 BLK_TAG_ALLOC_NAME(RR),
Bart Van Asschef5c0b0912017-03-30 11:21:27 -0700177};
Omar Sandoval1a435112017-05-04 00:31:24 -0700178#undef BLK_TAG_ALLOC_NAME
Bart Van Asschef5c0b0912017-03-30 11:21:27 -0700179
Omar Sandoval1a435112017-05-04 00:31:24 -0700180#define HCTX_FLAG_NAME(name) [ilog2(BLK_MQ_F_##name)] = #name
Bart Van Asschef5c0b0912017-03-30 11:21:27 -0700181static const char *const hctx_flag_name[] = {
Omar Sandoval1a435112017-05-04 00:31:24 -0700182 HCTX_FLAG_NAME(SHOULD_MERGE),
183 HCTX_FLAG_NAME(TAG_SHARED),
184 HCTX_FLAG_NAME(SG_MERGE),
185 HCTX_FLAG_NAME(BLOCKING),
186 HCTX_FLAG_NAME(NO_SCHED),
Bart Van Asschef5c0b0912017-03-30 11:21:27 -0700187};
Omar Sandoval1a435112017-05-04 00:31:24 -0700188#undef HCTX_FLAG_NAME
Bart Van Asschef5c0b0912017-03-30 11:21:27 -0700189
Omar Sandovalf57de232017-05-04 00:31:28 -0700190static int hctx_flags_show(void *data, struct seq_file *m)
Omar Sandoval9abb2ad2017-01-25 08:06:41 -0800191{
Omar Sandovalf57de232017-05-04 00:31:28 -0700192 struct blk_mq_hw_ctx *hctx = data;
Bart Van Asschef5c0b0912017-03-30 11:21:27 -0700193 const int alloc_policy = BLK_MQ_FLAG_TO_ALLOC_POLICY(hctx->flags);
Omar Sandoval9abb2ad2017-01-25 08:06:41 -0800194
Bart Van Asschef5c0b0912017-03-30 11:21:27 -0700195 seq_puts(m, "alloc_policy=");
196 if (alloc_policy < ARRAY_SIZE(alloc_policy_name) &&
197 alloc_policy_name[alloc_policy])
198 seq_puts(m, alloc_policy_name[alloc_policy]);
199 else
200 seq_printf(m, "%d", alloc_policy);
201 seq_puts(m, " ");
202 blk_flags_show(m,
203 hctx->flags ^ BLK_ALLOC_POLICY_TO_MQ_FLAG(alloc_policy),
204 hctx_flag_name, ARRAY_SIZE(hctx_flag_name));
Bart Van Asschefd07dc82017-04-26 13:47:54 -0700205 seq_puts(m, "\n");
Omar Sandoval9abb2ad2017-01-25 08:06:41 -0800206 return 0;
207}
208
Omar Sandoval1a435112017-05-04 00:31:24 -0700209#define REQ_OP_NAME(name) [REQ_OP_##name] = #name
Bart Van Assche8658dca2017-04-26 13:47:55 -0700210static const char *const op_name[] = {
Omar Sandoval1a435112017-05-04 00:31:24 -0700211 REQ_OP_NAME(READ),
212 REQ_OP_NAME(WRITE),
213 REQ_OP_NAME(FLUSH),
214 REQ_OP_NAME(DISCARD),
215 REQ_OP_NAME(ZONE_REPORT),
216 REQ_OP_NAME(SECURE_ERASE),
217 REQ_OP_NAME(ZONE_RESET),
218 REQ_OP_NAME(WRITE_SAME),
219 REQ_OP_NAME(WRITE_ZEROES),
220 REQ_OP_NAME(SCSI_IN),
221 REQ_OP_NAME(SCSI_OUT),
222 REQ_OP_NAME(DRV_IN),
223 REQ_OP_NAME(DRV_OUT),
Bart Van Assche8658dca2017-04-26 13:47:55 -0700224};
Omar Sandoval1a435112017-05-04 00:31:24 -0700225#undef REQ_OP_NAME
Bart Van Assche8658dca2017-04-26 13:47:55 -0700226
Omar Sandoval1a435112017-05-04 00:31:24 -0700227#define CMD_FLAG_NAME(name) [__REQ_##name] = #name
Bart Van Assche8658dca2017-04-26 13:47:55 -0700228static const char *const cmd_flag_name[] = {
Omar Sandoval1a435112017-05-04 00:31:24 -0700229 CMD_FLAG_NAME(FAILFAST_DEV),
230 CMD_FLAG_NAME(FAILFAST_TRANSPORT),
231 CMD_FLAG_NAME(FAILFAST_DRIVER),
232 CMD_FLAG_NAME(SYNC),
233 CMD_FLAG_NAME(META),
234 CMD_FLAG_NAME(PRIO),
235 CMD_FLAG_NAME(NOMERGE),
236 CMD_FLAG_NAME(IDLE),
237 CMD_FLAG_NAME(INTEGRITY),
238 CMD_FLAG_NAME(FUA),
239 CMD_FLAG_NAME(PREFLUSH),
240 CMD_FLAG_NAME(RAHEAD),
241 CMD_FLAG_NAME(BACKGROUND),
242 CMD_FLAG_NAME(NOUNMAP),
Bart Van Assche8658dca2017-04-26 13:47:55 -0700243};
Omar Sandoval1a435112017-05-04 00:31:24 -0700244#undef CMD_FLAG_NAME
Bart Van Assche8658dca2017-04-26 13:47:55 -0700245
Omar Sandoval1a435112017-05-04 00:31:24 -0700246#define RQF_NAME(name) [ilog2((__force u32)RQF_##name)] = #name
Bart Van Assche8658dca2017-04-26 13:47:55 -0700247static const char *const rqf_name[] = {
Omar Sandoval1a435112017-05-04 00:31:24 -0700248 RQF_NAME(SORTED),
249 RQF_NAME(STARTED),
250 RQF_NAME(QUEUED),
251 RQF_NAME(SOFTBARRIER),
252 RQF_NAME(FLUSH_SEQ),
253 RQF_NAME(MIXED_MERGE),
254 RQF_NAME(MQ_INFLIGHT),
255 RQF_NAME(DONTPREP),
256 RQF_NAME(PREEMPT),
257 RQF_NAME(COPY_USER),
258 RQF_NAME(FAILED),
259 RQF_NAME(QUIET),
260 RQF_NAME(ELVPRIV),
261 RQF_NAME(IO_STAT),
262 RQF_NAME(ALLOCED),
263 RQF_NAME(PM),
264 RQF_NAME(HASHED),
265 RQF_NAME(STATS),
266 RQF_NAME(SPECIAL_PAYLOAD),
Bart Van Assche8658dca2017-04-26 13:47:55 -0700267};
Omar Sandoval1a435112017-05-04 00:31:24 -0700268#undef RQF_NAME
Bart Van Assche8658dca2017-04-26 13:47:55 -0700269
Bart Van Asschec0cb1c62017-06-01 08:55:10 -0700270#define RQAF_NAME(name) [REQ_ATOM_##name] = #name
271static const char *const rqaf_name[] = {
272 RQAF_NAME(COMPLETE),
273 RQAF_NAME(STARTED),
274 RQAF_NAME(POLL_SLEPT),
275};
276#undef RQAF_NAME
277
Omar Sandovaldaaadb32017-05-04 00:31:34 -0700278int __blk_mq_debugfs_rq_show(struct seq_file *m, struct request *rq)
Omar Sandoval950cd7e2017-01-25 08:06:42 -0800279{
Bart Van Assche2836ee42017-04-26 13:47:56 -0700280 const struct blk_mq_ops *const mq_ops = rq->q->mq_ops;
Bart Van Assche8658dca2017-04-26 13:47:55 -0700281 const unsigned int op = rq->cmd_flags & REQ_OP_MASK;
Omar Sandoval950cd7e2017-01-25 08:06:42 -0800282
Bart Van Assche8658dca2017-04-26 13:47:55 -0700283 seq_printf(m, "%p {.op=", rq);
284 if (op < ARRAY_SIZE(op_name) && op_name[op])
285 seq_printf(m, "%s", op_name[op]);
286 else
287 seq_printf(m, "%d", op);
288 seq_puts(m, ", .cmd_flags=");
289 blk_flags_show(m, rq->cmd_flags & ~REQ_OP_MASK, cmd_flag_name,
290 ARRAY_SIZE(cmd_flag_name));
291 seq_puts(m, ", .rq_flags=");
292 blk_flags_show(m, (__force unsigned int)rq->rq_flags, rqf_name,
293 ARRAY_SIZE(rqf_name));
Bart Van Asschec0cb1c62017-06-01 08:55:10 -0700294 seq_puts(m, ", .atomic_flags=");
295 blk_flags_show(m, rq->atomic_flags, rqaf_name, ARRAY_SIZE(rqaf_name));
Bart Van Assche2836ee42017-04-26 13:47:56 -0700296 seq_printf(m, ", .tag=%d, .internal_tag=%d", rq->tag,
Bart Van Assche8658dca2017-04-26 13:47:55 -0700297 rq->internal_tag);
Bart Van Assche2836ee42017-04-26 13:47:56 -0700298 if (mq_ops->show_rq)
299 mq_ops->show_rq(m, rq);
300 seq_puts(m, "}\n");
Omar Sandoval950cd7e2017-01-25 08:06:42 -0800301 return 0;
302}
Omar Sandovaldaaadb32017-05-04 00:31:34 -0700303EXPORT_SYMBOL_GPL(__blk_mq_debugfs_rq_show);
304
305int blk_mq_debugfs_rq_show(struct seq_file *m, void *v)
306{
307 return __blk_mq_debugfs_rq_show(m, list_entry_rq(v));
308}
Omar Sandoval16b738f2017-05-04 00:31:33 -0700309EXPORT_SYMBOL_GPL(blk_mq_debugfs_rq_show);
Omar Sandoval950cd7e2017-01-25 08:06:42 -0800310
Bart Van Assche8ef1a192017-06-01 08:55:11 -0700311static void *queue_requeue_list_start(struct seq_file *m, loff_t *pos)
312 __acquires(&q->requeue_lock)
313{
314 struct request_queue *q = m->private;
315
316 spin_lock_irq(&q->requeue_lock);
317 return seq_list_start(&q->requeue_list, *pos);
318}
319
320static void *queue_requeue_list_next(struct seq_file *m, void *v, loff_t *pos)
321{
322 struct request_queue *q = m->private;
323
324 return seq_list_next(v, &q->requeue_list, pos);
325}
326
327static void queue_requeue_list_stop(struct seq_file *m, void *v)
328 __releases(&q->requeue_lock)
329{
330 struct request_queue *q = m->private;
331
332 spin_unlock_irq(&q->requeue_lock);
333}
334
335static const struct seq_operations queue_requeue_list_seq_ops = {
336 .start = queue_requeue_list_start,
337 .next = queue_requeue_list_next,
338 .stop = queue_requeue_list_stop,
339 .show = blk_mq_debugfs_rq_show,
340};
341
Omar Sandoval950cd7e2017-01-25 08:06:42 -0800342static void *hctx_dispatch_start(struct seq_file *m, loff_t *pos)
Bart Van Asschef3bcb0e2017-02-01 10:20:56 -0800343 __acquires(&hctx->lock)
Omar Sandoval950cd7e2017-01-25 08:06:42 -0800344{
345 struct blk_mq_hw_ctx *hctx = m->private;
346
347 spin_lock(&hctx->lock);
348 return seq_list_start(&hctx->dispatch, *pos);
349}
350
351static void *hctx_dispatch_next(struct seq_file *m, void *v, loff_t *pos)
352{
353 struct blk_mq_hw_ctx *hctx = m->private;
354
355 return seq_list_next(v, &hctx->dispatch, pos);
356}
357
358static void hctx_dispatch_stop(struct seq_file *m, void *v)
Bart Van Asschef3bcb0e2017-02-01 10:20:56 -0800359 __releases(&hctx->lock)
Omar Sandoval950cd7e2017-01-25 08:06:42 -0800360{
361 struct blk_mq_hw_ctx *hctx = m->private;
362
363 spin_unlock(&hctx->lock);
364}
365
366static const struct seq_operations hctx_dispatch_seq_ops = {
367 .start = hctx_dispatch_start,
368 .next = hctx_dispatch_next,
369 .stop = hctx_dispatch_stop,
370 .show = blk_mq_debugfs_rq_show,
371};
372
Bart Van Assche2720bab2017-06-01 08:55:12 -0700373struct show_busy_params {
374 struct seq_file *m;
375 struct blk_mq_hw_ctx *hctx;
376};
377
378/*
379 * Note: the state of a request may change while this function is in progress,
380 * e.g. due to a concurrent blk_mq_finish_request() call.
381 */
382static void hctx_show_busy_rq(struct request *rq, void *data, bool reserved)
383{
384 const struct show_busy_params *params = data;
385
386 if (blk_mq_map_queue(rq->q, rq->mq_ctx->cpu) == params->hctx &&
387 test_bit(REQ_ATOM_STARTED, &rq->atomic_flags))
388 __blk_mq_debugfs_rq_show(params->m,
389 list_entry_rq(&rq->queuelist));
390}
391
392static int hctx_busy_show(void *data, struct seq_file *m)
393{
394 struct blk_mq_hw_ctx *hctx = data;
395 struct show_busy_params params = { .m = m, .hctx = hctx };
396
397 blk_mq_tagset_busy_iter(hctx->queue->tag_set, hctx_show_busy_rq,
398 &params);
399
400 return 0;
401}
402
Omar Sandovalf57de232017-05-04 00:31:28 -0700403static int hctx_ctx_map_show(void *data, struct seq_file *m)
Omar Sandoval950cd7e2017-01-25 08:06:42 -0800404{
Omar Sandovalf57de232017-05-04 00:31:28 -0700405 struct blk_mq_hw_ctx *hctx = data;
Omar Sandoval0bfa5282017-01-25 08:06:45 -0800406
407 sbitmap_bitmap_show(&hctx->ctx_map, m);
408 return 0;
409}
410
Omar Sandovald96b37c2017-01-25 08:06:46 -0800411static void blk_mq_debugfs_tags_show(struct seq_file *m,
412 struct blk_mq_tags *tags)
413{
414 seq_printf(m, "nr_tags=%u\n", tags->nr_tags);
415 seq_printf(m, "nr_reserved_tags=%u\n", tags->nr_reserved_tags);
416 seq_printf(m, "active_queues=%d\n",
417 atomic_read(&tags->active_queues));
418
419 seq_puts(m, "\nbitmap_tags:\n");
420 sbitmap_queue_show(&tags->bitmap_tags, m);
421
422 if (tags->nr_reserved_tags) {
423 seq_puts(m, "\nbreserved_tags:\n");
424 sbitmap_queue_show(&tags->breserved_tags, m);
425 }
426}
427
Omar Sandovalf57de232017-05-04 00:31:28 -0700428static int hctx_tags_show(void *data, struct seq_file *m)
Omar Sandovald96b37c2017-01-25 08:06:46 -0800429{
Omar Sandovalf57de232017-05-04 00:31:28 -0700430 struct blk_mq_hw_ctx *hctx = data;
Omar Sandovald96b37c2017-01-25 08:06:46 -0800431 struct request_queue *q = hctx->queue;
Bart Van Assche8c0f14e2017-02-01 10:20:58 -0800432 int res;
Omar Sandovald96b37c2017-01-25 08:06:46 -0800433
Bart Van Assche8c0f14e2017-02-01 10:20:58 -0800434 res = mutex_lock_interruptible(&q->sysfs_lock);
435 if (res)
436 goto out;
Omar Sandovald96b37c2017-01-25 08:06:46 -0800437 if (hctx->tags)
438 blk_mq_debugfs_tags_show(m, hctx->tags);
439 mutex_unlock(&q->sysfs_lock);
440
Bart Van Assche8c0f14e2017-02-01 10:20:58 -0800441out:
442 return res;
Omar Sandovald96b37c2017-01-25 08:06:46 -0800443}
444
Omar Sandovalf57de232017-05-04 00:31:28 -0700445static int hctx_tags_bitmap_show(void *data, struct seq_file *m)
Omar Sandovald96b37c2017-01-25 08:06:46 -0800446{
Omar Sandovalf57de232017-05-04 00:31:28 -0700447 struct blk_mq_hw_ctx *hctx = data;
Omar Sandovald7e36212017-01-25 08:06:47 -0800448 struct request_queue *q = hctx->queue;
Bart Van Assche8c0f14e2017-02-01 10:20:58 -0800449 int res;
Omar Sandovald7e36212017-01-25 08:06:47 -0800450
Bart Van Assche8c0f14e2017-02-01 10:20:58 -0800451 res = mutex_lock_interruptible(&q->sysfs_lock);
452 if (res)
453 goto out;
Omar Sandovald7e36212017-01-25 08:06:47 -0800454 if (hctx->tags)
455 sbitmap_bitmap_show(&hctx->tags->bitmap_tags.sb, m);
456 mutex_unlock(&q->sysfs_lock);
Bart Van Assche8c0f14e2017-02-01 10:20:58 -0800457
458out:
459 return res;
Omar Sandovald7e36212017-01-25 08:06:47 -0800460}
461
Omar Sandovalf57de232017-05-04 00:31:28 -0700462static int hctx_sched_tags_show(void *data, struct seq_file *m)
Omar Sandovald7e36212017-01-25 08:06:47 -0800463{
Omar Sandovalf57de232017-05-04 00:31:28 -0700464 struct blk_mq_hw_ctx *hctx = data;
Omar Sandovald96b37c2017-01-25 08:06:46 -0800465 struct request_queue *q = hctx->queue;
Bart Van Assche8c0f14e2017-02-01 10:20:58 -0800466 int res;
Omar Sandovald96b37c2017-01-25 08:06:46 -0800467
Bart Van Assche8c0f14e2017-02-01 10:20:58 -0800468 res = mutex_lock_interruptible(&q->sysfs_lock);
469 if (res)
470 goto out;
Omar Sandovald96b37c2017-01-25 08:06:46 -0800471 if (hctx->sched_tags)
472 blk_mq_debugfs_tags_show(m, hctx->sched_tags);
473 mutex_unlock(&q->sysfs_lock);
474
Bart Van Assche8c0f14e2017-02-01 10:20:58 -0800475out:
476 return res;
Omar Sandovald96b37c2017-01-25 08:06:46 -0800477}
478
Omar Sandovalf57de232017-05-04 00:31:28 -0700479static int hctx_sched_tags_bitmap_show(void *data, struct seq_file *m)
Omar Sandovald96b37c2017-01-25 08:06:46 -0800480{
Omar Sandovalf57de232017-05-04 00:31:28 -0700481 struct blk_mq_hw_ctx *hctx = data;
Omar Sandovald7e36212017-01-25 08:06:47 -0800482 struct request_queue *q = hctx->queue;
Bart Van Assche8c0f14e2017-02-01 10:20:58 -0800483 int res;
Omar Sandovald7e36212017-01-25 08:06:47 -0800484
Bart Van Assche8c0f14e2017-02-01 10:20:58 -0800485 res = mutex_lock_interruptible(&q->sysfs_lock);
486 if (res)
487 goto out;
Omar Sandovald7e36212017-01-25 08:06:47 -0800488 if (hctx->sched_tags)
489 sbitmap_bitmap_show(&hctx->sched_tags->bitmap_tags.sb, m);
490 mutex_unlock(&q->sysfs_lock);
Bart Van Assche8c0f14e2017-02-01 10:20:58 -0800491
492out:
493 return res;
Omar Sandovald7e36212017-01-25 08:06:47 -0800494}
495
Omar Sandovalf57de232017-05-04 00:31:28 -0700496static int hctx_io_poll_show(void *data, struct seq_file *m)
Omar Sandovald7e36212017-01-25 08:06:47 -0800497{
Omar Sandovalf57de232017-05-04 00:31:28 -0700498 struct blk_mq_hw_ctx *hctx = data;
Omar Sandovalbe215472017-01-25 08:06:48 -0800499
500 seq_printf(m, "considered=%lu\n", hctx->poll_considered);
501 seq_printf(m, "invoked=%lu\n", hctx->poll_invoked);
502 seq_printf(m, "success=%lu\n", hctx->poll_success);
503 return 0;
504}
505
Omar Sandovalf57de232017-05-04 00:31:28 -0700506static ssize_t hctx_io_poll_write(void *data, const char __user *buf,
Omar Sandovalbe215472017-01-25 08:06:48 -0800507 size_t count, loff_t *ppos)
508{
Omar Sandovalf57de232017-05-04 00:31:28 -0700509 struct blk_mq_hw_ctx *hctx = data;
Omar Sandovalbe215472017-01-25 08:06:48 -0800510
511 hctx->poll_considered = hctx->poll_invoked = hctx->poll_success = 0;
512 return count;
513}
514
Omar Sandovalf57de232017-05-04 00:31:28 -0700515static int hctx_dispatched_show(void *data, struct seq_file *m)
Omar Sandovalbe215472017-01-25 08:06:48 -0800516{
Omar Sandovalf57de232017-05-04 00:31:28 -0700517 struct blk_mq_hw_ctx *hctx = data;
Omar Sandovalbe215472017-01-25 08:06:48 -0800518 int i;
519
520 seq_printf(m, "%8u\t%lu\n", 0U, hctx->dispatched[0]);
521
522 for (i = 1; i < BLK_MQ_MAX_DISPATCH_ORDER - 1; i++) {
523 unsigned int d = 1U << (i - 1);
524
525 seq_printf(m, "%8u\t%lu\n", d, hctx->dispatched[i]);
526 }
527
528 seq_printf(m, "%8u+\t%lu\n", 1U << (i - 1), hctx->dispatched[i]);
529 return 0;
530}
531
Omar Sandovalf57de232017-05-04 00:31:28 -0700532static ssize_t hctx_dispatched_write(void *data, const char __user *buf,
Omar Sandovalbe215472017-01-25 08:06:48 -0800533 size_t count, loff_t *ppos)
534{
Omar Sandovalf57de232017-05-04 00:31:28 -0700535 struct blk_mq_hw_ctx *hctx = data;
Omar Sandovalbe215472017-01-25 08:06:48 -0800536 int i;
537
538 for (i = 0; i < BLK_MQ_MAX_DISPATCH_ORDER; i++)
539 hctx->dispatched[i] = 0;
540 return count;
541}
542
Omar Sandovalf57de232017-05-04 00:31:28 -0700543static int hctx_queued_show(void *data, struct seq_file *m)
Omar Sandoval4a46f052017-01-25 08:06:49 -0800544{
Omar Sandovalf57de232017-05-04 00:31:28 -0700545 struct blk_mq_hw_ctx *hctx = data;
Omar Sandoval4a46f052017-01-25 08:06:49 -0800546
547 seq_printf(m, "%lu\n", hctx->queued);
548 return 0;
549}
550
Omar Sandovalf57de232017-05-04 00:31:28 -0700551static ssize_t hctx_queued_write(void *data, const char __user *buf,
Omar Sandoval4a46f052017-01-25 08:06:49 -0800552 size_t count, loff_t *ppos)
553{
Omar Sandovalf57de232017-05-04 00:31:28 -0700554 struct blk_mq_hw_ctx *hctx = data;
Omar Sandoval4a46f052017-01-25 08:06:49 -0800555
556 hctx->queued = 0;
557 return count;
558}
559
Omar Sandovalf57de232017-05-04 00:31:28 -0700560static int hctx_run_show(void *data, struct seq_file *m)
Omar Sandoval4a46f052017-01-25 08:06:49 -0800561{
Omar Sandovalf57de232017-05-04 00:31:28 -0700562 struct blk_mq_hw_ctx *hctx = data;
Omar Sandoval4a46f052017-01-25 08:06:49 -0800563
564 seq_printf(m, "%lu\n", hctx->run);
565 return 0;
566}
567
Omar Sandovalf57de232017-05-04 00:31:28 -0700568static ssize_t hctx_run_write(void *data, const char __user *buf, size_t count,
569 loff_t *ppos)
Omar Sandoval4a46f052017-01-25 08:06:49 -0800570{
Omar Sandovalf57de232017-05-04 00:31:28 -0700571 struct blk_mq_hw_ctx *hctx = data;
Omar Sandoval4a46f052017-01-25 08:06:49 -0800572
573 hctx->run = 0;
574 return count;
575}
576
Omar Sandovalf57de232017-05-04 00:31:28 -0700577static int hctx_active_show(void *data, struct seq_file *m)
Omar Sandoval4a46f052017-01-25 08:06:49 -0800578{
Omar Sandovalf57de232017-05-04 00:31:28 -0700579 struct blk_mq_hw_ctx *hctx = data;
Omar Sandoval4a46f052017-01-25 08:06:49 -0800580
581 seq_printf(m, "%d\n", atomic_read(&hctx->nr_active));
582 return 0;
583}
584
Omar Sandoval950cd7e2017-01-25 08:06:42 -0800585static void *ctx_rq_list_start(struct seq_file *m, loff_t *pos)
Bart Van Asschef3bcb0e2017-02-01 10:20:56 -0800586 __acquires(&ctx->lock)
Omar Sandoval950cd7e2017-01-25 08:06:42 -0800587{
588 struct blk_mq_ctx *ctx = m->private;
589
590 spin_lock(&ctx->lock);
591 return seq_list_start(&ctx->rq_list, *pos);
592}
593
594static void *ctx_rq_list_next(struct seq_file *m, void *v, loff_t *pos)
595{
596 struct blk_mq_ctx *ctx = m->private;
597
598 return seq_list_next(v, &ctx->rq_list, pos);
599}
600
601static void ctx_rq_list_stop(struct seq_file *m, void *v)
Bart Van Asschef3bcb0e2017-02-01 10:20:56 -0800602 __releases(&ctx->lock)
Omar Sandoval950cd7e2017-01-25 08:06:42 -0800603{
604 struct blk_mq_ctx *ctx = m->private;
605
606 spin_unlock(&ctx->lock);
607}
608
609static const struct seq_operations ctx_rq_list_seq_ops = {
610 .start = ctx_rq_list_start,
611 .next = ctx_rq_list_next,
612 .stop = ctx_rq_list_stop,
613 .show = blk_mq_debugfs_rq_show,
614};
Omar Sandovalf57de232017-05-04 00:31:28 -0700615static int ctx_dispatched_show(void *data, struct seq_file *m)
Omar Sandoval950cd7e2017-01-25 08:06:42 -0800616{
Omar Sandovalf57de232017-05-04 00:31:28 -0700617 struct blk_mq_ctx *ctx = data;
Omar Sandoval4a46f052017-01-25 08:06:49 -0800618
619 seq_printf(m, "%lu %lu\n", ctx->rq_dispatched[1], ctx->rq_dispatched[0]);
620 return 0;
621}
622
Omar Sandovalf57de232017-05-04 00:31:28 -0700623static ssize_t ctx_dispatched_write(void *data, const char __user *buf,
Omar Sandoval4a46f052017-01-25 08:06:49 -0800624 size_t count, loff_t *ppos)
625{
Omar Sandovalf57de232017-05-04 00:31:28 -0700626 struct blk_mq_ctx *ctx = data;
Omar Sandoval4a46f052017-01-25 08:06:49 -0800627
628 ctx->rq_dispatched[0] = ctx->rq_dispatched[1] = 0;
629 return count;
630}
631
Omar Sandovalf57de232017-05-04 00:31:28 -0700632static int ctx_merged_show(void *data, struct seq_file *m)
Omar Sandoval4a46f052017-01-25 08:06:49 -0800633{
Omar Sandovalf57de232017-05-04 00:31:28 -0700634 struct blk_mq_ctx *ctx = data;
Omar Sandoval4a46f052017-01-25 08:06:49 -0800635
636 seq_printf(m, "%lu\n", ctx->rq_merged);
637 return 0;
638}
639
Omar Sandovalf57de232017-05-04 00:31:28 -0700640static ssize_t ctx_merged_write(void *data, const char __user *buf,
641 size_t count, loff_t *ppos)
Omar Sandoval4a46f052017-01-25 08:06:49 -0800642{
Omar Sandovalf57de232017-05-04 00:31:28 -0700643 struct blk_mq_ctx *ctx = data;
Omar Sandoval4a46f052017-01-25 08:06:49 -0800644
645 ctx->rq_merged = 0;
646 return count;
647}
648
Omar Sandovalf57de232017-05-04 00:31:28 -0700649static int ctx_completed_show(void *data, struct seq_file *m)
Omar Sandoval4a46f052017-01-25 08:06:49 -0800650{
Omar Sandovalf57de232017-05-04 00:31:28 -0700651 struct blk_mq_ctx *ctx = data;
Omar Sandoval4a46f052017-01-25 08:06:49 -0800652
653 seq_printf(m, "%lu %lu\n", ctx->rq_completed[1], ctx->rq_completed[0]);
654 return 0;
655}
656
Omar Sandovalf57de232017-05-04 00:31:28 -0700657static ssize_t ctx_completed_write(void *data, const char __user *buf,
Omar Sandoval4a46f052017-01-25 08:06:49 -0800658 size_t count, loff_t *ppos)
659{
Omar Sandovalf57de232017-05-04 00:31:28 -0700660 struct blk_mq_ctx *ctx = data;
Omar Sandoval4a46f052017-01-25 08:06:49 -0800661
662 ctx->rq_completed[0] = ctx->rq_completed[1] = 0;
663 return count;
664}
665
Omar Sandovalf57de232017-05-04 00:31:28 -0700666static int blk_mq_debugfs_show(struct seq_file *m, void *v)
667{
668 const struct blk_mq_debugfs_attr *attr = m->private;
669 void *data = d_inode(m->file->f_path.dentry->d_parent)->i_private;
670
671 return attr->show(data, m);
672}
673
674static ssize_t blk_mq_debugfs_write(struct file *file, const char __user *buf,
675 size_t count, loff_t *ppos)
676{
677 struct seq_file *m = file->private_data;
678 const struct blk_mq_debugfs_attr *attr = m->private;
679 void *data = d_inode(file->f_path.dentry->d_parent)->i_private;
680
681 if (!attr->write)
682 return -EPERM;
683
684 return attr->write(data, buf, count, ppos);
685}
686
687static int blk_mq_debugfs_open(struct inode *inode, struct file *file)
688{
689 const struct blk_mq_debugfs_attr *attr = inode->i_private;
690 void *data = d_inode(file->f_path.dentry->d_parent)->i_private;
691 struct seq_file *m;
692 int ret;
693
694 if (attr->seq_ops) {
695 ret = seq_open(file, attr->seq_ops);
696 if (!ret) {
697 m = file->private_data;
698 m->private = data;
699 }
700 return ret;
701 }
702
703 if (WARN_ON_ONCE(!attr->show))
704 return -EPERM;
705
706 return single_open(file, blk_mq_debugfs_show, inode->i_private);
707}
708
709static int blk_mq_debugfs_release(struct inode *inode, struct file *file)
710{
711 const struct blk_mq_debugfs_attr *attr = inode->i_private;
712
713 if (attr->show)
714 return single_release(inode, file);
715 else
716 return seq_release(inode, file);
717}
718
719const struct file_operations blk_mq_debugfs_fops = {
720 .open = blk_mq_debugfs_open,
Omar Sandoval4a46f052017-01-25 08:06:49 -0800721 .read = seq_read,
Omar Sandovalf57de232017-05-04 00:31:28 -0700722 .write = blk_mq_debugfs_write,
Omar Sandoval4a46f052017-01-25 08:06:49 -0800723 .llseek = seq_lseek,
Omar Sandovalf57de232017-05-04 00:31:28 -0700724 .release = blk_mq_debugfs_release,
Omar Sandoval4a46f052017-01-25 08:06:49 -0800725};
726
Omar Sandoval34dbad52017-03-21 08:56:08 -0700727static const struct blk_mq_debugfs_attr blk_mq_debugfs_queue_attrs[] = {
Omar Sandovalf57de232017-05-04 00:31:28 -0700728 {"poll_stat", 0400, queue_poll_stat_show},
Bart Van Assche8ef1a192017-06-01 08:55:11 -0700729 {"requeue_list", 0400, .seq_ops = &queue_requeue_list_seq_ops},
Omar Sandovalf57de232017-05-04 00:31:28 -0700730 {"state", 0600, queue_state_show, queue_state_write},
Omar Sandoval34dbad52017-03-21 08:56:08 -0700731 {},
732};
733
Omar Sandoval07e4fea2017-01-25 08:06:40 -0800734static const struct blk_mq_debugfs_attr blk_mq_debugfs_hctx_attrs[] = {
Omar Sandovalf57de232017-05-04 00:31:28 -0700735 {"state", 0400, hctx_state_show},
736 {"flags", 0400, hctx_flags_show},
737 {"dispatch", 0400, .seq_ops = &hctx_dispatch_seq_ops},
Bart Van Assche2720bab2017-06-01 08:55:12 -0700738 {"busy", 0400, hctx_busy_show},
Omar Sandovalf57de232017-05-04 00:31:28 -0700739 {"ctx_map", 0400, hctx_ctx_map_show},
740 {"tags", 0400, hctx_tags_show},
741 {"tags_bitmap", 0400, hctx_tags_bitmap_show},
742 {"sched_tags", 0400, hctx_sched_tags_show},
743 {"sched_tags_bitmap", 0400, hctx_sched_tags_bitmap_show},
744 {"io_poll", 0600, hctx_io_poll_show, hctx_io_poll_write},
745 {"dispatched", 0600, hctx_dispatched_show, hctx_dispatched_write},
746 {"queued", 0600, hctx_queued_show, hctx_queued_write},
747 {"run", 0600, hctx_run_show, hctx_run_write},
748 {"active", 0400, hctx_active_show},
Bart Van Assche72f2f8f2017-02-01 10:20:59 -0800749 {},
Omar Sandoval07e4fea2017-01-25 08:06:40 -0800750};
751
752static const struct blk_mq_debugfs_attr blk_mq_debugfs_ctx_attrs[] = {
Omar Sandovalf57de232017-05-04 00:31:28 -0700753 {"rq_list", 0400, .seq_ops = &ctx_rq_list_seq_ops},
754 {"dispatched", 0600, ctx_dispatched_show, ctx_dispatched_write},
755 {"merged", 0600, ctx_merged_show, ctx_merged_write},
756 {"completed", 0600, ctx_completed_show, ctx_completed_write},
Bart Van Assche72f2f8f2017-02-01 10:20:59 -0800757 {},
Omar Sandoval07e4fea2017-01-25 08:06:40 -0800758};
759
Bart Van Assche72f2f8f2017-02-01 10:20:59 -0800760static bool debugfs_create_files(struct dentry *parent, void *data,
Omar Sandovalf57de232017-05-04 00:31:28 -0700761 const struct blk_mq_debugfs_attr *attr)
Bart Van Assche72f2f8f2017-02-01 10:20:59 -0800762{
Omar Sandovalf57de232017-05-04 00:31:28 -0700763 d_inode(parent)->i_private = data;
764
Bart Van Assche72f2f8f2017-02-01 10:20:59 -0800765 for (; attr->name; attr++) {
766 if (!debugfs_create_file(attr->name, attr->mode, parent,
Omar Sandovalf57de232017-05-04 00:31:28 -0700767 (void *)attr, &blk_mq_debugfs_fops))
Bart Van Assche72f2f8f2017-02-01 10:20:59 -0800768 return false;
769 }
770 return true;
771}
772
Omar Sandoval9c1051a2017-05-04 08:17:21 -0600773int blk_mq_debugfs_register(struct request_queue *q)
774{
775 struct blk_mq_hw_ctx *hctx;
776 int i;
777
778 if (!blk_debugfs_root)
779 return -ENOENT;
780
781 q->debugfs_dir = debugfs_create_dir(kobject_name(q->kobj.parent),
782 blk_debugfs_root);
783 if (!q->debugfs_dir)
784 return -ENOMEM;
785
786 if (!debugfs_create_files(q->debugfs_dir, q,
787 blk_mq_debugfs_queue_attrs))
788 goto err;
789
790 /*
791 * blk_mq_init_hctx() attempted to do this already, but q->debugfs_dir
792 * didn't exist yet (because we don't know what to name the directory
793 * until the queue is registered to a gendisk).
794 */
795 queue_for_each_hw_ctx(q, hctx, i) {
796 if (!hctx->debugfs_dir && blk_mq_debugfs_register_hctx(q, hctx))
797 goto err;
Omar Sandovald332ce02017-05-04 08:24:40 -0600798 if (q->elevator && !hctx->sched_debugfs_dir &&
799 blk_mq_debugfs_register_sched_hctx(q, hctx))
800 goto err;
Omar Sandoval9c1051a2017-05-04 08:17:21 -0600801 }
802
803 return 0;
804
805err:
806 blk_mq_debugfs_unregister(q);
807 return -ENOMEM;
808}
809
810void blk_mq_debugfs_unregister(struct request_queue *q)
811{
812 debugfs_remove_recursive(q->debugfs_dir);
Omar Sandovald332ce02017-05-04 08:24:40 -0600813 q->sched_debugfs_dir = NULL;
Omar Sandoval9c1051a2017-05-04 08:17:21 -0600814 q->debugfs_dir = NULL;
815}
816
817static int blk_mq_debugfs_register_ctx(struct blk_mq_hw_ctx *hctx,
818 struct blk_mq_ctx *ctx)
Omar Sandoval07e4fea2017-01-25 08:06:40 -0800819{
820 struct dentry *ctx_dir;
821 char name[20];
Omar Sandoval07e4fea2017-01-25 08:06:40 -0800822
823 snprintf(name, sizeof(name), "cpu%u", ctx->cpu);
Omar Sandoval9c1051a2017-05-04 08:17:21 -0600824 ctx_dir = debugfs_create_dir(name, hctx->debugfs_dir);
Omar Sandoval07e4fea2017-01-25 08:06:40 -0800825 if (!ctx_dir)
826 return -ENOMEM;
827
Bart Van Assche72f2f8f2017-02-01 10:20:59 -0800828 if (!debugfs_create_files(ctx_dir, ctx, blk_mq_debugfs_ctx_attrs))
829 return -ENOMEM;
Omar Sandoval07e4fea2017-01-25 08:06:40 -0800830
831 return 0;
832}
833
Omar Sandoval9c1051a2017-05-04 08:17:21 -0600834int blk_mq_debugfs_register_hctx(struct request_queue *q,
835 struct blk_mq_hw_ctx *hctx)
Omar Sandoval07e4fea2017-01-25 08:06:40 -0800836{
837 struct blk_mq_ctx *ctx;
Omar Sandoval07e4fea2017-01-25 08:06:40 -0800838 char name[20];
839 int i;
840
Omar Sandoval07e4fea2017-01-25 08:06:40 -0800841 if (!q->debugfs_dir)
842 return -ENOENT;
843
Omar Sandoval9c1051a2017-05-04 08:17:21 -0600844 snprintf(name, sizeof(name), "hctx%u", hctx->queue_num);
845 hctx->debugfs_dir = debugfs_create_dir(name, q->debugfs_dir);
846 if (!hctx->debugfs_dir)
847 return -ENOMEM;
848
849 if (!debugfs_create_files(hctx->debugfs_dir, hctx,
850 blk_mq_debugfs_hctx_attrs))
Omar Sandoval07e4fea2017-01-25 08:06:40 -0800851 goto err;
852
Omar Sandoval9c1051a2017-05-04 08:17:21 -0600853 hctx_for_each_ctx(hctx, ctx, i) {
854 if (blk_mq_debugfs_register_ctx(hctx, ctx))
Omar Sandoval07e4fea2017-01-25 08:06:40 -0800855 goto err;
856 }
857
858 return 0;
859
860err:
Omar Sandoval9c1051a2017-05-04 08:17:21 -0600861 blk_mq_debugfs_unregister_hctx(hctx);
Omar Sandoval07e4fea2017-01-25 08:06:40 -0800862 return -ENOMEM;
863}
864
Omar Sandoval9c1051a2017-05-04 08:17:21 -0600865void blk_mq_debugfs_unregister_hctx(struct blk_mq_hw_ctx *hctx)
Omar Sandoval07e4fea2017-01-25 08:06:40 -0800866{
Omar Sandoval9c1051a2017-05-04 08:17:21 -0600867 debugfs_remove_recursive(hctx->debugfs_dir);
Omar Sandovald332ce02017-05-04 08:24:40 -0600868 hctx->sched_debugfs_dir = NULL;
Omar Sandoval9c1051a2017-05-04 08:17:21 -0600869 hctx->debugfs_dir = NULL;
870}
871
872int blk_mq_debugfs_register_hctxs(struct request_queue *q)
873{
874 struct blk_mq_hw_ctx *hctx;
875 int i;
876
877 queue_for_each_hw_ctx(q, hctx, i) {
878 if (blk_mq_debugfs_register_hctx(q, hctx))
879 return -ENOMEM;
880 }
881
882 return 0;
883}
884
885void blk_mq_debugfs_unregister_hctxs(struct request_queue *q)
886{
887 struct blk_mq_hw_ctx *hctx;
888 int i;
889
890 queue_for_each_hw_ctx(q, hctx, i)
891 blk_mq_debugfs_unregister_hctx(hctx);
Omar Sandoval07e4fea2017-01-25 08:06:40 -0800892}
Omar Sandovald332ce02017-05-04 08:24:40 -0600893
894int blk_mq_debugfs_register_sched(struct request_queue *q)
895{
896 struct elevator_type *e = q->elevator->type;
897
898 if (!q->debugfs_dir)
899 return -ENOENT;
900
901 if (!e->queue_debugfs_attrs)
902 return 0;
903
904 q->sched_debugfs_dir = debugfs_create_dir("sched", q->debugfs_dir);
905 if (!q->sched_debugfs_dir)
906 return -ENOMEM;
907
908 if (!debugfs_create_files(q->sched_debugfs_dir, q,
909 e->queue_debugfs_attrs))
910 goto err;
911
912 return 0;
913
914err:
915 blk_mq_debugfs_unregister_sched(q);
916 return -ENOMEM;
917}
918
919void blk_mq_debugfs_unregister_sched(struct request_queue *q)
920{
921 debugfs_remove_recursive(q->sched_debugfs_dir);
922 q->sched_debugfs_dir = NULL;
923}
924
925int blk_mq_debugfs_register_sched_hctx(struct request_queue *q,
926 struct blk_mq_hw_ctx *hctx)
927{
928 struct elevator_type *e = q->elevator->type;
929
930 if (!hctx->debugfs_dir)
931 return -ENOENT;
932
933 if (!e->hctx_debugfs_attrs)
934 return 0;
935
936 hctx->sched_debugfs_dir = debugfs_create_dir("sched",
937 hctx->debugfs_dir);
938 if (!hctx->sched_debugfs_dir)
939 return -ENOMEM;
940
941 if (!debugfs_create_files(hctx->sched_debugfs_dir, hctx,
942 e->hctx_debugfs_attrs))
943 return -ENOMEM;
944
945 return 0;
946}
947
948void blk_mq_debugfs_unregister_sched_hctx(struct blk_mq_hw_ctx *hctx)
949{
950 debugfs_remove_recursive(hctx->sched_debugfs_dir);
951 hctx->sched_debugfs_dir = NULL;
952}