2017-01-25 16:06:40 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2017 Facebook
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public
|
|
|
|
* License v2 as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/debugfs.h>
|
|
|
|
|
|
|
|
#include <linux/blk-mq.h>
|
2017-01-31 22:53:20 +00:00
|
|
|
#include "blk.h"
|
2017-01-25 16:06:40 +00:00
|
|
|
#include "blk-mq.h"
|
2017-05-04 07:31:30 +00:00
|
|
|
#include "blk-mq-debugfs.h"
|
2017-01-25 16:06:46 +00:00
|
|
|
#include "blk-mq-tag.h"
|
2017-01-25 16:06:40 +00:00
|
|
|
|
2018-02-28 00:32:13 +00:00
|
|
|
static void print_stat(struct seq_file *m, struct blk_rq_stat *stat)
|
|
|
|
{
|
|
|
|
if (stat->nr_samples) {
|
|
|
|
seq_printf(m, "samples=%d, mean=%lld, min=%llu, max=%llu",
|
|
|
|
stat->nr_samples, stat->mean, stat->min, stat->max);
|
|
|
|
} else {
|
|
|
|
seq_puts(m, "samples=0");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int queue_poll_stat_show(void *data, struct seq_file *m)
|
|
|
|
{
|
|
|
|
struct request_queue *q = data;
|
|
|
|
int bucket;
|
|
|
|
|
|
|
|
for (bucket = 0; bucket < BLK_MQ_POLL_STATS_BKTS/2; bucket++) {
|
|
|
|
seq_printf(m, "read (%d Bytes): ", 1 << (9+bucket));
|
|
|
|
print_stat(m, &q->poll_stat[2*bucket]);
|
|
|
|
seq_puts(m, "\n");
|
|
|
|
|
|
|
|
seq_printf(m, "write (%d Bytes): ", 1 << (9+bucket));
|
|
|
|
print_stat(m, &q->poll_stat[2*bucket+1]);
|
|
|
|
seq_puts(m, "\n");
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *queue_requeue_list_start(struct seq_file *m, loff_t *pos)
|
|
|
|
__acquires(&q->requeue_lock)
|
|
|
|
{
|
|
|
|
struct request_queue *q = m->private;
|
|
|
|
|
|
|
|
spin_lock_irq(&q->requeue_lock);
|
|
|
|
return seq_list_start(&q->requeue_list, *pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *queue_requeue_list_next(struct seq_file *m, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct request_queue *q = m->private;
|
|
|
|
|
|
|
|
return seq_list_next(v, &q->requeue_list, pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void queue_requeue_list_stop(struct seq_file *m, void *v)
|
|
|
|
__releases(&q->requeue_lock)
|
|
|
|
{
|
|
|
|
struct request_queue *q = m->private;
|
|
|
|
|
|
|
|
spin_unlock_irq(&q->requeue_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct seq_operations queue_requeue_list_seq_ops = {
|
|
|
|
.start = queue_requeue_list_start,
|
|
|
|
.next = queue_requeue_list_next,
|
|
|
|
.stop = queue_requeue_list_stop,
|
|
|
|
.show = blk_mq_debugfs_rq_show,
|
|
|
|
};
|
|
|
|
|
2017-04-10 22:13:15 +00:00
|
|
|
static int blk_flags_show(struct seq_file *m, const unsigned long flags,
|
|
|
|
const char *const *flag_name, int flag_name_count)
|
|
|
|
{
|
|
|
|
bool sep = false;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < sizeof(flags) * BITS_PER_BYTE; i++) {
|
|
|
|
if (!(flags & BIT(i)))
|
|
|
|
continue;
|
|
|
|
if (sep)
|
2017-05-04 07:31:23 +00:00
|
|
|
seq_puts(m, "|");
|
2017-04-10 22:13:15 +00:00
|
|
|
sep = true;
|
|
|
|
if (i < flag_name_count && flag_name[i])
|
|
|
|
seq_puts(m, flag_name[i]);
|
|
|
|
else
|
|
|
|
seq_printf(m, "%d", i);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:24 +00:00
|
|
|
#define QUEUE_FLAG_NAME(name) [QUEUE_FLAG_##name] = #name
|
2017-04-10 22:13:15 +00:00
|
|
|
static const char *const blk_queue_flag_name[] = {
|
2017-05-04 07:31:24 +00:00
|
|
|
QUEUE_FLAG_NAME(QUEUED),
|
|
|
|
QUEUE_FLAG_NAME(STOPPED),
|
|
|
|
QUEUE_FLAG_NAME(DYING),
|
|
|
|
QUEUE_FLAG_NAME(BYPASS),
|
|
|
|
QUEUE_FLAG_NAME(BIDI),
|
|
|
|
QUEUE_FLAG_NAME(NOMERGES),
|
|
|
|
QUEUE_FLAG_NAME(SAME_COMP),
|
|
|
|
QUEUE_FLAG_NAME(FAIL_IO),
|
|
|
|
QUEUE_FLAG_NAME(NONROT),
|
|
|
|
QUEUE_FLAG_NAME(IO_STAT),
|
|
|
|
QUEUE_FLAG_NAME(DISCARD),
|
|
|
|
QUEUE_FLAG_NAME(NOXMERGES),
|
|
|
|
QUEUE_FLAG_NAME(ADD_RANDOM),
|
|
|
|
QUEUE_FLAG_NAME(SECERASE),
|
|
|
|
QUEUE_FLAG_NAME(SAME_FORCE),
|
|
|
|
QUEUE_FLAG_NAME(DEAD),
|
|
|
|
QUEUE_FLAG_NAME(INIT_DONE),
|
|
|
|
QUEUE_FLAG_NAME(NO_SG_MERGE),
|
|
|
|
QUEUE_FLAG_NAME(POLL),
|
|
|
|
QUEUE_FLAG_NAME(WC),
|
|
|
|
QUEUE_FLAG_NAME(FUA),
|
|
|
|
QUEUE_FLAG_NAME(FLUSH_NQ),
|
|
|
|
QUEUE_FLAG_NAME(DAX),
|
|
|
|
QUEUE_FLAG_NAME(STATS),
|
|
|
|
QUEUE_FLAG_NAME(POLL_STATS),
|
|
|
|
QUEUE_FLAG_NAME(REGISTERED),
|
2017-08-18 22:52:54 +00:00
|
|
|
QUEUE_FLAG_NAME(SCSI_PASSTHROUGH),
|
|
|
|
QUEUE_FLAG_NAME(QUIESCED),
|
2017-11-09 18:49:57 +00:00
|
|
|
QUEUE_FLAG_NAME(PREEMPT_ONLY),
|
2017-04-10 22:13:15 +00:00
|
|
|
};
|
2017-05-04 07:31:24 +00:00
|
|
|
#undef QUEUE_FLAG_NAME
|
2017-04-10 22:13:15 +00:00
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static int queue_state_show(void *data, struct seq_file *m)
|
2017-04-10 22:13:15 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct request_queue *q = data;
|
2017-04-10 22:13:15 +00:00
|
|
|
|
|
|
|
blk_flags_show(m, q->queue_flags, blk_queue_flag_name,
|
|
|
|
ARRAY_SIZE(blk_queue_flag_name));
|
2017-04-26 20:47:54 +00:00
|
|
|
seq_puts(m, "\n");
|
2017-04-10 22:13:15 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static ssize_t queue_state_write(void *data, const char __user *buf,
|
|
|
|
size_t count, loff_t *ppos)
|
2017-04-10 22:13:15 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct request_queue *q = data;
|
2017-05-04 07:31:26 +00:00
|
|
|
char opbuf[16] = { }, *op;
|
2017-04-10 22:13:15 +00:00
|
|
|
|
2017-05-04 07:31:29 +00:00
|
|
|
/*
|
|
|
|
* The "state" attribute is removed after blk_cleanup_queue() has called
|
|
|
|
* blk_mq_free_queue(). Return if QUEUE_FLAG_DEAD has been set to avoid
|
|
|
|
* triggering a use-after-free.
|
|
|
|
*/
|
|
|
|
if (blk_queue_dead(q))
|
|
|
|
return -ENOENT;
|
|
|
|
|
2017-05-04 07:31:26 +00:00
|
|
|
if (count >= sizeof(opbuf)) {
|
2017-05-04 07:31:25 +00:00
|
|
|
pr_err("%s: operation too long\n", __func__);
|
|
|
|
goto inval;
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:26 +00:00
|
|
|
if (copy_from_user(opbuf, buf, count))
|
2017-04-10 22:13:15 +00:00
|
|
|
return -EFAULT;
|
2017-05-04 07:31:26 +00:00
|
|
|
op = strstrip(opbuf);
|
2017-04-10 22:13:15 +00:00
|
|
|
if (strcmp(op, "run") == 0) {
|
|
|
|
blk_mq_run_hw_queues(q, true);
|
|
|
|
} else if (strcmp(op, "start") == 0) {
|
|
|
|
blk_mq_start_stopped_hw_queues(q, true);
|
2017-06-01 15:55:13 +00:00
|
|
|
} else if (strcmp(op, "kick") == 0) {
|
|
|
|
blk_mq_kick_requeue_list(q);
|
2017-04-10 22:13:15 +00:00
|
|
|
} else {
|
2017-05-04 07:31:25 +00:00
|
|
|
pr_err("%s: unsupported operation '%s'\n", __func__, op);
|
|
|
|
inval:
|
2017-06-01 15:55:13 +00:00
|
|
|
pr_err("%s: use 'run', 'start' or 'kick'\n", __func__);
|
2017-04-10 22:13:15 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2017-05-04 07:31:25 +00:00
|
|
|
return count;
|
2017-04-10 22:13:15 +00:00
|
|
|
}
|
|
|
|
|
2017-06-26 14:15:27 +00:00
|
|
|
static int queue_write_hint_show(void *data, struct seq_file *m)
|
|
|
|
{
|
|
|
|
struct request_queue *q = data;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < BLK_MAX_WRITE_HINTS; i++)
|
|
|
|
seq_printf(m, "hint%d: %llu\n", i, q->write_hints[i]);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t queue_write_hint_store(void *data, const char __user *buf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
struct request_queue *q = data;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < BLK_MAX_WRITE_HINTS; i++)
|
|
|
|
q->write_hints[i] = 0;
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2018-02-28 00:32:14 +00:00
|
|
|
static int queue_zone_wlock_show(void *data, struct seq_file *m)
|
|
|
|
{
|
|
|
|
struct request_queue *q = data;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
if (!q->seq_zones_wlock)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
for (i = 0; i < blk_queue_nr_zones(q); i++)
|
|
|
|
if (test_bit(i, q->seq_zones_wlock))
|
|
|
|
seq_printf(m, "%u\n", i);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-02-28 00:32:13 +00:00
|
|
|
static const struct blk_mq_debugfs_attr blk_mq_debugfs_queue_attrs[] = {
|
|
|
|
{ "poll_stat", 0400, queue_poll_stat_show },
|
|
|
|
{ "requeue_list", 0400, .seq_ops = &queue_requeue_list_seq_ops },
|
|
|
|
{ "state", 0600, queue_state_show, queue_state_write },
|
|
|
|
{ "write_hints", 0600, queue_write_hint_show, queue_write_hint_store },
|
2018-02-28 00:32:14 +00:00
|
|
|
{ "zone_wlock", 0400, queue_zone_wlock_show, NULL },
|
2018-02-28 00:32:13 +00:00
|
|
|
{ },
|
|
|
|
};
|
blk-stat: convert to callback-based statistics reporting
Currently, statistics are gathered in ~0.13s windows, and users grab the
statistics whenever they need them. This is not ideal for both in-tree
users:
1. Writeback throttling wants its own dynamically sized window of
statistics. Since the blk-stats statistics are reset after every
window and the wbt windows don't line up with the blk-stats windows,
wbt doesn't see every I/O.
2. Polling currently grabs the statistics on every I/O. Again, depending
on how the window lines up, we may miss some I/Os. It's also
unnecessary overhead to get the statistics on every I/O; the hybrid
polling heuristic would be just as happy with the statistics from the
previous full window.
This reworks the blk-stats infrastructure to be callback-based: users
register a callback that they want called at a given time with all of
the statistics from the window during which the callback was active.
Users can dynamically bucketize the statistics. wbt and polling both
currently use read vs. write, but polling can be extended to further
subdivide based on request size.
The callbacks are kept on an RCU list, and each callback has percpu
stats buffers. There will only be a few users, so the overhead on the
I/O completion side is low. The stats flushing is also simplified
considerably: since the timer function is responsible for clearing the
statistics, we don't have to worry about stale statistics.
wbt is a trivial conversion. After the conversion, the windowing problem
mentioned above is fixed.
For polling, we register an extra callback that caches the previous
window's statistics in the struct request_queue for the hybrid polling
heuristic to use.
Since we no longer have a single stats buffer for the request queue,
this also removes the sysfs and debugfs stats entries. To replace those,
we add a debugfs entry for the poll statistics.
Signed-off-by: Omar Sandoval <osandov@fb.com>
Signed-off-by: Jens Axboe <axboe@fb.com>
2017-03-21 15:56:08 +00:00
|
|
|
|
2017-05-04 07:31:24 +00:00
|
|
|
#define HCTX_STATE_NAME(name) [BLK_MQ_S_##name] = #name
|
2017-03-30 18:21:27 +00:00
|
|
|
static const char *const hctx_state_name[] = {
|
2017-05-04 07:31:24 +00:00
|
|
|
HCTX_STATE_NAME(STOPPED),
|
|
|
|
HCTX_STATE_NAME(TAG_ACTIVE),
|
|
|
|
HCTX_STATE_NAME(SCHED_RESTART),
|
|
|
|
HCTX_STATE_NAME(START_ON_RUN),
|
2017-03-30 18:21:27 +00:00
|
|
|
};
|
2017-05-04 07:31:24 +00:00
|
|
|
#undef HCTX_STATE_NAME
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static int hctx_state_show(void *data, struct seq_file *m)
|
2017-01-25 16:06:41 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_hw_ctx *hctx = data;
|
2017-01-25 16:06:41 +00:00
|
|
|
|
2017-03-30 18:21:27 +00:00
|
|
|
blk_flags_show(m, hctx->state, hctx_state_name,
|
|
|
|
ARRAY_SIZE(hctx_state_name));
|
2017-04-26 20:47:54 +00:00
|
|
|
seq_puts(m, "\n");
|
2017-01-25 16:06:41 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:24 +00:00
|
|
|
#define BLK_TAG_ALLOC_NAME(name) [BLK_TAG_ALLOC_##name] = #name
|
2017-03-30 18:21:27 +00:00
|
|
|
static const char *const alloc_policy_name[] = {
|
2017-05-04 07:31:24 +00:00
|
|
|
BLK_TAG_ALLOC_NAME(FIFO),
|
|
|
|
BLK_TAG_ALLOC_NAME(RR),
|
2017-03-30 18:21:27 +00:00
|
|
|
};
|
2017-05-04 07:31:24 +00:00
|
|
|
#undef BLK_TAG_ALLOC_NAME
|
2017-03-30 18:21:27 +00:00
|
|
|
|
2017-05-04 07:31:24 +00:00
|
|
|
#define HCTX_FLAG_NAME(name) [ilog2(BLK_MQ_F_##name)] = #name
|
2017-03-30 18:21:27 +00:00
|
|
|
static const char *const hctx_flag_name[] = {
|
2017-05-04 07:31:24 +00:00
|
|
|
HCTX_FLAG_NAME(SHOULD_MERGE),
|
|
|
|
HCTX_FLAG_NAME(TAG_SHARED),
|
|
|
|
HCTX_FLAG_NAME(SG_MERGE),
|
|
|
|
HCTX_FLAG_NAME(BLOCKING),
|
|
|
|
HCTX_FLAG_NAME(NO_SCHED),
|
2017-03-30 18:21:27 +00:00
|
|
|
};
|
2017-05-04 07:31:24 +00:00
|
|
|
#undef HCTX_FLAG_NAME
|
2017-03-30 18:21:27 +00:00
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static int hctx_flags_show(void *data, struct seq_file *m)
|
2017-01-25 16:06:41 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_hw_ctx *hctx = data;
|
2017-03-30 18:21:27 +00:00
|
|
|
const int alloc_policy = BLK_MQ_FLAG_TO_ALLOC_POLICY(hctx->flags);
|
2017-01-25 16:06:41 +00:00
|
|
|
|
2017-03-30 18:21:27 +00:00
|
|
|
seq_puts(m, "alloc_policy=");
|
|
|
|
if (alloc_policy < ARRAY_SIZE(alloc_policy_name) &&
|
|
|
|
alloc_policy_name[alloc_policy])
|
|
|
|
seq_puts(m, alloc_policy_name[alloc_policy]);
|
|
|
|
else
|
|
|
|
seq_printf(m, "%d", alloc_policy);
|
|
|
|
seq_puts(m, " ");
|
|
|
|
blk_flags_show(m,
|
|
|
|
hctx->flags ^ BLK_ALLOC_POLICY_TO_MQ_FLAG(alloc_policy),
|
|
|
|
hctx_flag_name, ARRAY_SIZE(hctx_flag_name));
|
2017-04-26 20:47:54 +00:00
|
|
|
seq_puts(m, "\n");
|
2017-01-25 16:06:41 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:24 +00:00
|
|
|
#define REQ_OP_NAME(name) [REQ_OP_##name] = #name
|
2017-04-26 20:47:55 +00:00
|
|
|
static const char *const op_name[] = {
|
2017-05-04 07:31:24 +00:00
|
|
|
REQ_OP_NAME(READ),
|
|
|
|
REQ_OP_NAME(WRITE),
|
|
|
|
REQ_OP_NAME(FLUSH),
|
|
|
|
REQ_OP_NAME(DISCARD),
|
|
|
|
REQ_OP_NAME(ZONE_REPORT),
|
|
|
|
REQ_OP_NAME(SECURE_ERASE),
|
|
|
|
REQ_OP_NAME(ZONE_RESET),
|
|
|
|
REQ_OP_NAME(WRITE_SAME),
|
|
|
|
REQ_OP_NAME(WRITE_ZEROES),
|
|
|
|
REQ_OP_NAME(SCSI_IN),
|
|
|
|
REQ_OP_NAME(SCSI_OUT),
|
|
|
|
REQ_OP_NAME(DRV_IN),
|
|
|
|
REQ_OP_NAME(DRV_OUT),
|
2017-04-26 20:47:55 +00:00
|
|
|
};
|
2017-05-04 07:31:24 +00:00
|
|
|
#undef REQ_OP_NAME
|
2017-04-26 20:47:55 +00:00
|
|
|
|
2017-05-04 07:31:24 +00:00
|
|
|
#define CMD_FLAG_NAME(name) [__REQ_##name] = #name
|
2017-04-26 20:47:55 +00:00
|
|
|
static const char *const cmd_flag_name[] = {
|
2017-05-04 07:31:24 +00:00
|
|
|
CMD_FLAG_NAME(FAILFAST_DEV),
|
|
|
|
CMD_FLAG_NAME(FAILFAST_TRANSPORT),
|
|
|
|
CMD_FLAG_NAME(FAILFAST_DRIVER),
|
|
|
|
CMD_FLAG_NAME(SYNC),
|
|
|
|
CMD_FLAG_NAME(META),
|
|
|
|
CMD_FLAG_NAME(PRIO),
|
|
|
|
CMD_FLAG_NAME(NOMERGE),
|
|
|
|
CMD_FLAG_NAME(IDLE),
|
|
|
|
CMD_FLAG_NAME(INTEGRITY),
|
|
|
|
CMD_FLAG_NAME(FUA),
|
|
|
|
CMD_FLAG_NAME(PREFLUSH),
|
|
|
|
CMD_FLAG_NAME(RAHEAD),
|
|
|
|
CMD_FLAG_NAME(BACKGROUND),
|
|
|
|
CMD_FLAG_NAME(NOUNMAP),
|
2017-08-18 22:52:54 +00:00
|
|
|
CMD_FLAG_NAME(NOWAIT),
|
2017-04-26 20:47:55 +00:00
|
|
|
};
|
2017-05-04 07:31:24 +00:00
|
|
|
#undef CMD_FLAG_NAME
|
2017-04-26 20:47:55 +00:00
|
|
|
|
2017-05-04 07:31:24 +00:00
|
|
|
#define RQF_NAME(name) [ilog2((__force u32)RQF_##name)] = #name
|
2017-04-26 20:47:55 +00:00
|
|
|
static const char *const rqf_name[] = {
|
2017-05-04 07:31:24 +00:00
|
|
|
RQF_NAME(SORTED),
|
2018-01-12 21:47:57 +00:00
|
|
|
RQF_NAME(STARTED),
|
2017-05-04 07:31:24 +00:00
|
|
|
RQF_NAME(QUEUED),
|
|
|
|
RQF_NAME(SOFTBARRIER),
|
|
|
|
RQF_NAME(FLUSH_SEQ),
|
|
|
|
RQF_NAME(MIXED_MERGE),
|
|
|
|
RQF_NAME(MQ_INFLIGHT),
|
|
|
|
RQF_NAME(DONTPREP),
|
|
|
|
RQF_NAME(PREEMPT),
|
|
|
|
RQF_NAME(COPY_USER),
|
|
|
|
RQF_NAME(FAILED),
|
|
|
|
RQF_NAME(QUIET),
|
|
|
|
RQF_NAME(ELVPRIV),
|
|
|
|
RQF_NAME(IO_STAT),
|
|
|
|
RQF_NAME(ALLOCED),
|
|
|
|
RQF_NAME(PM),
|
|
|
|
RQF_NAME(HASHED),
|
|
|
|
RQF_NAME(STATS),
|
|
|
|
RQF_NAME(SPECIAL_PAYLOAD),
|
2018-01-10 18:30:08 +00:00
|
|
|
RQF_NAME(ZONE_WRITE_LOCKED),
|
|
|
|
RQF_NAME(MQ_TIMEOUT_EXPIRED),
|
2018-01-10 18:30:56 +00:00
|
|
|
RQF_NAME(MQ_POLL_SLEPT),
|
2017-04-26 20:47:55 +00:00
|
|
|
};
|
2017-05-04 07:31:24 +00:00
|
|
|
#undef RQF_NAME
|
2017-04-26 20:47:55 +00:00
|
|
|
|
2018-03-16 17:31:11 +00:00
|
|
|
static const char *const blk_mq_rq_state_name_array[] = {
|
|
|
|
[MQ_RQ_IDLE] = "idle",
|
|
|
|
[MQ_RQ_IN_FLIGHT] = "in_flight",
|
|
|
|
[MQ_RQ_COMPLETE] = "complete",
|
|
|
|
};
|
|
|
|
|
|
|
|
static const char *blk_mq_rq_state_name(enum mq_rq_state rq_state)
|
|
|
|
{
|
|
|
|
if (WARN_ON_ONCE((unsigned int)rq_state >
|
|
|
|
ARRAY_SIZE(blk_mq_rq_state_name_array)))
|
|
|
|
return "(?)";
|
|
|
|
return blk_mq_rq_state_name_array[rq_state];
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:34 +00:00
|
|
|
int __blk_mq_debugfs_rq_show(struct seq_file *m, struct request *rq)
|
2017-01-25 16:06:42 +00:00
|
|
|
{
|
2017-04-26 20:47:56 +00:00
|
|
|
const struct blk_mq_ops *const mq_ops = rq->q->mq_ops;
|
2017-04-26 20:47:55 +00:00
|
|
|
const unsigned int op = rq->cmd_flags & REQ_OP_MASK;
|
2017-01-25 16:06:42 +00:00
|
|
|
|
2017-04-26 20:47:55 +00:00
|
|
|
seq_printf(m, "%p {.op=", rq);
|
|
|
|
if (op < ARRAY_SIZE(op_name) && op_name[op])
|
|
|
|
seq_printf(m, "%s", op_name[op]);
|
|
|
|
else
|
|
|
|
seq_printf(m, "%d", op);
|
|
|
|
seq_puts(m, ", .cmd_flags=");
|
|
|
|
blk_flags_show(m, rq->cmd_flags & ~REQ_OP_MASK, cmd_flag_name,
|
|
|
|
ARRAY_SIZE(cmd_flag_name));
|
|
|
|
seq_puts(m, ", .rq_flags=");
|
|
|
|
blk_flags_show(m, (__force unsigned int)rq->rq_flags, rqf_name,
|
|
|
|
ARRAY_SIZE(rqf_name));
|
2018-03-16 17:31:11 +00:00
|
|
|
seq_printf(m, ", .state=%s", blk_mq_rq_state_name(blk_mq_rq_state(rq)));
|
2017-04-26 20:47:56 +00:00
|
|
|
seq_printf(m, ", .tag=%d, .internal_tag=%d", rq->tag,
|
2017-04-26 20:47:55 +00:00
|
|
|
rq->internal_tag);
|
2017-04-26 20:47:56 +00:00
|
|
|
if (mq_ops->show_rq)
|
|
|
|
mq_ops->show_rq(m, rq);
|
|
|
|
seq_puts(m, "}\n");
|
2017-01-25 16:06:42 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2017-05-04 07:31:34 +00:00
|
|
|
EXPORT_SYMBOL_GPL(__blk_mq_debugfs_rq_show);
|
|
|
|
|
|
|
|
int blk_mq_debugfs_rq_show(struct seq_file *m, void *v)
|
|
|
|
{
|
|
|
|
return __blk_mq_debugfs_rq_show(m, list_entry_rq(v));
|
|
|
|
}
|
2017-05-04 07:31:33 +00:00
|
|
|
EXPORT_SYMBOL_GPL(blk_mq_debugfs_rq_show);
|
2017-01-25 16:06:42 +00:00
|
|
|
|
|
|
|
static void *hctx_dispatch_start(struct seq_file *m, loff_t *pos)
|
2017-02-01 18:20:56 +00:00
|
|
|
__acquires(&hctx->lock)
|
2017-01-25 16:06:42 +00:00
|
|
|
{
|
|
|
|
struct blk_mq_hw_ctx *hctx = m->private;
|
|
|
|
|
|
|
|
spin_lock(&hctx->lock);
|
|
|
|
return seq_list_start(&hctx->dispatch, *pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *hctx_dispatch_next(struct seq_file *m, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct blk_mq_hw_ctx *hctx = m->private;
|
|
|
|
|
|
|
|
return seq_list_next(v, &hctx->dispatch, pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hctx_dispatch_stop(struct seq_file *m, void *v)
|
2017-02-01 18:20:56 +00:00
|
|
|
__releases(&hctx->lock)
|
2017-01-25 16:06:42 +00:00
|
|
|
{
|
|
|
|
struct blk_mq_hw_ctx *hctx = m->private;
|
|
|
|
|
|
|
|
spin_unlock(&hctx->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct seq_operations hctx_dispatch_seq_ops = {
|
|
|
|
.start = hctx_dispatch_start,
|
|
|
|
.next = hctx_dispatch_next,
|
|
|
|
.stop = hctx_dispatch_stop,
|
|
|
|
.show = blk_mq_debugfs_rq_show,
|
|
|
|
};
|
|
|
|
|
2017-06-01 15:55:12 +00:00
|
|
|
struct show_busy_params {
|
|
|
|
struct seq_file *m;
|
|
|
|
struct blk_mq_hw_ctx *hctx;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note: the state of a request may change while this function is in progress,
|
|
|
|
* e.g. due to a concurrent blk_mq_finish_request() call.
|
|
|
|
*/
|
|
|
|
static void hctx_show_busy_rq(struct request *rq, void *data, bool reserved)
|
|
|
|
{
|
|
|
|
const struct show_busy_params *params = data;
|
|
|
|
|
|
|
|
if (blk_mq_map_queue(rq->q, rq->mq_ctx->cpu) == params->hctx &&
|
2018-01-09 16:29:52 +00:00
|
|
|
blk_mq_rq_state(rq) != MQ_RQ_IDLE)
|
2017-06-01 15:55:12 +00:00
|
|
|
__blk_mq_debugfs_rq_show(params->m,
|
|
|
|
list_entry_rq(&rq->queuelist));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hctx_busy_show(void *data, struct seq_file *m)
|
|
|
|
{
|
|
|
|
struct blk_mq_hw_ctx *hctx = data;
|
|
|
|
struct show_busy_params params = { .m = m, .hctx = hctx };
|
|
|
|
|
|
|
|
blk_mq_tagset_busy_iter(hctx->queue->tag_set, hctx_show_busy_rq,
|
|
|
|
¶ms);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static int hctx_ctx_map_show(void *data, struct seq_file *m)
|
2017-01-25 16:06:45 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_hw_ctx *hctx = data;
|
2017-01-25 16:06:45 +00:00
|
|
|
|
|
|
|
sbitmap_bitmap_show(&hctx->ctx_map, m);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-01-25 16:06:46 +00:00
|
|
|
static void blk_mq_debugfs_tags_show(struct seq_file *m,
|
|
|
|
struct blk_mq_tags *tags)
|
|
|
|
{
|
|
|
|
seq_printf(m, "nr_tags=%u\n", tags->nr_tags);
|
|
|
|
seq_printf(m, "nr_reserved_tags=%u\n", tags->nr_reserved_tags);
|
|
|
|
seq_printf(m, "active_queues=%d\n",
|
|
|
|
atomic_read(&tags->active_queues));
|
|
|
|
|
|
|
|
seq_puts(m, "\nbitmap_tags:\n");
|
|
|
|
sbitmap_queue_show(&tags->bitmap_tags, m);
|
|
|
|
|
|
|
|
if (tags->nr_reserved_tags) {
|
|
|
|
seq_puts(m, "\nbreserved_tags:\n");
|
|
|
|
sbitmap_queue_show(&tags->breserved_tags, m);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static int hctx_tags_show(void *data, struct seq_file *m)
|
2017-01-25 16:06:46 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_hw_ctx *hctx = data;
|
2017-01-25 16:06:46 +00:00
|
|
|
struct request_queue *q = hctx->queue;
|
2017-02-01 18:20:58 +00:00
|
|
|
int res;
|
2017-01-25 16:06:46 +00:00
|
|
|
|
2017-02-01 18:20:58 +00:00
|
|
|
res = mutex_lock_interruptible(&q->sysfs_lock);
|
|
|
|
if (res)
|
|
|
|
goto out;
|
2017-01-25 16:06:46 +00:00
|
|
|
if (hctx->tags)
|
|
|
|
blk_mq_debugfs_tags_show(m, hctx->tags);
|
|
|
|
mutex_unlock(&q->sysfs_lock);
|
|
|
|
|
2017-02-01 18:20:58 +00:00
|
|
|
out:
|
|
|
|
return res;
|
2017-01-25 16:06:46 +00:00
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static int hctx_tags_bitmap_show(void *data, struct seq_file *m)
|
2017-01-25 16:06:47 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_hw_ctx *hctx = data;
|
2017-01-25 16:06:47 +00:00
|
|
|
struct request_queue *q = hctx->queue;
|
2017-02-01 18:20:58 +00:00
|
|
|
int res;
|
2017-01-25 16:06:47 +00:00
|
|
|
|
2017-02-01 18:20:58 +00:00
|
|
|
res = mutex_lock_interruptible(&q->sysfs_lock);
|
|
|
|
if (res)
|
|
|
|
goto out;
|
2017-01-25 16:06:47 +00:00
|
|
|
if (hctx->tags)
|
|
|
|
sbitmap_bitmap_show(&hctx->tags->bitmap_tags.sb, m);
|
|
|
|
mutex_unlock(&q->sysfs_lock);
|
2017-02-01 18:20:58 +00:00
|
|
|
|
|
|
|
out:
|
|
|
|
return res;
|
2017-01-25 16:06:47 +00:00
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static int hctx_sched_tags_show(void *data, struct seq_file *m)
|
2017-01-25 16:06:46 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_hw_ctx *hctx = data;
|
2017-01-25 16:06:46 +00:00
|
|
|
struct request_queue *q = hctx->queue;
|
2017-02-01 18:20:58 +00:00
|
|
|
int res;
|
2017-01-25 16:06:46 +00:00
|
|
|
|
2017-02-01 18:20:58 +00:00
|
|
|
res = mutex_lock_interruptible(&q->sysfs_lock);
|
|
|
|
if (res)
|
|
|
|
goto out;
|
2017-01-25 16:06:46 +00:00
|
|
|
if (hctx->sched_tags)
|
|
|
|
blk_mq_debugfs_tags_show(m, hctx->sched_tags);
|
|
|
|
mutex_unlock(&q->sysfs_lock);
|
|
|
|
|
2017-02-01 18:20:58 +00:00
|
|
|
out:
|
|
|
|
return res;
|
2017-01-25 16:06:46 +00:00
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static int hctx_sched_tags_bitmap_show(void *data, struct seq_file *m)
|
2017-01-25 16:06:47 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_hw_ctx *hctx = data;
|
2017-01-25 16:06:47 +00:00
|
|
|
struct request_queue *q = hctx->queue;
|
2017-02-01 18:20:58 +00:00
|
|
|
int res;
|
2017-01-25 16:06:47 +00:00
|
|
|
|
2017-02-01 18:20:58 +00:00
|
|
|
res = mutex_lock_interruptible(&q->sysfs_lock);
|
|
|
|
if (res)
|
|
|
|
goto out;
|
2017-01-25 16:06:47 +00:00
|
|
|
if (hctx->sched_tags)
|
|
|
|
sbitmap_bitmap_show(&hctx->sched_tags->bitmap_tags.sb, m);
|
|
|
|
mutex_unlock(&q->sysfs_lock);
|
2017-02-01 18:20:58 +00:00
|
|
|
|
|
|
|
out:
|
|
|
|
return res;
|
2017-01-25 16:06:47 +00:00
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static int hctx_io_poll_show(void *data, struct seq_file *m)
|
2017-01-25 16:06:48 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_hw_ctx *hctx = data;
|
2017-01-25 16:06:48 +00:00
|
|
|
|
|
|
|
seq_printf(m, "considered=%lu\n", hctx->poll_considered);
|
|
|
|
seq_printf(m, "invoked=%lu\n", hctx->poll_invoked);
|
|
|
|
seq_printf(m, "success=%lu\n", hctx->poll_success);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static ssize_t hctx_io_poll_write(void *data, const char __user *buf,
|
2017-01-25 16:06:48 +00:00
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_hw_ctx *hctx = data;
|
2017-01-25 16:06:48 +00:00
|
|
|
|
|
|
|
hctx->poll_considered = hctx->poll_invoked = hctx->poll_success = 0;
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static int hctx_dispatched_show(void *data, struct seq_file *m)
|
2017-01-25 16:06:48 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_hw_ctx *hctx = data;
|
2017-01-25 16:06:48 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
seq_printf(m, "%8u\t%lu\n", 0U, hctx->dispatched[0]);
|
|
|
|
|
|
|
|
for (i = 1; i < BLK_MQ_MAX_DISPATCH_ORDER - 1; i++) {
|
|
|
|
unsigned int d = 1U << (i - 1);
|
|
|
|
|
|
|
|
seq_printf(m, "%8u\t%lu\n", d, hctx->dispatched[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
seq_printf(m, "%8u+\t%lu\n", 1U << (i - 1), hctx->dispatched[i]);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static ssize_t hctx_dispatched_write(void *data, const char __user *buf,
|
2017-01-25 16:06:48 +00:00
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_hw_ctx *hctx = data;
|
2017-01-25 16:06:48 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < BLK_MQ_MAX_DISPATCH_ORDER; i++)
|
|
|
|
hctx->dispatched[i] = 0;
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static int hctx_queued_show(void *data, struct seq_file *m)
|
2017-01-25 16:06:49 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_hw_ctx *hctx = data;
|
2017-01-25 16:06:49 +00:00
|
|
|
|
|
|
|
seq_printf(m, "%lu\n", hctx->queued);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static ssize_t hctx_queued_write(void *data, const char __user *buf,
|
2017-01-25 16:06:49 +00:00
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_hw_ctx *hctx = data;
|
2017-01-25 16:06:49 +00:00
|
|
|
|
|
|
|
hctx->queued = 0;
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static int hctx_run_show(void *data, struct seq_file *m)
|
2017-01-25 16:06:49 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_hw_ctx *hctx = data;
|
2017-01-25 16:06:49 +00:00
|
|
|
|
|
|
|
seq_printf(m, "%lu\n", hctx->run);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static ssize_t hctx_run_write(void *data, const char __user *buf, size_t count,
|
|
|
|
loff_t *ppos)
|
2017-01-25 16:06:49 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_hw_ctx *hctx = data;
|
2017-01-25 16:06:49 +00:00
|
|
|
|
|
|
|
hctx->run = 0;
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static int hctx_active_show(void *data, struct seq_file *m)
|
2017-01-25 16:06:49 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_hw_ctx *hctx = data;
|
2017-01-25 16:06:49 +00:00
|
|
|
|
|
|
|
seq_printf(m, "%d\n", atomic_read(&hctx->nr_active));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-01-25 16:06:42 +00:00
|
|
|
static void *ctx_rq_list_start(struct seq_file *m, loff_t *pos)
|
2017-02-01 18:20:56 +00:00
|
|
|
__acquires(&ctx->lock)
|
2017-01-25 16:06:42 +00:00
|
|
|
{
|
|
|
|
struct blk_mq_ctx *ctx = m->private;
|
|
|
|
|
|
|
|
spin_lock(&ctx->lock);
|
|
|
|
return seq_list_start(&ctx->rq_list, *pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *ctx_rq_list_next(struct seq_file *m, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct blk_mq_ctx *ctx = m->private;
|
|
|
|
|
|
|
|
return seq_list_next(v, &ctx->rq_list, pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ctx_rq_list_stop(struct seq_file *m, void *v)
|
2017-02-01 18:20:56 +00:00
|
|
|
__releases(&ctx->lock)
|
2017-01-25 16:06:42 +00:00
|
|
|
{
|
|
|
|
struct blk_mq_ctx *ctx = m->private;
|
|
|
|
|
|
|
|
spin_unlock(&ctx->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct seq_operations ctx_rq_list_seq_ops = {
|
|
|
|
.start = ctx_rq_list_start,
|
|
|
|
.next = ctx_rq_list_next,
|
|
|
|
.stop = ctx_rq_list_stop,
|
|
|
|
.show = blk_mq_debugfs_rq_show,
|
|
|
|
};
|
2017-05-04 07:31:28 +00:00
|
|
|
static int ctx_dispatched_show(void *data, struct seq_file *m)
|
2017-01-25 16:06:49 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_ctx *ctx = data;
|
2017-01-25 16:06:49 +00:00
|
|
|
|
|
|
|
seq_printf(m, "%lu %lu\n", ctx->rq_dispatched[1], ctx->rq_dispatched[0]);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static ssize_t ctx_dispatched_write(void *data, const char __user *buf,
|
2017-01-25 16:06:49 +00:00
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_ctx *ctx = data;
|
2017-01-25 16:06:49 +00:00
|
|
|
|
|
|
|
ctx->rq_dispatched[0] = ctx->rq_dispatched[1] = 0;
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static int ctx_merged_show(void *data, struct seq_file *m)
|
2017-01-25 16:06:49 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_ctx *ctx = data;
|
2017-01-25 16:06:49 +00:00
|
|
|
|
|
|
|
seq_printf(m, "%lu\n", ctx->rq_merged);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static ssize_t ctx_merged_write(void *data, const char __user *buf,
|
|
|
|
size_t count, loff_t *ppos)
|
2017-01-25 16:06:49 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_ctx *ctx = data;
|
2017-01-25 16:06:49 +00:00
|
|
|
|
|
|
|
ctx->rq_merged = 0;
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static int ctx_completed_show(void *data, struct seq_file *m)
|
2017-01-25 16:06:49 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_ctx *ctx = data;
|
2017-01-25 16:06:49 +00:00
|
|
|
|
|
|
|
seq_printf(m, "%lu %lu\n", ctx->rq_completed[1], ctx->rq_completed[0]);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static ssize_t ctx_completed_write(void *data, const char __user *buf,
|
|
|
|
size_t count, loff_t *ppos)
|
2017-01-25 16:06:49 +00:00
|
|
|
{
|
2017-05-04 07:31:28 +00:00
|
|
|
struct blk_mq_ctx *ctx = data;
|
|
|
|
|
|
|
|
ctx->rq_completed[0] = ctx->rq_completed[1] = 0;
|
|
|
|
return count;
|
2017-01-25 16:06:49 +00:00
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static int blk_mq_debugfs_show(struct seq_file *m, void *v)
|
|
|
|
{
|
|
|
|
const struct blk_mq_debugfs_attr *attr = m->private;
|
|
|
|
void *data = d_inode(m->file->f_path.dentry->d_parent)->i_private;
|
|
|
|
|
|
|
|
return attr->show(data, m);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t blk_mq_debugfs_write(struct file *file, const char __user *buf,
|
|
|
|
size_t count, loff_t *ppos)
|
2017-01-25 16:06:49 +00:00
|
|
|
{
|
|
|
|
struct seq_file *m = file->private_data;
|
2017-05-04 07:31:28 +00:00
|
|
|
const struct blk_mq_debugfs_attr *attr = m->private;
|
|
|
|
void *data = d_inode(file->f_path.dentry->d_parent)->i_private;
|
2017-01-25 16:06:49 +00:00
|
|
|
|
2018-01-23 17:20:00 +00:00
|
|
|
/*
|
|
|
|
* Attributes that only implement .seq_ops are read-only and 'attr' is
|
|
|
|
* the same with 'data' in this case.
|
|
|
|
*/
|
|
|
|
if (attr == data || !attr->write)
|
2017-05-04 07:31:28 +00:00
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
return attr->write(data, buf, count, ppos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int blk_mq_debugfs_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
const struct blk_mq_debugfs_attr *attr = inode->i_private;
|
|
|
|
void *data = d_inode(file->f_path.dentry->d_parent)->i_private;
|
|
|
|
struct seq_file *m;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (attr->seq_ops) {
|
|
|
|
ret = seq_open(file, attr->seq_ops);
|
|
|
|
if (!ret) {
|
|
|
|
m = file->private_data;
|
|
|
|
m->private = data;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (WARN_ON_ONCE(!attr->show))
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
return single_open(file, blk_mq_debugfs_show, inode->i_private);
|
2017-01-25 16:06:49 +00:00
|
|
|
}
|
|
|
|
|
2017-05-04 07:31:28 +00:00
|
|
|
static int blk_mq_debugfs_release(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
const struct blk_mq_debugfs_attr *attr = inode->i_private;
|
|
|
|
|
|
|
|
if (attr->show)
|
|
|
|
return single_release(inode, file);
|
|
|
|
else
|
|
|
|
return seq_release(inode, file);
|
|
|
|
}
|
|
|
|
|
2017-08-17 23:23:04 +00:00
|
|
|
static const struct file_operations blk_mq_debugfs_fops = {
|
2017-05-04 07:31:28 +00:00
|
|
|
.open = blk_mq_debugfs_open,
|
2017-01-25 16:06:49 +00:00
|
|
|
.read = seq_read,
|
2017-05-04 07:31:28 +00:00
|
|
|
.write = blk_mq_debugfs_write,
|
2017-01-25 16:06:49 +00:00
|
|
|
.llseek = seq_lseek,
|
2017-05-04 07:31:28 +00:00
|
|
|
.release = blk_mq_debugfs_release,
|
2017-01-25 16:06:49 +00:00
|
|
|
};
|
|
|
|
|
2017-01-25 16:06:40 +00:00
|
|
|
static const struct blk_mq_debugfs_attr blk_mq_debugfs_hctx_attrs[] = {
|
2017-05-04 07:31:28 +00:00
|
|
|
{"state", 0400, hctx_state_show},
|
|
|
|
{"flags", 0400, hctx_flags_show},
|
|
|
|
{"dispatch", 0400, .seq_ops = &hctx_dispatch_seq_ops},
|
2017-06-01 15:55:12 +00:00
|
|
|
{"busy", 0400, hctx_busy_show},
|
2017-05-04 07:31:28 +00:00
|
|
|
{"ctx_map", 0400, hctx_ctx_map_show},
|
|
|
|
{"tags", 0400, hctx_tags_show},
|
|
|
|
{"tags_bitmap", 0400, hctx_tags_bitmap_show},
|
|
|
|
{"sched_tags", 0400, hctx_sched_tags_show},
|
|
|
|
{"sched_tags_bitmap", 0400, hctx_sched_tags_bitmap_show},
|
|
|
|
{"io_poll", 0600, hctx_io_poll_show, hctx_io_poll_write},
|
|
|
|
{"dispatched", 0600, hctx_dispatched_show, hctx_dispatched_write},
|
|
|
|
{"queued", 0600, hctx_queued_show, hctx_queued_write},
|
|
|
|
{"run", 0600, hctx_run_show, hctx_run_write},
|
|
|
|
{"active", 0400, hctx_active_show},
|
2017-02-01 18:20:59 +00:00
|
|
|
{},
|
2017-01-25 16:06:40 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct blk_mq_debugfs_attr blk_mq_debugfs_ctx_attrs[] = {
|
2017-05-04 07:31:28 +00:00
|
|
|
{"rq_list", 0400, .seq_ops = &ctx_rq_list_seq_ops},
|
|
|
|
{"dispatched", 0600, ctx_dispatched_show, ctx_dispatched_write},
|
|
|
|
{"merged", 0600, ctx_merged_show, ctx_merged_write},
|
|
|
|
{"completed", 0600, ctx_completed_show, ctx_completed_write},
|
2017-02-01 18:20:59 +00:00
|
|
|
{},
|
2017-01-25 16:06:40 +00:00
|
|
|
};
|
|
|
|
|
2017-05-04 14:17:21 +00:00
|
|
|
static bool debugfs_create_files(struct dentry *parent, void *data,
|
|
|
|
const struct blk_mq_debugfs_attr *attr)
|
|
|
|
{
|
|
|
|
d_inode(parent)->i_private = data;
|
|
|
|
|
|
|
|
for (; attr->name; attr++) {
|
|
|
|
if (!debugfs_create_file(attr->name, attr->mode, parent,
|
|
|
|
(void *)attr, &blk_mq_debugfs_fops))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-04-26 20:47:49 +00:00
|
|
|
int blk_mq_debugfs_register(struct request_queue *q)
|
2017-01-25 16:06:40 +00:00
|
|
|
{
|
2017-05-04 14:17:21 +00:00
|
|
|
struct blk_mq_hw_ctx *hctx;
|
|
|
|
int i;
|
|
|
|
|
2017-01-31 22:53:20 +00:00
|
|
|
if (!blk_debugfs_root)
|
2017-01-25 16:06:40 +00:00
|
|
|
return -ENOENT;
|
|
|
|
|
2017-04-26 20:47:49 +00:00
|
|
|
q->debugfs_dir = debugfs_create_dir(kobject_name(q->kobj.parent),
|
|
|
|
blk_debugfs_root);
|
2017-01-25 16:06:40 +00:00
|
|
|
if (!q->debugfs_dir)
|
2017-05-04 14:17:21 +00:00
|
|
|
return -ENOMEM;
|
2017-01-25 16:06:40 +00:00
|
|
|
|
2017-05-04 14:17:21 +00:00
|
|
|
if (!debugfs_create_files(q->debugfs_dir, q,
|
|
|
|
blk_mq_debugfs_queue_attrs))
|
2017-01-25 16:06:40 +00:00
|
|
|
goto err;
|
|
|
|
|
2017-05-04 14:17:21 +00:00
|
|
|
/*
|
2017-10-03 21:57:16 +00:00
|
|
|
* blk_mq_init_sched() attempted to do this already, but q->debugfs_dir
|
2017-05-04 14:17:21 +00:00
|
|
|
* didn't exist yet (because we don't know what to name the directory
|
|
|
|
* until the queue is registered to a gendisk).
|
|
|
|
*/
|
2017-10-03 21:57:16 +00:00
|
|
|
if (q->elevator && !q->sched_debugfs_dir)
|
|
|
|
blk_mq_debugfs_register_sched(q);
|
|
|
|
|
|
|
|
/* Similarly, blk_mq_init_hctx() couldn't do this previously. */
|
2017-05-04 14:17:21 +00:00
|
|
|
queue_for_each_hw_ctx(q, hctx, i) {
|
|
|
|
if (!hctx->debugfs_dir && blk_mq_debugfs_register_hctx(q, hctx))
|
|
|
|
goto err;
|
2017-05-04 14:24:40 +00:00
|
|
|
if (q->elevator && !hctx->sched_debugfs_dir &&
|
|
|
|
blk_mq_debugfs_register_sched_hctx(q, hctx))
|
|
|
|
goto err;
|
2017-05-04 14:17:21 +00:00
|
|
|
}
|
|
|
|
|
2017-01-25 16:06:40 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
|
|
|
blk_mq_debugfs_unregister(q);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
void blk_mq_debugfs_unregister(struct request_queue *q)
|
|
|
|
{
|
|
|
|
debugfs_remove_recursive(q->debugfs_dir);
|
2017-05-04 14:24:40 +00:00
|
|
|
q->sched_debugfs_dir = NULL;
|
2017-01-25 16:06:40 +00:00
|
|
|
q->debugfs_dir = NULL;
|
|
|
|
}
|
|
|
|
|
2017-05-04 14:17:21 +00:00
|
|
|
static int blk_mq_debugfs_register_ctx(struct blk_mq_hw_ctx *hctx,
|
|
|
|
struct blk_mq_ctx *ctx)
|
2017-01-25 16:06:40 +00:00
|
|
|
{
|
|
|
|
struct dentry *ctx_dir;
|
|
|
|
char name[20];
|
|
|
|
|
|
|
|
snprintf(name, sizeof(name), "cpu%u", ctx->cpu);
|
2017-05-04 14:17:21 +00:00
|
|
|
ctx_dir = debugfs_create_dir(name, hctx->debugfs_dir);
|
2017-01-25 16:06:40 +00:00
|
|
|
if (!ctx_dir)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2017-02-01 18:20:59 +00:00
|
|
|
if (!debugfs_create_files(ctx_dir, ctx, blk_mq_debugfs_ctx_attrs))
|
|
|
|
return -ENOMEM;
|
2017-01-25 16:06:40 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-04 14:17:21 +00:00
|
|
|
int blk_mq_debugfs_register_hctx(struct request_queue *q,
|
|
|
|
struct blk_mq_hw_ctx *hctx)
|
2017-01-25 16:06:40 +00:00
|
|
|
{
|
|
|
|
struct blk_mq_ctx *ctx;
|
|
|
|
char name[20];
|
|
|
|
int i;
|
|
|
|
|
2017-05-04 14:17:21 +00:00
|
|
|
if (!q->debugfs_dir)
|
|
|
|
return -ENOENT;
|
|
|
|
|
2017-05-04 07:31:27 +00:00
|
|
|
snprintf(name, sizeof(name), "hctx%u", hctx->queue_num);
|
2017-05-04 14:17:21 +00:00
|
|
|
hctx->debugfs_dir = debugfs_create_dir(name, q->debugfs_dir);
|
|
|
|
if (!hctx->debugfs_dir)
|
2017-01-25 16:06:40 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2017-05-04 14:17:21 +00:00
|
|
|
if (!debugfs_create_files(hctx->debugfs_dir, hctx,
|
|
|
|
blk_mq_debugfs_hctx_attrs))
|
|
|
|
goto err;
|
2017-01-25 16:06:40 +00:00
|
|
|
|
|
|
|
hctx_for_each_ctx(hctx, ctx, i) {
|
2017-05-04 14:17:21 +00:00
|
|
|
if (blk_mq_debugfs_register_ctx(hctx, ctx))
|
|
|
|
goto err;
|
2017-01-25 16:06:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2017-05-04 14:17:21 +00:00
|
|
|
|
|
|
|
err:
|
|
|
|
blk_mq_debugfs_unregister_hctx(hctx);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
void blk_mq_debugfs_unregister_hctx(struct blk_mq_hw_ctx *hctx)
|
|
|
|
{
|
|
|
|
debugfs_remove_recursive(hctx->debugfs_dir);
|
2017-05-04 14:24:40 +00:00
|
|
|
hctx->sched_debugfs_dir = NULL;
|
2017-05-04 14:17:21 +00:00
|
|
|
hctx->debugfs_dir = NULL;
|
2017-01-25 16:06:40 +00:00
|
|
|
}
|
|
|
|
|
2017-05-04 14:17:21 +00:00
|
|
|
int blk_mq_debugfs_register_hctxs(struct request_queue *q)
|
2017-01-25 16:06:40 +00:00
|
|
|
{
|
|
|
|
struct blk_mq_hw_ctx *hctx;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
queue_for_each_hw_ctx(q, hctx, i) {
|
|
|
|
if (blk_mq_debugfs_register_hctx(q, hctx))
|
2017-05-04 14:17:21 +00:00
|
|
|
return -ENOMEM;
|
2017-01-25 16:06:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-04 14:17:21 +00:00
|
|
|
void blk_mq_debugfs_unregister_hctxs(struct request_queue *q)
|
2017-01-25 16:06:40 +00:00
|
|
|
{
|
2017-05-04 14:17:21 +00:00
|
|
|
struct blk_mq_hw_ctx *hctx;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
queue_for_each_hw_ctx(q, hctx, i)
|
|
|
|
blk_mq_debugfs_unregister_hctx(hctx);
|
2017-01-25 16:06:40 +00:00
|
|
|
}
|
2017-05-04 14:24:40 +00:00
|
|
|
|
|
|
|
int blk_mq_debugfs_register_sched(struct request_queue *q)
|
|
|
|
{
|
|
|
|
struct elevator_type *e = q->elevator->type;
|
|
|
|
|
|
|
|
if (!q->debugfs_dir)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
if (!e->queue_debugfs_attrs)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
q->sched_debugfs_dir = debugfs_create_dir("sched", q->debugfs_dir);
|
|
|
|
if (!q->sched_debugfs_dir)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (!debugfs_create_files(q->sched_debugfs_dir, q,
|
|
|
|
e->queue_debugfs_attrs))
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
|
|
|
blk_mq_debugfs_unregister_sched(q);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
void blk_mq_debugfs_unregister_sched(struct request_queue *q)
|
|
|
|
{
|
|
|
|
debugfs_remove_recursive(q->sched_debugfs_dir);
|
|
|
|
q->sched_debugfs_dir = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int blk_mq_debugfs_register_sched_hctx(struct request_queue *q,
|
|
|
|
struct blk_mq_hw_ctx *hctx)
|
|
|
|
{
|
|
|
|
struct elevator_type *e = q->elevator->type;
|
|
|
|
|
|
|
|
if (!hctx->debugfs_dir)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
if (!e->hctx_debugfs_attrs)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
hctx->sched_debugfs_dir = debugfs_create_dir("sched",
|
|
|
|
hctx->debugfs_dir);
|
|
|
|
if (!hctx->sched_debugfs_dir)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (!debugfs_create_files(hctx->sched_debugfs_dir, hctx,
|
|
|
|
e->hctx_debugfs_attrs))
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void blk_mq_debugfs_unregister_sched_hctx(struct blk_mq_hw_ctx *hctx)
|
|
|
|
{
|
|
|
|
debugfs_remove_recursive(hctx->sched_debugfs_dir);
|
|
|
|
hctx->sched_debugfs_dir = NULL;
|
|
|
|
}
|