block/blk-mq-debugfs.c

   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-tag.h"
  25
  26 struct blk_mq_debugfs_attr {
  27         const char *name;
  28         umode_t mode;
  29         int (*show)(void *, struct seq_file *);
  30         ssize_t (*write)(void *, const char __user *, size_t, loff_t *);
  31         /* Set either .show or .seq_ops. */
  32         const struct seq_operations *seq_ops;
  33 };
  34
  35 static int blk_flags_show(struct seq_file *m, const unsigned long flags,
  36                           const char *const *flag_name, int flag_name_count)
  37 {
  38         bool sep = false;
  39         int i;
  40
  41         for (i = 0; i < sizeof(flags) * BITS_PER_BYTE; i++) {
  42                 if (!(flags & BIT(i)))
  43                         continue;
  44                 if (sep)
  45                         seq_puts(m, "|");
  46                 sep = true;
  47                 if (i < flag_name_count && flag_name[i])
  48                         seq_puts(m, flag_name[i]);
  49                 else
  50                         seq_printf(m, "%d", i);
  51         }
  52         return 0;
  53 }
  54
  55 #define QUEUE_FLAG_NAME(name) [QUEUE_FLAG_##name] = #name
  56 static const char *const blk_queue_flag_name[] = {
  57         QUEUE_FLAG_NAME(QUEUED),
  58         QUEUE_FLAG_NAME(STOPPED),
  59         QUEUE_FLAG_NAME(SYNCFULL),
  60         QUEUE_FLAG_NAME(ASYNCFULL),
  61         QUEUE_FLAG_NAME(DYING),
  62         QUEUE_FLAG_NAME(BYPASS),
  63         QUEUE_FLAG_NAME(BIDI),
  64         QUEUE_FLAG_NAME(NOMERGES),
  65         QUEUE_FLAG_NAME(SAME_COMP),
  66         QUEUE_FLAG_NAME(FAIL_IO),
  67         QUEUE_FLAG_NAME(STACKABLE),
  68         QUEUE_FLAG_NAME(NONROT),
  69         QUEUE_FLAG_NAME(IO_STAT),
  70         QUEUE_FLAG_NAME(DISCARD),
  71         QUEUE_FLAG_NAME(NOXMERGES),
  72         QUEUE_FLAG_NAME(ADD_RANDOM),
  73         QUEUE_FLAG_NAME(SECERASE),
  74         QUEUE_FLAG_NAME(SAME_FORCE),
  75         QUEUE_FLAG_NAME(DEAD),
  76         QUEUE_FLAG_NAME(INIT_DONE),
  77         QUEUE_FLAG_NAME(NO_SG_MERGE),
  78         QUEUE_FLAG_NAME(POLL),
  79         QUEUE_FLAG_NAME(WC),
  80         QUEUE_FLAG_NAME(FUA),
  81         QUEUE_FLAG_NAME(FLUSH_NQ),
  82         QUEUE_FLAG_NAME(DAX),
  83         QUEUE_FLAG_NAME(STATS),
  84         QUEUE_FLAG_NAME(POLL_STATS),
  85         QUEUE_FLAG_NAME(REGISTERED),
  86 };
  87 #undef QUEUE_FLAG_NAME
  88
  89 static int queue_state_show(void *data, struct seq_file *m)
  90 {
  91         struct request_queue *q = data;
  92
  93         blk_flags_show(m, q->queue_flags, blk_queue_flag_name,
  94                        ARRAY_SIZE(blk_queue_flag_name));
  95         seq_puts(m, "\n");
  96         return 0;
  97 }
  98
  99 static ssize_t queue_state_write(void *data, const char __user *buf,
 100                                  size_t count, loff_t *ppos)
 101 {
 102         struct request_queue *q = data;
 103         char opbuf[16] = { }, *op;
 104
 105         if (count >= sizeof(opbuf)) {
 106                 pr_err("%s: operation too long\n", __func__);
 107                 goto inval;
 108         }
 109
 110         if (copy_from_user(opbuf, buf, count))
 111                 return -EFAULT;
 112         op = strstrip(opbuf);
 113         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 {
 118                 pr_err("%s: unsupported operation '%s'\n", __func__, op);
 119 inval:
 120                 pr_err("%s: use either 'run' or 'start'\n", __func__);
 121                 return -EINVAL;
 122         }
 123         return count;
 124 }
 125
 126 static 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
 136 static int queue_poll_stat_show(void *data, struct seq_file *m)
 137 {
 138         struct request_queue *q = data;
 139         int bucket;
 140
 141         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");
 145
 146                 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         }
 150         return 0;
 151 }
 152
 153 #define HCTX_STATE_NAME(name) [BLK_MQ_S_##name] = #name
 154 static const char *const hctx_state_name[] = {
 155         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),
 160 };
 161 #undef HCTX_STATE_NAME
 162
 163 static int hctx_state_show(void *data, struct seq_file *m)
 164 {
 165         struct blk_mq_hw_ctx *hctx = data;
 166
 167         blk_flags_show(m, hctx->state, hctx_state_name,
 168                        ARRAY_SIZE(hctx_state_name));
 169         seq_puts(m, "\n");
 170         return 0;
 171 }
 172
 173 #define BLK_TAG_ALLOC_NAME(name) [BLK_TAG_ALLOC_##name] = #name
 174 static const char *const alloc_policy_name[] = {
 175         BLK_TAG_ALLOC_NAME(FIFO),
 176         BLK_TAG_ALLOC_NAME(RR),
 177 };
 178 #undef BLK_TAG_ALLOC_NAME
 179
 180 #define HCTX_FLAG_NAME(name) [ilog2(BLK_MQ_F_##name)] = #name
 181 static const char *const hctx_flag_name[] = {
 182         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),
 187 };
 188 #undef HCTX_FLAG_NAME
 189
 190 static int hctx_flags_show(void *data, struct seq_file *m)
 191 {
 192         struct blk_mq_hw_ctx *hctx = data;
 193         const int alloc_policy = BLK_MQ_FLAG_TO_ALLOC_POLICY(hctx->flags);
 194
 195         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));
 205         seq_puts(m, "\n");
 206         return 0;
 207 }
 208
 209 #define REQ_OP_NAME(name) [REQ_OP_##name] = #name
 210 static const char *const op_name[] = {
 211         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),
 224 };
 225 #undef REQ_OP_NAME
 226
 227 #define CMD_FLAG_NAME(name) [__REQ_##name] = #name
 228 static const char *const cmd_flag_name[] = {
 229         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),
 243 };
 244 #undef CMD_FLAG_NAME
 245
 246 #define RQF_NAME(name) [ilog2((__force u32)RQF_##name)] = #name
 247 static const char *const rqf_name[] = {
 248         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),
 267 };
 268 #undef RQF_NAME
 269
 270 static int blk_mq_debugfs_rq_show(struct seq_file *m, void *v)
 271 {
 272         struct request *rq = list_entry_rq(v);
 273         const struct blk_mq_ops *const mq_ops = rq->q->mq_ops;
 274         const unsigned int op = rq->cmd_flags & REQ_OP_MASK;
 275
 276         seq_printf(m, "%p {.op=", rq);
 277         if (op < ARRAY_SIZE(op_name) && op_name[op])
 278                 seq_printf(m, "%s", op_name[op]);
 279         else
 280                 seq_printf(m, "%d", op);
 281         seq_puts(m, ", .cmd_flags=");
 282         blk_flags_show(m, rq->cmd_flags & ~REQ_OP_MASK, cmd_flag_name,
 283                        ARRAY_SIZE(cmd_flag_name));
 284         seq_puts(m, ", .rq_flags=");
 285         blk_flags_show(m, (__force unsigned int)rq->rq_flags, rqf_name,
 286                        ARRAY_SIZE(rqf_name));
 287         seq_printf(m, ", .tag=%d, .internal_tag=%d", rq->tag,
 288                    rq->internal_tag);
 289         if (mq_ops->show_rq)
 290                 mq_ops->show_rq(m, rq);
 291         seq_puts(m, "}\n");
 292         return 0;
 293 }
 294
 295 static void *hctx_dispatch_start(struct seq_file *m, loff_t *pos)
 296         __acquires(&hctx->lock)
 297 {
 298         struct blk_mq_hw_ctx *hctx = m->private;
 299
 300         spin_lock(&hctx->lock);
 301         return seq_list_start(&hctx->dispatch, *pos);
 302 }
 303
 304 static void *hctx_dispatch_next(struct seq_file *m, void *v, loff_t *pos)
 305 {
 306         struct blk_mq_hw_ctx *hctx = m->private;
 307
 308         return seq_list_next(v, &hctx->dispatch, pos);
 309 }
 310
 311 static void hctx_dispatch_stop(struct seq_file *m, void *v)
 312         __releases(&hctx->lock)
 313 {
 314         struct blk_mq_hw_ctx *hctx = m->private;
 315
 316         spin_unlock(&hctx->lock);
 317 }
 318
 319 static const struct seq_operations hctx_dispatch_seq_ops = {
 320         .start  = hctx_dispatch_start,
 321         .next   = hctx_dispatch_next,
 322         .stop   = hctx_dispatch_stop,
 323         .show   = blk_mq_debugfs_rq_show,
 324 };
 325
 326 static int hctx_ctx_map_show(void *data, struct seq_file *m)
 327 {
 328         struct blk_mq_hw_ctx *hctx = data;
 329
 330         sbitmap_bitmap_show(&hctx->ctx_map, m);
 331         return 0;
 332 }
 333
 334 static void blk_mq_debugfs_tags_show(struct seq_file *m,
 335                                      struct blk_mq_tags *tags)
 336 {
 337         seq_printf(m, "nr_tags=%u\n", tags->nr_tags);
 338         seq_printf(m, "nr_reserved_tags=%u\n", tags->nr_reserved_tags);
 339         seq_printf(m, "active_queues=%d\n",
 340                    atomic_read(&tags->active_queues));
 341
 342         seq_puts(m, "\nbitmap_tags:\n");
 343         sbitmap_queue_show(&tags->bitmap_tags, m);
 344
 345         if (tags->nr_reserved_tags) {
 346                 seq_puts(m, "\nbreserved_tags:\n");
 347                 sbitmap_queue_show(&tags->breserved_tags, m);
 348         }
 349 }
 350
 351 static int hctx_tags_show(void *data, struct seq_file *m)
 352 {
 353         struct blk_mq_hw_ctx *hctx = data;
 354         struct request_queue *q = hctx->queue;
 355         int res;
 356
 357         res = mutex_lock_interruptible(&q->sysfs_lock);
 358         if (res)
 359                 goto out;
 360         if (hctx->tags)
 361                 blk_mq_debugfs_tags_show(m, hctx->tags);
 362         mutex_unlock(&q->sysfs_lock);
 363
 364 out:
 365         return res;
 366 }
 367
 368 static int hctx_tags_bitmap_show(void *data, struct seq_file *m)
 369 {
 370         struct blk_mq_hw_ctx *hctx = data;
 371         struct request_queue *q = hctx->queue;
 372         int res;
 373
 374         res = mutex_lock_interruptible(&q->sysfs_lock);
 375         if (res)
 376                 goto out;
 377         if (hctx->tags)
 378                 sbitmap_bitmap_show(&hctx->tags->bitmap_tags.sb, m);
 379         mutex_unlock(&q->sysfs_lock);
 380
 381 out:
 382         return res;
 383 }
 384
 385 static int hctx_sched_tags_show(void *data, struct seq_file *m)
 386 {
 387         struct blk_mq_hw_ctx *hctx = data;
 388         struct request_queue *q = hctx->queue;
 389         int res;
 390
 391         res = mutex_lock_interruptible(&q->sysfs_lock);
 392         if (res)
 393                 goto out;
 394         if (hctx->sched_tags)
 395                 blk_mq_debugfs_tags_show(m, hctx->sched_tags);
 396         mutex_unlock(&q->sysfs_lock);
 397
 398 out:
 399         return res;
 400 }
 401
 402 static int hctx_sched_tags_bitmap_show(void *data, struct seq_file *m)
 403 {
 404         struct blk_mq_hw_ctx *hctx = data;
 405         struct request_queue *q = hctx->queue;
 406         int res;
 407
 408         res = mutex_lock_interruptible(&q->sysfs_lock);
 409         if (res)
 410                 goto out;
 411         if (hctx->sched_tags)
 412                 sbitmap_bitmap_show(&hctx->sched_tags->bitmap_tags.sb, m);
 413         mutex_unlock(&q->sysfs_lock);
 414
 415 out:
 416         return res;
 417 }
 418
 419 static int hctx_io_poll_show(void *data, struct seq_file *m)
 420 {
 421         struct blk_mq_hw_ctx *hctx = data;
 422
 423         seq_printf(m, "considered=%lu\n", hctx->poll_considered);
 424         seq_printf(m, "invoked=%lu\n", hctx->poll_invoked);
 425         seq_printf(m, "success=%lu\n", hctx->poll_success);
 426         return 0;
 427 }
 428
 429 static ssize_t hctx_io_poll_write(void *data, const char __user *buf,
 430                                   size_t count, loff_t *ppos)
 431 {
 432         struct blk_mq_hw_ctx *hctx = data;
 433
 434         hctx->poll_considered = hctx->poll_invoked = hctx->poll_success = 0;
 435         return count;
 436 }
 437
 438 static int hctx_dispatched_show(void *data, struct seq_file *m)
 439 {
 440         struct blk_mq_hw_ctx *hctx = data;
 441         int i;
 442
 443         seq_printf(m, "%8u\t%lu\n", 0U, hctx->dispatched[0]);
 444
 445         for (i = 1; i < BLK_MQ_MAX_DISPATCH_ORDER - 1; i++) {
 446                 unsigned int d = 1U << (i - 1);
 447
 448                 seq_printf(m, "%8u\t%lu\n", d, hctx->dispatched[i]);
 449         }
 450
 451         seq_printf(m, "%8u+\t%lu\n", 1U << (i - 1), hctx->dispatched[i]);
 452         return 0;
 453 }
 454
 455 static ssize_t hctx_dispatched_write(void *data, const char __user *buf,
 456                                      size_t count, loff_t *ppos)
 457 {
 458         struct blk_mq_hw_ctx *hctx = data;
 459         int i;
 460
 461         for (i = 0; i < BLK_MQ_MAX_DISPATCH_ORDER; i++)
 462                 hctx->dispatched[i] = 0;
 463         return count;
 464 }
 465
 466 static int hctx_queued_show(void *data, struct seq_file *m)
 467 {
 468         struct blk_mq_hw_ctx *hctx = data;
 469
 470         seq_printf(m, "%lu\n", hctx->queued);
 471         return 0;
 472 }
 473
 474 static ssize_t hctx_queued_write(void *data, const char __user *buf,
 475                                  size_t count, loff_t *ppos)
 476 {
 477         struct blk_mq_hw_ctx *hctx = data;
 478
 479         hctx->queued = 0;
 480         return count;
 481 }
 482
 483 static int hctx_run_show(void *data, struct seq_file *m)
 484 {
 485         struct blk_mq_hw_ctx *hctx = data;
 486
 487         seq_printf(m, "%lu\n", hctx->run);
 488         return 0;
 489 }
 490
 491 static ssize_t hctx_run_write(void *data, const char __user *buf, size_t count,
 492                               loff_t *ppos)
 493 {
 494         struct blk_mq_hw_ctx *hctx = data;
 495
 496         hctx->run = 0;
 497         return count;
 498 }
 499
 500 static int hctx_active_show(void *data, struct seq_file *m)
 501 {
 502         struct blk_mq_hw_ctx *hctx = data;
 503
 504         seq_printf(m, "%d\n", atomic_read(&hctx->nr_active));
 505         return 0;
 506 }
 507
 508 static void *ctx_rq_list_start(struct seq_file *m, loff_t *pos)
 509         __acquires(&ctx->lock)
 510 {
 511         struct blk_mq_ctx *ctx = m->private;
 512
 513         spin_lock(&ctx->lock);
 514         return seq_list_start(&ctx->rq_list, *pos);
 515 }
 516
 517 static void *ctx_rq_list_next(struct seq_file *m, void *v, loff_t *pos)
 518 {
 519         struct blk_mq_ctx *ctx = m->private;
 520
 521         return seq_list_next(v, &ctx->rq_list, pos);
 522 }
 523
 524 static void ctx_rq_list_stop(struct seq_file *m, void *v)
 525         __releases(&ctx->lock)
 526 {
 527         struct blk_mq_ctx *ctx = m->private;
 528
 529         spin_unlock(&ctx->lock);
 530 }
 531
 532 static const struct seq_operations ctx_rq_list_seq_ops = {
 533         .start  = ctx_rq_list_start,
 534         .next   = ctx_rq_list_next,
 535         .stop   = ctx_rq_list_stop,
 536         .show   = blk_mq_debugfs_rq_show,
 537 };
 538 static int ctx_dispatched_show(void *data, struct seq_file *m)
 539 {
 540         struct blk_mq_ctx *ctx = data;
 541
 542         seq_printf(m, "%lu %lu\n", ctx->rq_dispatched[1], ctx->rq_dispatched[0]);
 543         return 0;
 544 }
 545
 546 static ssize_t ctx_dispatched_write(void *data, const char __user *buf,
 547                                     size_t count, loff_t *ppos)
 548 {
 549         struct blk_mq_ctx *ctx = data;
 550
 551         ctx->rq_dispatched[0] = ctx->rq_dispatched[1] = 0;
 552         return count;
 553 }
 554
 555 static int ctx_merged_show(void *data, struct seq_file *m)
 556 {
 557         struct blk_mq_ctx *ctx = data;
 558
 559         seq_printf(m, "%lu\n", ctx->rq_merged);
 560         return 0;
 561 }
 562
 563 static ssize_t ctx_merged_write(void *data, const char __user *buf,
 564                                 size_t count, loff_t *ppos)
 565 {
 566         struct blk_mq_ctx *ctx = data;
 567
 568         ctx->rq_merged = 0;
 569         return count;
 570 }
 571
 572 static int ctx_completed_show(void *data, struct seq_file *m)
 573 {
 574         struct blk_mq_ctx *ctx = data;
 575
 576         seq_printf(m, "%lu %lu\n", ctx->rq_completed[1], ctx->rq_completed[0]);
 577         return 0;
 578 }
 579
 580 static ssize_t ctx_completed_write(void *data, const char __user *buf,
 581                                    size_t count, loff_t *ppos)
 582 {
 583         struct blk_mq_ctx *ctx = data;
 584
 585         ctx->rq_completed[0] = ctx->rq_completed[1] = 0;
 586         return count;
 587 }
 588
 589 static int blk_mq_debugfs_show(struct seq_file *m, void *v)
 590 {
 591         const struct blk_mq_debugfs_attr *attr = m->private;
 592         void *data = d_inode(m->file->f_path.dentry->d_parent)->i_private;
 593
 594         return attr->show(data, m);
 595 }
 596
 597 static ssize_t blk_mq_debugfs_write(struct file *file, const char __user *buf,
 598                                     size_t count, loff_t *ppos)
 599 {
 600         struct seq_file *m = file->private_data;
 601         const struct blk_mq_debugfs_attr *attr = m->private;
 602         void *data = d_inode(file->f_path.dentry->d_parent)->i_private;
 603
 604         if (!attr->write)
 605                 return -EPERM;
 606
 607         return attr->write(data, buf, count, ppos);
 608 }
 609
 610 static int blk_mq_debugfs_open(struct inode *inode, struct file *file)
 611 {
 612         const struct blk_mq_debugfs_attr *attr = inode->i_private;
 613         void *data = d_inode(file->f_path.dentry->d_parent)->i_private;
 614         struct seq_file *m;
 615         int ret;
 616
 617         if (attr->seq_ops) {
 618                 ret = seq_open(file, attr->seq_ops);
 619                 if (!ret) {
 620                         m = file->private_data;
 621                         m->private = data;
 622                 }
 623                 return ret;
 624         }
 625
 626         if (WARN_ON_ONCE(!attr->show))
 627                 return -EPERM;
 628
 629         return single_open(file, blk_mq_debugfs_show, inode->i_private);
 630 }
 631
 632 static int blk_mq_debugfs_release(struct inode *inode, struct file *file)
 633 {
 634         const struct blk_mq_debugfs_attr *attr = inode->i_private;
 635
 636         if (attr->show)
 637                 return single_release(inode, file);
 638         else
 639                 return seq_release(inode, file);
 640 }
 641
 642 const struct file_operations blk_mq_debugfs_fops = {
 643         .open           = blk_mq_debugfs_open,
 644         .read           = seq_read,
 645         .write          = blk_mq_debugfs_write,
 646         .llseek         = seq_lseek,
 647         .release        = blk_mq_debugfs_release,
 648 };
 649
 650 static const struct blk_mq_debugfs_attr blk_mq_debugfs_queue_attrs[] = {
 651         {"poll_stat", 0400, queue_poll_stat_show},
 652         {"state", 0600, queue_state_show, queue_state_write},
 653         {},
 654 };
 655
 656 static const struct blk_mq_debugfs_attr blk_mq_debugfs_hctx_attrs[] = {
 657         {"state", 0400, hctx_state_show},
 658         {"flags", 0400, hctx_flags_show},
 659         {"dispatch", 0400, .seq_ops = &hctx_dispatch_seq_ops},
 660         {"ctx_map", 0400, hctx_ctx_map_show},
 661         {"tags", 0400, hctx_tags_show},
 662         {"tags_bitmap", 0400, hctx_tags_bitmap_show},
 663         {"sched_tags", 0400, hctx_sched_tags_show},
 664         {"sched_tags_bitmap", 0400, hctx_sched_tags_bitmap_show},
 665         {"io_poll", 0600, hctx_io_poll_show, hctx_io_poll_write},
 666         {"dispatched", 0600, hctx_dispatched_show, hctx_dispatched_write},
 667         {"queued", 0600, hctx_queued_show, hctx_queued_write},
 668         {"run", 0600, hctx_run_show, hctx_run_write},
 669         {"active", 0400, hctx_active_show},
 670         {},
 671 };
 672
 673 static const struct blk_mq_debugfs_attr blk_mq_debugfs_ctx_attrs[] = {
 674         {"rq_list", 0400, .seq_ops = &ctx_rq_list_seq_ops},
 675         {"dispatched", 0600, ctx_dispatched_show, ctx_dispatched_write},
 676         {"merged", 0600, ctx_merged_show, ctx_merged_write},
 677         {"completed", 0600, ctx_completed_show, ctx_completed_write},
 678         {},
 679 };
 680
 681 int blk_mq_debugfs_register(struct request_queue *q)
 682 {
 683         if (!blk_debugfs_root)
 684                 return -ENOENT;
 685
 686         q->debugfs_dir = debugfs_create_dir(kobject_name(q->kobj.parent),
 687                                             blk_debugfs_root);
 688         if (!q->debugfs_dir)
 689                 goto err;
 690
 691         if (blk_mq_debugfs_register_mq(q))
 692                 goto err;
 693
 694         return 0;
 695
 696 err:
 697         blk_mq_debugfs_unregister(q);
 698         return -ENOMEM;
 699 }
 700
 701 void blk_mq_debugfs_unregister(struct request_queue *q)
 702 {
 703         debugfs_remove_recursive(q->debugfs_dir);
 704         q->mq_debugfs_dir = NULL;
 705         q->debugfs_dir = NULL;
 706 }
 707
 708 static bool debugfs_create_files(struct dentry *parent, void *data,
 709                                  const struct blk_mq_debugfs_attr *attr)
 710 {
 711         d_inode(parent)->i_private = data;
 712
 713         for (; attr->name; attr++) {
 714                 if (!debugfs_create_file(attr->name, attr->mode, parent,
 715                                          (void *)attr, &blk_mq_debugfs_fops))
 716                         return false;
 717         }
 718         return true;
 719 }
 720
 721 static int blk_mq_debugfs_register_ctx(struct request_queue *q,
 722                                        struct blk_mq_ctx *ctx,
 723                                        struct dentry *hctx_dir)
 724 {
 725         struct dentry *ctx_dir;
 726         char name[20];
 727
 728         snprintf(name, sizeof(name), "cpu%u", ctx->cpu);
 729         ctx_dir = debugfs_create_dir(name, hctx_dir);
 730         if (!ctx_dir)
 731                 return -ENOMEM;
 732
 733         if (!debugfs_create_files(ctx_dir, ctx, blk_mq_debugfs_ctx_attrs))
 734                 return -ENOMEM;
 735
 736         return 0;
 737 }
 738
 739 static int blk_mq_debugfs_register_hctx(struct request_queue *q,
 740                                         struct blk_mq_hw_ctx *hctx)
 741 {
 742         struct blk_mq_ctx *ctx;
 743         struct dentry *hctx_dir;
 744         char name[20];
 745         int i;
 746
 747         snprintf(name, sizeof(name), "hctx%u", hctx->queue_num);
 748         hctx_dir = debugfs_create_dir(name, q->mq_debugfs_dir);
 749         if (!hctx_dir)
 750                 return -ENOMEM;
 751
 752         if (!debugfs_create_files(hctx_dir, hctx, blk_mq_debugfs_hctx_attrs))
 753                 return -ENOMEM;
 754
 755         hctx_for_each_ctx(hctx, ctx, i) {
 756                 if (blk_mq_debugfs_register_ctx(q, ctx, hctx_dir))
 757                         return -ENOMEM;
 758         }
 759
 760         return 0;
 761 }
 762
 763 int blk_mq_debugfs_register_mq(struct request_queue *q)
 764 {
 765         struct blk_mq_hw_ctx *hctx;
 766         int i;
 767
 768         if (!q->debugfs_dir)
 769                 return -ENOENT;
 770
 771         q->mq_debugfs_dir = debugfs_create_dir("mq", q->debugfs_dir);
 772         if (!q->mq_debugfs_dir)
 773                 goto err;
 774
 775         if (!debugfs_create_files(q->mq_debugfs_dir, q, blk_mq_debugfs_queue_attrs))
 776                 goto err;
 777
 778         queue_for_each_hw_ctx(q, hctx, i) {
 779                 if (blk_mq_debugfs_register_hctx(q, hctx))
 780                         goto err;
 781         }
 782
 783         return 0;
 784
 785 err:
 786         blk_mq_debugfs_unregister_mq(q);
 787         return -ENOMEM;
 788 }
 789
 790 void blk_mq_debugfs_unregister_mq(struct request_queue *q)
 791 {
 792         debugfs_remove_recursive(q->mq_debugfs_dir);
 793         q->mq_debugfs_dir = NULL;
 794 }