~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/block/blk-mq-debugfs.c

Version: ~ [ linux-5.1-rc2 ] ~ [ linux-5.0.4 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.31 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.108 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.165 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.177 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.137 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.63 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  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>
 22 #include "blk.h"
 23 #include "blk-mq.h"
 24 #include "blk-mq-debugfs.h"
 25 #include "blk-mq-tag.h"
 26 #include "blk-rq-qos.h"
 27 
 28 static void print_stat(struct seq_file *m, struct blk_rq_stat *stat)
 29 {
 30         if (stat->nr_samples) {
 31                 seq_printf(m, "samples=%d, mean=%lld, min=%llu, max=%llu",
 32                            stat->nr_samples, stat->mean, stat->min, stat->max);
 33         } else {
 34                 seq_puts(m, "samples=0");
 35         }
 36 }
 37 
 38 static int queue_poll_stat_show(void *data, struct seq_file *m)
 39 {
 40         struct request_queue *q = data;
 41         int bucket;
 42 
 43         for (bucket = 0; bucket < BLK_MQ_POLL_STATS_BKTS/2; bucket++) {
 44                 seq_printf(m, "read  (%d Bytes): ", 1 << (9+bucket));
 45                 print_stat(m, &q->poll_stat[2*bucket]);
 46                 seq_puts(m, "\n");
 47 
 48                 seq_printf(m, "write (%d Bytes): ",  1 << (9+bucket));
 49                 print_stat(m, &q->poll_stat[2*bucket+1]);
 50                 seq_puts(m, "\n");
 51         }
 52         return 0;
 53 }
 54 
 55 static void *queue_requeue_list_start(struct seq_file *m, loff_t *pos)
 56         __acquires(&q->requeue_lock)
 57 {
 58         struct request_queue *q = m->private;
 59 
 60         spin_lock_irq(&q->requeue_lock);
 61         return seq_list_start(&q->requeue_list, *pos);
 62 }
 63 
 64 static void *queue_requeue_list_next(struct seq_file *m, void *v, loff_t *pos)
 65 {
 66         struct request_queue *q = m->private;
 67 
 68         return seq_list_next(v, &q->requeue_list, pos);
 69 }
 70 
 71 static void queue_requeue_list_stop(struct seq_file *m, void *v)
 72         __releases(&q->requeue_lock)
 73 {
 74         struct request_queue *q = m->private;
 75 
 76         spin_unlock_irq(&q->requeue_lock);
 77 }
 78 
 79 static const struct seq_operations queue_requeue_list_seq_ops = {
 80         .start  = queue_requeue_list_start,
 81         .next   = queue_requeue_list_next,
 82         .stop   = queue_requeue_list_stop,
 83         .show   = blk_mq_debugfs_rq_show,
 84 };
 85 
 86 static int blk_flags_show(struct seq_file *m, const unsigned long flags,
 87                           const char *const *flag_name, int flag_name_count)
 88 {
 89         bool sep = false;
 90         int i;
 91 
 92         for (i = 0; i < sizeof(flags) * BITS_PER_BYTE; i++) {
 93                 if (!(flags & BIT(i)))
 94                         continue;
 95                 if (sep)
 96                         seq_puts(m, "|");
 97                 sep = true;
 98                 if (i < flag_name_count && flag_name[i])
 99                         seq_puts(m, flag_name[i]);
100                 else
101                         seq_printf(m, "%d", i);
102         }
103         return 0;
104 }
105 
106 static int queue_pm_only_show(void *data, struct seq_file *m)
107 {
108         struct request_queue *q = data;
109 
110         seq_printf(m, "%d\n", atomic_read(&q->pm_only));
111         return 0;
112 }
113 
114 #define QUEUE_FLAG_NAME(name) [QUEUE_FLAG_##name] = #name
115 static const char *const blk_queue_flag_name[] = {
116         QUEUE_FLAG_NAME(STOPPED),
117         QUEUE_FLAG_NAME(DYING),
118         QUEUE_FLAG_NAME(NOMERGES),
119         QUEUE_FLAG_NAME(SAME_COMP),
120         QUEUE_FLAG_NAME(FAIL_IO),
121         QUEUE_FLAG_NAME(NONROT),
122         QUEUE_FLAG_NAME(IO_STAT),
123         QUEUE_FLAG_NAME(DISCARD),
124         QUEUE_FLAG_NAME(NOXMERGES),
125         QUEUE_FLAG_NAME(ADD_RANDOM),
126         QUEUE_FLAG_NAME(SECERASE),
127         QUEUE_FLAG_NAME(SAME_FORCE),
128         QUEUE_FLAG_NAME(DEAD),
129         QUEUE_FLAG_NAME(INIT_DONE),
130         QUEUE_FLAG_NAME(POLL),
131         QUEUE_FLAG_NAME(WC),
132         QUEUE_FLAG_NAME(FUA),
133         QUEUE_FLAG_NAME(DAX),
134         QUEUE_FLAG_NAME(STATS),
135         QUEUE_FLAG_NAME(POLL_STATS),
136         QUEUE_FLAG_NAME(REGISTERED),
137         QUEUE_FLAG_NAME(SCSI_PASSTHROUGH),
138         QUEUE_FLAG_NAME(QUIESCED),
139 };
140 #undef QUEUE_FLAG_NAME
141 
142 static int queue_state_show(void *data, struct seq_file *m)
143 {
144         struct request_queue *q = data;
145 
146         blk_flags_show(m, q->queue_flags, blk_queue_flag_name,
147                        ARRAY_SIZE(blk_queue_flag_name));
148         seq_puts(m, "\n");
149         return 0;
150 }
151 
152 static ssize_t queue_state_write(void *data, const char __user *buf,
153                                  size_t count, loff_t *ppos)
154 {
155         struct request_queue *q = data;
156         char opbuf[16] = { }, *op;
157 
158         /*
159          * The "state" attribute is removed after blk_cleanup_queue() has called
160          * blk_mq_free_queue(). Return if QUEUE_FLAG_DEAD has been set to avoid
161          * triggering a use-after-free.
162          */
163         if (blk_queue_dead(q))
164                 return -ENOENT;
165 
166         if (count >= sizeof(opbuf)) {
167                 pr_err("%s: operation too long\n", __func__);
168                 goto inval;
169         }
170 
171         if (copy_from_user(opbuf, buf, count))
172                 return -EFAULT;
173         op = strstrip(opbuf);
174         if (strcmp(op, "run") == 0) {
175                 blk_mq_run_hw_queues(q, true);
176         } else if (strcmp(op, "start") == 0) {
177                 blk_mq_start_stopped_hw_queues(q, true);
178         } else if (strcmp(op, "kick") == 0) {
179                 blk_mq_kick_requeue_list(q);
180         } else {
181                 pr_err("%s: unsupported operation '%s'\n", __func__, op);
182 inval:
183                 pr_err("%s: use 'run', 'start' or 'kick'\n", __func__);
184                 return -EINVAL;
185         }
186         return count;
187 }
188 
189 static int queue_write_hint_show(void *data, struct seq_file *m)
190 {
191         struct request_queue *q = data;
192         int i;
193 
194         for (i = 0; i < BLK_MAX_WRITE_HINTS; i++)
195                 seq_printf(m, "hint%d: %llu\n", i, q->write_hints[i]);
196 
197         return 0;
198 }
199 
200 static ssize_t queue_write_hint_store(void *data, const char __user *buf,
201                                       size_t count, loff_t *ppos)
202 {
203         struct request_queue *q = data;
204         int i;
205 
206         for (i = 0; i < BLK_MAX_WRITE_HINTS; i++)
207                 q->write_hints[i] = 0;
208 
209         return count;
210 }
211 
212 static const struct blk_mq_debugfs_attr blk_mq_debugfs_queue_attrs[] = {
213         { "poll_stat", 0400, queue_poll_stat_show },
214         { "requeue_list", 0400, .seq_ops = &queue_requeue_list_seq_ops },
215         { "pm_only", 0600, queue_pm_only_show, NULL },
216         { "state", 0600, queue_state_show, queue_state_write },
217         { "write_hints", 0600, queue_write_hint_show, queue_write_hint_store },
218         { "zone_wlock", 0400, queue_zone_wlock_show, NULL },
219         { },
220 };
221 
222 #define HCTX_STATE_NAME(name) [BLK_MQ_S_##name] = #name
223 static const char *const hctx_state_name[] = {
224         HCTX_STATE_NAME(STOPPED),
225         HCTX_STATE_NAME(TAG_ACTIVE),
226         HCTX_STATE_NAME(SCHED_RESTART),
227 };
228 #undef HCTX_STATE_NAME
229 
230 static int hctx_state_show(void *data, struct seq_file *m)
231 {
232         struct blk_mq_hw_ctx *hctx = data;
233 
234         blk_flags_show(m, hctx->state, hctx_state_name,
235                        ARRAY_SIZE(hctx_state_name));
236         seq_puts(m, "\n");
237         return 0;
238 }
239 
240 #define BLK_TAG_ALLOC_NAME(name) [BLK_TAG_ALLOC_##name] = #name
241 static const char *const alloc_policy_name[] = {
242         BLK_TAG_ALLOC_NAME(FIFO),
243         BLK_TAG_ALLOC_NAME(RR),
244 };
245 #undef BLK_TAG_ALLOC_NAME
246 
247 #define HCTX_FLAG_NAME(name) [ilog2(BLK_MQ_F_##name)] = #name
248 static const char *const hctx_flag_name[] = {
249         HCTX_FLAG_NAME(SHOULD_MERGE),
250         HCTX_FLAG_NAME(TAG_SHARED),
251         HCTX_FLAG_NAME(BLOCKING),
252         HCTX_FLAG_NAME(NO_SCHED),
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         seq_puts(m, "alloc_policy=");
262         if (alloc_policy < ARRAY_SIZE(alloc_policy_name) &&
263             alloc_policy_name[alloc_policy])
264                 seq_puts(m, alloc_policy_name[alloc_policy]);
265         else
266                 seq_printf(m, "%d", alloc_policy);
267         seq_puts(m, " ");
268         blk_flags_show(m,
269                        hctx->flags ^ BLK_ALLOC_POLICY_TO_MQ_FLAG(alloc_policy),
270                        hctx_flag_name, ARRAY_SIZE(hctx_flag_name));
271         seq_puts(m, "\n");
272         return 0;
273 }
274 
275 #define REQ_OP_NAME(name) [REQ_OP_##name] = #name
276 static const char *const op_name[] = {
277         REQ_OP_NAME(READ),
278         REQ_OP_NAME(WRITE),
279         REQ_OP_NAME(FLUSH),
280         REQ_OP_NAME(DISCARD),
281         REQ_OP_NAME(SECURE_ERASE),
282         REQ_OP_NAME(ZONE_RESET),
283         REQ_OP_NAME(WRITE_SAME),
284         REQ_OP_NAME(WRITE_ZEROES),
285         REQ_OP_NAME(SCSI_IN),
286         REQ_OP_NAME(SCSI_OUT),
287         REQ_OP_NAME(DRV_IN),
288         REQ_OP_NAME(DRV_OUT),
289 };
290 #undef REQ_OP_NAME
291 
292 #define CMD_FLAG_NAME(name) [__REQ_##name] = #name
293 static const char *const cmd_flag_name[] = {
294         CMD_FLAG_NAME(FAILFAST_DEV),
295         CMD_FLAG_NAME(FAILFAST_TRANSPORT),
296         CMD_FLAG_NAME(FAILFAST_DRIVER),
297         CMD_FLAG_NAME(SYNC),
298         CMD_FLAG_NAME(META),
299         CMD_FLAG_NAME(PRIO),
300         CMD_FLAG_NAME(NOMERGE),
301         CMD_FLAG_NAME(IDLE),
302         CMD_FLAG_NAME(INTEGRITY),
303         CMD_FLAG_NAME(FUA),
304         CMD_FLAG_NAME(PREFLUSH),
305         CMD_FLAG_NAME(RAHEAD),
306         CMD_FLAG_NAME(BACKGROUND),
307         CMD_FLAG_NAME(NOWAIT),
308         CMD_FLAG_NAME(NOUNMAP),
309         CMD_FLAG_NAME(HIPRI),
310 };
311 #undef CMD_FLAG_NAME
312 
313 #define RQF_NAME(name) [ilog2((__force u32)RQF_##name)] = #name
314 static const char *const rqf_name[] = {
315         RQF_NAME(SORTED),
316         RQF_NAME(STARTED),
317         RQF_NAME(SOFTBARRIER),
318         RQF_NAME(FLUSH_SEQ),
319         RQF_NAME(MIXED_MERGE),
320         RQF_NAME(MQ_INFLIGHT),
321         RQF_NAME(DONTPREP),
322         RQF_NAME(PREEMPT),
323         RQF_NAME(COPY_USER),
324         RQF_NAME(FAILED),
325         RQF_NAME(QUIET),
326         RQF_NAME(ELVPRIV),
327         RQF_NAME(IO_STAT),
328         RQF_NAME(ALLOCED),
329         RQF_NAME(PM),
330         RQF_NAME(HASHED),
331         RQF_NAME(STATS),
332         RQF_NAME(SPECIAL_PAYLOAD),
333         RQF_NAME(ZONE_WRITE_LOCKED),
334         RQF_NAME(MQ_POLL_SLEPT),
335 };
336 #undef RQF_NAME
337 
338 static const char *const blk_mq_rq_state_name_array[] = {
339         [MQ_RQ_IDLE]            = "idle",
340         [MQ_RQ_IN_FLIGHT]       = "in_flight",
341         [MQ_RQ_COMPLETE]        = "complete",
342 };
343 
344 static const char *blk_mq_rq_state_name(enum mq_rq_state rq_state)
345 {
346         if (WARN_ON_ONCE((unsigned int)rq_state >=
347                          ARRAY_SIZE(blk_mq_rq_state_name_array)))
348                 return "(?)";
349         return blk_mq_rq_state_name_array[rq_state];
350 }
351 
352 int __blk_mq_debugfs_rq_show(struct seq_file *m, struct request *rq)
353 {
354         const struct blk_mq_ops *const mq_ops = rq->q->mq_ops;
355         const unsigned int op = rq->cmd_flags & REQ_OP_MASK;
356 
357         seq_printf(m, "%p {.op=", rq);
358         if (op < ARRAY_SIZE(op_name) && op_name[op])
359                 seq_printf(m, "%s", op_name[op]);
360         else
361                 seq_printf(m, "%d", op);
362         seq_puts(m, ", .cmd_flags=");
363         blk_flags_show(m, rq->cmd_flags & ~REQ_OP_MASK, cmd_flag_name,
364                        ARRAY_SIZE(cmd_flag_name));
365         seq_puts(m, ", .rq_flags=");
366         blk_flags_show(m, (__force unsigned int)rq->rq_flags, rqf_name,
367                        ARRAY_SIZE(rqf_name));
368         seq_printf(m, ", .state=%s", blk_mq_rq_state_name(blk_mq_rq_state(rq)));
369         seq_printf(m, ", .tag=%d, .internal_tag=%d", rq->tag,
370                    rq->internal_tag);
371         if (mq_ops->show_rq)
372                 mq_ops->show_rq(m, rq);
373         seq_puts(m, "}\n");
374         return 0;
375 }
376 EXPORT_SYMBOL_GPL(__blk_mq_debugfs_rq_show);
377 
378 int blk_mq_debugfs_rq_show(struct seq_file *m, void *v)
379 {
380         return __blk_mq_debugfs_rq_show(m, list_entry_rq(v));
381 }
382 EXPORT_SYMBOL_GPL(blk_mq_debugfs_rq_show);
383 
384 static void *hctx_dispatch_start(struct seq_file *m, loff_t *pos)
385         __acquires(&hctx->lock)
386 {
387         struct blk_mq_hw_ctx *hctx = m->private;
388 
389         spin_lock(&hctx->lock);
390         return seq_list_start(&hctx->dispatch, *pos);
391 }
392 
393 static void *hctx_dispatch_next(struct seq_file *m, void *v, loff_t *pos)
394 {
395         struct blk_mq_hw_ctx *hctx = m->private;
396 
397         return seq_list_next(v, &hctx->dispatch, pos);
398 }
399 
400 static void hctx_dispatch_stop(struct seq_file *m, void *v)
401         __releases(&hctx->lock)
402 {
403         struct blk_mq_hw_ctx *hctx = m->private;
404 
405         spin_unlock(&hctx->lock);
406 }
407 
408 static const struct seq_operations hctx_dispatch_seq_ops = {
409         .start  = hctx_dispatch_start,
410         .next   = hctx_dispatch_next,
411         .stop   = hctx_dispatch_stop,
412         .show   = blk_mq_debugfs_rq_show,
413 };
414 
415 struct show_busy_params {
416         struct seq_file         *m;
417         struct blk_mq_hw_ctx    *hctx;
418 };
419 
420 /*
421  * Note: the state of a request may change while this function is in progress,
422  * e.g. due to a concurrent blk_mq_finish_request() call. Returns true to
423  * keep iterating requests.
424  */
425 static bool hctx_show_busy_rq(struct request *rq, void *data, bool reserved)
426 {
427         const struct show_busy_params *params = data;
428 
429         if (rq->mq_hctx == params->hctx)
430                 __blk_mq_debugfs_rq_show(params->m,
431                                          list_entry_rq(&rq->queuelist));
432 
433         return true;
434 }
435 
436 static int hctx_busy_show(void *data, struct seq_file *m)
437 {
438         struct blk_mq_hw_ctx *hctx = data;
439         struct show_busy_params params = { .m = m, .hctx = hctx };
440 
441         blk_mq_tagset_busy_iter(hctx->queue->tag_set, hctx_show_busy_rq,
442                                 &params);
443 
444         return 0;
445 }
446 
447 static const char *const hctx_types[] = {
448         [HCTX_TYPE_DEFAULT]     = "default",
449         [HCTX_TYPE_READ]        = "read",
450         [HCTX_TYPE_POLL]        = "poll",
451 };
452 
453 static int hctx_type_show(void *data, struct seq_file *m)
454 {
455         struct blk_mq_hw_ctx *hctx = data;
456 
457         BUILD_BUG_ON(ARRAY_SIZE(hctx_types) != HCTX_MAX_TYPES);
458         seq_printf(m, "%s\n", hctx_types[hctx->type]);
459         return 0;
460 }
461 
462 static int hctx_ctx_map_show(void *data, struct seq_file *m)
463 {
464         struct blk_mq_hw_ctx *hctx = data;
465 
466         sbitmap_bitmap_show(&hctx->ctx_map, m);
467         return 0;
468 }
469 
470 static void blk_mq_debugfs_tags_show(struct seq_file *m,
471                                      struct blk_mq_tags *tags)
472 {
473         seq_printf(m, "nr_tags=%u\n", tags->nr_tags);
474         seq_printf(m, "nr_reserved_tags=%u\n", tags->nr_reserved_tags);
475         seq_printf(m, "active_queues=%d\n",
476                    atomic_read(&tags->active_queues));
477 
478         seq_puts(m, "\nbitmap_tags:\n");
479         sbitmap_queue_show(&tags->bitmap_tags, m);
480 
481         if (tags->nr_reserved_tags) {
482                 seq_puts(m, "\nbreserved_tags:\n");
483                 sbitmap_queue_show(&tags->breserved_tags, m);
484         }
485 }
486 
487 static int hctx_tags_show(void *data, struct seq_file *m)
488 {
489         struct blk_mq_hw_ctx *hctx = data;
490         struct request_queue *q = hctx->queue;
491         int res;
492 
493         res = mutex_lock_interruptible(&q->sysfs_lock);
494         if (res)
495                 goto out;
496         if (hctx->tags)
497                 blk_mq_debugfs_tags_show(m, hctx->tags);
498         mutex_unlock(&q->sysfs_lock);
499 
500 out:
501         return res;
502 }
503 
504 static int hctx_tags_bitmap_show(void *data, struct seq_file *m)
505 {
506         struct blk_mq_hw_ctx *hctx = data;
507         struct request_queue *q = hctx->queue;
508         int res;
509 
510         res = mutex_lock_interruptible(&q->sysfs_lock);
511         if (res)
512                 goto out;
513         if (hctx->tags)
514                 sbitmap_bitmap_show(&hctx->tags->bitmap_tags.sb, m);
515         mutex_unlock(&q->sysfs_lock);
516 
517 out:
518         return res;
519 }
520 
521 static int hctx_sched_tags_show(void *data, struct seq_file *m)
522 {
523         struct blk_mq_hw_ctx *hctx = data;
524         struct request_queue *q = hctx->queue;
525         int res;
526 
527         res = mutex_lock_interruptible(&q->sysfs_lock);
528         if (res)
529                 goto out;
530         if (hctx->sched_tags)
531                 blk_mq_debugfs_tags_show(m, hctx->sched_tags);
532         mutex_unlock(&q->sysfs_lock);
533 
534 out:
535         return res;
536 }
537 
538 static int hctx_sched_tags_bitmap_show(void *data, struct seq_file *m)
539 {
540         struct blk_mq_hw_ctx *hctx = data;
541         struct request_queue *q = hctx->queue;
542         int res;
543 
544         res = mutex_lock_interruptible(&q->sysfs_lock);
545         if (res)
546                 goto out;
547         if (hctx->sched_tags)
548                 sbitmap_bitmap_show(&hctx->sched_tags->bitmap_tags.sb, m);
549         mutex_unlock(&q->sysfs_lock);
550 
551 out:
552         return res;
553 }
554 
555 static int hctx_io_poll_show(void *data, struct seq_file *m)
556 {
557         struct blk_mq_hw_ctx *hctx = data;
558 
559         seq_printf(m, "considered=%lu\n", hctx->poll_considered);
560         seq_printf(m, "invoked=%lu\n", hctx->poll_invoked);
561         seq_printf(m, "success=%lu\n", hctx->poll_success);
562         return 0;
563 }
564 
565 static ssize_t hctx_io_poll_write(void *data, const char __user *buf,
566                                   size_t count, loff_t *ppos)
567 {
568         struct blk_mq_hw_ctx *hctx = data;
569 
570         hctx->poll_considered = hctx->poll_invoked = hctx->poll_success = 0;
571         return count;
572 }
573 
574 static int hctx_dispatched_show(void *data, struct seq_file *m)
575 {
576         struct blk_mq_hw_ctx *hctx = data;
577         int i;
578 
579         seq_printf(m, "%8u\t%lu\n", 0U, hctx->dispatched[0]);
580 
581         for (i = 1; i < BLK_MQ_MAX_DISPATCH_ORDER - 1; i++) {
582                 unsigned int d = 1U << (i - 1);
583 
584                 seq_printf(m, "%8u\t%lu\n", d, hctx->dispatched[i]);
585         }
586 
587         seq_printf(m, "%8u+\t%lu\n", 1U << (i - 1), hctx->dispatched[i]);
588         return 0;
589 }
590 
591 static ssize_t hctx_dispatched_write(void *data, const char __user *buf,
592                                      size_t count, loff_t *ppos)
593 {
594         struct blk_mq_hw_ctx *hctx = data;
595         int i;
596 
597         for (i = 0; i < BLK_MQ_MAX_DISPATCH_ORDER; i++)
598                 hctx->dispatched[i] = 0;
599         return count;
600 }
601 
602 static int hctx_queued_show(void *data, struct seq_file *m)
603 {
604         struct blk_mq_hw_ctx *hctx = data;
605 
606         seq_printf(m, "%lu\n", hctx->queued);
607         return 0;
608 }
609 
610 static ssize_t hctx_queued_write(void *data, const char __user *buf,
611                                  size_t count, loff_t *ppos)
612 {
613         struct blk_mq_hw_ctx *hctx = data;
614 
615         hctx->queued = 0;
616         return count;
617 }
618 
619 static int hctx_run_show(void *data, struct seq_file *m)
620 {
621         struct blk_mq_hw_ctx *hctx = data;
622 
623         seq_printf(m, "%lu\n", hctx->run);
624         return 0;
625 }
626 
627 static ssize_t hctx_run_write(void *data, const char __user *buf, size_t count,
628                               loff_t *ppos)
629 {
630         struct blk_mq_hw_ctx *hctx = data;
631 
632         hctx->run = 0;
633         return count;
634 }
635 
636 static int hctx_active_show(void *data, struct seq_file *m)
637 {
638         struct blk_mq_hw_ctx *hctx = data;
639 
640         seq_printf(m, "%d\n", atomic_read(&hctx->nr_active));
641         return 0;
642 }
643 
644 static int hctx_dispatch_busy_show(void *data, struct seq_file *m)
645 {
646         struct blk_mq_hw_ctx *hctx = data;
647 
648         seq_printf(m, "%u\n", hctx->dispatch_busy);
649         return 0;
650 }
651 
652 #define CTX_RQ_SEQ_OPS(name, type)                                      \
653 static void *ctx_##name##_rq_list_start(struct seq_file *m, loff_t *pos) \
654         __acquires(&ctx->lock)                                          \
655 {                                                                       \
656         struct blk_mq_ctx *ctx = m->private;                            \
657                                                                         \
658         spin_lock(&ctx->lock);                                          \
659         return seq_list_start(&ctx->rq_lists[type], *pos);              \
660 }                                                                       \
661                                                                         \
662 static void *ctx_##name##_rq_list_next(struct seq_file *m, void *v,     \
663                                      loff_t *pos)                       \
664 {                                                                       \
665         struct blk_mq_ctx *ctx = m->private;                            \
666                                                                         \
667         return seq_list_next(v, &ctx->rq_lists[type], pos);             \
668 }                                                                       \
669                                                                         \
670 static void ctx_##name##_rq_list_stop(struct seq_file *m, void *v)      \
671         __releases(&ctx->lock)                                          \
672 {                                                                       \
673         struct blk_mq_ctx *ctx = m->private;                            \
674                                                                         \
675         spin_unlock(&ctx->lock);                                        \
676 }                                                                       \
677                                                                         \
678 static const struct seq_operations ctx_##name##_rq_list_seq_ops = {     \
679         .start  = ctx_##name##_rq_list_start,                           \
680         .next   = ctx_##name##_rq_list_next,                            \
681         .stop   = ctx_##name##_rq_list_stop,                            \
682         .show   = blk_mq_debugfs_rq_show,                               \
683 }
684 
685 CTX_RQ_SEQ_OPS(default, HCTX_TYPE_DEFAULT);
686 CTX_RQ_SEQ_OPS(read, HCTX_TYPE_READ);
687 CTX_RQ_SEQ_OPS(poll, HCTX_TYPE_POLL);
688 
689 static int ctx_dispatched_show(void *data, struct seq_file *m)
690 {
691         struct blk_mq_ctx *ctx = data;
692 
693         seq_printf(m, "%lu %lu\n", ctx->rq_dispatched[1], ctx->rq_dispatched[0]);
694         return 0;
695 }
696 
697 static ssize_t ctx_dispatched_write(void *data, const char __user *buf,
698                                     size_t count, loff_t *ppos)
699 {
700         struct blk_mq_ctx *ctx = data;
701 
702         ctx->rq_dispatched[0] = ctx->rq_dispatched[1] = 0;
703         return count;
704 }
705 
706 static int ctx_merged_show(void *data, struct seq_file *m)
707 {
708         struct blk_mq_ctx *ctx = data;
709 
710         seq_printf(m, "%lu\n", ctx->rq_merged);
711         return 0;
712 }
713 
714 static ssize_t ctx_merged_write(void *data, const char __user *buf,
715                                 size_t count, loff_t *ppos)
716 {
717         struct blk_mq_ctx *ctx = data;
718 
719         ctx->rq_merged = 0;
720         return count;
721 }
722 
723 static int ctx_completed_show(void *data, struct seq_file *m)
724 {
725         struct blk_mq_ctx *ctx = data;
726 
727         seq_printf(m, "%lu %lu\n", ctx->rq_completed[1], ctx->rq_completed[0]);
728         return 0;
729 }
730 
731 static ssize_t ctx_completed_write(void *data, const char __user *buf,
732                                    size_t count, loff_t *ppos)
733 {
734         struct blk_mq_ctx *ctx = data;
735 
736         ctx->rq_completed[0] = ctx->rq_completed[1] = 0;
737         return count;
738 }
739 
740 static int blk_mq_debugfs_show(struct seq_file *m, void *v)
741 {
742         const struct blk_mq_debugfs_attr *attr = m->private;
743         void *data = d_inode(m->file->f_path.dentry->d_parent)->i_private;
744 
745         return attr->show(data, m);
746 }
747 
748 static ssize_t blk_mq_debugfs_write(struct file *file, const char __user *buf,
749                                     size_t count, loff_t *ppos)
750 {
751         struct seq_file *m = file->private_data;
752         const struct blk_mq_debugfs_attr *attr = m->private;
753         void *data = d_inode(file->f_path.dentry->d_parent)->i_private;
754 
755         /*
756          * Attributes that only implement .seq_ops are read-only and 'attr' is
757          * the same with 'data' in this case.
758          */
759         if (attr == data || !attr->write)
760                 return -EPERM;
761 
762         return attr->write(data, buf, count, ppos);
763 }
764 
765 static int blk_mq_debugfs_open(struct inode *inode, struct file *file)
766 {
767         const struct blk_mq_debugfs_attr *attr = inode->i_private;
768         void *data = d_inode(file->f_path.dentry->d_parent)->i_private;
769         struct seq_file *m;
770         int ret;
771 
772         if (attr->seq_ops) {
773                 ret = seq_open(file, attr->seq_ops);
774                 if (!ret) {
775                         m = file->private_data;
776                         m->private = data;
777                 }
778                 return ret;
779         }
780 
781         if (WARN_ON_ONCE(!attr->show))
782                 return -EPERM;
783 
784         return single_open(file, blk_mq_debugfs_show, inode->i_private);
785 }
786 
787 static int blk_mq_debugfs_release(struct inode *inode, struct file *file)
788 {
789         const struct blk_mq_debugfs_attr *attr = inode->i_private;
790 
791         if (attr->show)
792                 return single_release(inode, file);
793         else
794                 return seq_release(inode, file);
795 }
796 
797 static const struct file_operations blk_mq_debugfs_fops = {
798         .open           = blk_mq_debugfs_open,
799         .read           = seq_read,
800         .write          = blk_mq_debugfs_write,
801         .llseek         = seq_lseek,
802         .release        = blk_mq_debugfs_release,
803 };
804 
805 static const struct blk_mq_debugfs_attr blk_mq_debugfs_hctx_attrs[] = {
806         {"state", 0400, hctx_state_show},
807         {"flags", 0400, hctx_flags_show},
808         {"dispatch", 0400, .seq_ops = &hctx_dispatch_seq_ops},
809         {"busy", 0400, hctx_busy_show},
810         {"ctx_map", 0400, hctx_ctx_map_show},
811         {"tags", 0400, hctx_tags_show},
812         {"tags_bitmap", 0400, hctx_tags_bitmap_show},
813         {"sched_tags", 0400, hctx_sched_tags_show},
814         {"sched_tags_bitmap", 0400, hctx_sched_tags_bitmap_show},
815         {"io_poll", 0600, hctx_io_poll_show, hctx_io_poll_write},
816         {"dispatched", 0600, hctx_dispatched_show, hctx_dispatched_write},
817         {"queued", 0600, hctx_queued_show, hctx_queued_write},
818         {"run", 0600, hctx_run_show, hctx_run_write},
819         {"active", 0400, hctx_active_show},
820         {"dispatch_busy", 0400, hctx_dispatch_busy_show},
821         {"type", 0400, hctx_type_show},
822         {},
823 };
824 
825 static const struct blk_mq_debugfs_attr blk_mq_debugfs_ctx_attrs[] = {
826         {"default_rq_list", 0400, .seq_ops = &ctx_default_rq_list_seq_ops},
827         {"read_rq_list", 0400, .seq_ops = &ctx_read_rq_list_seq_ops},
828         {"poll_rq_list", 0400, .seq_ops = &ctx_poll_rq_list_seq_ops},
829         {"dispatched", 0600, ctx_dispatched_show, ctx_dispatched_write},
830         {"merged", 0600, ctx_merged_show, ctx_merged_write},
831         {"completed", 0600, ctx_completed_show, ctx_completed_write},
832         {},
833 };
834 
835 static bool debugfs_create_files(struct dentry *parent, void *data,
836                                  const struct blk_mq_debugfs_attr *attr)
837 {
838         if (IS_ERR_OR_NULL(parent))
839                 return false;
840 
841         d_inode(parent)->i_private = data;
842 
843         for (; attr->name; attr++) {
844                 if (!debugfs_create_file(attr->name, attr->mode, parent,
845                                          (void *)attr, &blk_mq_debugfs_fops))
846                         return false;
847         }
848         return true;
849 }
850 
851 int blk_mq_debugfs_register(struct request_queue *q)
852 {
853         struct blk_mq_hw_ctx *hctx;
854         int i;
855 
856         if (!blk_debugfs_root)
857                 return -ENOENT;
858 
859         q->debugfs_dir = debugfs_create_dir(kobject_name(q->kobj.parent),
860                                             blk_debugfs_root);
861         if (!q->debugfs_dir)
862                 return -ENOMEM;
863 
864         if (!debugfs_create_files(q->debugfs_dir, q,
865                                   blk_mq_debugfs_queue_attrs))
866                 goto err;
867 
868         /*
869          * blk_mq_init_sched() attempted to do this already, but q->debugfs_dir
870          * didn't exist yet (because we don't know what to name the directory
871          * until the queue is registered to a gendisk).
872          */
873         if (q->elevator && !q->sched_debugfs_dir)
874                 blk_mq_debugfs_register_sched(q);
875 
876         /* Similarly, blk_mq_init_hctx() couldn't do this previously. */
877         queue_for_each_hw_ctx(q, hctx, i) {
878                 if (!hctx->debugfs_dir && blk_mq_debugfs_register_hctx(q, hctx))
879                         goto err;
880                 if (q->elevator && !hctx->sched_debugfs_dir &&
881                     blk_mq_debugfs_register_sched_hctx(q, hctx))
882                         goto err;
883         }
884 
885         if (q->rq_qos) {
886                 struct rq_qos *rqos = q->rq_qos;
887 
888                 while (rqos) {
889                         blk_mq_debugfs_register_rqos(rqos);
890                         rqos = rqos->next;
891                 }
892         }
893 
894         return 0;
895 
896 err:
897         blk_mq_debugfs_unregister(q);
898         return -ENOMEM;
899 }
900 
901 void blk_mq_debugfs_unregister(struct request_queue *q)
902 {
903         debugfs_remove_recursive(q->debugfs_dir);
904         q->sched_debugfs_dir = NULL;
905         q->debugfs_dir = NULL;
906 }
907 
908 static int blk_mq_debugfs_register_ctx(struct blk_mq_hw_ctx *hctx,
909                                        struct blk_mq_ctx *ctx)
910 {
911         struct dentry *ctx_dir;
912         char name[20];
913 
914         snprintf(name, sizeof(name), "cpu%u", ctx->cpu);
915         ctx_dir = debugfs_create_dir(name, hctx->debugfs_dir);
916         if (!ctx_dir)
917                 return -ENOMEM;
918 
919         if (!debugfs_create_files(ctx_dir, ctx, blk_mq_debugfs_ctx_attrs))
920                 return -ENOMEM;
921 
922         return 0;
923 }
924 
925 int blk_mq_debugfs_register_hctx(struct request_queue *q,
926                                  struct blk_mq_hw_ctx *hctx)
927 {
928         struct blk_mq_ctx *ctx;
929         char name[20];
930         int i;
931 
932         if (!q->debugfs_dir)
933                 return -ENOENT;
934 
935         snprintf(name, sizeof(name), "hctx%u", hctx->queue_num);
936         hctx->debugfs_dir = debugfs_create_dir(name, q->debugfs_dir);
937         if (!hctx->debugfs_dir)
938                 return -ENOMEM;
939 
940         if (!debugfs_create_files(hctx->debugfs_dir, hctx,
941                                   blk_mq_debugfs_hctx_attrs))
942                 goto err;
943 
944         hctx_for_each_ctx(hctx, ctx, i) {
945                 if (blk_mq_debugfs_register_ctx(hctx, ctx))
946                         goto err;
947         }
948 
949         return 0;
950 
951 err:
952         blk_mq_debugfs_unregister_hctx(hctx);
953         return -ENOMEM;
954 }
955 
956 void blk_mq_debugfs_unregister_hctx(struct blk_mq_hw_ctx *hctx)
957 {
958         debugfs_remove_recursive(hctx->debugfs_dir);
959         hctx->sched_debugfs_dir = NULL;
960         hctx->debugfs_dir = NULL;
961 }
962 
963 int blk_mq_debugfs_register_hctxs(struct request_queue *q)
964 {
965         struct blk_mq_hw_ctx *hctx;
966         int i;
967 
968         queue_for_each_hw_ctx(q, hctx, i) {
969                 if (blk_mq_debugfs_register_hctx(q, hctx))
970                         return -ENOMEM;
971         }
972 
973         return 0;
974 }
975 
976 void blk_mq_debugfs_unregister_hctxs(struct request_queue *q)
977 {
978         struct blk_mq_hw_ctx *hctx;
979         int i;
980 
981         queue_for_each_hw_ctx(q, hctx, i)
982                 blk_mq_debugfs_unregister_hctx(hctx);
983 }
984 
985 int blk_mq_debugfs_register_sched(struct request_queue *q)
986 {
987         struct elevator_type *e = q->elevator->type;
988 
989         if (!q->debugfs_dir)
990                 return -ENOENT;
991 
992         if (!e->queue_debugfs_attrs)
993                 return 0;
994 
995         q->sched_debugfs_dir = debugfs_create_dir("sched", q->debugfs_dir);
996         if (!q->sched_debugfs_dir)
997                 return -ENOMEM;
998 
999         if (!debugfs_create_files(q->sched_debugfs_dir, q,
1000                                   e->queue_debugfs_attrs))
1001                 goto err;
1002 
1003         return 0;
1004 
1005 err:
1006         blk_mq_debugfs_unregister_sched(q);
1007         return -ENOMEM;
1008 }
1009 
1010 void blk_mq_debugfs_unregister_sched(struct request_queue *q)
1011 {
1012         debugfs_remove_recursive(q->sched_debugfs_dir);
1013         q->sched_debugfs_dir = NULL;
1014 }
1015 
1016 void blk_mq_debugfs_unregister_rqos(struct rq_qos *rqos)
1017 {
1018         debugfs_remove_recursive(rqos->debugfs_dir);
1019         rqos->debugfs_dir = NULL;
1020 }
1021 
1022 int blk_mq_debugfs_register_rqos(struct rq_qos *rqos)
1023 {
1024         struct request_queue *q = rqos->q;
1025         const char *dir_name = rq_qos_id_to_name(rqos->id);
1026 
1027         if (!q->debugfs_dir)
1028                 return -ENOENT;
1029 
1030         if (rqos->debugfs_dir || !rqos->ops->debugfs_attrs)
1031                 return 0;
1032 
1033         if (!q->rqos_debugfs_dir) {
1034                 q->rqos_debugfs_dir = debugfs_create_dir("rqos",
1035                                                          q->debugfs_dir);
1036                 if (!q->rqos_debugfs_dir)
1037                         return -ENOMEM;
1038         }
1039 
1040         rqos->debugfs_dir = debugfs_create_dir(dir_name,
1041                                                rqos->q->rqos_debugfs_dir);
1042         if (!rqos->debugfs_dir)
1043                 return -ENOMEM;
1044 
1045         if (!debugfs_create_files(rqos->debugfs_dir, rqos,
1046                                   rqos->ops->debugfs_attrs))
1047                 goto err;
1048         return 0;
1049  err:
1050         blk_mq_debugfs_unregister_rqos(rqos);
1051         return -ENOMEM;
1052 }
1053 
1054 void blk_mq_debugfs_unregister_queue_rqos(struct request_queue *q)
1055 {
1056         debugfs_remove_recursive(q->rqos_debugfs_dir);
1057         q->rqos_debugfs_dir = NULL;
1058 }
1059 
1060 int blk_mq_debugfs_register_sched_hctx(struct request_queue *q,
1061                                        struct blk_mq_hw_ctx *hctx)
1062 {
1063         struct elevator_type *e = q->elevator->type;
1064 
1065         if (!hctx->debugfs_dir)
1066                 return -ENOENT;
1067 
1068         if (!e->hctx_debugfs_attrs)
1069                 return 0;
1070 
1071         hctx->sched_debugfs_dir = debugfs_create_dir("sched",
1072                                                      hctx->debugfs_dir);
1073         if (!hctx->sched_debugfs_dir)
1074                 return -ENOMEM;
1075 
1076         if (!debugfs_create_files(hctx->sched_debugfs_dir, hctx,
1077                                   e->hctx_debugfs_attrs))
1078                 return -ENOMEM;
1079 
1080         return 0;
1081 }
1082 
1083 void blk_mq_debugfs_unregister_sched_hctx(struct blk_mq_hw_ctx *hctx)
1084 {
1085         debugfs_remove_recursive(hctx->sched_debugfs_dir);
1086         hctx->sched_debugfs_dir = NULL;
1087 }
1088 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp