Quelle  debugfs.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * DebugFS interface for the NVMe target.
 * Copyright (c) 2022-2024 Shadow
 * Copyright (c) 2024 SUSE LLC
 */

#include <linux/debugfs.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/kernel.h>

#include "nvmet.h"
#include "debugfs.h"

static struct dentry *nvmet_debugfs;

#define NVMET_DEBUGFS_ATTR(field) \
 static int field##_open(struct inode *inode, struct file *file) \
 { return single_open(file, field##_show, inode->i_private); } \
 \
 static const struct file_operations field##_fops = { \
  .open = field##_open, \
  .read = seq_read, \
  .release = single_release, \
 }

#define NVMET_DEBUGFS_RW_ATTR(field) \
 static int field##_open(struct inode *inode, struct file *file) \
 { return single_open(file, field##_show, inode->i_private); } \
 \
 static const struct file_operations field##_fops = { \
  .open = field##_open, \
  .read = seq_read, \
  .write = field##_write, \
  .release = single_release, \
 }

static int nvmet_ctrl_hostnqn_show(struct seq_file *m, void *p)
{
 struct nvmet_ctrl *ctrl = m->private;

 seq_puts(m, ctrl->hostnqn);
 return 0;
}
NVMET_DEBUGFS_ATTR(nvmet_ctrl_hostnqn);

static int nvmet_ctrl_kato_show(struct seq_file *m, void *p)
{
 struct nvmet_ctrl *ctrl = m->private;

 seq_printf(m, "%d\n", ctrl->kato);
 return 0;
}
NVMET_DEBUGFS_ATTR(nvmet_ctrl_kato);

static int nvmet_ctrl_port_show(struct seq_file *m, void *p)
{
 struct nvmet_ctrl *ctrl = m->private;

 seq_printf(m, "%d\n", le16_to_cpu(ctrl->port->disc_addr.portid));
 return 0;
}
NVMET_DEBUGFS_ATTR(nvmet_ctrl_port);

static const char *const csts_state_names[] = {
 [NVME_CSTS_RDY]  = "ready",
 [NVME_CSTS_CFS]  = "fatal",
 [NVME_CSTS_NSSRO] = "reset",
 [NVME_CSTS_SHST_OCCUR] = "shutdown",
 [NVME_CSTS_SHST_CMPLT] = "completed",
 [NVME_CSTS_PP]  = "paused",
};

static int nvmet_ctrl_state_show(struct seq_file *m, void *p)
{
 struct nvmet_ctrl *ctrl = m->private;
 bool sep = false;
 int i;

 for (i = 0; i < ARRAY_SIZE(csts_state_names); i++) {
  int state = BIT(i);

  if (!(ctrl->csts & state))
   continue;
  if (sep)
   seq_puts(m, "|");
  sep = true;
  if (csts_state_names[state])
   seq_puts(m, csts_state_names[state]);
  else
   seq_printf(m, "%d", state);
 }
 if (sep)
  seq_printf(m, "\n");
 return 0;
}

static ssize_t nvmet_ctrl_state_write(struct file *file, const char __user *buf,
          size_t count, loff_t *ppos)
{
 struct seq_file *m = file->private_data;
 struct nvmet_ctrl *ctrl = m->private;
 char reset[16];

 if (count >= sizeof(reset))
  return -EINVAL;
 if (copy_from_user(reset, buf, count))
  return -EFAULT;
 if (!memcmp(reset, "fatal", 5))
  nvmet_ctrl_fatal_error(ctrl);
 else
  return -EINVAL;
 return count;
}
NVMET_DEBUGFS_RW_ATTR(nvmet_ctrl_state);

static int nvmet_ctrl_host_traddr_show(struct seq_file *m, void *p)
{
 struct nvmet_ctrl *ctrl = m->private;
 ssize_t size;
 char buf[NVMF_TRADDR_SIZE + 1];

 size = nvmet_ctrl_host_traddr(ctrl, buf, NVMF_TRADDR_SIZE);
 if (size < 0) {
  buf[0] = '\0';
  size = 0;
 }
 buf[size] = '\0';
 seq_printf(m, "%s\n", buf);
 return 0;
}
NVMET_DEBUGFS_ATTR(nvmet_ctrl_host_traddr);

#ifdef CONFIG_NVME_TARGET_TCP_TLS
static int nvmet_ctrl_tls_key_show(struct seq_file *m, void *p)
{
 struct nvmet_ctrl *ctrl = m->private;
 key_serial_t keyid = nvmet_queue_tls_keyid(ctrl->sqs[0]);

 seq_printf(m, "%08x\n", keyid);
 return 0;
}
NVMET_DEBUGFS_ATTR(nvmet_ctrl_tls_key);

static int nvmet_ctrl_tls_concat_show(struct seq_file *m, void *p)
{
 struct nvmet_ctrl *ctrl = m->private;

 seq_printf(m, "%d\n", ctrl->concat);
 return 0;
}
NVMET_DEBUGFS_ATTR(nvmet_ctrl_tls_concat);
#endif

int nvmet_debugfs_ctrl_setup(struct nvmet_ctrl *ctrl)
{
 char name[32];
 struct dentry *parent = ctrl->subsys->debugfs_dir;
 int ret;

 if (!parent)
  return -ENODEV;
 snprintf(name, sizeof(name), "ctrl%d", ctrl->cntlid);
 ctrl->debugfs_dir = debugfs_create_dir(name, parent);
 if (IS_ERR(ctrl->debugfs_dir)) {
  ret = PTR_ERR(ctrl->debugfs_dir);
  ctrl->debugfs_dir = NULL;
  return ret;
 }
 debugfs_create_file("port", S_IRUSR, ctrl->debugfs_dir, ctrl,
       &nvmet_ctrl_port_fops);
 debugfs_create_file("hostnqn", S_IRUSR, ctrl->debugfs_dir, ctrl,
       &nvmet_ctrl_hostnqn_fops);
 debugfs_create_file("kato", S_IRUSR, ctrl->debugfs_dir, ctrl,
       &nvmet_ctrl_kato_fops);
 debugfs_create_file("state", S_IRUSR | S_IWUSR, ctrl->debugfs_dir, ctrl,
       &nvmet_ctrl_state_fops);
 debugfs_create_file("host_traddr", S_IRUSR, ctrl->debugfs_dir, ctrl,
       &nvmet_ctrl_host_traddr_fops);
#ifdef CONFIG_NVME_TARGET_TCP_TLS
 debugfs_create_file("tls_concat", S_IRUSR, ctrl->debugfs_dir, ctrl,
       &nvmet_ctrl_tls_concat_fops);
 debugfs_create_file("tls_key", S_IRUSR, ctrl->debugfs_dir, ctrl,
       &nvmet_ctrl_tls_key_fops);
#endif
 return 0;
}

void nvmet_debugfs_ctrl_free(struct nvmet_ctrl *ctrl)
{
 debugfs_remove_recursive(ctrl->debugfs_dir);
}

int nvmet_debugfs_subsys_setup(struct nvmet_subsys *subsys)
{
 int ret = 0;

 subsys->debugfs_dir = debugfs_create_dir(subsys->subsysnqn,
       nvmet_debugfs);
 if (IS_ERR(subsys->debugfs_dir)) {
  ret = PTR_ERR(subsys->debugfs_dir);
  subsys->debugfs_dir = NULL;
 }
 return ret;
}

void nvmet_debugfs_subsys_free(struct nvmet_subsys *subsys)
{
 debugfs_remove_recursive(subsys->debugfs_dir);
}

int __init nvmet_init_debugfs(void)
{
 struct dentry *parent;

 parent = debugfs_create_dir("nvmet", NULL);
 if (IS_ERR(parent)) {
  pr_warn("%s: failed to create debugfs directory\n", "nvmet");
  return PTR_ERR(parent);
 }
 nvmet_debugfs = parent;
 return 0;
}

void nvmet_exit_debugfs(void)
{
 debugfs_remove_recursive(nvmet_debugfs);
}