Merging upstream version 2.9.1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 889 insertions, 229 deletions

diff --git a/nvme.c b/nvme.c
index e9aac8f..4a65c4b 100644
--- a/nvme.c
+++ b/nvme.c
@@ -52,9 +52,10 @@
 	#include <sys/random.h>
 #endif
 
+#include <libnvme.h>
+
 #include "common.h"
 #include "nvme.h"
-#include "libnvme.h"
 #include "nvme-print.h"
 #include "plugin.h"
 #include "util/base64.h"
@@ -62,6 +63,7 @@
 #include "nvme-wrap.h"
 #include "util/argconfig.h"
 #include "util/suffix.h"
+#include "util/logging.h"
 #include "fabrics.h"
 #define CREATE_CMD
 #include "nvme-builtin.h"
@@ -106,9 +108,64 @@ struct passthru_config {
 	bool	latency;
 };
 
+struct get_reg_config {
+	int offset;
+	bool human_readable;
+	bool cap;
+	bool vs;
+	bool intms;
+	bool intmc;
+	bool cc;
+	bool csts;
+	bool nssr;
+	bool aqa;
+	bool asq;
+	bool acq;
+	bool cmbloc;
+	bool cmbsz;
+	bool bpinfo;
+	bool bprsel;
+	bool bpmbl;
+	bool cmbmsc;
+	bool cmbsts;
+	bool cmbebs;
+	bool cmbswtp;
+	bool nssd;
+	bool crto;
+	bool pmrcap;
+	bool pmrctl;
+	bool pmrsts;
+	bool pmrebs;
+	bool pmrswtp;
+	bool pmrmscl;
+	bool pmrmscu;
+	bool fabrics;
+};
+
+struct set_reg_config {
+	int offset;
+	bool mmio32;
+	__u64 value;
+	__u32 intms;
+	__u32 intmc;
+	__u32 cc;
+	__u32 csts;
+	__u32 nssr;
+	__u32 aqa;
+	__u64 asq;
+	__u64 acq;
+	__u32 bprsel;
+	__u64 bpmbl;
+	__u64 cmbmsc;
+	__u32 nssd;
+	__u32 pmrctl;
+	__u32 pmrmscl;
+	__u32 pmrmscu;
+};
+
 #define NVME_ARGS(n, ...)                                                         \
 	struct argconfig_commandline_options n[] = {                              \
-		OPT_FLAG("verbose",      'v', NULL,               verbose),       \
+		OPT_INCR("verbose",      'v', &verbose_level,     verbose),       \
 		OPT_FMT("output-format", 'o', &output_format_val, output_format), \
 		##__VA_ARGS__,                                                    \
 		OPT_END()                                                         \
@@ -184,10 +241,27 @@ static const char *uuid_index_specify = "specify uuid index";
 static const char *verbose = "Increase output verbosity";
 static const char dash[51] = {[0 ... 49] = '=', '\0'};
 static const char space[51] = {[0 ... 49] = ' ', '\0'};
+static const char *offset = "offset of the requested register";
+static const char *intms = "INTMS=0xc register offset";
+static const char *intmc = "INTMC=0x10 register offset";
+static const char *cc = "CC=0x14 register offset";
+static const char *csts = "CSTS=0x1c register offset";
+static const char *nssr = "NSSR=0x20 register offset";
+static const char *aqa = "AQA=0x24 register offset";
+static const char *asq = "ASQ=0x28 register offset";
+static const char *acq = "ACQ=0x30 register offset";
+static const char *bprsel = "BPRSEL=0x44 register offset";
+static const char *bpmbl = "BPMBL=0x48 register offset";
+static const char *cmbmsc = "CMBMSC=0x50 register offset";
+static const char *nssd = "NSSD=0x64 register offset";
+static const char *pmrctl = "PMRCTL=0xe04 register offset";
+static const char *pmrmscl = "PMRMSCL=0xe14 register offset";
+static const char *pmrmscu = "PMRMSCU=0xe18 register offset";
 
 static char *output_format_val = "normal";
+int verbose_level;
 
-static void *mmap_registers(nvme_root_t r, struct nvme_dev *dev);
+static void *mmap_registers(struct nvme_dev *dev, bool writable);
 
 const char *nvme_strerror(int errnum)
 {
@@ -196,36 +270,6 @@ const char *nvme_strerror(int errnum)
 	return strerror(errnum);
 }
 
-int map_log_level(int verbose, bool quiet)
-{
-	int log_level;
-
-	/*
-	 * LOG_NOTICE is unused thus the user has to provide two 'v' for getting
-	 * any feedback at all. Thus skip this level
-	 */
-	verbose++;
-
-	switch (verbose) {
-	case 0:
-		log_level = LOG_WARNING;
-		break;
-	case 1:
-		log_level = LOG_NOTICE;
-		break;
-	case 2:
-		log_level = LOG_INFO;
-		break;
-	default:
-		log_level = LOG_DEBUG;
-		break;
-	}
-	if (quiet)
-		log_level = LOG_ERR;
-
-	return log_level;
-}
-
 static ssize_t getrandom_bytes(void *buf, size_t buflen)
 {
 #if HAVE_SYS_RANDOM
@@ -281,7 +325,8 @@ static int open_dev_direct(struct nvme_dev **devp, char *devstr, int flags)
 	}
 	if (!is_chardev(dev) && !is_blkdev(dev)) {
 		nvme_show_error("%s is not a block or character device", devstr);
-		err = -ENODEV;
+		errno = ENODEV;
+		err = -1;
 		goto err_close;
 	}
 	*devp = dev;
@@ -400,8 +445,8 @@ int parse_and_open(struct nvme_dev **dev, int argc, char **argv,
 	ret = get_dev(dev, argc, argv, O_RDONLY);
 	if (ret < 0)
 		argconfig_print_help(desc, opts);
-	else if (argconfig_parse_seen(opts, "verbose"))
-		nvme_cli_set_debug(*dev, true);
+	else
+		log_level = map_log_level(verbose_level, false);
 
 	return ret;
 }
@@ -531,7 +576,7 @@ static int get_ana_log(int argc, char **argv, struct command *cmd,
 		"decoded format (default), json or binary.";
 	const char *groups = "Return ANA groups only.";
 
-	_cleanup_nvme_dev_ struct nvme_dev *dev= NULL;
+	_cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
 	_cleanup_free_ struct nvme_id_ctrl *ctrl = NULL;
 	_cleanup_free_ void *ana_log = NULL;
 	size_t ana_log_len;
@@ -868,7 +913,9 @@ static int get_telemetry_log(int argc, char **argv, struct command *cmd,
 	while (data_remaining) {
 		data_written = write(output, data_ptr, data_remaining);
 		if (data_written < 0) {
-			data_remaining = data_written;
+			err = -errno;
+			nvme_show_error("ERROR: %s: : write failed with error : %s",
+					__func__, strerror(errno));
 			break;
 		} else if (data_written <= data_remaining) {
 			data_remaining -= data_written;
@@ -877,6 +924,7 @@ static int get_telemetry_log(int argc, char **argv, struct command *cmd,
 			/* Unexpected overwrite */
 			fprintf(stderr, "Failure: Unexpected telemetry log overwrite - data_remaining = 0x%x, data_written = 0x%x\n",
 					data_remaining, data_written);
+			err = -1;
 			break;
 		}
 	}
@@ -1007,12 +1055,9 @@ static int get_effects_log(int argc, char **argv, struct command *cmd, struct pl
 	list_head_init(&log_pages);
 
 	if (cfg.csi < 0) {
-		nvme_root_t r;
 		__u64 cap;
 
-		r = nvme_scan(NULL);
-		bar = mmap_registers(r, dev);
-		nvme_free_tree(r);
+		bar = mmap_registers(dev, false);
 
 		if (bar) {
 			cap = mmio_read64(bar + NVME_REG_CAP);
@@ -1172,7 +1217,7 @@ static int get_fw_log(int argc, char **argv, struct command *cmd, struct plugin
 	const char *desc = "Retrieve the firmware log for the "
 		"specified device in either decoded format (default) or binary.";
 
-	_cleanup_free_ struct nvme_firmware_slot *fw_log = NULL;;
+	_cleanup_free_ struct nvme_firmware_slot *fw_log = NULL;
 	_cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
 	enum nvme_print_flags flags;
 	int err;
@@ -3251,7 +3296,8 @@ static int list_subsys(int argc, char **argv, struct command *cmd,
 	if (argconfig_parse_seen(opts, "verbose"))
 		flags |= VERBOSE;
 
-	r = nvme_create_root(stderr, map_log_level(!!(flags & VERBOSE), false));
+
+	r = nvme_create_root(stderr, log_level);
 	if (!r) {
 		if (devname)
 			nvme_show_error("Failed to scan nvme subsystem for %s", devname);
@@ -3274,7 +3320,8 @@ static int list_subsys(int argc, char **argv, struct command *cmd,
 
 	err = nvme_scan_topology(r, filter, (void *)devname);
 	if (err) {
-		nvme_show_error("Failed to scan topology: %s", nvme_strerror(errno));
+		if (errno != ENOENT)
+			nvme_show_error("Failed to scan topology: %s", nvme_strerror(errno));
 		goto ret;
 	}
 
@@ -3308,14 +3355,15 @@ static int list(int argc, char **argv, struct command *cmd, struct plugin *plugi
 	if (argconfig_parse_seen(opts, "verbose"))
 		flags |= VERBOSE;
 
-	r = nvme_create_root(stderr, map_log_level(!!(flags & VERBOSE), false));
+	r = nvme_create_root(stderr, log_level);
 	if (!r) {
 		nvme_show_error("Failed to create topology root: %s", nvme_strerror(errno));
 		return -errno;
 	}
 	err = nvme_scan_topology(r, NULL, NULL);
 	if (err < 0) {
-		nvme_show_error("Failed to scan topology: %s", nvme_strerror(errno));
+		if (errno != ENOENT)
+			nvme_show_error("Failed to scan topology: %s", nvme_strerror(errno));
 		nvme_free_tree(r);
 		return err;
 	}
@@ -3584,7 +3632,7 @@ static int ns_descs(int argc, char **argv, struct command *cmd, struct plugin *p
 	const char *raw = "show descriptors in binary format";
 
 	_cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-	_cleanup_free_ void *nsdescs = NULL;;
+	_cleanup_free_ void *nsdescs = NULL;
 	enum nvme_print_flags flags;
 	int err;
 
@@ -3615,6 +3663,9 @@ static int ns_descs(int argc, char **argv, struct command *cmd, struct plugin *p
 	if (cfg.raw_binary)
 		flags = BINARY;
 
+	if (argconfig_parse_seen(opts, "verbose"))
+		flags |= VERBOSE;
+
 	if (!cfg.namespace_id) {
 		err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
 		if (err < 0) {
@@ -4824,7 +4875,7 @@ static int fw_download(int argc, char **argv, struct command *cmd, struct plugin
 	int err;
 	struct stat sb;
 	void *fw_buf;
-	struct nvme_id_ctrl ctrl;
+	struct nvme_id_ctrl ctrl = { 0 };
 
 	struct config {
 		char	*fw;
@@ -4836,7 +4887,7 @@ static int fw_download(int argc, char **argv, struct command *cmd, struct plugin
 
 	struct config cfg = {
 		.fw         = "",
-		.xfer       = 4096,
+		.xfer       = 0,
 		.offset     = 0,
 		.progress   = false,
 		.ignore_ovr = false,
@@ -4885,6 +4936,10 @@ static int fw_download(int argc, char **argv, struct command *cmd, struct plugin
 	} else if (cfg.xfer % 4096)
 		cfg.xfer = 4096;
 
+	if (ctrl.fwug && ctrl.fwug != 0xff && fw_size % cfg.xfer)
+		nvme_show_error("WARNING: firmware file size %u not conform to FWUG alignment %lu",
+				fw_size, cfg.xfer);
+
 	fw_buf = nvme_alloc_huge(fw_size, &mh);
 	if (!fw_buf)
 		return -ENOMEM;
@@ -5119,7 +5174,7 @@ static int ns_rescan(int argc, char **argv, struct command *cmd, struct plugin *
 
 	err = nvme_ns_rescan(dev_fd(dev));
 	if (err < 0)
-		nvme_show_error("Namespace Rescan");
+		nvme_show_error("Namespace Rescan: %s\n", nvme_strerror(errno));
 
 	return err;
 }
@@ -5224,42 +5279,62 @@ static int sanitize_cmd(int argc, char **argv, struct command *cmd, struct plugi
 	return err;
 }
 
-static int nvme_get_properties(int fd, void **pbar)
+static int nvme_get_single_property(int fd, struct get_reg_config *cfg, __u64 *value)
+{
+	int err;
+	struct nvme_get_property_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.offset		= cfg->offset,
+		.value		= value,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+	};
+
+	err = nvme_get_property(&args);
+	if (!err)
+		return 0;
+
+	if (!cfg->fabrics &&
+	    nvme_status_equals(err, NVME_STATUS_TYPE_NVME, NVME_SC_INVALID_FIELD)) {
+		*value = -1;
+		return 0;
+	}
+
+	if (cfg->fabrics && err > 0)
+		nvme_show_status(err);
+	else
+		nvme_show_error("get-property: %s", nvme_strerror(errno));
+
+	return err;
+}
+
+static int nvme_get_properties(int fd, void **pbar, struct get_reg_config *cfg)
 {
-	int offset, err, size = getpagesize();
+	int err, size = getpagesize();
+	bool is_64bit = false;
 	__u64 value;
-	void *bar = malloc(size);
+	void *bar;
+	int offset;
 
+	bar = malloc(size);
 	if (!bar) {
 		nvme_show_error("malloc: %s", strerror(errno));
-		return -1;
+		return -errno;
 	}
 
 	memset(bar, 0xff, size);
-	for (offset = NVME_REG_CAP; offset <= NVME_REG_CMBSZ;) {
-		struct nvme_get_property_args args = {
-			.args_size	= sizeof(args),
-			.fd		= fd,
-			.offset		= offset,
-			.value		= &value,
-			.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
-		};
-
-		err = nvme_get_property(&args);
-		if (nvme_status_equals(err, NVME_STATUS_TYPE_NVME, NVME_SC_INVALID_FIELD)) {
-			err = 0;
-			value = -1;
-		} else if (err) {
-			nvme_show_error("get-property: %s", nvme_strerror(errno));
+	for (offset = NVME_REG_CAP; offset <= NVME_REG_CMBSZ;
+	     offset += is_64bit ? sizeof(uint64_t) : sizeof(uint32_t)) {
+		cfg->offset = offset;
+		err = nvme_get_single_property(fd, cfg, &value);
+		if (err)
 			break;
-		}
-		if (nvme_is_64bit_reg(offset)) {
-			*(uint64_t *)(bar + offset) = value;
-			offset += 8;
-		} else {
-			*(uint32_t *)(bar + offset) = value;
-			offset += 4;
-		}
+
+		is_64bit = nvme_is_64bit_reg(cfg->offset);
+		if (is_64bit)
+			*(uint64_t *)(bar + cfg->offset) = value;
+		else
+			*(uint32_t *)(bar + cfg->offset) = value;
 	}
 
 	if (err)
@@ -5270,42 +5345,28 @@ static int nvme_get_properties(int fd, void **pbar)
 	return err;
 }
 
-static void *mmap_registers(nvme_root_t r, struct nvme_dev *dev)
+static void *mmap_registers(struct nvme_dev *dev, bool writable)
 {
-	nvme_ctrl_t c = NULL;
-	nvme_ns_t n = NULL;
-
 	char path[512];
 	void *membase;
 	int fd;
+	int prot = PROT_READ;
 
-	c = nvme_scan_ctrl(r, dev->name);
-	if (c) {
-		snprintf(path, sizeof(path), "%s/device/resource0",
-			nvme_ctrl_get_sysfs_dir(c));
-		nvme_free_ctrl(c);
-	} else {
-		n = nvme_scan_namespace(dev->name);
-		if (!n) {
-			nvme_show_error("Unable to find %s", dev->name);
-			return NULL;
-		}
-		snprintf(path, sizeof(path), "%s/device/device/resource0",
-			 nvme_ns_get_sysfs_dir(n));
-		nvme_free_ns(n);
-	}
+	if (writable)
+		prot |= PROT_WRITE;
 
-	fd = open(path, O_RDONLY);
+	sprintf(path, "/sys/class/nvme/%s/device/resource0", dev->name);
+	fd = open(path, writable ? O_RDWR : O_RDONLY);
 	if (fd < 0) {
-		if (map_log_level(0, false) >= LOG_DEBUG)
+		if (log_level >= LOG_DEBUG)
 			nvme_show_error("%s did not find a pci resource, open failed %s",
 					dev->name, strerror(errno));
 		return NULL;
 	}
 
-	membase = mmap(NULL, getpagesize(), PROT_READ, MAP_SHARED, fd, 0);
+	membase = mmap(NULL, getpagesize(), prot, MAP_SHARED, fd, 0);
 	if (membase == MAP_FAILED) {
-		if (map_log_level(0, false) >= LOG_DEBUG) {
+		if (log_level >= LOG_DEBUG) {
 			fprintf(stderr, "%s failed to map. ", dev->name);
 			fprintf(stderr, "Did your kernel enable CONFIG_IO_STRICT_DEVMEM?\n");
 		}
@@ -5326,15 +5387,10 @@ static int show_registers(int argc, char **argv, struct command *cmd, struct plu
 	_cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
 	enum nvme_print_flags flags;
 	bool fabrics = false;
-	nvme_root_t r;
 	void *bar;
 	int err;
 
-	struct config {
-		bool	human_readable;
-	};
-
-	struct config cfg = {
+	struct get_reg_config cfg = {
 		.human_readable	= false,
 	};
 
@@ -5345,21 +5401,20 @@ static int show_registers(int argc, char **argv, struct command *cmd, struct plu
 	if (err)
 		return err;
 
-	r = nvme_scan(NULL);
 	err = validate_output_format(output_format_val, &flags);
 	if (err < 0) {
 		nvme_show_error("Invalid output format");
-		goto free_tree;
+		return err;
 	}
 
 	if (cfg.human_readable)
 		flags |= VERBOSE;
 
-	bar = mmap_registers(r, dev);
+	bar = mmap_registers(dev, false);
 	if (!bar) {
-		err = nvme_get_properties(dev_fd(dev), &bar);
+		err = nvme_get_properties(dev_fd(dev), &bar, &cfg);
 		if (err)
-			goto free_tree;
+			return err;
 		fabrics = true;
 	}
 
@@ -5368,8 +5423,575 @@ static int show_registers(int argc, char **argv, struct command *cmd, struct plu
 		free(bar);
 	else
 		munmap(bar, getpagesize());
-free_tree:
-	nvme_free_tree(r);
+
+	return 0;
+}
+
+int get_reg_size(int offset)
+{
+	return nvme_is_64bit_reg(offset) ? sizeof(uint64_t) : sizeof(uint32_t);
+}
+
+static bool is_reg_selected(struct get_reg_config *cfg, int offset)
+{
+	switch (offset) {
+	case NVME_REG_CAP:
+		return cfg->cap;
+	case NVME_REG_VS:
+		return cfg->vs;
+	case NVME_REG_INTMS:
+		return cfg->intms;
+	case NVME_REG_INTMC:
+		return cfg->intmc;
+	case NVME_REG_CC:
+		return cfg->cc;
+	case NVME_REG_CSTS:
+		return cfg->csts;
+	case NVME_REG_NSSR:
+		return cfg->nssr;
+	case NVME_REG_AQA:
+		return cfg->aqa;
+	case NVME_REG_ASQ:
+		return cfg->asq;
+	case NVME_REG_ACQ:
+		return cfg->acq;
+	case NVME_REG_CMBLOC:
+		return cfg->cmbloc;
+	case NVME_REG_CMBSZ:
+		return cfg->cmbsz;
+	case NVME_REG_BPINFO:
+		return cfg->bpinfo;
+	case NVME_REG_BPRSEL:
+		return cfg->bprsel;
+	case NVME_REG_BPMBL:
+		return cfg->bpmbl;
+	case NVME_REG_CMBMSC:
+		return cfg->cmbmsc;
+	case NVME_REG_CMBSTS:
+		return cfg->cmbsts;
+	case NVME_REG_CMBEBS:
+		return cfg->cmbebs;
+	case NVME_REG_CMBSWTP:
+		return cfg->cmbswtp;
+	case NVME_REG_NSSD:
+		return cfg->nssd;
+	case NVME_REG_CRTO:
+		return cfg->crto;
+	case NVME_REG_PMRCAP:
+		return cfg->pmrcap;
+	case NVME_REG_PMRCTL:
+		return cfg->pmrctl;
+	case NVME_REG_PMRSTS:
+		return cfg->pmrsts;
+	case NVME_REG_PMREBS:
+		return cfg->pmrebs;
+	case NVME_REG_PMRSWTP:
+		return cfg->pmrswtp;
+	case NVME_REG_PMRMSCL:
+		return cfg->pmrmscl;
+	case NVME_REG_PMRMSCU:
+		return cfg->pmrmscu;
+	default:
+		break;
+	}
+
+	return false;
+}
+
+static int get_register_properties(int fd, void **pbar, struct get_reg_config *cfg)
+{
+	int offset = NVME_REG_CRTO;
+	__u64 value;
+	int size;
+	int err;
+	void *bar;
+	struct nvme_get_property_args args = {
+		.args_size = sizeof(args),
+		.fd = fd,
+		.value = &value,
+		.timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+	};
+
+	size = offset + get_reg_size(offset);
+	bar = malloc(size);
+	if (!bar) {
+		nvme_show_error("malloc: %s", strerror(errno));
+		return -1;
+	}
+
+	for (offset = NVME_REG_CAP; offset <= NVME_REG_CRTO; offset += get_reg_size(offset)) {
+		if ((cfg->offset != offset && !is_reg_selected(cfg, offset)) ||
+		    !nvme_is_fabrics_reg(offset))
+			continue;
+
+		args.offset = offset;
+		err = nvme_get_property(&args);
+		if (nvme_status_equals(err, NVME_STATUS_TYPE_NVME, NVME_SC_INVALID_FIELD)) {
+			value = -1;
+		} else if (err) {
+			nvme_show_error("get-property: %s", nvme_strerror(errno));
+			free(bar);
+			return err;
+		}
+
+		if (nvme_is_64bit_reg(offset))
+			*(uint64_t *)(bar + offset) = value;
+		else
+			*(uint32_t *)(bar + offset) = value;
+	}
+
+	*pbar = bar;
+
+	return 0;
+}
+
+bool nvme_is_ctrl_reg(int offset)
+{
+	switch (offset) {
+	case NVME_REG_CAP:
+	case NVME_REG_VS:
+	case NVME_REG_INTMS:
+	case NVME_REG_INTMC:
+	case NVME_REG_CC:
+	case NVME_REG_CSTS:
+	case NVME_REG_NSSR:
+	case NVME_REG_AQA:
+	case NVME_REG_ASQ:
+	case NVME_REG_ACQ:
+	case NVME_REG_CMBLOC:
+	case NVME_REG_CMBSZ:
+	case NVME_REG_BPINFO:
+	case NVME_REG_BPRSEL:
+	case NVME_REG_BPMBL:
+	case NVME_REG_CMBMSC:
+	case NVME_REG_CMBSTS:
+	case NVME_REG_CMBEBS:
+	case NVME_REG_CMBSWTP:
+	case NVME_REG_NSSD:
+	case NVME_REG_CRTO:
+	case NVME_REG_PMRCAP:
+	case NVME_REG_PMRCTL:
+	case NVME_REG_PMRSTS:
+	case NVME_REG_PMREBS:
+	case NVME_REG_PMRSWTP:
+	case NVME_REG_PMRMSCL:
+	case NVME_REG_PMRMSCU:
+		return true;
+	default:
+		break;
+	}
+
+	return false;
+}
+
+static bool get_register_offset(void *bar, bool fabrics, struct get_reg_config *cfg,
+				enum nvme_print_flags flags)
+{
+	bool offset_matched = cfg->offset >= 0;
+	int offset;
+
+	if (offset_matched)
+		nvme_show_ctrl_register(bar, fabrics, cfg->offset, flags);
+
+	for (offset = NVME_REG_CAP; offset <= NVME_REG_PMRMSCU; offset += get_reg_size(offset)) {
+		if (!nvme_is_ctrl_reg(offset) || offset == cfg->offset || !is_reg_selected(cfg, offset))
+			continue;
+		nvme_show_ctrl_register(bar, fabrics, offset, flags);
+		if (!offset_matched)
+			offset_matched = true;
+	}
+
+	return offset_matched;
+}
+
+static int get_register(int argc, char **argv, struct command *cmd, struct plugin *plugin)
+{
+	const char *desc = "Reads and shows the defined NVMe controller register.\n"
+		"Register offset must be one of:\n"
+		"CAP=0x0, VS=0x8, INTMS=0xc, INTMC=0x10, CC=0x14, CSTS=0x1c,\n"
+		"NSSR=0x20, AQA=0x24, ASQ=0x28, ACQ=0x30, CMBLOC=0x38,\n"
+		"CMBSZ=0x3c, BPINFO=0x40, BPRSEL=0x44, BPMBL=0x48, CMBMSC=0x50,\n"
+		"CMBSTS=0x58, CRTO=0x68, PMRCAP=0xe00, PMRCTL=0xe04,\n"
+		"PMRSTS=0xe08, PMREBS=0xe0c, PMRSWTP=0xe10, PMRMSCL=0xe14, PMRMSCU=0xe18";
+	const char *human_readable = "show register in readable format";
+	const char *cap = "CAP=0x0 register offset";
+	const char *vs = "VS=0x8 register offset";
+	const char *cmbloc = "CMBLOC=0x38 register offset";
+	const char *cmbsz = "CMBSZ=0x3c register offset";
+	const char *bpinfo = "BPINFO=0x40 register offset";
+	const char *cmbsts = "CMBSTS=0x58 register offset";
+	const char *cmbebs = "CMBEBS=0x5c register offset";
+	const char *cmbswtp = "CMBSWTP=0x60 register offset";
+	const char *crto = "CRTO=0x68 register offset";
+	const char *pmrcap = "PMRCAP=0xe00 register offset";
+	const char *pmrsts = "PMRSTS=0xe08 register offset";
+	const char *pmrebs = "PMREBS=0xe0c register offset";
+	const char *pmrswtp = "PMRSWTP=0xe10 register offset";
+	const char *pmrmscl = "PMRMSCL=0xe14 register offset";
+	const char *pmrmscu = "PMRMSCU=0xe18 register offset";
+
+	_cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
+	int err;
+	enum nvme_print_flags flags;
+	bool fabrics = false;
+
+	void *bar;
+
+	struct get_reg_config cfg = {
+		.offset = -1,
+	};
+
+	NVME_ARGS(opts,
+		  OPT_UINT("offset",         'O', &cfg.offset,         offset),
+		  OPT_FLAG("human-readable", 'H', &cfg.human_readable, human_readable),
+		  OPT_FLAG("cap",              0, &cfg.cap,            cap),
+		  OPT_FLAG("vs",               0, &cfg.vs,             vs),
+		  OPT_FLAG("cmbloc",           0, &cfg.cmbloc,         cmbloc),
+		  OPT_FLAG("cmbsz",            0, &cfg.cmbsz,          cmbsz),
+		  OPT_FLAG("bpinfo",           0, &cfg.bpinfo,         bpinfo),
+		  OPT_FLAG("cmbsts",           0, &cfg.cmbsts,         cmbsts),
+		  OPT_FLAG("cmbebs",           0, &cfg.cmbebs,         cmbebs),
+		  OPT_FLAG("cmbswtp",          0, &cfg.cmbswtp,        cmbswtp),
+		  OPT_FLAG("crto",             0, &cfg.crto,           crto),
+		  OPT_FLAG("pmrcap",           0, &cfg.pmrcap,         pmrcap),
+		  OPT_FLAG("pmrsts",           0, &cfg.pmrsts,         pmrsts),
+		  OPT_FLAG("pmrebs",           0, &cfg.pmrebs,         pmrebs),
+		  OPT_FLAG("pmrswtp",          0, &cfg.pmrswtp,        pmrswtp),
+		  OPT_FLAG("intms",            0, &cfg.intms,          intms),
+		  OPT_FLAG("intmc",            0, &cfg.intmc,          intmc),
+		  OPT_FLAG("cc",               0, &cfg.cc,             cc),
+		  OPT_FLAG("csts",             0, &cfg.csts,           csts),
+		  OPT_FLAG("nssr",             0, &cfg.nssr,           nssr),
+		  OPT_FLAG("aqa",              0, &cfg.aqa,            aqa),
+		  OPT_FLAG("asq",              0, &cfg.asq,            asq),
+		  OPT_FLAG("acq",              0, &cfg.acq,            acq),
+		  OPT_FLAG("bprsel",           0, &cfg.bprsel,         bprsel),
+		  OPT_FLAG("bpmbl",            0, &cfg.bpmbl,          bpmbl),
+		  OPT_FLAG("cmbmsc",           0, &cfg.cmbmsc,         cmbmsc),
+		  OPT_FLAG("nssd",             0, &cfg.nssd,           nssd),
+		  OPT_FLAG("pmrctl",           0, &cfg.pmrctl,         pmrctl),
+		  OPT_FLAG("pmrmscl",          0, &cfg.pmrmscl,        pmrmscl),
+		  OPT_FLAG("pmrmscu",          0, &cfg.pmrmscu,        pmrmscu));
+
+	err = parse_and_open(&dev, argc, argv, desc, opts);
+	if (err)
+		return err;
+
+	err = validate_output_format(output_format_val, &flags);
+	if (err < 0) {
+		nvme_show_error("Invalid output format");
+		return err;
+	}
+
+	if (cfg.human_readable)
+		flags |= VERBOSE;
+
+	bar = mmap_registers(dev, false);
+	if (!bar) {
+		err = get_register_properties(dev_fd(dev), &bar, &cfg);
+		if (err)
+			return err;
+		fabrics = true;
+	}
+
+	nvme_show_init();
+
+	if (!get_register_offset(bar, fabrics, &cfg, flags)) {
+		nvme_show_error("offset required param");
+		err = -EINVAL;
+	}
+
+	nvme_show_finish();
+
+	if (fabrics)
+		free(bar);
+	else
+		munmap(bar, getpagesize());
+
+	return err;
+}
+
+static int nvme_set_single_property(int fd, int offset, uint64_t value)
+{
+	struct nvme_set_property_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.offset		= offset,
+		.value		= value,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= NULL,
+	};
+	int err = nvme_set_property(&args);
+
+	if (err < 0)
+		nvme_show_error("set-property: %s", nvme_strerror(errno));
+	else if (!err)
+		printf("set-property: %#02x (%s), value: %#"PRIx64"\n", offset,
+		       nvme_register_to_string(offset), value);
+	else if (err > 0)
+		nvme_show_status(err);
+
+	return err;
+}
+
+static int set_register_property(int fd, int offset, uint64_t value)
+{
+	if (!nvme_is_fabrics_reg(offset)) {
+		printf("register: %#04x (%s) not fabrics\n", offset,
+		       nvme_register_to_string(offset));
+		return -EINVAL;
+	}
+
+	return nvme_set_single_property(fd, offset, value);
+}
+
+static int nvme_set_register(int fd, void *bar, int offset, uint64_t value, bool mmio32)
+{
+	if (!bar)
+		return set_register_property(fd, offset, value);
+
+	if (nvme_is_64bit_reg(offset))
+		mmio_write64(bar + offset, value, mmio32);
+	else
+		mmio_write32(bar + offset, value);
+
+	printf("set-register: %#02x (%s), value: %#"PRIx64"\n", offset,
+	       nvme_register_to_string(offset), value);
+
+	return 0;
+}
+
+static inline int set_register_names_check(struct argconfig_commandline_options *opts, int offset)
+{
+	switch (offset) {
+	case NVME_REG_INTMS:
+		if (argconfig_parse_seen(opts, "intms"))
+			return -EINVAL;
+		break;
+	case NVME_REG_INTMC:
+		if (argconfig_parse_seen(opts, "intmc"))
+			return -EINVAL;
+		break;
+	case NVME_REG_CC:
+		if (argconfig_parse_seen(opts, "cc"))
+			return -EINVAL;
+		break;
+	case NVME_REG_CSTS:
+		if (argconfig_parse_seen(opts, "csts"))
+			return -EINVAL;
+		break;
+	case NVME_REG_NSSR:
+		if (argconfig_parse_seen(opts, "nssr"))
+			return -EINVAL;
+		break;
+	case NVME_REG_AQA:
+		if (argconfig_parse_seen(opts, "aqa"))
+			return -EINVAL;
+		break;
+	case NVME_REG_ASQ:
+		if (argconfig_parse_seen(opts, "asq"))
+			return -EINVAL;
+		break;
+	case NVME_REG_ACQ:
+		if (argconfig_parse_seen(opts, "acq"))
+			return -EINVAL;
+		break;
+	case NVME_REG_BPRSEL:
+		if (argconfig_parse_seen(opts, "bprsel"))
+			return -EINVAL;
+		break;
+	case NVME_REG_CMBMSC:
+		if (argconfig_parse_seen(opts, "cmbmsc"))
+			return -EINVAL;
+		break;
+	case NVME_REG_NSSD:
+		if (argconfig_parse_seen(opts, "nssd"))
+			return -EINVAL;
+		break;
+	case NVME_REG_PMRCTL:
+		if (argconfig_parse_seen(opts, "pmrctl"))
+			return -EINVAL;
+		break;
+	case NVME_REG_PMRMSCL:
+		if (argconfig_parse_seen(opts, "pmrmscl"))
+			return -EINVAL;
+		break;
+	case NVME_REG_PMRMSCU:
+		if (argconfig_parse_seen(opts, "pmrmscu"))
+			return -EINVAL;
+		break;
+	default:
+		break;
+	}
+
+	return 0;
+}
+
+static int set_register_offset(int fd, void *bar, struct argconfig_commandline_options *opts,
+			       struct set_reg_config *cfg)
+{
+	int err;
+
+	if (!argconfig_parse_seen(opts, "value")) {
+		nvme_show_error("value required param");
+		return -EINVAL;
+	}
+
+	err = set_register_names_check(opts, cfg->offset);
+	if (err) {
+		nvme_show_error("offset duplicated param");
+		return err;
+	}
+
+	err = nvme_set_register(fd, bar, cfg->offset, cfg->value, cfg->mmio32);
+	if (err)
+		return err;
+
+	return 0;
+}
+
+static int set_register_names(int fd, void *bar, struct argconfig_commandline_options *opts,
+			      struct set_reg_config *cfg)
+{
+	int err;
+
+	if (argconfig_parse_seen(opts, "intms")) {
+		err = nvme_set_register(fd, bar, NVME_REG_INTMS, cfg->intms, cfg->mmio32);
+		if (err)
+			return err;
+	}
+
+	if (argconfig_parse_seen(opts, "intmc")) {
+		err = nvme_set_register(fd, bar, NVME_REG_INTMC, cfg->intmc, cfg->mmio32);
+		if (err)
+			return err;
+	}
+
+	if (argconfig_parse_seen(opts, "cc")) {
+		err = nvme_set_register(fd, bar, NVME_REG_CC, cfg->cc, cfg->mmio32);
+		if (err)
+			return err;
+	}
+
+	if (argconfig_parse_seen(opts, "csts")) {
+		err = nvme_set_register(fd, bar, NVME_REG_CSTS, cfg->csts, cfg->mmio32);
+		if (err)
+			return err;
+	}
+
+	if (argconfig_parse_seen(opts, "nssr")) {
+		err = nvme_set_register(fd, bar, NVME_REG_NSSR, cfg->nssr, cfg->mmio32);
+		if (err)
+			return err;
+	}
+
+	if (argconfig_parse_seen(opts, "aqa")) {
+		err = nvme_set_register(fd, bar, NVME_REG_AQA, cfg->aqa, cfg->mmio32);
+		if (err)
+			return err;
+	}
+
+	if (argconfig_parse_seen(opts, "asq")) {
+		err = nvme_set_register(fd, bar, NVME_REG_ASQ, cfg->asq, cfg->mmio32);
+		if (err)
+			return err;
+	}
+
+	if (argconfig_parse_seen(opts, "acq")) {
+		err = nvme_set_register(fd, bar, NVME_REG_ACQ, cfg->acq, cfg->mmio32);
+		if (err)
+			return err;
+	}
+
+	if (argconfig_parse_seen(opts, "bprsel")) {
+		err = nvme_set_register(fd, bar, NVME_REG_BPRSEL, cfg->bprsel, cfg->mmio32);
+		if (err)
+			return err;
+	}
+
+	if (argconfig_parse_seen(opts, "cmbmsc")) {
+		err = nvme_set_register(fd, bar, NVME_REG_CMBMSC, cfg->cmbmsc, cfg->mmio32);
+		if (err)
+			return err;
+	}
+
+	if (argconfig_parse_seen(opts, "nssd")) {
+		err = nvme_set_register(fd, bar, NVME_REG_NSSD, cfg->nssd, cfg->mmio32);
+		if (err)
+			return err;
+	}
+
+	if (argconfig_parse_seen(opts, "pmrctl")) {
+		err = nvme_set_register(fd, bar, NVME_REG_PMRCTL, cfg->pmrctl, cfg->mmio32);
+		if (err)
+			return err;
+	}
+
+	if (argconfig_parse_seen(opts, "pmrmscl")) {
+		err = nvme_set_register(fd, bar, NVME_REG_PMRMSCL, cfg->pmrmscl, cfg->mmio32);
+		if (err)
+			return err;
+	}
+
+	if (argconfig_parse_seen(opts, "pmrmscu")) {
+		err = nvme_set_register(fd, bar, NVME_REG_PMRMSCU, cfg->pmrmscu, cfg->mmio32);
+		if (err)
+			return err;
+	}
+
+	return 0;
+}
+
+static int set_register(int argc, char **argv, struct command *cmd, struct plugin *plugin)
+{
+	const char *desc = "Writes and shows the defined NVMe controller register";
+	const char *value = "the value of the register to be set";
+	const char *mmio32 = "Access 64-bit registers as 2 32-bit";
+
+	_cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
+	int err;
+
+	void *bar;
+
+	struct set_reg_config cfg = {
+		.offset = -1,
+	};
+
+	NVME_ARGS(opts,
+		  OPT_UINT("offset",  'O', &cfg.offset,  offset),
+		  OPT_SUFFIX("value", 'V', &cfg.value,   value),
+		  OPT_FLAG("mmio32",  'm', &cfg.mmio32,  mmio32),
+		  OPT_UINT("intms",     0, &cfg.intms,   intms),
+		  OPT_UINT("intmc",     0, &cfg.intmc,   intmc),
+		  OPT_UINT("cc",        0, &cfg.cc,      cc),
+		  OPT_UINT("csts",      0, &cfg.csts,    csts),
+		  OPT_UINT("nssr",      0, &cfg.nssr,    nssr),
+		  OPT_UINT("aqa",       0, &cfg.aqa,     aqa),
+		  OPT_SUFFIX("asq",     0, &cfg.asq,     asq),
+		  OPT_SUFFIX("acq",     0, &cfg.acq,     acq),
+		  OPT_UINT("bprsel",    0, &cfg.bprsel,  bprsel),
+		  OPT_SUFFIX("bpmbl",   0, &cfg.bpmbl,   bpmbl),
+		  OPT_SUFFIX("cmbmsc",  0, &cfg.cmbmsc,  cmbmsc),
+		  OPT_UINT("nssd",      0, &cfg.nssd,    nssd),
+		  OPT_UINT("pmrctl",    0, &cfg.pmrctl,  pmrctl),
+		  OPT_UINT("pmrmscl",   0, &cfg.pmrmscl, pmrmscl),
+		  OPT_UINT("pmrmscu",   0, &cfg.pmrmscu, pmrmscu));
+
+	err = parse_and_open(&dev, argc, argv, desc, opts);
+	if (err)
+		return err;
+
+	bar = mmap_registers(dev, true);
+
+	if (argconfig_parse_seen(opts, "offset"))
+		err = set_register_offset(dev_fd(dev), bar, opts, &cfg);
+
+	if (!err)
+		err = set_register_names(dev_fd(dev), bar, opts, &cfg);
+
+	if (bar)
+		munmap(bar, getpagesize());
+
 	return err;
 }
 
@@ -5377,7 +5999,7 @@ static int get_property(int argc, char **argv, struct command *cmd, struct plugi
 {
 	const char *desc = "Reads and shows the defined NVMe controller property\n"
 		"for NVMe over Fabric. Property offset must be one of:\n"
-		"CAP=0x0, VS=0x8, CC=0x14, CSTS=0x1c, NSSR=0x20";
+		"CAP=0x0, VS=0x8, CC=0x14, CSTS=0x1c, NSSR=0x20, NSSD=0x64, CRTO=0x68";
 	const char *offset = "offset of the requested property";
 	const char *human_readable = "show property in readable format";
 
@@ -5385,14 +6007,10 @@ static int get_property(int argc, char **argv, struct command *cmd, struct plugi
 	__u64 value;
 	int err;
 
-	struct config {
-		int	offset;
-		bool	human_readable;
-	};
-
-	struct config cfg = {
+	struct get_reg_config cfg = {
 		.offset		= -1,
 		.human_readable	= false,
+		.fabrics	= true,
 	};
 
 	NVME_ARGS(opts,
@@ -5408,20 +6026,9 @@ static int get_property(int argc, char **argv, struct command *cmd, struct plugi
 		return -EINVAL;
 	}
 
-	struct nvme_get_property_args args = {
-		.args_size	= sizeof(args),
-		.fd		= dev_fd(dev),
-		.offset		= cfg.offset,
-		.value		= &value,
-		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
-	};
-	err = nvme_get_property(&args);
-	if (err < 0)
-		nvme_show_error("get-property: %s", nvme_strerror(errno));
-	else if (!err)
+	err = nvme_get_single_property(dev_fd(dev), &cfg, &value);
+	if (!err)
 		nvme_show_single_property(cfg.offset, value, cfg.human_readable);
-	else if (err > 0)
-		nvme_show_status(err);
 
 	return err;
 }
@@ -5436,12 +6043,7 @@ static int set_property(int argc, char **argv, struct command *cmd, struct plugi
 	_cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
 	int err;
 
-	struct config {
-		int	offset;
-		int	value;
-	};
-
-	struct config cfg = {
+	struct set_reg_config cfg = {
 		.offset	= -1,
 		.value	= -1,
 	};
@@ -5463,24 +6065,7 @@ static int set_property(int argc, char **argv, struct command *cmd, struct plugi
 		return -EINVAL;
 	}
 
-	struct nvme_set_property_args args = {
-		.args_size	= sizeof(args),
-		.fd		= dev_fd(dev),
-		.offset		= cfg.offset,
-		.value		= cfg.value,
-		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
-		.result		= NULL,
-	};
-	err = nvme_set_property(&args);
-	if (err < 0)
-		nvme_show_error("set-property: %s", nvme_strerror(errno));
-	else if (!err)
-		printf("set-property: %02x (%s), value: %#08x\n", cfg.offset,
-		       nvme_register_to_string(cfg.offset), cfg.value);
-	else if (err > 0)
-		nvme_show_status(err);
-
-	return err;
+	return nvme_set_single_property(dev_fd(dev), cfg.offset, cfg.value);
 }
 
 static int format_cmd(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -7644,7 +8229,7 @@ static int sec_recv(int argc, char **argv, struct command *cmd, struct plugin *p
 		return err;
 
 	if (cfg.size) {
-		sec_buf = nvme_alloc(sizeof(*sec_buf));
+		sec_buf = nvme_alloc(cfg.size);
 		if (!sec_buf)
 			return -ENOMEM;
 	}
@@ -8363,7 +8948,8 @@ static int gen_dhchap_key(int argc, char **argv, struct command *command, struct
 	    "HMAC function to use for key transformation (0 = none, 1 = SHA-256, 2 = SHA-384, 3 = SHA-512).";
 	const char *nqn = "Host NQN to use for key transformation.";
 
-	unsigned char *raw_secret;
+	_cleanup_free_ unsigned char *raw_secret = NULL;
+	_cleanup_free_ char *hnqn = NULL;
 	unsigned char key[68];
 	char encoded_key[128];
 	unsigned long crc = crc32(0L, NULL, 0);
@@ -8458,7 +9044,7 @@ static int gen_dhchap_key(int argc, char **argv, struct command *command, struct
 	}
 
 	if (!cfg.nqn) {
-		cfg.nqn = nvmf_hostnqn_from_file();
+		cfg.nqn = hnqn = nvmf_hostnqn_from_file();
 		if (!cfg.nqn) {
 			nvme_show_error("Could not read host NQN");
 			return -ENOENT;
@@ -8581,12 +9167,12 @@ static int gen_tls_key(int argc, char **argv, struct command *command, struct pl
 	const char *subsysnqn = "Subsystem NQN for the retained key.";
 	const char *keyring = "Keyring for the retained key.";
 	const char *keytype = "Key type of the retained key.";
-	const char *insert = "Insert only, do not print the retained key.";
+	const char *insert = "Insert retained key into the keyring.";
 
-	unsigned char *raw_secret;
-	char encoded_key[128];
+	_cleanup_free_ unsigned char *raw_secret = NULL;
+	_cleanup_free_ char *encoded_key = NULL;
+	_cleanup_free_ char *hnqn = NULL;
 	int key_len = 32;
-	unsigned long crc = crc32(0L, NULL, 0);
 	int err;
 	long tls_key;
 
@@ -8640,7 +9226,7 @@ static int gen_tls_key(int argc, char **argv, struct command *command, struct pl
 			return -EINVAL;
 		}
 		if (!cfg.hostnqn) {
-			cfg.hostnqn = nvmf_hostnqn_from_file();
+			cfg.hostnqn = hnqn = nvmf_hostnqn_from_file();
 			if (!cfg.hostnqn) {
 				nvme_show_error("Failed to read host NQN");
 				return -EINVAL;
@@ -8677,6 +9263,9 @@ static int gen_tls_key(int argc, char **argv, struct command *command, struct pl
 		}
 	}
 
+	encoded_key = nvme_export_tls_key(raw_secret, key_len);
+	printf("%s\n", encoded_key);
+
 	if (cfg.insert) {
 		tls_key = nvme_insert_tls_key_versioned(cfg.keyring,
 					cfg.keytype, cfg.hostnqn,
@@ -8688,18 +9277,7 @@ static int gen_tls_key(int argc, char **argv, struct command *command, struct pl
 		}
 
 		printf("Inserted TLS key %08x\n", (unsigned int)tls_key);
-		return 0;
 	}
-	crc = crc32(crc, raw_secret, key_len);
-	raw_secret[key_len++] = crc & 0xff;
-	raw_secret[key_len++] = (crc >> 8) & 0xff;
-	raw_secret[key_len++] = (crc >> 16) & 0xff;
-	raw_secret[key_len++] = (crc >> 24) & 0xff;
-
-	memset(encoded_key, 0, sizeof(encoded_key));
-	base64_encode(raw_secret, key_len, encoded_key);
-
-	printf("NVMeTLSkey-1:%02x:%s:\n", cfg.hmac, encoded_key);
 	return 0;
 }
 
@@ -8714,11 +9292,10 @@ static int check_tls_key(int argc, char **argv, struct command *command, struct
 	const char *keytype = "Key type of the retained key.";
 	const char *insert = "Insert retained key into the keyring.";
 
-	unsigned char decoded_key[128];
-	unsigned int decoded_len;
-	u_int32_t crc = crc32(0L, NULL, 0);
-	u_int32_t key_crc;
-	int err = 0, hmac;
+	_cleanup_free_ unsigned char *decoded_key = NULL;
+	_cleanup_free_ char *hnqn = NULL;
+	int decoded_len, err = 0;
+	unsigned int hmac;
 	long tls_key;
 	struct config {
 		char		*keyring;
@@ -8763,60 +9340,25 @@ static int check_tls_key(int argc, char **argv, struct command *command, struct
 		return -EINVAL;
 	}
 
-	if (sscanf(cfg.keydata, "NVMeTLSkey-1:%02x:*s", &hmac) != 1) {
-		nvme_show_error("Invalid key '%s'", cfg.keydata);
-		return -EINVAL;
-	}
-	switch (hmac) {
-	case 1:
-		if (strlen(cfg.keydata) != 65) {
-			nvme_show_error("Invalid key length %zu for SHA(256)", strlen(cfg.keydata));
-			return -EINVAL;
-		}
-		break;
-	case 2:
-		if (strlen(cfg.keydata) != 89) {
-			nvme_show_error("Invalid key length %zu for SHA(384)", strlen(cfg.keydata));
-			return -EINVAL;
-		}
-		break;
-	default:
-		nvme_show_error("Invalid HMAC identifier %d", hmac);
-		return -EINVAL;
+	decoded_key = nvme_import_tls_key(cfg.keydata, &decoded_len, &hmac);
+	if (!decoded_key) {
+		nvme_show_error("Key decoding failed, error %d\n", errno);
+		return -errno;
 	}
 
 	if (cfg.subsysnqn) {
-		if (cfg.insert && !cfg.hostnqn) {
-			cfg.hostnqn = nvmf_hostnqn_from_file();
+		if (!cfg.hostnqn) {
+			cfg.hostnqn = hnqn = nvmf_hostnqn_from_file();
 			if (!cfg.hostnqn) {
 				nvme_show_error("Failed to read host NQN");
 				return -EINVAL;
 			}
 		}
-	} else if (cfg.insert || cfg.identity == 1) {
+	} else {
 		nvme_show_error("Need to specify a subsystem NQN");
 		return -EINVAL;
 	}
-	err = base64_decode(cfg.keydata + 16, strlen(cfg.keydata) - 17, decoded_key);
-	if (err < 0) {
-		nvme_show_error("Base64 decoding failed (%s, error %d)", cfg.keydata + 16, err);
-		return err;
-	}
-	decoded_len = err;
-	decoded_len -= 4;
-	if (decoded_len != 32 && decoded_len != 48) {
-		nvme_show_error("Invalid key length %d", decoded_len);
-		return -EINVAL;
-	}
-	crc = crc32(crc, decoded_key, decoded_len);
-	key_crc = ((u_int32_t)decoded_key[decoded_len]) |
-		((u_int32_t)decoded_key[decoded_len + 1] << 8) |
-		((u_int32_t)decoded_key[decoded_len + 2] << 16) |
-		((u_int32_t)decoded_key[decoded_len + 3] << 24);
-	if (key_crc != crc) {
-		nvme_show_error("CRC mismatch (key %08x, crc %08x)", key_crc, crc);
-		return -EINVAL;
-	}
+
 	if (cfg.insert) {
 		tls_key = nvme_insert_tls_key_versioned(cfg.keyring,
 					cfg.keytype, cfg.hostnqn,
@@ -8828,7 +9370,7 @@ static int check_tls_key(int argc, char **argv, struct command *command, struct
 		}
 		printf("Inserted TLS key %08x\n", (unsigned int)tls_key);
 	} else {
-		char *tls_id;
+		_cleanup_free_ char *tls_id = NULL;
 
 		tls_id = nvme_generate_tls_key_identity(cfg.hostnqn,
 					cfg.subsysnqn, cfg.identity,
@@ -8839,11 +9381,128 @@ static int check_tls_key(int argc, char **argv, struct command *command, struct
 			return -errno;
 		}
 		printf("%s\n", tls_id);
-		free(tls_id);
 	}
 	return 0;
 }
 
+static void __scan_tls_key(long keyring_id, long key_id,
+			   char *desc, int desc_len, void *data)
+{
+	FILE *fd = data;
+	_cleanup_free_ const unsigned char *key_data = NULL;
+	_cleanup_free_ char *encoded_key = NULL;
+	int key_len;
+
+	key_data = nvme_read_key(keyring_id, key_id, &key_len);
+	if (!key_data)
+		return;
+	encoded_key = nvme_export_tls_key(key_data, key_len);
+	if (!encoded_key)
+		return;
+	fprintf(fd, "%s %s\n", desc, encoded_key);
+}
+
+static int tls_key(int argc, char **argv, struct command *command, struct plugin *plugin)
+{
+	const char *desc = "Manipulation of TLS keys.\n";
+	const char *keyring = "Keyring for the retained key.";
+	const char *keytype = "Key type of the retained key.";
+	const char *keyfile = "File for list of keys.";
+	const char *import = "Import all keys into the keyring.";
+	const char *export = "Export all keys from the keyring.";
+
+	FILE *fd;
+	int err = 0;
+
+	struct config {
+		char		*keyring;
+		char		*keytype;
+		char		*keyfile;
+		bool		import;
+		bool		export;
+	};
+
+	struct config cfg = {
+		.keyring	= ".nvme",
+		.keytype	= "psk",
+		.keyfile	= NULL,
+		.import		= false,
+		.export		= false,
+	};
+
+	NVME_ARGS(opts,
+		  OPT_STR("keyring",	'k', &cfg.keyring,	keyring),
+		  OPT_STR("keytype",	't', &cfg.keytype,	keytype),
+		  OPT_STR("keyfile",	'f', &cfg.keyfile,	keyfile),
+		  OPT_FLAG("import",	'i', &cfg.import,	import),
+		  OPT_FLAG("export",	'e', &cfg.export,	export));
+
+	err = argconfig_parse(argc, argv, desc, opts);
+	if (err)
+		return err;
+
+	if (cfg.keyfile) {
+		fd = fopen(cfg.keyfile, "r");
+		if (!fd) {
+			nvme_show_error("Cannot open keyfile %s, error %d\n",
+					cfg.keyfile, errno);
+			return -errno;
+		}
+	} else
+		fd = stdin;
+
+	if (cfg.export && cfg.import) {
+		nvme_show_error("Cannot specify both --import and --export");
+		err = -EINVAL;
+	} else if (cfg.export) {
+		nvme_scan_tls_keys(cfg.keyring, __scan_tls_key, fd);
+	} else if (cfg.import) {
+		long keyring_id;
+		char tls_str[512];
+		char *tls_key;
+		unsigned char *psk;
+		unsigned int hmac;
+		int linenum = -1, key_len;
+
+		keyring_id = nvme_lookup_keyring(cfg.keyring);
+		if (!keyring_id) {
+			nvme_show_error("Invalid keyring '%s'", cfg.keyring);
+			err = -ENOKEY;
+			goto out;
+		}
+
+		while (fgets(tls_str, 512, fd)) {
+			linenum++;
+			tls_key = strrchr(tls_str, ' ');
+			if (!tls_key) {
+				nvme_show_error("Parse error in line %d",
+						linenum);
+				continue;
+			}
+			*tls_key = '\0';
+			tls_key++;
+			psk = nvme_import_tls_key(tls_key, &key_len, &hmac);
+			if (!psk) {
+				nvme_show_error("Failed to import key in line %d",
+						linenum);
+				continue;
+			}
+			nvme_update_key(keyring_id, "psk", tls_str,
+					psk, key_len);
+			free(psk);
+		}
+	} else {
+		nvme_show_error("Must specify either --import or --export");
+		err = -EINVAL;
+	}
+
+out:
+	if (cfg.keyfile)
+		fclose(fd);
+
+	return err;
+}
+
 static int show_topology_cmd(int argc, char **argv, struct command *command, struct plugin *plugin)
 {
 	const char *desc = "Show the topology\n";
@@ -8886,7 +9545,7 @@ static int show_topology_cmd(int argc, char **argv, struct command *command, str
 		return -EINVAL;
 	}
 
-	r = nvme_create_root(stderr, map_log_level(!!(flags & VERBOSE), false));
+	r = nvme_create_root(stderr, log_level);
 	if (!r) {
 		nvme_show_error("Failed to create topology root: %s", nvme_strerror(errno));
 		return -errno;
@@ -8894,7 +9553,8 @@ static int show_topology_cmd(int argc, char **argv, struct command *command, str
 
 	err = nvme_scan_topology(r, NULL, NULL);
 	if (err < 0) {
-		nvme_show_error("Failed to scan topology: %s", nvme_strerror(errno));
+		if (errno != ENOENT)
+			nvme_show_error("Failed to scan topology: %s", nvme_strerror(errno));
 		nvme_free_tree(r);
 		return err;
 	}