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         /*
 106          * The "state" attribute is removed after blk_cleanup_queue() has called
 107          * blk_mq_free_queue(). Return if QUEUE_FLAG_DEAD has been set to avoid
 108          * triggering a use-after-free.
 109          */
 110         if (blk_queue_dead(q))
 111                 return -ENOENT;
 112
 113         if (count >= sizeof(opbuf)) {
 114                 pr_err("%s: operation too long\n", __func__);
 115                 goto inval;
 116         }
 117
 118         if (copy_from_user(opbuf, buf, count))
 119                 return -EFAULT;
 120         op = strstrip(opbuf);
 121         if (strcmp(op, "run") == 0) {
 122                 blk_mq_run_hw_queues(q, true);
 123         } else if (strcmp(op, "start") == 0) {
 124                 blk_mq_start_stopped_hw_queues(q, true);
 125         } else {
 126                 pr_err("%s: unsupported operation '%s'\n", __func__, op);
 127 inval:
 128                 pr_err("%s: use either 'run' or 'start'\n", __func__);
 129                 return -EINVAL;
 130         }
 131         return count;
 132 }
 133
 134 static void print_stat(struct seq_file *m, struct blk_rq_stat *stat)
 135 {
 136         if (stat->nr_samples) {
 137                 seq_printf(m, "samples=%d, mean=%lld, min=%llu, max=%llu",
 138                            stat->nr_samples, stat->mean, stat->min, stat->max);
 139         } else {
 140                 seq_puts(m, "samples=0");
 141         }
 142 }
 143
 144 static int queue_poll_stat_show(void *data, struct seq_file *m)
 145 {
 146         struct request_queue *q = data;
 147         int bucket;
 148
 149         for (bucket = 0; bucket < BLK_MQ_POLL_STATS_BKTS/2; bucket++) {
 150                 seq_printf(m, "read  (%d Bytes): ", 1 << (9+bucket));
 151                 print_stat(m, &q->poll_stat[2*bucket]);
 152                 seq_puts(m, "\n");
 153
 154                 seq_printf(m, "write (%d Bytes): ",  1 << (9+bucket));
 155                 print_stat(m, &q->poll_stat[2*bucket+1]);
 156                 seq_puts(m, "\n");
 157         }
 158         return 0;
 159 }
 160
 161 #define HCTX_STATE_NAME(name) [BLK_MQ_S_##name] = #name
 162 static const char *const hctx_state_name[] = {
 163         HCTX_STATE_NAME(STOPPED),
 164         HCTX_STATE_NAME(TAG_ACTIVE),
 165         HCTX_STATE_NAME(SCHED_RESTART),
 166         HCTX_STATE_NAME(TAG_WAITING),
 167         HCTX_STATE_NAME(START_ON_RUN),
 168 };
 169 #undef HCTX_STATE_NAME
 170
 171 static int hctx_state_show(void *data, struct seq_file *m)
 172 {
 173         struct blk_mq_hw_ctx *hctx = data;
 174
 175         blk_flags_show(m, hctx->state, hctx_state_name,
 176                        ARRAY_SIZE(hctx_state_name));
 177         seq_puts(m, "\n");
 178         return 0;
 179 }
 180
 181 #define BLK_TAG_ALLOC_NAME(name) [BLK_TAG_ALLOC_##name] = #name
 182 static const char *const alloc_policy_name[] = {
 183         BLK_TAG_ALLOC_NAME(FIFO),
 184         BLK_TAG_ALLOC_NAME(RR),
 185 };
 186 #undef BLK_TAG_ALLOC_NAME
 187
 188 #define HCTX_FLAG_NAME(name) [ilog2(BLK_MQ_F_##name)] = #name
 189 static const char *const hctx_flag_name[] = {
 190         HCTX_FLAG_NAME(SHOULD_MERGE),
 191         HCTX_FLAG_NAME(TAG_SHARED),
 192         HCTX_FLAG_NAME(SG_MERGE),
 193         HCTX_FLAG_NAME(BLOCKING),
 194         HCTX_FLAG_NAME(NO_SCHED),
 195 };
 196 #undef HCTX_FLAG_NAME
 197
 198 static int hctx_flags_show(void *data, struct seq_file *m)
 199 {
 200         struct blk_mq_hw_ctx *hctx = data;
 201         const int alloc_policy = BLK_MQ_FLAG_TO_ALLOC_POLICY(hctx->flags);
 202
 203         seq_puts(m, "alloc_policy=");
 204         if (alloc_policy < ARRAY_SIZE(alloc_policy_name) &&
 205             alloc_policy_name[alloc_policy])
 206                 seq_puts(m, alloc_policy_name[alloc_policy]);
 207         else
 208                 seq_printf(m, "%d", alloc_policy);
 209         seq_puts(m, " ");
 210         blk_flags_show(m,
 211                        hctx->flags ^ BLK_ALLOC_POLICY_TO_MQ_FLAG(alloc_policy),
 212                        hctx_flag_name, ARRAY_SIZE(hctx_flag_name));
 213         seq_puts(m, "\n");
 214         return 0;
 215 }
 216
 217 #define REQ_OP_NAME(name) [REQ_OP_##name] = #name
 218 static const char *const op_name[] = {
 219         REQ_OP_NAME(READ),
 220         REQ_OP_NAME(WRITE),
 221         REQ_OP_NAME(FLUSH),
 222         REQ_OP_NAME(DISCARD),
 223         REQ_OP_NAME(ZONE_REPORT),
 224         REQ_OP_NAME(SECURE_ERASE),
 225         REQ_OP_NAME(ZONE_RESET),
 226         REQ_OP_NAME(WRITE_SAME),
 227         REQ_OP_NAME(WRITE_ZEROES),
 228         REQ_OP_NAME(SCSI_IN),
 229         REQ_OP_NAME(SCSI_OUT),
 230         REQ_OP_NAME(DRV_IN),
 231         REQ_OP_NAME(DRV_OUT),
 232 };
 233 #undef REQ_OP_NAME
 234
 235 #define CMD_FLAG_NAME(name) [__REQ_##name] = #name
 236 static const char *const cmd_flag_name[] = {
 237         CMD_FLAG_NAME(FAILFAST_DEV),
 238         CMD_FLAG_NAME(FAILFAST_TRANSPORT),
 239         CMD_FLAG_NAME(FAILFAST_DRIVER),
 240         CMD_FLAG_NAME(SYNC),
 241         CMD_FLAG_NAME(META),
 242         CMD_FLAG_NAME(PRIO),
 243         CMD_FLAG_NAME(NOMERGE),
 244         CMD_FLAG_NAME(IDLE),
 245         CMD_FLAG_NAME(INTEGRITY),
 246         CMD_FLAG_NAME(FUA),
 247         CMD_FLAG_NAME(PREFLUSH),
 248         CMD_FLAG_NAME(RAHEAD),
 249         CMD_FLAG_NAME(BACKGROUND),
 250         CMD_FLAG_NAME(NOUNMAP),
 251 };
 252 #undef CMD_FLAG_NAME
 253
 254 #define RQF_NAME(name) [ilog2((__force u32)RQF_##name)] = #name
 255 static const char *const rqf_name[] = {
 256         RQF_NAME(SORTED),
 257         RQF_NAME(STARTED),
 258         RQF_NAME(QUEUED),
 259         RQF_NAME(SOFTBARRIER),
 260         RQF_NAME(FLUSH_SEQ),
 261         RQF_NAME(MIXED_MERGE),
 262         RQF_NAME(MQ_INFLIGHT),
 263         RQF_NAME(DONTPREP),
 264         RQF_NAME(PREEMPT),
 265         RQF_NAME(COPY_USER),
 266         RQF_NAME(FAILED),
 267         RQF_NAME(QUIET),
 268         RQF_NAME(ELVPRIV),
 269         RQF_NAME(IO_STAT),
 270         RQF_NAME(ALLOCED),
 271         RQF_NAME(PM),
 272         RQF_NAME(HASHED),
 273         RQF_NAME(STATS),
 274         RQF_NAME(SPECIAL_PAYLOAD),
 275 };
 276 #undef RQF_NAME
 277
 278 static int blk_mq_debugfs_rq_show(struct seq_file *m, void *v)
 279 {
 280         struct request *rq = list_entry_rq(v);
 281         const struct blk_mq_ops *const mq_ops = rq->q->mq_ops;
 282         const unsigned int op = rq->cmd_flags & REQ_OP_MASK;
 283
 284         seq_printf(m, "%p {.op=", rq);
 285         if (op < ARRAY_SIZE(op_name) && op_name[op])
 286                 seq_printf(m, "%s", op_name[op]);
 287         else
 288                 seq_printf(m, "%d", op);
 289         seq_puts(m, ", .cmd_flags=");
 290         blk_flags_show(m, rq->cmd_flags & ~REQ_OP_MASK, cmd_flag_name,
 291                        ARRAY_SIZE(cmd_flag_name));
 292         seq_puts(m, ", .rq_flags=");
 293         blk_flags_show(m, (__force unsigned int)rq->rq_flags, rqf_name,
 294                        ARRAY_SIZE(rqf_name));
 295         seq_printf(m, ", .tag=%d, .internal_tag=%d", rq->tag,
 296                    rq->internal_tag);
 297         if (mq_ops->show_rq)
 298                 mq_ops->show_rq(m, rq);
 299         seq_puts(m, "}\n");
 300         return 0;
 301 }
 302
 303 static void *hctx_dispatch_start(struct seq_file *m, loff_t *pos)
 304         __acquires(&hctx->lock)
 305 {
 306         struct blk_mq_hw_ctx *hctx = m->private;
 307
 308         spin_lock(&hctx->lock);
 309         return seq_list_start(&hctx->dispatch, *pos);
 310 }
 311
 312 static void *hctx_dispatch_next(struct seq_file *m, void *v, loff_t *pos)
 313 {
 314         struct blk_mq_hw_ctx *hctx = m->private;
 315
 316         return seq_list_next(v, &hctx->dispatch, pos);
 317 }
 318
 319 static void hctx_dispatch_stop(struct seq_file *m, void *v)
 320         __releases(&hctx->lock)
 321 {
 322         struct blk_mq_hw_ctx *hctx = m->private;
 323
 324         spin_unlock(&hctx->lock);
 325 }
 326
 327 static const struct seq_operations hctx_dispatch_seq_ops = {
 328         .start  = hctx_dispatch_start,
 329         .next   = hctx_dispatch_next,
 330         .stop   = hctx_dispatch_stop,
 331         .show   = blk_mq_debugfs_rq_show,
 332 };
 333
 334 static int hctx_ctx_map_show(void *data, struct seq_file *m)
 335 {
 336         struct blk_mq_hw_ctx *hctx = data;
 337
 338         sbitmap_bitmap_show(&hctx->ctx_map, m);
 339         return 0;
 340 }
 341
 342 static void blk_mq_debugfs_tags_show(struct seq_file *m,
 343                                      struct blk_mq_tags *tags)
 344 {
 345         seq_printf(m, "nr_tags=%u\n", tags->nr_tags);
 346         seq_printf(m, "nr_reserved_tags=%u\n", tags->nr_reserved_tags);
 347         seq_printf(m, "active_queues=%d\n",
 348                    atomic_read(&tags->active_queues));
 349
 350         seq_puts(m, "\nbitmap_tags:\n");
 351         sbitmap_queue_show(&tags->bitmap_tags, m);
 352
 353         if (tags->nr_reserved_tags) {
 354                 seq_puts(m, "\nbreserved_tags:\n");
 355                 sbitmap_queue_show(&tags->breserved_tags, m);
 356         }
 357 }
 358
 359 static int hctx_tags_show(void *data, struct seq_file *m)
 360 {
 361         struct blk_mq_hw_ctx *hctx = data;
 362         struct request_queue *q = hctx->queue;
 363         int res;
 364
 365         res = mutex_lock_interruptible(&q->sysfs_lock);
 366         if (res)
 367                 goto out;
 368         if (hctx->tags)
 369                 blk_mq_debugfs_tags_show(m, hctx->tags);
 370         mutex_unlock(&q->sysfs_lock);
 371
 372 out:
 373         return res;
 374 }
 375
 376 static int hctx_tags_bitmap_show(void *data, struct seq_file *m)
 377 {
 378         struct blk_mq_hw_ctx *hctx = data;
 379         struct request_queue *q = hctx->queue;
 380         int res;
 381
 382         res = mutex_lock_interruptible(&q->sysfs_lock);
 383         if (res)
 384                 goto out;
 385         if (hctx->tags)
 386                 sbitmap_bitmap_show(&hctx->tags->bitmap_tags.sb, m);
 387         mutex_unlock(&q->sysfs_lock);
 388
 389 out:
 390         return res;
 391 }
 392
 393 static int hctx_sched_tags_show(void *data, struct seq_file *m)
 394 {
 395         struct blk_mq_hw_ctx *hctx = data;
 396         struct request_queue *q = hctx->queue;
 397         int res;
 398
 399         res = mutex_lock_interruptible(&q->sysfs_lock);
 400         if (res)
 401                 goto out;
 402         if (hctx->sched_tags)
 403                 blk_mq_debugfs_tags_show(m, hctx->sched_tags);
 404         mutex_unlock(&q->sysfs_lock);
 405
 406 out:
 407         return res;
 408 }
 409
 410 static int hctx_sched_tags_bitmap_show(void *data, struct seq_file *m)
 411 {
 412         struct blk_mq_hw_ctx *hctx = data;
 413         struct request_queue *q = hctx->queue;
 414         int res;
 415
 416         res = mutex_lock_interruptible(&q->sysfs_lock);
 417         if (res)
 418                 goto out;
 419         if (hctx->sched_tags)
 420                 sbitmap_bitmap_show(&hctx->sched_tags->bitmap_tags.sb, m);
 421         mutex_unlock(&q->sysfs_lock);
 422
 423 out:
 424         return res;
 425 }
 426
 427 static int hctx_io_poll_show(void *data, struct seq_file *m)
 428 {
 429         struct blk_mq_hw_ctx *hctx = data;
 430
 431         seq_printf(m, "considered=%lu\n", hctx->poll_considered);
 432         seq_printf(m, "invoked=%lu\n", hctx->poll_invoked);
 433         seq_printf(m, "success=%lu\n", hctx->poll_success);
 434         return 0;
 435 }
 436
 437 static ssize_t hctx_io_poll_write(void *data, const char __user *buf,
 438                                   size_t count, loff_t *ppos)
 439 {
 440         struct blk_mq_hw_ctx *hctx = data;
 441
 442         hctx->poll_considered = hctx->poll_invoked = hctx->poll_success = 0;
 443         return count;
 444 }
 445
 446 static int hctx_dispatched_show(void *data, struct seq_file *m)
 447 {
 448         struct blk_mq_hw_ctx *hctx = data;
 449         int i;
 450
 451         seq_printf(m, "%8u\t%lu\n", 0U, hctx->dispatched[0]);
 452
 453         for (i = 1; i < BLK_MQ_MAX_DISPATCH_ORDER - 1; i++) {
 454                 unsigned int d = 1U << (i - 1);
 455
 456                 seq_printf(m, "%8u\t%lu\n", d, hctx->dispatched[i]);
 457         }
 458
 459         seq_printf(m, "%8u+\t%lu\n", 1U << (i - 1), hctx->dispatched[i]);
 460         return 0;
 461 }
 462
 463 static ssize_t hctx_dispatched_write(void *data, const char __user *buf,
 464                                      size_t count, loff_t *ppos)
 465 {
 466         struct blk_mq_hw_ctx *hctx = data;
 467         int i;
 468
 469         for (i = 0; i < BLK_MQ_MAX_DISPATCH_ORDER; i++)
 470                 hctx->dispatched[i] = 0;
 471         return count;
 472 }
 473
 474 static int hctx_queued_show(void *data, struct seq_file *m)
 475 {
 476         struct blk_mq_hw_ctx *hctx = data;
 477
 478         seq_printf(m, "%lu\n", hctx->queued);
 479         return 0;
 480 }
 481
 482 static ssize_t hctx_queued_write(void *data, const char __user *buf,
 483                                  size_t count, loff_t *ppos)
 484 {
 485         struct blk_mq_hw_ctx *hctx = data;
 486
 487         hctx->queued = 0;
 488         return count;
 489 }
 490
 491 static int hctx_run_show(void *data, struct seq_file *m)
 492 {
 493         struct blk_mq_hw_ctx *hctx = data;
 494
 495         seq_printf(m, "%lu\n", hctx->run);
 496         return 0;
 497 }
 498
 499 static ssize_t hctx_run_write(void *data, const char __user *buf, size_t count,
 500                               loff_t *ppos)
 501 {
 502         struct blk_mq_hw_ctx *hctx = data;
 503
 504         hctx->run = 0;
 505         return count;
 506 }
 507
 508 static int hctx_active_show(void *data, struct seq_file *m)
 509 {
 510         struct blk_mq_hw_ctx *hctx = data;
 511
 512         seq_printf(m, "%d\n", atomic_read(&hctx->nr_active));
 513         return 0;
 514 }
 515
 516 static void *ctx_rq_list_start(struct seq_file *m, loff_t *pos)
 517         __acquires(&ctx->lock)
 518 {
 519         struct blk_mq_ctx *ctx = m->private;
 520
 521         spin_lock(&ctx->lock);
 522         return seq_list_start(&ctx->rq_list, *pos);
 523 }
 524
 525 static void *ctx_rq_list_next(struct seq_file *m, void *v, loff_t *pos)
 526 {
 527         struct blk_mq_ctx *ctx = m->private;
 528
 529         return seq_list_next(v, &ctx->rq_list, pos);
 530 }
 531
 532 static void ctx_rq_list_stop(struct seq_file *m, void *v)
 533         __releases(&ctx->lock)
 534 {
 535         struct blk_mq_ctx *ctx = m->private;
 536
 537         spin_unlock(&ctx->lock);
 538 }
 539
 540 static const struct seq_operations ctx_rq_list_seq_ops = {
 541         .start  = ctx_rq_list_start,
 542         .next   = ctx_rq_list_next,
 543         .stop   = ctx_rq_list_stop,
 544         .show   = blk_mq_debugfs_rq_show,
 545 };
 546 static int ctx_dispatched_show(void *data, struct seq_file *m)
 547 {
 548         struct blk_mq_ctx *ctx = data;
 549
 550         seq_printf(m, "%lu %lu\n", ctx->rq_dispatched[1], ctx->rq_dispatched[0]);
 551         return 0;
 552 }
 553
 554 static ssize_t ctx_dispatched_write(void *data, const char __user *buf,
 555                                     size_t count, loff_t *ppos)
 556 {
 557         struct blk_mq_ctx *ctx = data;
 558
 559         ctx->rq_dispatched[0] = ctx->rq_dispatched[1] = 0;
 560         return count;
 561 }
 562
 563 static int ctx_merged_show(void *data, struct seq_file *m)
 564 {
 565         struct blk_mq_ctx *ctx = data;
 566
 567         seq_printf(m, "%lu\n", ctx->rq_merged);
 568         return 0;
 569 }
 570
 571 static ssize_t ctx_merged_write(void *data, const char __user *buf,
 572                                 size_t count, loff_t *ppos)
 573 {
 574         struct blk_mq_ctx *ctx = data;
 575
 576         ctx->rq_merged = 0;
 577         return count;
 578 }
 579
 580 static int ctx_completed_show(void *data, struct seq_file *m)
 581 {
 582         struct blk_mq_ctx *ctx = data;
 583
 584         seq_printf(m, "%lu %lu\n", ctx->rq_completed[1], ctx->rq_completed[0]);
 585         return 0;
 586 }
 587
 588 static ssize_t ctx_completed_write(void *data, const char __user *buf,
 589                                    size_t count, loff_t *ppos)
 590 {
 591         struct blk_mq_ctx *ctx = data;
 592
 593         ctx->rq_completed[0] = ctx->rq_completed[1] = 0;
 594         return count;
 595 }
 596
 597 static int blk_mq_debugfs_show(struct seq_file *m, void *v)
 598 {
 599         const struct blk_mq_debugfs_attr *attr = m->private;
 600         void *data = d_inode(m->file->f_path.dentry->d_parent)->i_private;
 601
 602         return attr->show(data, m);
 603 }
 604
 605 static ssize_t blk_mq_debugfs_write(struct file *file, const char __user *buf,
 606                                     size_t count, loff_t *ppos)
 607 {
 608         struct seq_file *m = file->private_data;
 609         const struct blk_mq_debugfs_attr *attr = m->private;
 610         void *data = d_inode(file->f_path.dentry->d_parent)->i_private;
 611
 612         if (!attr->write)
 613                 return -EPERM;
 614
 615         return attr->write(data, buf, count, ppos);
 616 }
 617
 618 static int blk_mq_debugfs_open(struct inode *inode, struct file *file)
 619 {
 620         const struct blk_mq_debugfs_attr *attr = inode->i_private;
 621         void *data = d_inode(file->f_path.dentry->d_parent)->i_private;
 622         struct seq_file *m;
 623         int ret;
 624
 625         if (attr->seq_ops) {
 626                 ret = seq_open(file, attr->seq_ops);
 627                 if (!ret) {
 628                         m = file->private_data;
 629                         m->private = data;
 630                 }
 631                 return ret;
 632         }
 633
 634         if (WARN_ON_ONCE(!attr->show))
 635                 return -EPERM;
 636
 637         return single_open(file, blk_mq_debugfs_show, inode->i_private);
 638 }
 639
 640 static int blk_mq_debugfs_release(struct inode *inode, struct file *file)
 641 {
 642         const struct blk_mq_debugfs_attr *attr = inode->i_private;
 643
 644         if (attr->show)
 645                 return single_release(inode, file);
 646         else
 647                 return seq_release(inode, file);
 648 }
 649
 650 const struct file_operations blk_mq_debugfs_fops = {
 651         .open           = blk_mq_debugfs_open,
 652         .read           = seq_read,
 653         .write          = blk_mq_debugfs_write,
 654         .llseek         = seq_lseek,
 655         .release        = blk_mq_debugfs_release,
 656 };
 657
 658 static const struct blk_mq_debugfs_attr blk_mq_debugfs_queue_attrs[] = {
 659         {"poll_stat", 0400, queue_poll_stat_show},
 660         {"state", 0600, queue_state_show, queue_state_write},
 661         {},
 662 };
 663
 664 static const struct blk_mq_debugfs_attr blk_mq_debugfs_hctx_attrs[] = {
 665         {"state", 0400, hctx_state_show},
 666         {"flags", 0400, hctx_flags_show},
 667         {"dispatch", 0400, .seq_ops = &hctx_dispatch_seq_ops},
 668         {"ctx_map", 0400, hctx_ctx_map_show},
 669         {"tags", 0400, hctx_tags_show},
 670         {"tags_bitmap", 0400, hctx_tags_bitmap_show},
 671         {"sched_tags", 0400, hctx_sched_tags_show},
 672         {"sched_tags_bitmap", 0400, hctx_sched_tags_bitmap_show},
 673         {"io_poll", 0600, hctx_io_poll_show, hctx_io_poll_write},
 674         {"dispatched", 0600, hctx_dispatched_show, hctx_dispatched_write},
 675         {"queued", 0600, hctx_queued_show, hctx_queued_write},
 676         {"run", 0600, hctx_run_show, hctx_run_write},
 677         {"active", 0400, hctx_active_show},
 678         {},
 679 };
 680
 681 static const struct blk_mq_debugfs_attr blk_mq_debugfs_ctx_attrs[] = {
 682         {"rq_list", 0400, .seq_ops = &ctx_rq_list_seq_ops},
 683         {"dispatched", 0600, ctx_dispatched_show, ctx_dispatched_write},
 684         {"merged", 0600, ctx_merged_show, ctx_merged_write},
 685         {"completed", 0600, ctx_completed_show, ctx_completed_write},
 686         {},
 687 };
 688
 689 int blk_mq_debugfs_register(struct request_queue *q)
 690 {
 691         if (!blk_debugfs_root)
 692                 return -ENOENT;
 693
 694         q->debugfs_dir = debugfs_create_dir(kobject_name(q->kobj.parent),
 695                                             blk_debugfs_root);
 696         if (!q->debugfs_dir)
 697                 goto err;
 698
 699         if (blk_mq_debugfs_register_mq(q))
 700                 goto err;
 701
 702         return 0;
 703
 704 err:
 705         blk_mq_debugfs_unregister(q);
 706         return -ENOMEM;
 707 }
 708
 709 void blk_mq_debugfs_unregister(struct request_queue *q)
 710 {
 711         debugfs_remove_recursive(q->debugfs_dir);
 712         q->mq_debugfs_dir = NULL;
 713         q->debugfs_dir = NULL;
 714 }
 715
 716 static bool debugfs_create_files(struct dentry *parent, void *data,
 717                                  const struct blk_mq_debugfs_attr *attr)
 718 {
 719         d_inode(parent)->i_private = data;
 720
 721         for (; attr->name; attr++) {
 722                 if (!debugfs_create_file(attr->name, attr->mode, parent,
 723                                          (void *)attr, &blk_mq_debugfs_fops))
 724                         return false;
 725         }
 726         return true;
 727 }
 728
 729 static int blk_mq_debugfs_register_ctx(struct request_queue *q,
 730                                        struct blk_mq_ctx *ctx,
 731                                        struct dentry *hctx_dir)
 732 {
 733         struct dentry *ctx_dir;
 734         char name[20];
 735
 736         snprintf(name, sizeof(name), "cpu%u", ctx->cpu);
 737         ctx_dir = debugfs_create_dir(name, hctx_dir);
 738         if (!ctx_dir)
 739                 return -ENOMEM;
 740
 741         if (!debugfs_create_files(ctx_dir, ctx, blk_mq_debugfs_ctx_attrs))
 742                 return -ENOMEM;
 743
 744         return 0;
 745 }
 746
 747 static int blk_mq_debugfs_register_hctx(struct request_queue *q,
 748                                         struct blk_mq_hw_ctx *hctx)
 749 {
 750         struct blk_mq_ctx *ctx;
 751         struct dentry *hctx_dir;
 752         char name[20];
 753         int i;
 754
 755         snprintf(name, sizeof(name), "hctx%u", hctx->queue_num);
 756         hctx_dir = debugfs_create_dir(name, q->mq_debugfs_dir);
 757         if (!hctx_dir)
 758                 return -ENOMEM;
 759
 760         if (!debugfs_create_files(hctx_dir, hctx, blk_mq_debugfs_hctx_attrs))
 761                 return -ENOMEM;
 762
 763         hctx_for_each_ctx(hctx, ctx, i) {
 764                 if (blk_mq_debugfs_register_ctx(q, ctx, hctx_dir))
 765                         return -ENOMEM;
 766         }
 767
 768         return 0;
 769 }
 770
 771 int blk_mq_debugfs_register_mq(struct request_queue *q)
 772 {
 773         struct blk_mq_hw_ctx *hctx;
 774         int i;
 775
 776         if (!q->debugfs_dir)
 777                 return -ENOENT;
 778
 779         q->mq_debugfs_dir = debugfs_create_dir("mq", q->debugfs_dir);
 780         if (!q->mq_debugfs_dir)
 781                 goto err;
 782
 783         if (!debugfs_create_files(q->mq_debugfs_dir, q, blk_mq_debugfs_queue_attrs))
 784                 goto err;
 785
 786         queue_for_each_hw_ctx(q, hctx, i) {
 787                 if (blk_mq_debugfs_register_hctx(q, hctx))
 788                         goto err;
 789         }
 790
 791         return 0;
 792
 793 err:
 794         blk_mq_debugfs_unregister_mq(q);
 795         return -ENOMEM;
 796 }
 797
 798 void blk_mq_debugfs_unregister_mq(struct request_queue *q)
 799 {
 800         debugfs_remove_recursive(q->mq_debugfs_dir);
 801         q->mq_debugfs_dir = NULL;
 802 }