blk-mq-debugfs.c | Explore in Territory

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2017 Facebook
 */

#include <linux/kernel.h>
#include <linux/blkdev.h>
#include <linux/build_bug.h>
#include <linux/debugfs.h>

#include "blk.h"
#include "blk-mq.h"
#include "blk-mq-debugfs.h"
#include "blk-mq-sched.h"
#include "blk-rq-qos.h"

static int queue_poll_stat_show(void *data, struct seq_file *m)
{ … }

static void *queue_requeue_list_start(struct seq_file *m, loff_t *pos)
	__acquires(&q->requeue_lock)
{ … }

static void *queue_requeue_list_next(struct seq_file *m, void *v, loff_t *pos)
{ … }

static void queue_requeue_list_stop(struct seq_file *m, void *v)
	__releases(&q->requeue_lock)
{ … }

static const struct seq_operations queue_requeue_list_seq_ops = …;

static int blk_flags_show(struct seq_file *m, const unsigned long flags,
			  const char *const *flag_name, int flag_name_count)
{ … }

static int queue_pm_only_show(void *data, struct seq_file *m)
{ … }

#define QUEUE_FLAG_NAME …
static const char *const blk_queue_flag_name[] = …;
#undef QUEUE_FLAG_NAME

static int queue_state_show(void *data, struct seq_file *m)
{ … }

static ssize_t queue_state_write(void *data, const char __user *buf,
				 size_t count, loff_t *ppos)
{ … }

static const struct blk_mq_debugfs_attr blk_mq_debugfs_queue_attrs[] = …;

#define HCTX_STATE_NAME …
static const char *const hctx_state_name[] = …;
#undef HCTX_STATE_NAME

static int hctx_state_show(void *data, struct seq_file *m)
{ … }

#define BLK_TAG_ALLOC_NAME …
static const char *const alloc_policy_name[] = …;
#undef BLK_TAG_ALLOC_NAME

#define HCTX_FLAG_NAME …
static const char *const hctx_flag_name[] = …;
#undef HCTX_FLAG_NAME

static int hctx_flags_show(void *data, struct seq_file *m)
{ … }

#define CMD_FLAG_NAME …
static const char *const cmd_flag_name[] = …;
#undef CMD_FLAG_NAME

#define RQF_NAME …
static const char *const rqf_name[] = …;
#undef RQF_NAME

static const char *const blk_mq_rq_state_name_array[] = …;

static const char *blk_mq_rq_state_name(enum mq_rq_state rq_state)
{ … }

int __blk_mq_debugfs_rq_show(struct seq_file *m, struct request *rq)
{ … }
EXPORT_SYMBOL_GPL(…);

int blk_mq_debugfs_rq_show(struct seq_file *m, void *v)
{ … }
EXPORT_SYMBOL_GPL(…);

static void *hctx_dispatch_start(struct seq_file *m, loff_t *pos)
	__acquires(&hctx->lock)
{ … }

static void *hctx_dispatch_next(struct seq_file *m, void *v, loff_t *pos)
{ … }

static void hctx_dispatch_stop(struct seq_file *m, void *v)
	__releases(&hctx->lock)
{ … }

static const struct seq_operations hctx_dispatch_seq_ops = …;

struct show_busy_params { … };

/*
 * 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. Returns true to
 * keep iterating requests.
 */
static bool hctx_show_busy_rq(struct request *rq, void *data)
{ … }

static int hctx_busy_show(void *data, struct seq_file *m)
{ … }

static const char *const hctx_types[] = …;

static int hctx_type_show(void *data, struct seq_file *m)
{ … }

static int hctx_ctx_map_show(void *data, struct seq_file *m)
{ … }

static void blk_mq_debugfs_tags_show(struct seq_file *m,
				     struct blk_mq_tags *tags)
{ … }

static int hctx_tags_show(void *data, struct seq_file *m)
{ … }

static int hctx_tags_bitmap_show(void *data, struct seq_file *m)
{ … }

static int hctx_sched_tags_show(void *data, struct seq_file *m)
{ … }

static int hctx_sched_tags_bitmap_show(void *data, struct seq_file *m)
{ … }

static int hctx_active_show(void *data, struct seq_file *m)
{ … }

static int hctx_dispatch_busy_show(void *data, struct seq_file *m)
{ … }

#define CTX_RQ_SEQ_OPS(name, type) …

CTX_RQ_SEQ_OPS(…);
CTX_RQ_SEQ_OPS(…);
CTX_RQ_SEQ_OPS(…);

static int blk_mq_debugfs_show(struct seq_file *m, void *v)
{ … }

static ssize_t blk_mq_debugfs_write(struct file *file, const char __user *buf,
				    size_t count, loff_t *ppos)
{ … }

static int blk_mq_debugfs_open(struct inode *inode, struct file *file)
{ … }

static int blk_mq_debugfs_release(struct inode *inode, struct file *file)
{ … }

static const struct file_operations blk_mq_debugfs_fops = …;

static const struct blk_mq_debugfs_attr blk_mq_debugfs_hctx_attrs[] = …;

static const struct blk_mq_debugfs_attr blk_mq_debugfs_ctx_attrs[] = …;

static void debugfs_create_files(struct dentry *parent, void *data,
				 const struct blk_mq_debugfs_attr *attr)
{ … }

void blk_mq_debugfs_register(struct request_queue *q)
{ … }

static void blk_mq_debugfs_register_ctx(struct blk_mq_hw_ctx *hctx,
					struct blk_mq_ctx *ctx)
{ … }

void blk_mq_debugfs_register_hctx(struct request_queue *q,
				  struct blk_mq_hw_ctx *hctx)
{ … }

void blk_mq_debugfs_unregister_hctx(struct blk_mq_hw_ctx *hctx)
{ … }

void blk_mq_debugfs_register_hctxs(struct request_queue *q)
{ … }

void blk_mq_debugfs_unregister_hctxs(struct request_queue *q)
{ … }

void blk_mq_debugfs_register_sched(struct request_queue *q)
{ … }

void blk_mq_debugfs_unregister_sched(struct request_queue *q)
{ … }

static const char *rq_qos_id_to_name(enum rq_qos_id id)
{ … }

void blk_mq_debugfs_unregister_rqos(struct rq_qos *rqos)
{ … }

void blk_mq_debugfs_register_rqos(struct rq_qos *rqos)
{ … }

void blk_mq_debugfs_register_sched_hctx(struct request_queue *q,
					struct blk_mq_hw_ctx *hctx)
{ … }

void blk_mq_debugfs_unregister_sched_hctx(struct blk_mq_hw_ctx *hctx)
{ … }
linux/block/blk-mq-debugfs.c
