Adding upstream version 2.0.

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

2 files changed, 3080 insertions, 1716 deletions

diff --git a/nvme.c b/nvme.c
index 862f9b6..4533413 100644
--- a/nvme.c
+++ b/nvme.c
@@ -23,7 +23,9 @@
 /**
  * This program uses NVMe IOCTLs to run native nvme commands to a device.
  */
-
+#include "config.h"
+#include "nvme/tree.h"
+#include "nvme/types.h"
 #include <errno.h>
 #include <getopt.h>
 #include <fcntl.h>
@@ -36,31 +38,46 @@
 #include <math.h>
 #include <dirent.h>
 #include <libgen.h>
+#include <zlib.h>
 
-#ifdef LIBHUGETLBFS
+#ifdef CONFIG_LIBHUGETLBFS
 #include <hugetlbfs.h>
 #endif
 
 #include <linux/fs.h>
 
-#include <sys/ioctl.h>
 #include <sys/mman.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 
+#if HAVE_SYS_RANDOM
+	#include <sys/random.h>
+#endif
+
 #include "common.h"
+#include "nvme.h"
+#include "libnvme.h"
 #include "nvme-print.h"
-#include "nvme-ioctl.h"
-#include "nvme-status.h"
-#include "nvme-lightnvm.h"
 #include "plugin.h"
+#include "util/base64.h"
 
-#include "argconfig.h"
+#include "util/argconfig.h"
 #include "fabrics.h"
 
 #define CREATE_CMD
 #include "nvme-builtin.h"
 
+struct feat_cfg {
+	enum nvme_features_id feature_id;
+	__u32 namespace_id;
+	enum nvme_get_features_sel sel;
+	__u32 cdw11;
+	__u8  uuid_index;
+	__u32 data_len;
+	bool  raw_binary;
+	bool  human_readable;
+};
+
 static struct stat nvme_stat;
 const char *devicename;
 
@@ -84,23 +101,12 @@ static struct program nvme = {
 	.extensions = &builtin,
 };
 
-static __u16 nvme_feat_buf_len[0x100] = {
-	[NVME_FEAT_LBA_RANGE]		= 4096,
-	[NVME_FEAT_AUTO_PST]		= 256,
-	[NVME_FEAT_HOST_MEM_BUF]	= 4096,
-	[NVME_FEAT_HOST_ID]		= 8,
-	[NVME_FEAT_PLM_CONFIG]		= 512,
-	[NVME_FEAT_TIMESTAMP]		= 8,
-	[NVME_FEAT_HOST_BEHAVIOR]	= 512,
-	[NVME_MI_FEAT_CTRL_METADATA]	= 4096,
-	[NVME_MI_FEAT_NS_METADATA]	= 4096,
-};
-
 const char *output_format = "Output format: normal|json|binary";
 static const char *output_format_no_binary = "Output format: normal|json";
 
-static void *__nvme_alloc(size_t len, bool *huge)
-{
+static void *mmap_registers(nvme_root_t r, const char *dev);
+
+static void *__nvme_alloc(size_t len, bool *huge) {
 	void *p;
 
 	if (!posix_memalign(&p, getpagesize(), len)) {
@@ -113,11 +119,13 @@ static void *__nvme_alloc(size_t len, bool *huge)
 
 #define HUGE_MIN 0x80000
 
-#ifdef LIBHUGETLBFS
+#ifdef CONFIG_LIBHUGETLBFS
 void nvme_free(void *p, bool huge)
 {
-	if (huge)
-		free_hugepage_region(p);
+	if (huge) {
+		if (p)
+			free_hugepage_region(p);
+	}
 	else
 		free(p);
 }
@@ -148,6 +156,57 @@ void *nvme_alloc(size_t len, bool *huge)
 }
 #endif
 
+const char *nvme_strerror(int errnum)
+{
+	if (errnum >= ENVME_CONNECT_RESOLVE)
+		return nvme_errno_to_string(errnum);
+	return strerror(errnum);
+}
+
+int map_log_level(int verbose, bool quiet)
+{
+	int log_level;
+
+	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
+	return getrandom(buf, buflen, GRND_NONBLOCK);
+#else
+	ssize_t result;
+	int fd, err = 0;
+
+	fd = open("/dev/urandom", O_RDONLY);
+	if (fd < 0)
+		return fd;
+	result = read(fd, buf, buflen);
+	if (result < 0)
+		err = errno;
+	close(fd);
+	errno = err;
+	return result;
+#endif
+}
+
 static bool is_chardev(void)
 {
 	return S_ISCHR(nvme_stat.st_mode);
@@ -158,17 +217,12 @@ static bool is_blkdev(void)
 	return S_ISBLK(nvme_stat.st_mode);
 }
 
-static bool is_ns_chardev(void)
-{
-	return !strncmp(devicename, "ng", 2) && S_ISCHR(nvme_stat.st_mode);
-}
-
-static int open_dev(char *dev)
+static int open_dev(char *dev, int flags)
 {
 	int err, fd;
 
 	devicename = basename(dev);
-	err = open(dev, O_RDONLY);
+	err = open(dev, flags);
 	if (err < 0)
 		goto perror;
 	fd = err;
@@ -199,7 +253,7 @@ static int check_arg_dev(int argc, char **argv)
 	return 0;
 }
 
-static int get_dev(int argc, char **argv)
+static int get_dev(int argc, char **argv, int flags)
 {
 	int ret;
 
@@ -207,7 +261,7 @@ static int get_dev(int argc, char **argv)
 	if (ret)
 		return ret;
 
-	return open_dev(argv[optind]);
+	return open_dev(argv[optind], flags);
 }
 
 int parse_and_open(int argc, char **argv, const char *desc,
@@ -219,13 +273,23 @@ int parse_and_open(int argc, char **argv, const char *desc,
 	if (ret)
 		return ret;
 
-	ret = get_dev(argc, argv);
+	ret = get_dev(argc, argv, O_RDONLY);
 	if (ret < 0)
 		argconfig_print_help(desc, opts);
 
 	return ret;
 }
 
+int open_exclusive(int argc, char **argv, int ignore_exclusive)
+{
+    int flags = O_RDONLY;
+
+	if (!ignore_exclusive)
+		flags |= O_EXCL;
+
+    return get_dev(argc, argv, flags);
+}
+
 enum nvme_print_flags validate_output_format(const char *format)
 {
 	if (!format)
@@ -252,15 +316,17 @@ static int get_smart_log(int argc, char **argv, struct command *cmd, struct plug
 	int err = -1, fd;
 
 	struct config {
-		__u32 namespace_id;
-		int   raw_binary;
-		char *output_format;
-		int   human_readable;
+		__u32	namespace_id;
+		char	*output_format;
+		bool	raw_binary;
+		bool	human_readable;
 	};
 
 	struct config cfg = {
-		.namespace_id = NVME_NSID_ALL,
-		.output_format = "normal",
+		.namespace_id	= NVME_NSID_ALL,
+		.output_format	= "normal",
+		.raw_binary	= false,
+		.human_readable	= false,
 	};
 
 
@@ -284,18 +350,18 @@ static int get_smart_log(int argc, char **argv, struct command *cmd, struct plug
 	if (cfg.human_readable)
 		flags |= VERBOSE;
 
-	err = nvme_smart_log(fd, cfg.namespace_id, &smart_log);
+	err = nvme_get_log_smart(fd, cfg.namespace_id, true, &smart_log);
 	if (!err)
 		nvme_show_smart_log(&smart_log, cfg.namespace_id, devicename,
 				    flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("smart log");
+		fprintf(stderr, "smart log: %s\n", nvme_strerror(errno));
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int get_ana_log(int argc, char **argv, struct command *cmd,
@@ -309,9 +375,10 @@ static int get_ana_log(int argc, char **argv, struct command *cmd,
 	size_t ana_log_len;
 	struct nvme_id_ctrl ctrl;
 	enum nvme_print_flags flags;
+	enum nvme_log_ana_lsp lsp;
 
 	struct config {
-		char *output_format;
+		char	*output_format;
 	};
 
 	struct config cfg = {
@@ -333,69 +400,64 @@ static int get_ana_log(int argc, char **argv, struct command *cmd,
 
 	err = nvme_identify_ctrl(fd, &ctrl);
 	if (err) {
-		fprintf(stderr, "ERROR : nvme_identify_ctrl() failed 0x%x\n",
-				err);
+		fprintf(stderr, "ERROR : nvme_identify_ctrl() failed: %s\n",
+			nvme_strerror(errno));
 		goto close_fd;
 	}
 
-	ana_log_len = sizeof(struct nvme_ana_rsp_hdr) +
+	ana_log_len = sizeof(struct nvme_ana_log) +
 		le32_to_cpu(ctrl.nanagrpid) * sizeof(struct nvme_ana_group_desc);
 	if (!(ctrl.anacap & (1 << 6)))
 		ana_log_len += le32_to_cpu(ctrl.mnan) * sizeof(__le32);
 
 	ana_log = malloc(ana_log_len);
 	if (!ana_log) {
-		perror("malloc");
-		errno = ENOMEM;
-		err = -1;
+		err = -ENOMEM;
 		goto close_fd;
 	}
 
-	err = nvme_ana_log(fd, ana_log, ana_log_len, groups ? NVME_ANA_LOG_RGO : 0);
+	lsp = groups ? NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY :
+			NVME_LOG_ANA_LSP_RGO_NAMESPACES;
+
+	err = nvme_get_log_ana(fd, lsp, true, 0, ana_log_len, ana_log);
 	if (!err) {
 		nvme_show_ana_log(ana_log, devicename, flags, ana_log_len);
 	} else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("ana-log");
+		fprintf(stderr, "ana-log: %s", nvme_strerror(errno));
 	free(ana_log);
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
-}
-
-__u16 get_feat_buf_len(unsigned short feature) {
-	return nvme_feat_buf_len[feature];
+	return err;
 }
 
-static int get_telemetry_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
+static int get_telemetry_log(int argc, char **argv, struct command *cmd,
+			     struct plugin *plugin)
 {
 	const char *desc = "Retrieve telemetry log and write to binary file";
 	const char *fname = "File name to save raw binary, includes header";
 	const char *hgen = "Have the host tell the controller to generate the report";
 	const char *cgen = "Gather report generated by the controller.";
 	const char *dgen = "Pick which telemetry data area to report. Default is 3 to fetch areas 1-3. Valid options are 1, 2, 3, 4.";
-	const size_t bs = 512;
-	struct nvme_telemetry_log_page_hdr *hdr;
-	struct nvme_id_ctrl ctrl;
-	size_t full_size, offset = bs;
-	int err = -1, fd, output;
-	void *page_log;
-	__u32 result;
-	void *buf = NULL;
+	struct nvme_telemetry_log *log;
+	int err = 0, fd, output;
+	size_t total_size;
+	__u8 *data_ptr = NULL;
+	int data_written = 0, data_remaining = 0;
 
 	struct config {
-		char *file_name;
-		__u32 host_gen;
-		int ctrl_init;
-		int data_area;
+		char	*file_name;
+		__u32	host_gen;
+		bool	ctrl_init;
+		int	data_area;
 	};
 	struct config cfg = {
-		.file_name = NULL,
-		.host_gen = 1,
-		.ctrl_init = 0,
-		.data_area = 3,
+		.file_name	= NULL,
+		.host_gen	= 1,
+		.ctrl_init	= false,
+		.data_area	= 3,
 	};
 
 	OPT_ARGS(opts) = {
@@ -412,135 +474,68 @@ static int get_telemetry_log(int argc, char **argv, struct command *cmd, struct
 
 	if (!cfg.file_name) {
 		fprintf(stderr, "Please provide an output file!\n");
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
 	cfg.host_gen = !!cfg.host_gen;
-	hdr = malloc(bs);
-	page_log = malloc(bs);
-	if (!hdr || !page_log) {
-		perror("failed to allocate buf for log\n");
-		errno = ENOMEM;
-		err = -1;
-		goto free_mem;
-	}
-	memset(hdr, 0, bs);
-
 	output = open(cfg.file_name, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 	if (output < 0) {
 		fprintf(stderr, "Failed to open output file %s: %s!\n",
 				cfg.file_name, strerror(errno));
 		err = output;
-		goto free_mem;
+		goto close_fd;
 	}
 
-	err = nvme_get_telemetry_log(fd, hdr, cfg.host_gen, cfg.ctrl_init, bs, 0);
-	if (err < 0)
-		perror("get-telemetry-log");
-	else if (err > 0) {
-		nvme_show_status(err);
-		fprintf(stderr, "Failed to acquire telemetry header %d!\n", err);
-		goto close_output;
-	}
+	if (cfg.ctrl_init)
+		err = nvme_get_ctrl_telemetry(fd, true, &log, cfg.data_area, &total_size);
+	else if (cfg.host_gen)
+		err = nvme_get_new_host_telemetry(fd, &log, cfg.data_area, &total_size);
+	else
+		err = nvme_get_host_telemetry(fd, &log, cfg.data_area, &total_size);
 
-	err = write(output, (void *) hdr, bs);
-	if (err != bs) {
-		fprintf(stderr, "Failed to flush all data to file!\n");
+	if (err < 0) {
+		fprintf(stderr, "get-telemetry-log: %s\n",
+			nvme_strerror(errno));
+	} else if (err > 0) {
+		nvme_show_status(err);
+		fprintf(stderr, "Failed to acquire telemetry log %d!\n", err);
 		goto close_output;
 	}
 
-	switch (cfg.data_area) {
-	case 1:
-		full_size = (le16_to_cpu(hdr->dalb1) * bs) + offset;
-		break;
-	case 2:
-		full_size = (le16_to_cpu(hdr->dalb2) * bs) + offset;
-		break;
-	case 3:
-		full_size = (le16_to_cpu(hdr->dalb3) * bs) + offset;
-		break;
-	case 4:
-		err = nvme_identify_ctrl(fd, &ctrl);
-		if (err) {
-			perror("identify-ctrl");
-			goto close_output;
-		}
-
-		if (posix_memalign(&buf, getpagesize(), nvme_feat_buf_len[NVME_FEAT_HOST_BEHAVIOR])) {
-			fprintf(stderr, "can not allocate feature payload\n");
-			errno = ENOMEM;
-			err = -1;
-			goto close_output;
-		}
-		memset(buf, 0, nvme_feat_buf_len[NVME_FEAT_HOST_BEHAVIOR]);
-
-		err = nvme_get_feature(fd, NVME_NSID_ALL, NVME_FEAT_HOST_BEHAVIOR, 0, 0,
-				0, nvme_feat_buf_len[NVME_FEAT_HOST_BEHAVIOR], buf, &result);
-		if (err > 0) {
-			nvme_show_status(err);
-		} else if (err < 0) {
-			perror("get-feature");
-		} else {
-			if ((ctrl.lpa & 0x40)) {
-				if (((unsigned char *)buf)[1] == 1)
-					full_size = (le32_to_cpu(hdr->dalb4) * bs) + offset;
-				else {
-					fprintf(stderr, "Data area 4 unsupported, Host Behavior Support ETDAS not set to 1\n");
-					errno = EINVAL;
-					err = -1;
-				}
-			} else {
-				fprintf(stderr, "Data area 4 unsupported, bit 6 of Log Page Attributes not set\n");
-				errno = EINVAL;
-				err = -1;
-			}
-		}
-		free(buf);
-		if (err)
-			goto close_output;
-		break;
-	default:
-		fprintf(stderr, "Invalid data area requested\n");
-		errno = EINVAL;
-		err = -1;
-		goto close_output;
-	}
+	data_written = 0;
+	data_remaining = total_size;
+	data_ptr = (__u8 *)log;
 
-	/*
-	 * Continuously pull data until the offset hits the end of the last
-	 * block.
-	 */
-	while (offset != full_size) {
-		err = nvme_get_telemetry_log(fd, page_log, 0, cfg.ctrl_init, bs, offset);
-		if (err < 0) {
-			perror("get-telemetry-log");
+	while (data_remaining) {
+		data_written = write(output, data_ptr, data_remaining);
+		if (data_written < 0) {
+			data_remaining = data_written;
 			break;
-		} else if (err > 0) {
-			fprintf(stderr, "Failed to acquire full telemetry log!\n");
-			nvme_show_status(err);
+		} else if (data_written <= data_remaining) {
+			data_remaining -= data_written;
+			data_ptr += data_written;
+		} else {
+			/* Unexpected overwrite */
+			fprintf(stderr, "Failure: Unexpected telemetry log overwrite - data_remaining = 0x%x, data_written = 0x%x\n",
+					data_remaining, data_written);
 			break;
 		}
+	}
 
-		err = write(output, (void *) page_log, bs);
-		if (err != bs) {
-			fprintf(stderr, "Failed to flush all data to file!\n");
-			break;
-		}
-		err = 0;
-		offset += bs;
+	if (fsync(output) < 0) {
+		fprintf(stderr, "ERROR : %s: : fsync : %s\n", __func__, strerror(errno));
+		return -1;
 	}
 
+	free(log);
+
 close_output:
 	close(output);
-free_mem:
-	free(hdr);
-	free(page_log);
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int get_endurance_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -549,16 +544,16 @@ static int get_endurance_log(int argc, char **argv, struct command *cmd, struct
 	const char *desc = "Retrieves endurance groups log page and prints the log.";
 	const char *group_id = "The endurance group identifier";
 	enum nvme_print_flags flags;
-	int err = -1, fd;
+	int err, fd;
 
 	struct config {
-		char *output_format;
-		__u16 group_id;
+		char	*output_format;
+		__u16	group_id;
 	};
 
 	struct config cfg = {
-		.output_format = "normal",
-		.group_id = 0,
+		.output_format	= "normal",
+		.group_id	= 0,
 	};
 
 	OPT_ARGS(opts) = {
@@ -575,17 +570,38 @@ static int get_endurance_log(int argc, char **argv, struct command *cmd, struct
 	if (flags < 0)
 		goto close_fd;
 
-	err = nvme_endurance_log(fd, cfg.group_id, &endurance_log);
+	err = nvme_get_log_endurance_group(fd, cfg.group_id, &endurance_log);
 	if (!err)
 		nvme_show_endurance_log(&endurance_log, cfg.group_id, devicename, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("endurance log");
+		fprintf(stderr, "endurance log: %s\n", nvme_strerror(errno));
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
+}
+
+void collect_effects_log(int fd, enum nvme_csi csi, struct list_head *list, int flags)
+{
+	int err;
+	nvme_effects_log_node_t *node = malloc(sizeof(nvme_effects_log_node_t));
+	if (!node)
+		return;
+	node->csi = csi;
+
+	err = nvme_get_log_cmd_effects(fd, csi, &node->effects);
+	if (!err) {
+		list_add(list, &node->node);
+		return;
+	}
+	else if (err > 0)
+		nvme_show_status(err);
+	else
+		fprintf(stderr, "effects log page: %s\n", nvme_strerror(errno));
+
+	free(node);
 }
 
 static int get_effects_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -593,25 +609,34 @@ static int get_effects_log(int argc, char **argv, struct command *cmd, struct pl
 	const char *desc = "Retrieve command effects log page and print the table.";
 	const char *raw = "show log in binary format";
 	const char *human_readable = "show log in readable format";
-	struct nvme_effects_log_page effects;
+	const char *csi = "";
+	struct list_head log_pages;
+	nvme_effects_log_node_t *node;
+
+	void *bar = NULL;
 
 	int err = -1, fd;
 	enum nvme_print_flags flags;
 
 	struct config {
-		int   raw_binary;
-		int   human_readable;
-		char *output_format;
+		char	*output_format;
+		bool	human_readable;
+		bool	raw_binary;
+		int	csi;
 	};
 
 	struct config cfg = {
-		.output_format = "normal",
+		.output_format	= "normal",
+		.human_readable	= false,
+		.raw_binary	= false,
+		.csi		= -1,
 	};
 
 	OPT_ARGS(opts) = {
 		OPT_FMT("output-format",  'o', &cfg.output_format,  output_format),
 		OPT_FLAG("human-readable",'H', &cfg.human_readable, human_readable),
 		OPT_FLAG("raw-binary",    'b', &cfg.raw_binary,     raw),
+		OPT_INT("csi",            'c', &cfg.csi,            csi),
 		OPT_END()
 	};
 
@@ -627,17 +652,52 @@ static int get_effects_log(int argc, char **argv, struct command *cmd, struct pl
 	if (cfg.human_readable)
 		flags |= VERBOSE;
 
-	err = nvme_effects_log(fd, &effects);
-	if (!err)
-		nvme_show_effects_log(&effects, flags);
-	else if (err > 0)
-		nvme_show_status(err);
-	else
-		perror("effects log page");
+	list_head_init(&log_pages);
+
+	if (cfg.csi < 0) {
+		nvme_root_t nvme_root;
+		uint64_t cap;
+		int nvme_command_set_supported;
+		int other_command_sets_supported;
+		nvme_root = nvme_scan(NULL);
+		bar = mmap_registers(nvme_root, devicename);
+		nvme_free_tree(nvme_root);
+
+		if (!bar) {
+			goto close_fd;
+		}
+		cap = mmio_read64(bar + NVME_REG_CAP);
+		munmap(bar, getpagesize());
+
+		nvme_command_set_supported = NVME_CAP_CSS(cap) & NVME_CAP_CSS_NVM;
+		other_command_sets_supported = NVME_CAP_CSS(cap) & NVME_CAP_CSS_CSI;
+
+
+		if (nvme_command_set_supported) {
+			collect_effects_log(fd, NVME_CSI_NVM, &log_pages, flags);
+		}
+
+		if (other_command_sets_supported) {
+			collect_effects_log(fd, NVME_CSI_ZNS, &log_pages, flags);
+		}
+
+		nvme_print_effects_log_pages(&log_pages, flags);
+
+	}
+	else {
+		collect_effects_log(fd, cfg.csi, &log_pages, flags);
+		nvme_print_effects_log_pages(&log_pages, flags);
+	}
+
+
 close_fd:
+	while ((node = list_pop(&log_pages, nvme_effects_log_node_t, node))) {
+		free(node);
+	}
+
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int get_supported_log_pages(int argc, char **argv, struct command *cmd,
@@ -645,18 +705,19 @@ static int get_supported_log_pages(int argc, char **argv, struct command *cmd,
 {
 	const char *desc = "Retrieve supported logs and print the table.";
 	const char *verbose = "Increase output verbosity";
-	struct nvme_support_log_pages supports;
+	struct nvme_supported_log_pages supports;
 
 	int err = -1, fd;
 	enum nvme_print_flags flags;
 
 	struct config {
-		int   verbose;
-		char *output_format;
+		char	*output_format;
+		bool	verbose;
 	};
 
 	struct config cfg = {
-		.output_format = "normal",
+		.output_format	= "normal",
+		.verbose	= false
 	};
 
 	OPT_ARGS(opts) = {
@@ -676,18 +737,19 @@ static int get_supported_log_pages(int argc, char **argv, struct command *cmd,
 	if (cfg.verbose)
 		flags |= VERBOSE;
 
-	err = nvme_supported_log(fd, &supports);
+	err = nvme_get_log_supported_log_pages(fd, false, &supports);
 	if (!err)
 		nvme_show_supported_log(&supports, devicename, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("supported log pages");
+		fprintf(stderr, "supported log pages: %s",
+			nvme_strerror(errno));
 
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int get_error_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -703,14 +765,15 @@ static int get_error_log(int argc, char **argv, struct command *cmd, struct plug
 	int err = -1, fd;
 
 	struct config {
-		__u32 log_entries;
-		int   raw_binary;
-		char *output_format;
+		__u32	log_entries;
+		char	*output_format;
+		bool	raw_binary;
 	};
 
 	struct config cfg = {
-		.log_entries  = 64,
-		.output_format = "normal",
+		.log_entries	= 64,
+		.output_format	= "normal",
+		.raw_binary	= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -732,7 +795,6 @@ static int get_error_log(int argc, char **argv, struct command *cmd, struct plug
 
 	if (!cfg.log_entries) {
 		fprintf(stderr, "non-zero log-entries is required param\n");
-		errno = EINVAL;
 		err = -1;
 		goto close_fd;
 	}
@@ -743,7 +805,6 @@ static int get_error_log(int argc, char **argv, struct command *cmd, struct plug
 		goto close_fd;
 	} else if (err) {
 		fprintf(stderr, "could not identify controller\n");
-		errno = ENODEV;
 		err = -1;
 		goto close_fd;
 	}
@@ -751,13 +812,11 @@ static int get_error_log(int argc, char **argv, struct command *cmd, struct plug
 	cfg.log_entries = min(cfg.log_entries, ctrl.elpe + 1);
 	err_log = calloc(cfg.log_entries, sizeof(struct nvme_error_log_page));
 	if (!err_log) {
-		perror("could not alloc buffer for error log\n");
-		errno = ENOMEM;
 		err = -1;
 		goto close_fd;
 	}
 
-	err = nvme_error_log(fd, cfg.log_entries, err_log);
+	err = nvme_get_log_error(fd, cfg.log_entries, true, err_log);
 	if (!err)
 		nvme_show_error_log(err_log, cfg.log_entries, devicename, flags);
 	else if (err > 0)
@@ -768,7 +827,7 @@ static int get_error_log(int argc, char **argv, struct command *cmd, struct plug
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int get_fw_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -776,17 +835,18 @@ 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.";
 	const char *raw = "use binary output";
-	struct nvme_firmware_log_page fw_log;
+	struct nvme_firmware_slot fw_log;
 	enum nvme_print_flags flags;
-	int err = -1, fd;
+	int err, fd;
 
 	struct config {
-		int raw_binary;
-		char *output_format;
+		char	*output_format;
+		bool	raw_binary;
 	};
 
 	struct config cfg = {
-		.output_format = "normal",
+		.output_format	= "normal",
+		.raw_binary	= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -805,36 +865,37 @@ static int get_fw_log(int argc, char **argv, struct command *cmd, struct plugin
 	if (cfg.raw_binary)
 		flags = BINARY;
 
-	err = nvme_fw_log(fd, &fw_log);
+	err = nvme_get_log_fw_slot(fd, true, &fw_log);
 	if (!err)
 		nvme_show_fw_log(&fw_log, devicename, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("fw log");
+		fprintf(stderr, "fw log: %s\n", nvme_strerror(errno));
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int get_changed_ns_list_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
 {
-	struct nvme_changed_ns_list_log changed_ns_list_log;
 	const char *desc = "Retrieve Changed Namespaces log for the given device "\
 			"in either decoded format "\
 			"(default) or binary.";
 	const char *raw = "output in binary format";
+	struct nvme_ns_list changed_ns_list_log;
 	enum nvme_print_flags flags;
-	int err = -1, fd;
+	int err, fd;
 
 	struct config {
-		int   raw_binary;
-		char *output_format;
+		char	*output_format;
+		bool	raw_binary;
 	};
 
 	struct config cfg = {
-		.output_format = "normal",
+		.output_format	= "normal",
+		.raw_binary	= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -853,18 +914,19 @@ static int get_changed_ns_list_log(int argc, char **argv, struct command *cmd, s
 	if (cfg.raw_binary)
 		flags = BINARY;
 
-	err = nvme_changed_ns_list_log(fd, &changed_ns_list_log);
+	err = nvme_get_log_changed_ns_list(fd, true, &changed_ns_list_log);
 	if (!err)
 		nvme_show_changed_ns_list_log(&changed_ns_list_log, devicename,
 					      flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("changed ns list log");
+		fprintf(stderr, "changed ns list log: %s\n",
+			nvme_strerror(errno));
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int get_pred_lat_per_nvmset_log(int argc, char **argv,
@@ -875,25 +937,26 @@ static int get_pred_lat_per_nvmset_log(int argc, char **argv,
 			"format(default),json or binary.";
 	const char *nvmset_id = "NVM Set Identifier";
 	const char *raw = "use binary output";
-	struct nvme_predlat_per_nvmset_log_page plpns_log;
+	struct nvme_nvmset_predictable_lat_log plpns_log;
 	enum nvme_print_flags flags;
-	int err = -1, fd;
+	int err, fd;
 
 	struct config {
-		__u16 nvmset_id;
-		char *output_format;
-		int raw_binary;
+		__u16	nvmset_id;
+		char	*output_format;
+		bool	raw_binary;
 	};
 
 	struct config cfg = {
-		.nvmset_id = 1,
-		.output_format = "normal",
+		.nvmset_id	= 1,
+		.output_format	= "normal",
+		.raw_binary	= false,
 	};
 
 	OPT_ARGS(opts) = {
-		OPT_SHRT("nvmset-id", 	 'i', &cfg.nvmset_id,     nvmset_id),
+		OPT_SHRT("nvmset-id",	 'i', &cfg.nvmset_id,     nvmset_id),
 		OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
-		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary, 	  raw),
+		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,	  raw),
 		OPT_END()
 	};
 
@@ -907,20 +970,20 @@ static int get_pred_lat_per_nvmset_log(int argc, char **argv,
 	if (cfg.raw_binary)
 		flags = BINARY;
 
-	err = nvme_predictable_latency_per_nvmset_log(fd,
-		cfg.nvmset_id, &plpns_log);
+	err = nvme_get_log_predictable_lat_nvmset(fd, cfg.nvmset_id, &plpns_log);
 	if (!err)
 		nvme_show_predictable_latency_per_nvmset(&plpns_log,
 			cfg.nvmset_id, devicename, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("predictable latency per nvm set");
+		fprintf(stderr, "predictable latency per nvm set: %s\n",
+			nvme_strerror(errno));
 
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int get_pred_lat_event_agg_log(int argc, char **argv,
@@ -934,23 +997,24 @@ static int get_pred_lat_event_agg_log(int argc, char **argv,
 			"log Entries list";
 	const char *rae = "Retain an Asynchronous Event";
 	const char *raw = "use binary output";
-	void *pea_log;
-	struct nvme_id_ctrl ctrl;
 	enum nvme_print_flags flags;
-	int err = -1, fd;
+	struct nvme_id_ctrl ctrl;
 	__u32 log_size;
+	void *pea_log;
+	int err, fd;
 
 	struct config {
-		__u64 log_entries;
-		bool rae;
-		char *output_format;
-		int raw_binary;
+		__u64	log_entries;
+		bool	rae;
+		char	*output_format;
+		bool	raw_binary;
 	};
 
 	struct config cfg = {
-		.log_entries = 2044,
-		.rae = false,
-		.output_format = "normal",
+		.log_entries	= 2044,
+		.rae		= false,
+		.output_format	= "normal",
+		.raw_binary	= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -973,14 +1037,14 @@ static int get_pred_lat_event_agg_log(int argc, char **argv,
 
 	if (!cfg.log_entries) {
 		fprintf(stderr, "non-zero log-entries is required param\n");
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
 	err = nvme_identify_ctrl(fd, &ctrl);
 	if (err < 0) {
-		perror("identify controller");
+		fprintf(stderr, "identify controller: %s\n",
+			nvme_strerror(errno));
 		goto close_fd;
 	} else if (err) {
 		nvme_show_status(err);
@@ -991,28 +1055,25 @@ static int get_pred_lat_event_agg_log(int argc, char **argv,
 	log_size = sizeof(__u64) + cfg.log_entries * sizeof(__u16);
 	pea_log = calloc(log_size, 1);
 	if (!pea_log) {
-		perror("could not alloc buffer for predictable " \
-			"latency event agggregate log entries\n");
-		errno = ENOMEM;
-		err = -1;
+		err = -ENOMEM;
 		goto close_fd;
 	}
 
-	err = nvme_predictable_latency_event_agg_log(fd, pea_log, cfg.rae,
-		log_size);
+	err = nvme_get_log_predictable_lat_event(fd, cfg.rae, 0, log_size, pea_log);
 	if (!err)
 		nvme_show_predictable_latency_event_agg_log(pea_log, cfg.log_entries,
 			log_size, devicename, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("predictable latency event gggregate log page");
+		fprintf(stderr, "predictable latency event aggregate log page: %s",
+			nvme_strerror(errno));
 	free(pea_log);
 
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int get_persistent_event_log(int argc, char **argv,
@@ -1025,28 +1086,29 @@ static int get_persistent_event_log(int argc, char **argv,
 			" processing this persistent log page command.";
 	const char *log_len = "number of bytes to retrieve";
 	const char *raw = "use binary output";
-	void *pevent_log_info;
-	struct nvme_persistent_event_log_head *pevent_log_head, *collected_head;
+	struct nvme_persistent_event_log *pevent, *pevent_collected;
 	enum nvme_print_flags flags;
-	int err = -1, fd;
+	void *pevent_log_info;
+	int err, fd;
 	bool huge;
 
 	struct config {
-		__u8 action;
-		__u32 log_len;
-		int raw_binary;
-		char *output_format;
+		__u8	action;
+		__u32	log_len;
+		char	*output_format;
+		bool	raw_binary;
 	};
 
 	struct config cfg = {
-		.action = 0xff,
-		.log_len = 0,
-		.output_format = "normal",
+		.action		= 0xff,
+		.log_len	= 0,
+		.output_format	= "normal",
+		.raw_binary	= false,
 	};
 
 	OPT_ARGS(opts) = {
 		OPT_BYTE("action",       'a', &cfg.action,        action),
-		OPT_UINT("log_len", 	 'l', &cfg.log_len,  	  log_len),
+		OPT_UINT("log_len",	 'l', &cfg.log_len,	  log_len),
 		OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
 		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,    raw),
 		OPT_END()
@@ -1062,42 +1124,33 @@ static int get_persistent_event_log(int argc, char **argv,
 	if (cfg.raw_binary)
 		flags = BINARY;
 
-	if (cfg.action > 3) {
-		fprintf(stderr, "invalid action field: %u\n", cfg.action);
-		errno = EINVAL;
-		err = -1;
-		goto close_fd;
-	}
-
-	pevent_log_head = calloc(sizeof(*pevent_log_head), 1);
-	if (!pevent_log_head) {
-		perror("could not alloc buffer for persistent " \
-			"event log header\n");
-		errno = ENOMEM;
-		err = -1;
+	pevent = calloc(sizeof(*pevent), 1);
+	if (!pevent) {
+		err = -ENOMEM;
 		goto close_fd;
 	}
 
-	err = nvme_persistent_event_log(fd, cfg.action,
-			sizeof(*pevent_log_head), pevent_log_head);
+	err = nvme_get_log_persistent_event(fd, cfg.action,
+			sizeof(*pevent), pevent);
 	if (err < 0) {
-		perror("persistent event log");
-		goto free_head;
+		fprintf(stderr, "persistent event log: %s\n",
+			nvme_strerror(errno));
+		goto free_pevent;
 	} else if (err) {
 		nvme_show_status(err);
-		goto free_head;
+		goto free_pevent;
 	}
 
 	if (cfg.action == NVME_PEVENT_LOG_RELEASE_CTX) {
 		printf("Releasing Persistent Event Log Context\n");
-		goto free_head;
+		goto free_pevent;
 	}
 
 	if (!cfg.log_len && cfg.action != NVME_PEVENT_LOG_EST_CTX_AND_READ) {
-		cfg.log_len = le64_to_cpu(pevent_log_head->tll);
+		cfg.log_len = le64_to_cpu(pevent->tll);
 	} else if (!cfg.log_len && cfg.action == NVME_PEVENT_LOG_EST_CTX_AND_READ) {
 		printf("Establishing Persistent Event Log Context\n");
-		goto free_head;
+		goto free_pevent;
 	}
 
 	/*
@@ -1112,45 +1165,45 @@ static int get_persistent_event_log(int argc, char **argv,
 
 	pevent_log_info = nvme_alloc(cfg.log_len, &huge);
 	if (!pevent_log_info) {
-		perror("could not alloc buffer for persistent event log page\n");
-		errno = ENOMEM;
-		err = -1;
-		goto free_head;
+		err = -ENOMEM;
+		goto free_pevent;
 	}
-	err = nvme_persistent_event_log(fd, cfg.action,
+	err = nvme_get_log_persistent_event(fd, cfg.action,
 		cfg.log_len, pevent_log_info);
 	if (!err) {
-		err = nvme_persistent_event_log(fd, cfg.action,
-				sizeof(*pevent_log_head), pevent_log_head);
+		err = nvme_get_log_persistent_event(fd, cfg.action,
+				sizeof(*pevent), pevent);
 		if (err < 0) {
-			perror("persistent event log");
+			fprintf(stderr, "persistent event log: %s\n",
+				nvme_strerror(errno));
 			goto free;
 		} else if (err) {
 			nvme_show_status(err);
 			goto free;
 		}
-		collected_head = pevent_log_info;
-		if(collected_head->gen_number != pevent_log_head->gen_number) {
+		pevent_collected = pevent_log_info;
+		if (pevent_collected->gen_number != pevent->gen_number) {
 			printf("Collected Persistent Event Log may be invalid, "\
 				"Re-read the log is reiquired\n");
 			goto free;
 		}
+
 		nvme_show_persistent_event_log(pevent_log_info, cfg.action,
 			cfg.log_len, devicename, flags);
-	}
-	else if (err > 0)
+	} else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("persistent event log");
+		fprintf(stderr, "persistent event log: %s\n",
+			nvme_strerror(errno));
 
 free:
 	nvme_free(pevent_log_info, huge);
-free_head:
-	free(pevent_log_head);
+free_pevent:
+	free(pevent);
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int get_endurance_event_agg_log(int argc, char **argv,
@@ -1167,20 +1220,21 @@ static int get_endurance_event_agg_log(int argc, char **argv,
 	void *endurance_log;
 	struct nvme_id_ctrl ctrl;
 	enum nvme_print_flags flags;
-	int err = -1, fd;
+	int err, fd;
 	__u32 log_size;
 
 	struct config {
-		__u64 log_entries;
-		bool rae;
-		char *output_format;
-		int raw_binary;
+		__u64	log_entries;
+		bool	rae;
+		char	*output_format;
+		bool	raw_binary;
 	};
 
 	struct config cfg = {
-		.log_entries = 2044,
-		.rae = false,
-		.output_format = "normal",
+		.log_entries	= 2044,
+		.rae		= false,
+		.output_format	= "normal",
+		.raw_binary	= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -1203,19 +1257,18 @@ static int get_endurance_event_agg_log(int argc, char **argv,
 
 	if (!cfg.log_entries) {
 		fprintf(stderr, "non-zero log-entries is required param\n");
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
 	err = nvme_identify_ctrl(fd, &ctrl);
 	if (err < 0) {
-		perror("identify controller");
+		fprintf(stderr, "identify controller: %s\n",
+			nvme_strerror(errno));
 		goto close_fd;
 	} else if (err) {
 		fprintf(stderr, "could not identify controller\n");
-		errno = ENODEV;
-		err = -1;
+		err = -ENODEV;
 		goto close_fd;
 	}
 
@@ -1223,28 +1276,25 @@ static int get_endurance_event_agg_log(int argc, char **argv,
 	log_size = sizeof(__u64) + cfg.log_entries * sizeof(__u16);
 	endurance_log = calloc(log_size, 1);
 	if (!endurance_log) {
-		perror("could not alloc buffer for endurance group" \
-			" event agggregate log entries\n");
-		errno = ENOMEM;
-		err = -1;
+		err = -ENOMEM;
 		goto close_fd;
 	}
 
-	err = nvme_endurance_group_event_agg_log(fd, endurance_log, cfg.rae,
-		log_size);
+	err = nvme_get_log_endurance_grp_evt(fd, cfg.rae, 0, log_size, endurance_log);
 	if (!err)
 		nvme_show_endurance_group_event_agg_log(endurance_log, cfg.log_entries,
 			log_size, devicename, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("endurance group event aggregate log page");
+		fprintf(stderr, "endurance group event aggregate log page: %s\n",
+			nvme_strerror(errno));
 	free(endurance_log);
 
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int get_lba_status_log(int argc, char **argv,
@@ -1256,17 +1306,17 @@ static int get_lba_status_log(int argc, char **argv,
 	const char *rae = "Retain an Asynchronous Event";
 	void *lab_status;
 	enum nvme_print_flags flags;
-	int err = -1, fd;
+	int err, fd;
 	__u32 lslplen;
 
 	struct config {
-		bool rae;
-		char *output_format;
+		bool	rae;
+		char	*output_format;
 	};
 
 	struct config cfg = {
-		.rae = false,
-		.output_format = "normal",
+		.rae		= false,
+		.output_format	= "normal",
 	};
 
 	OPT_ARGS(opts) = {
@@ -1283,9 +1333,10 @@ static int get_lba_status_log(int argc, char **argv,
 	if (flags < 0)
 		goto close_fd;
 
-	err = nvme_lba_status_log(fd, &lslplen, true, sizeof(__u32));
+	err = nvme_get_log_lba_status(fd, true, 0, sizeof(__u32), &lslplen);
 	if (err < 0) {
-		perror("lba status log page");
+		fprintf(stderr, "lba status log page: %s\n",
+			nvme_strerror(errno));
 		goto close_fd;
 	} else if (err) {
 		nvme_show_status(err);
@@ -1294,25 +1345,24 @@ static int get_lba_status_log(int argc, char **argv,
 
 	lab_status = calloc(lslplen, 1);
 	if (!lab_status) {
-		perror("could not alloc buffer for lba status log");
-		errno = ENOMEM;
-		err = -1;
+		err = -ENOMEM;
 		goto close_fd;
 	}
 
-	err = nvme_lba_status_log(fd, lab_status, cfg.rae, lslplen);
+	err = nvme_get_log_lba_status(fd, cfg.rae, 0, lslplen, lab_status);
 	if (!err)
 		nvme_show_lba_status_log(lab_status, lslplen, devicename, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("lba status log page");
+		fprintf(stderr, "lba status log page: %s\n",
+			nvme_strerror(errno));
 	free(lab_status);
 
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int get_resv_notif_log(int argc, char **argv,
@@ -1323,16 +1373,16 @@ static int get_resv_notif_log(int argc, char **argv,
 		"log page and prints it, for the given " \
 		"device in either decoded format(default), " \
 		"json or binary.";
-	struct nvme_resv_notif_log resv;
+	struct nvme_resv_notification_log resv;
 	enum nvme_print_flags flags;
-	int err = -1, fd;
+	int err, fd;
 
 	struct config {
-		char *output_format;
+		char	*output_format;
 	};
 
 	struct config cfg = {
-		.output_format = "normal",
+		.output_format	= "normal",
 	};
 
 	OPT_ARGS(opts) = {
@@ -1348,18 +1398,19 @@ static int get_resv_notif_log(int argc, char **argv,
 	if (flags < 0)
 		goto close_fd;
 
-	err = nvme_resv_notif_log(fd, &resv);
+	err = nvme_get_log_reservation(fd, true, &resv);
 	if (!err)
 		nvme_show_resv_notif_log(&resv, devicename, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("resv notifi log");
+		fprintf(stderr, "resv notifi log: %s\n",
+			nvme_strerror(errno));
 
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 
 }
 
@@ -1371,22 +1422,22 @@ static int get_boot_part_log(int argc, char **argv, struct command *cmd, struct
 		"json or binary.";
 	const char *lsp = "log specific field";
 	const char *fname = "boot partition data output file name";
-	struct nvme_boot_part_hdr boot;
+	struct nvme_boot_partition boot;
 	__u8 *bp_log;
 	enum nvme_print_flags flags;
 	int err = -1, fd = 0, output = 0;
 	__u32 bpsz = 0;
 
 	struct config {
-		__u8 lsp;
-		char *output_format;
-		char *file_name;
+		__u8	lsp;
+		char	*file_name;
+		char	*output_format;
 	};
 
 	struct config cfg = {
-		.lsp = 0,
-		.file_name = NULL,
-		.output_format = "normal",
+		.lsp		= 0,
+		.output_format	= "normal",
+		.file_name	= NULL,
 	};
 
 	OPT_ARGS(opts) = {
@@ -1406,14 +1457,12 @@ static int get_boot_part_log(int argc, char **argv, struct command *cmd, struct
 
 	if (!cfg.file_name) {
 		fprintf(stderr, "Please provide an output file!\n");
-		errno = EINVAL;
 		err = -1;
 		goto close_fd;
 	}
 
 	if (cfg.lsp > 128) {
 		fprintf(stderr, "invalid lsp param: %u\n", cfg.lsp);
-		errno = EINVAL;
 		err = -1;
 		goto close_fd;
 	}
@@ -1426,9 +1475,11 @@ static int get_boot_part_log(int argc, char **argv, struct command *cmd, struct
 		goto close_fd;
 	}
 
-	err = nvme_boot_part_log(fd, cfg.lsp, &boot, sizeof(boot));
+	err = nvme_get_log_boot_partition(fd, false, cfg.lsp,
+					  sizeof(boot), &boot);
 	if (err < 0) {
-		perror("boot partition log");
+		fprintf(stderr, "boot partition log: %s\n",
+			nvme_strerror(errno));
 		goto close_output;
 	} else if (err) {
 		nvme_show_status(err);
@@ -1438,19 +1489,20 @@ static int get_boot_part_log(int argc, char **argv, struct command *cmd, struct
 	bpsz = (boot.bpinfo & 0x7fff) * 128 * 1024;
 	bp_log = calloc(sizeof(boot) + bpsz, 1);
 	if (!bp_log) {
-		perror("could not alloc buffer for boot partition log");
-		errno = ENOMEM;
 		err = -1;
 		goto close_output;
 	}
 
-	err = nvme_boot_part_log(fd, cfg.lsp, &bp_log, sizeof(boot) + bpsz);
+	err = nvme_get_log_boot_partition(fd, false, cfg.lsp,
+					  sizeof(boot) + bpsz,
+					  (struct nvme_boot_partition *)bp_log);
 	if (!err)
 		nvme_show_boot_part_log(&bp_log, devicename, flags, sizeof(boot) + bpsz);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("boot partition log");
+		fprintf(stderr, "boot partition log: %s\n",
+			nvme_strerror(errno));
 
 	err = write(output, (void *) bp_log + sizeof(boot), bpsz);
 	if (err != bpsz) {
@@ -1467,7 +1519,118 @@ close_output:
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
+}
+
+static int get_media_unit_stat_log(int argc, char **argv, struct command *cmd,
+				   struct plugin *plugin)
+{
+	const char *desc = "Retrieve the configuration and wear of media units and print it";
+	const char *domainid = "Domain Identifier";
+	const char *raw = "use binary output";
+	struct nvme_media_unit_stat_log mus;
+
+	int err = -1, fd;
+	enum nvme_print_flags flags;
+
+	struct config {
+		__u16	domainid;
+		char	*output_format;
+		bool	raw_binary;
+	};
+
+	struct config cfg = {
+		.domainid	= 0,
+		.output_format	= "normal",
+		.raw_binary	= false,
+	};
+
+	OPT_ARGS(opts) = {
+		OPT_UINT("domain-id",     'd', &cfg.domainid, domainid),
+		OPT_FMT("output-format",  'o', &cfg.output_format, output_format),
+		OPT_FLAG("raw-binary",    'b', &cfg.raw_binary, raw),
+		OPT_END()
+	};
+
+	err = fd = parse_and_open(argc, argv, desc, opts);
+	if (fd < 0)
+		goto ret;
+
+	err = flags = validate_output_format(cfg.output_format);
+	if (flags < 0)
+		goto close_fd;
+
+	if (cfg.raw_binary)
+		flags = BINARY;
+
+	err = nvme_get_log_media_unit_stat(fd, cfg.domainid, &mus);
+	if (!err)
+		nvme_show_media_unit_stat_log(&mus, flags);
+	else if (err > 0)
+		nvme_show_status(err);
+	else
+		fprintf(stderr, "media unit status log: %s\n",
+			nvme_strerror(errno));
+
+close_fd:
+	close(fd);
+ret:
+	return err;
+}
+
+static int get_supp_cap_config_log(int argc, char **argv, struct command *cmd,
+				   struct plugin *plugin)
+{
+	const char *desc = "Retrieve the list of Supported Capacity Configuration Descriptors";
+	const char *domainid = "Domain Identifier";
+	const char *raw = "use binary output";
+	struct nvme_supported_cap_config_list_log cap_log;
+
+	int err = -1, fd;
+	enum nvme_print_flags flags;
+
+	struct config {
+		__u16	domainid;
+		char	*output_format;
+		bool	raw_binary;
+	};
+
+	struct config cfg = {
+		.domainid	= 0,
+		.output_format	= "normal",
+		.raw_binary	= false,
+	};
+
+	OPT_ARGS(opts) = {
+		OPT_UINT("domain-id",     'd', &cfg.domainid,       domainid),
+		OPT_FMT("output-format",  'o', &cfg.output_format,  output_format),
+		OPT_FLAG("raw-binary",    'b', &cfg.raw_binary,     raw),
+		OPT_END()
+	};
+
+	err = fd = parse_and_open(argc, argv, desc, opts);
+	if (fd < 0)
+		goto ret;
+
+	err = flags = validate_output_format(cfg.output_format);
+	if (flags < 0)
+		goto close_fd;
+
+	if (cfg.raw_binary)
+		flags = BINARY;
+
+	err = nvme_get_log_support_cap_config_list(fd, cfg.domainid, &cap_log);
+	if (!err)
+		nvme_show_supported_cap_config_log(&cap_log, flags);
+	else if (err > 0)
+		nvme_show_status(err);
+	else
+		perror("supported capacity configuration list log");
+
+close_fd:
+	close(fd);
+ret:
+	return err;
 }
 
 static int get_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -1487,35 +1650,37 @@ static int get_log(int argc, char **argv, struct command *cmd, struct plugin *pl
 	const char *uuid_index = "UUID index";
 	const char *csi = "command set identifier";
 	const char *offset_type = "offset type";
-	int err = -1, fd;
+	int err, fd;
 	unsigned char *log;
 
 	struct config {
-		__u16 lsi;
-		__u32 namespace_id;
-		__u8  log_id;
-		__u32 log_len;
-		__u32 aen;
-		__u64 lpo;
-		__u8  lsp;
-		__u8  uuid_index;
-		__u8  csi;
-		int   ot;
-		int   rae;
-		int   raw_binary;
+		__u32	namespace_id;
+		__u8	log_id;
+		__u32	log_len;
+		__u32	aen;
+		__u64	lpo;
+		__u8	lsp;
+		__u16	lsi;
+		bool	rae;
+		__u8	uuid_index;
+		bool	raw_binary;
+		__u8	csi;
+		bool	ot;
 	};
 
 	struct config cfg = {
-		.namespace_id = NVME_NSID_ALL,
-		.log_id       = 0xff,
-		.log_len      = 0,
-		.lpo          = NVME_NO_LOG_LPO,
-		.lsp          = NVME_NO_LOG_LSP,
-		.lsi          = 0,
-		.rae          = 0,
-		.uuid_index   = 0,
-		.csi          = 0,
-		.ot           = 0,
+		.namespace_id	= NVME_NSID_ALL,
+		.log_id		= 0xff,
+		.log_len	= 0,
+		.aen		= 0,
+		.lpo		= NVME_LOG_LPO_NONE,
+		.lsp		= NVME_LOG_LSP_NONE,
+		.lsi		= NVME_LOG_LSI_NONE,
+		.rae		= false,
+		.uuid_index	= NVME_UUID_NONE,
+		.raw_binary	= false,
+		.csi		= NVME_CSI_NVM,
+		.ot		= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -1528,9 +1693,9 @@ static int get_log(int argc, char **argv, struct command *cmd, struct plugin *pl
 		OPT_SHRT("lsi",          'S', &cfg.lsi,          lsi),
 		OPT_FLAG("rae",          'r', &cfg.rae,          rae),
 		OPT_BYTE("uuid-index",   'U', &cfg.uuid_index,   uuid_index),
+		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,   raw),
 		OPT_BYTE("csi",          'y', &cfg.csi,          csi),
 		OPT_FLAG("ot",           'O', &cfg.ot,           offset_type),
-		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,   raw),
 		OPT_END()
 	};
 
@@ -1544,23 +1709,20 @@ static int get_log(int argc, char **argv, struct command *cmd, struct plugin *pl
 	}
 
 	if (!cfg.log_len) {
-		fprintf(stderr, "non-zero log-len is required param\n");
-		errno = EINVAL;
-		err = -1;
+		perror("non-zero log-len is required param\n");
+		err = -EINVAL;
 		goto close_fd;
 	}
 
 	if (cfg.lsp > 128) {
-		fprintf(stderr, "invalid lsp param: %u\n", cfg.lsp);
-		errno = EINVAL;
-		err = -1;
+		perror("invalid lsp param\n");
+		err = -EINVAL;
 		goto close_fd;
 	}
 
 	if (cfg.uuid_index > 128) {
-		fprintf(stderr, "invalid uuid index param: %u\n", cfg.uuid_index);
-		errno = EINVAL;
-		err = -1;
+		perror("invalid uuid index param\n");
+		err = -EINVAL;
 		goto close_fd;
 	}
 
@@ -1571,27 +1733,42 @@ static int get_log(int argc, char **argv, struct command *cmd, struct plugin *pl
 		goto close_fd;
 	}
 
-	err = nvme_get_log14(fd, cfg.namespace_id, cfg.log_id,
-					cfg.lsp, cfg.lpo, cfg.lsi, cfg.rae,
-					cfg.uuid_index, cfg.csi, cfg.ot, cfg.log_len, log);
+	struct nvme_get_log_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.lid		= cfg.log_id,
+		.nsid		= cfg.namespace_id,
+		.lpo		= cfg.lpo,
+		.lsp		= cfg.lsp,
+		.lsi		= cfg.lsi,
+		.rae		= cfg.rae,
+		.uuidx		= cfg.uuid_index,
+		.csi		= cfg.csi,
+		.ot		= cfg.ot,
+		.len		= cfg.log_len,
+		.log		= log,
+		.timeout        = NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= NULL,
+	};
+	err = nvme_get_log(&args);
 	if (!err) {
 		if (!cfg.raw_binary) {
 			printf("Device:%s log-id:%d namespace-id:%#x\n",
-					devicename, cfg.log_id,
-					cfg.namespace_id);
+				devicename, cfg.log_id,
+				cfg.namespace_id);
 			d(log, cfg.log_len, 16, 1);
 		} else
 			d_raw((unsigned char *)log, cfg.log_len);
 	} else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("log page");
+		fprintf(stderr, "log page: %s\n", nvme_strerror(errno));
 	free(log);
 
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int sanitize_log(int argc, char **argv, struct command *command, struct plugin *plugin)
@@ -1602,18 +1779,20 @@ static int sanitize_log(int argc, char **argv, struct command *command, struct p
 	const char *human_readable = "show log in readable format";
 	struct nvme_sanitize_log_page sanitize_log;
 	enum nvme_print_flags flags;
-	int fd, err = -1;
+	int fd, err;
 
 	struct config {
-		bool  rae;
-		int   raw_binary;
-		int   human_readable;
-		char *output_format;
+		bool	rae;
+		char	*output_format;
+		bool	human_readable;
+		bool	raw_binary;
 	};
 
 	struct config cfg = {
-		.rae = false,
-		.output_format = "normal",
+		.rae		= false,
+		.output_format	= "normal",
+		.human_readable	= false,
+		.raw_binary	= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -1636,17 +1815,18 @@ static int sanitize_log(int argc, char **argv, struct command *command, struct p
 	if (cfg.human_readable)
 		flags |= VERBOSE;
 
-	err = nvme_sanitize_log(fd, cfg.rae, &sanitize_log);
+	err = nvme_get_log_sanitize(fd, cfg.rae, &sanitize_log);
 	if (!err)
 		nvme_show_sanitize_log(&sanitize_log, devicename, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("sanitize status log");
+		fprintf(stderr, "sanitize status log: %s\n",
+			nvme_strerror(errno));
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int get_fid_support_effects_log(int argc, char **argv, struct command *cmd,
@@ -1654,17 +1834,18 @@ static int get_fid_support_effects_log(int argc, char **argv, struct command *cm
 {
 	const char *desc = "Retrieve FID Support and Effects log and show it.";
 	const char *human_readable = "show log in readable format";
-	struct nvme_fid_support_effects fid_support_log;
+	struct nvme_fid_supported_effects_log fid_support_log;
 	enum nvme_print_flags flags;
 	int fd, err = -1;
 
 	struct config {
-		int   human_readable;
-		char *output_format;
+		char	*output_format;
+		bool	human_readable;
 	};
 
 	struct config cfg = {
-		.output_format = "normal",
+		.output_format	= "normal",
+		.human_readable	= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -1683,17 +1864,67 @@ static int get_fid_support_effects_log(int argc, char **argv, struct command *cm
 	if (cfg.human_readable)
 		flags |= VERBOSE;
 
-	err = nvme_fid_support_effects_log(fd, &fid_support_log);
+	err = nvme_get_log_fid_supported_effects(fd, false, &fid_support_log);
 	if (!err)
 		nvme_show_fid_support_effects_log(&fid_support_log, devicename, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("fid support effects log");
+		fprintf(stderr, "fid support effects log: %s\n",
+			nvme_strerror(errno));
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
+}
+
+static int get_mi_cmd_support_effects_log(int argc, char **argv, struct command *cmd,
+	struct plugin *plugin)
+{
+	const char *desc = "Retrieve NVMe-MI Command Support and Effects log and show it.";
+	const char *human_readable = "show log in readable format";
+	struct nvme_mi_cmd_supported_effects_log mi_cmd_support_log;
+	enum nvme_print_flags flags;
+	int fd, err = -1;
+
+	struct config {
+		char	*output_format;
+		bool	human_readable;
+	};
+
+	struct config cfg = {
+		.output_format	= "normal",
+		.human_readable	= false,
+	};
+
+	OPT_ARGS(opts) = {
+		OPT_FMT("output-format",  'o', &cfg.output_format,  output_format),
+		OPT_FLAG("human-readable",'H', &cfg.human_readable, human_readable),
+		OPT_END()
+	};
+
+	err = fd = parse_and_open(argc, argv, desc, opts);
+	if (fd < 0)
+		goto ret;
+
+	err = flags = validate_output_format(cfg.output_format);
+	if (flags < 0)
+		goto close_fd;
+	if (cfg.human_readable)
+		flags |= VERBOSE;
+
+	err = nvme_get_log_mi_cmd_supported_effects(fd, false, &mi_cmd_support_log);
+	if (!err)
+		nvme_show_mi_cmd_support_effects_log(&mi_cmd_support_log, devicename, flags);
+	else if (err > 0)
+		nvme_show_status(err);
+	else
+		fprintf(stderr, "mi command support effects log: %s\n",
+			nvme_strerror(errno));
+close_fd:
+	close(fd);
+ret:
+	return err;
 }
 
 static int list_ctrl(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -1702,19 +1933,20 @@ static int list_ctrl(int argc, char **argv, struct command *cmd, struct plugin *
 		"given device is part of, or optionally controllers attached to a specific namespace.";
 	const char *controller = "controller to display";
 	const char *namespace_id = "optional namespace attached to controller";
-	int err = -1, fd;
-	struct nvme_controller_list *cntlist;
+	int err, fd;
+	struct nvme_ctrl_list *cntlist;
 	enum nvme_print_flags flags;
 
 	struct config {
-		__u16 cntid;
-		__u32 namespace_id;
-		char *output_format;
+		__u16	cntid;
+		__u32	namespace_id;
+		char	*output_format;
 	};
 
 	struct config cfg = {
-		.cntid = 0,
-		.output_format = "normal",
+		.cntid		= 0,
+		.namespace_id	= NVME_NSID_NONE,
+		.output_format	= "normal",
 	};
 
 	OPT_ARGS(opts) = {
@@ -1731,31 +1963,31 @@ static int list_ctrl(int argc, char **argv, struct command *cmd, struct plugin *
 	err = flags = validate_output_format(cfg.output_format);
 	if (flags < 0)
 		goto close_fd;
-	if (flags != JSON && flags != NORMAL) {
-		err = -EINVAL;
-		goto close_fd;
-	}
 
 	if (posix_memalign((void *)&cntlist, getpagesize(), 0x1000)) {
 		fprintf(stderr, "can not allocate controller list payload\n");
-		errno = ENOMEM;
-		err = -1;
+		err = -ENOMEM;
 		goto close_fd;
 	}
 
-	err = nvme_identify_ctrl_list(fd, cfg.namespace_id, cfg.cntid, cntlist);
+	if (cfg.namespace_id == NVME_NSID_NONE)
+                 err = nvme_identify_ctrl_list(fd, cfg.cntid, cntlist);
+        else
+                 err = nvme_identify_nsid_ctrl_list(fd, cfg.namespace_id,
+					   cfg.cntid, cntlist);
 	if (!err)
 		nvme_show_list_ctrl(cntlist, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("id controller list");
+		fprintf(stderr, "id controller list: %s\n",
+			nvme_strerror(errno));
 
 	free(cntlist);
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int list_ns(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -1765,25 +1997,27 @@ static int list_ns(int argc, char **argv, struct command *cmd, struct plugin *pl
 	const char *namespace_id = "first nsid returned list should start from";
 	const char *csi = "I/O command set identifier";
 	const char *all = "show all namespaces in the subsystem, whether attached or inactive";
-	int err = -1, fd;
-	__le32 ns_list[1024];
+	int err, fd;
+	struct nvme_ns_list ns_list;
 	enum nvme_print_flags flags;
 
 	struct config {
-		__u32 namespace_id;
-		int  all;
-		__u8 csi;
-		char *output_format;
+		__u32	namespace_id;
+		int	csi;
+		bool	all;
+		char	*output_format;
 	};
 
 	struct config cfg = {
-		.namespace_id = 1,
+		.namespace_id	= 1,
+		.csi		= -1,
+		.all		= false,
 		.output_format = "normal",
 	};
 
 	OPT_ARGS(opts) = {
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id,  namespace_id),
-		OPT_BYTE("csi",          'y', &cfg.csi,           csi),
+		OPT_INT("csi",           'y', &cfg.csi,           csi),
 		OPT_FLAG("all",          'a', &cfg.all,           all),
 		OPT_FMT("output-format", 'o', &cfg.output_format, output_format_no_binary),
 		OPT_END()
@@ -1802,20 +2036,95 @@ static int list_ns(int argc, char **argv, struct command *cmd, struct plugin *pl
 	}
 
 	if (!cfg.namespace_id) {
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		fprintf(stderr, "invalid nsid parameter\n");
 		goto close_fd;
 	}
 
-	err = nvme_identify_ns_list_csi(fd, cfg.namespace_id - 1, cfg.csi,
-					!!cfg.all, ns_list);
+	if (cfg.csi < 0) {
+		if (cfg.all)
+			err = nvme_identify_allocated_ns_list(fd,
+				cfg.namespace_id - 1, &ns_list);
+		else
+			err = nvme_identify_active_ns_list(fd,
+				cfg.namespace_id - 1, &ns_list);
+
+	} else {
+		if (cfg.all)
+			err = nvme_identify_allocated_ns_list_csi(fd,
+				cfg.namespace_id - 1, cfg.csi, &ns_list);
+		else
+			err = nvme_identify_active_ns_list_csi(fd,
+				cfg.namespace_id - 1, cfg.csi, &ns_list);
+	}
+
+	if (!err)
+		nvme_show_list_ns(&ns_list, flags);
+	else if (err > 0)
+		nvme_show_status(err);
+	else
+		fprintf(stderr, "id namespace list: %s",
+			nvme_strerror(errno));
+close_fd:
+	close(fd);
+ret:
+	return err;
+}
+
+static int id_ns_lba_format(int argc, char **argv, struct command *cmd, struct plugin *plugin)
+{
+	const char *desc = "Send an Identify Namespace command to the given "\
+		"device, returns capability field properties of the specified "\
+		"LBA Format index in  various formats.";
+	const char *lba_format_index = "The index into the LBA Format list "\
+		"identifying the LBA Format capabilities that are to be returned";
+	const char *uuid_index = "UUID index";
+	const char *verbose = "Increase output verbosity";
+	enum nvme_print_flags flags;
+	struct nvme_id_ns ns;
+	int err = -1, fd;
+
+	struct config {
+		__u16	lba_format_index;
+		__u8	uuid_index;
+		bool	verbose;
+		char	*output_format;
+	};
+
+	struct config cfg = {
+		.lba_format_index	= 0,
+		.uuid_index		= NVME_UUID_NONE,
+		.verbose		= false,
+		.output_format		= "normal",
+	};
+
+	OPT_ARGS(opts) = {
+		OPT_UINT("lba-format-index", 'i', &cfg.lba_format_index, lba_format_index),
+		OPT_BYTE("uuid-index",       'U', &cfg.uuid_index,       uuid_index),
+		OPT_FLAG("verbose",          'v', &cfg.verbose,          verbose),
+		OPT_FMT("output-format",     'o', &cfg.output_format,    output_format),
+		OPT_END()
+	};
+
+	err = fd = parse_and_open(argc, argv, desc, opts);
+	if (fd < 0)
+		goto ret;
+
+	err = flags = validate_output_format(cfg.output_format);
+	if (flags < 0)
+		goto close_fd;
+
+	if (cfg.verbose)
+		flags |= VERBOSE;
+
+	err = nvme_identify_ns_csi_user_data_format(fd, cfg.lba_format_index,
+										cfg.uuid_index, NVME_CSI_NVM, &ns);
 	if (!err)
-		nvme_show_list_ns(ns_list, flags);
+		nvme_show_id_ns(&ns, 0, cfg.lba_format_index, true, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("id namespace list");
+		perror("identify namespace for specific LBA format");
 close_fd:
 	close(fd);
 ret:
@@ -1829,17 +2138,17 @@ static int id_endurance_grp_list(int argc, char **argv, struct command *cmd,
 		"group id";
 	const char *endurance_grp_id = "Endurance Group ID";
 	int err = -1, fd;
-	struct nvme_endurance_group_list *endgrp_list;
+	struct nvme_id_endurance_group_list *endgrp_list;
 	enum nvme_print_flags flags;
 
 	struct config {
-		__u16 endgrp_id;
-		char *output_format;
+		__u16	endgrp_id;
+		char	*output_format;
 	};
 
 	struct config cfg = {
-		.endgrp_id = 0,
-		.output_format = "normal",
+		.endgrp_id	= 0,
+		.output_format	= "normal",
 	};
 
 	OPT_ARGS(opts) = {
@@ -1862,8 +2171,6 @@ static int id_endurance_grp_list(int argc, char **argv, struct command *cmd,
 	}
 
 	if (posix_memalign((void *)&endgrp_list, getpagesize(), 0x1000)) {
-		fprintf(stderr, "can not allocate memory for endurance gropu list\n");
-		errno = ENOMEM;
 		err = -1;
 		goto close_fd;
 	}
@@ -1874,13 +2181,14 @@ static int id_endurance_grp_list(int argc, char **argv, struct command *cmd,
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("id endurance group list");
+		fprintf(stderr, "Id endurance group list: %s",
+			nvme_strerror(errno));
 
 	free(endgrp_list);
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int delete_ns(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -1893,7 +2201,7 @@ static int delete_ns(int argc, char **argv, struct command *cmd, struct plugin *
 		"the namespace is not already inactive, once deleted.";
 	const char *namespace_id = "namespace to delete";
 	const char *timeout = "timeout value, in milliseconds";
-	int err = -1, fd;
+	int err, fd;
 
 	struct config {
 		__u32	namespace_id;
@@ -1902,7 +2210,7 @@ static int delete_ns(int argc, char **argv, struct command *cmd, struct plugin *
 
 	struct config cfg = {
 		.namespace_id	= 0,
-		.timeout	= NVME_IOCTL_TIMEOUT,
+		.timeout	= 120000,
 	};
 
 	OPT_ARGS(opts) = {
@@ -1916,44 +2224,46 @@ static int delete_ns(int argc, char **argv, struct command *cmd, struct plugin *
 		goto ret;
 
 	if (!cfg.namespace_id) {
-		err = cfg.namespace_id = nvme_get_nsid(fd);
+		err = nvme_get_nsid(fd, &cfg.namespace_id);
 		if (err < 0) {
-			perror("get-namespace-id");
+			fprintf(stderr, "get-namespace-id: %s\n",
+				nvme_strerror(errno));
 			goto close_fd;
 		}
 	}
 
-	err = nvme_ns_delete(fd, cfg.namespace_id, cfg.timeout);
+	err = nvme_ns_mgmt_delete(fd, cfg.namespace_id);
 	if (!err)
 		printf("%s: Success, deleted nsid:%d\n", cmd->name,
 								cfg.namespace_id);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("delete namespace");
+		fprintf(stderr, "delete namespace: %s\n", nvme_strerror(errno));
 
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int nvme_attach_ns(int argc, char **argv, int attach, const char *desc, struct command *cmd)
 {
-	int err = -1, num, i, fd, list[2048];
+	int err, num, fd, i, list[2048];
+	struct nvme_ctrl_list cntlist;
 	__u16 ctrlist[2048];
 
 	const char *namespace_id = "namespace to attach";
 	const char *cont = "optional comma-sep controller id list";
 
 	struct config {
-		char  *cntlist;
-		__u32 namespace_id;
+		__u32	namespace_id;
+		char	*cntlist;
 	};
 
 	struct config cfg = {
-		.cntlist = "",
-		.namespace_id = 0,
+		.namespace_id	= 0,
+		.cntlist	= "",
 	};
 
 	OPT_ARGS(opts) = {
@@ -1969,8 +2279,7 @@ static int nvme_attach_ns(int argc, char **argv, int attach, const char *desc, s
 	if (!cfg.namespace_id) {
 		fprintf(stderr, "%s: namespace-id parameter required\n",
 						cmd->name);
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
@@ -1982,15 +2291,19 @@ static int nvme_attach_ns(int argc, char **argv, int attach, const char *desc, s
 	if (num == -1) {
 		fprintf(stderr, "%s: controller id list is malformed\n",
 						cmd->name);
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
 	for (i = 0; i < num; i++)
-		ctrlist[i] = (uint16_t)list[i];
+		ctrlist[i] = (__u16)list[i];
+
+	nvme_init_ctrl_list(&cntlist, num, ctrlist);
 
-	err = nvme_ns_attachment(fd, cfg.namespace_id, num, ctrlist, attach);
+	if (attach)
+		err = nvme_ns_attach_ctrls(fd, cfg.namespace_id, &cntlist);
+	else
+		err = nvme_ns_detach_ctrls(fd, cfg.namespace_id, &cntlist);
 
 	if (!err)
 		printf("%s: Success, nsid:%d\n", cmd->name, cfg.namespace_id);
@@ -2002,7 +2315,7 @@ static int nvme_attach_ns(int argc, char **argv, int attach, const char *desc, s
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int attach_ns(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -2040,11 +2353,12 @@ static int create_ns(int argc, char **argv, struct command *cmd, struct plugin *
 	const char *anagrpid = "ANA Group Identifier (ANAGRPID)";
 	const char *nvmsetid = "NVM Set Identifier (NVMSETID)";
 	const char *csi = "command set identifier (CSI)";
+	const char *lbstm = "logical block storage tag mask (LBSTM)";
 	const char *timeout = "timeout value, in milliseconds";
 	const char *bs = "target block size, specify only if \'FLBAS\' "\
 		"value not entered";
 
-	int err = -1, fd, i;
+	int err = 0, fd, i;
 	struct nvme_id_ns ns;
 	__u32 nsid;
 
@@ -2058,15 +2372,22 @@ static int create_ns(int argc, char **argv, struct command *cmd, struct plugin *
 		__u16	nvmsetid;
 		__u64	bs;
 		__u32	timeout;
-		__u8  	csi;
+		__u8	csi;
+		__u64	lbstm;
 	};
 
 	struct config cfg = {
+		.nsze		= 0,
+		.ncap		= 0,
 		.flbas		= 0xff,
+		.dps		= 0,
+		.nmic		= 0,
 		.anagrpid	= 0,
 		.nvmsetid	= 0,
 		.bs		= 0x00,
-		.timeout	= NVME_IOCTL_TIMEOUT,
+		.timeout	= 120000,
+		.csi		= 0,
+		.lbstm		= 0,
 	};
 
 	OPT_ARGS(opts) = {
@@ -2080,6 +2401,7 @@ static int create_ns(int argc, char **argv, struct command *cmd, struct plugin *
 		OPT_SUFFIX("block-size", 'b', &cfg.bs,       bs),
 		OPT_UINT("timeout",      't', &cfg.timeout,  timeout),
 		OPT_BYTE("csi",          'y', &cfg.csi,      csi),
+		OPT_SUFFIX("lbstm",      'l', &cfg.lbstm,    lbstm),
 		OPT_END()
 	};
 
@@ -2090,8 +2412,7 @@ static int create_ns(int argc, char **argv, struct command *cmd, struct plugin *
 	if (cfg.flbas != 0xff && cfg.bs != 0x00) {
 		fprintf(stderr,
 			"Invalid specification of both FLBAS and Block Size, please specify only one\n");
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 	if (cfg.bs) {
@@ -2099,14 +2420,14 @@ static int create_ns(int argc, char **argv, struct command *cmd, struct plugin *
 			fprintf(stderr,
 				"Invalid value for block size (%"PRIu64"). Block size must be a power of two\n",
 				(uint64_t)cfg.bs);
-			errno = EINVAL;
-			err = -1;
+			err = -EINVAL;
 			goto close_fd;
 		}
-		err = nvme_identify_ns(fd, NVME_NSID_ALL, 0, &ns);
+		err = nvme_identify_ns(fd, NVME_NSID_ALL, &ns);
 		if (err) {
 			if (err < 0)
-				perror("identify-namespace");
+				fprintf(stderr, "identify-namespace: %s",
+					nvme_strerror(errno));
 			else {
 				fprintf(stderr, "identify failed\n");
 				nvme_show_status(err);
@@ -2128,51 +2449,93 @@ static int create_ns(int argc, char **argv, struct command *cmd, struct plugin *
 		fprintf(stderr,
 			"Please correct block size, or specify FLBAS directly\n");
 
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
-	err = nvme_ns_create(fd, cfg.nsze, cfg.ncap, cfg.flbas, cfg.dps, cfg.nmic,
-			    cfg.anagrpid, cfg.nvmsetid, cfg.csi, cfg.timeout,
-			    &nsid);
+	struct nvme_id_ns ns2 = {
+		.nsze = cpu_to_le64(cfg.nsze),
+		.ncap = cpu_to_le64(cfg.ncap),
+		.flbas = cfg.flbas,
+		.dps = cfg.dps,
+		.nmic = cfg.nmic,
+		.anagrpid = cpu_to_le32(cfg.anagrpid),
+		.nvmsetid = cpu_to_le16(cfg.nvmsetid),
+		.lbstm = cpu_to_le64(cfg.lbstm),
+	};
+
+	err = nvme_ns_mgmt_create(fd, &ns2, &nsid, cfg.timeout, cfg.csi);
 	if (!err)
 		printf("%s: Success, created nsid:%d\n", cmd->name, nsid);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("create namespace");
+		fprintf(stderr, "create namespace: %s\n", nvme_strerror(errno));
 
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
+}
+
+static bool nvme_match_device_filter(nvme_subsystem_t s,
+		nvme_ctrl_t c, nvme_ns_t ns, void *f_args)
+{
+	int ret, instance, nsid, s_num;
+	char *devname = f_args;
+
+	if (!devname || !strlen(devname))
+		return true;
+
+	ret = sscanf(devname, "nvme%dn%d", &instance, &nsid);
+	if (ret != 2)
+		return true;
+
+	if (s) {
+		ret = sscanf(nvme_subsystem_get_name(s), "nvme-subsys%d",
+			     &s_num);
+		if (ret == 1 && s_num == instance)
+			return true;
+	}
+	if (c) {
+		s = nvme_ctrl_get_subsystem(c);
+
+		ret = sscanf(nvme_subsystem_get_name(s), "nvme-subsys%d",
+			     &s_num);
+		if (ret == 1 && s_num == instance)
+			return true;
+	}
+	if (ns) {
+		if (!strcmp(devname, nvme_ns_get_name(ns)))
+			return true;
+	}
+
+	return false;
 }
 
 static int list_subsys(int argc, char **argv, struct command *cmd,
 		struct plugin *plugin)
 {
-	struct nvme_topology t = { };
+	nvme_root_t r = NULL;
 	enum nvme_print_flags flags;
-	char *subsysnqn = NULL;
 	const char *desc = "Retrieve information for subsystems";
 	const char *verbose = "Increase output verbosity";
-	__u32 ns_instance = 0;
-	int err = -1, nsid = 0;
+	nvme_scan_filter_t filter = NULL;
+	int err;
 
 	struct config {
-		char *output_format;
-		int verbose;
+		char	*output_format;
+		int	verbose;
 	};
 
 	struct config cfg = {
-		.output_format = "normal",
-		.verbose = 0,
+		.output_format	= "normal",
+		.verbose	= 0,
 	};
 
 	OPT_ARGS(opts) = {
 		OPT_FMT("output-format", 'o', &cfg.output_format, output_format_no_binary),
-		OPT_FLAG("verbose",      'v', &cfg.verbose,       verbose),
+		OPT_INCR("verbose",      'v', &cfg.verbose,       verbose),
 		OPT_END()
 	};
 
@@ -2181,95 +2544,77 @@ static int list_subsys(int argc, char **argv, struct command *cmd,
 		goto ret;
 
 	devicename = NULL;
-	if (optind < argc) {
-		char path[512];
-		int id, fd;
-
-		devicename = basename(argv[optind]);
-		if (sscanf(devicename, "nvme%dn%d", &id, &ns_instance) != 2) {
-			fprintf(stderr, "%s is not a NVMe namespace device\n",
-				argv[optind]);
-			errno = EINVAL;
-			err = -1;
-			goto ret;
-		}
-		sprintf(path, "/dev/%s", devicename);
-		fd = open(path, O_RDONLY);
-		if (fd < 0) {
-			fprintf(stderr, "Cannot read nsid from %s\n",
-				devicename);
-			errno = EINVAL;
-			err = -1;
-			goto ret;
-		}
-		nsid = nvme_get_nsid(fd);
-		close(fd);
-		if (nsid < 0) {
-			fprintf(stderr, "Cannot read nsid from %s\n",
-				devicename);
-			errno = EINVAL;
-			err = -1;
-			goto ret;
-		}
-		sprintf(path, "/sys/block/%s/device", devicename);
-		subsysnqn = get_nvme_subsnqn(path);
-		if (!subsysnqn) {
-			fprintf(stderr, "Cannot read subsys NQN from %s\n",
-				devicename);
-			errno = EINVAL;
-			err = -1;
-			goto ret;
-		}
-		optind++;
-	}
+	if (optind < argc)
+		devicename = basename(argv[optind++]);
 
 	err = flags = validate_output_format(cfg.output_format);
 	if (flags < 0)
-		goto free;
+		goto ret;
 	if (flags != JSON && flags != NORMAL) {
-		errno = EINVAL;
-		err = -1;
-		goto free;
+		err = -EINVAL;
+		goto ret;
 	}
 	if (cfg.verbose)
 		flags |= VERBOSE;
 
-	err = scan_subsystems(&t, subsysnqn, ns_instance, nsid, NULL);
+	r = nvme_create_root(stderr, map_log_level(cfg.verbose, false));
+	if (!r) {
+		if (devicename)
+			fprintf(stderr,
+				"Failed to scan nvme subsystem for %s\n",
+				devicename);
+		else
+			fprintf(stderr, "Failed to scan nvme subsystem\n");
+		err = -errno;
+		goto ret;
+	}
+
+	if (devicename) {
+		int subsys_num, nsid;
+
+		if (sscanf(devicename,"nvme%dn%d",
+			   &subsys_num, &nsid) != 2) {
+			fprintf(stderr, "Invalid device name %s\n", devicename);
+			err = -EINVAL;
+			goto ret;
+		}
+		filter = nvme_match_device_filter;
+	}
+
+	err = nvme_scan_topology(r, filter, (void *)devicename);
 	if (err) {
-		fprintf(stderr, "Failed to scan namespaces\n");
-		goto free;
+		fprintf(stderr, "Failed to scan topology: %s\n",
+			nvme_strerror(errno));
+		goto ret;
 	}
-	nvme_show_subsystem_list(&t, flags);
-free:
-	free_topology(&t);
-	free(subsysnqn);
+
+	nvme_show_subsystem_list(r, flags);
+
 ret:
-	return nvme_status_to_errno(err, false);
+	if (r)
+		nvme_free_tree(r);
+	return err;
 }
 
 static int list(int argc, char **argv, struct command *cmd, struct plugin *plugin)
 {
 	const char *desc = "Retrieve basic information for all NVMe namespaces";
-	const char *device_dir = "Additional directory to search for devices";
 	const char *verbose = "Increase output verbosity";
-	struct nvme_topology t = { };
 	enum nvme_print_flags flags;
-	int err = -1;
+	nvme_root_t r;
+	int err = 0;
 
 	struct config {
-		char *device_dir;
-		char *output_format;
-		int verbose;
+		char	*output_format;
+		bool	verbose;
 	};
 
 	struct config cfg = {
-		.device_dir = NULL,
-		.output_format = "normal",
-		.verbose = 0,
+		.output_format	= "normal",
+		.verbose	= false,
 	};
 
 	OPT_ARGS(opts) = {
-		OPT_STRING("directory",  'd', "DIR",             &cfg.device_dir, device_dir),
 		OPT_FMT("output-format", 'o', &cfg.output_format, output_format_no_binary),
 		OPT_FLAG("verbose",      'v', &cfg.verbose,       verbose),
 		OPT_END()
@@ -2289,15 +2634,24 @@ static int list(int argc, char **argv, struct command *cmd, struct plugin *plugi
 	if (cfg.verbose)
 		flags |= VERBOSE;
 
-	err = scan_subsystems(&t, NULL, 0, 0, cfg.device_dir);
-	if (err) {
-		fprintf(stderr, "Failed to scan namespaces\n");
+	r = nvme_create_root(stderr, map_log_level(cfg.verbose, false));
+	if (!r) {
+		fprintf(stderr, "Failed to create topology root: %s\n",
+			nvme_strerror(errno));
+		return -errno;
+	}
+	err = nvme_scan_topology(r, NULL, NULL);
+	if (err < 0) {
+		fprintf(stderr, "Failed to scan topoplogy: %s\n",
+			 nvme_strerror(errno));
+		nvme_free_tree(r);
 		return err;
 	}
 
-	nvme_show_list_items(&t, flags);
-	free_topology(&t);
-	return 0;
+	nvme_show_list_items(r, flags);
+	nvme_free_tree(r);
+
+	return err;
 }
 
 int __id_ctrl(int argc, char **argv, struct command *cmd, struct plugin *plugin,
@@ -2313,17 +2667,20 @@ int __id_ctrl(int argc, char **argv, struct command *cmd, struct plugin *plugin,
 	const char *human_readable = "show identify in readable format";
 	enum nvme_print_flags flags;
 	struct nvme_id_ctrl ctrl;
-	int err = -1, fd;
+	int err, fd;
 
 	struct config {
-		int vendor_specific;
-		int raw_binary;
-		int human_readable;
-		char *output_format;
+		bool	vendor_specific;
+		char	*output_format;
+		bool	raw_binary;
+		bool	human_readable;
 	};
 
 	struct config cfg = {
-		.output_format = "normal",
+		.vendor_specific	= false,
+		.output_format		= "normal",
+		.raw_binary		= false,
+		.human_readable		= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -2350,15 +2707,15 @@ int __id_ctrl(int argc, char **argv, struct command *cmd, struct plugin *plugin,
 
 	err = nvme_identify_ctrl(fd, &ctrl);
 	if (!err)
-		__nvme_show_id_ctrl(&ctrl, flags, vs);
+		nvme_show_id_ctrl(&ctrl, flags, vs);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("identify controller");
+		fprintf(stderr, "identify controller: %s\n", nvme_strerror(errno));
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int id_ctrl(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -2377,15 +2734,15 @@ static int nvm_id_ctrl(int argc, char **argv, struct command *cmd,
 	int fd, err = -1;
 
 	struct config {
-		char *output_format;
+		char	*output_format;
 	};
 
 	struct config cfg = {
-		.output_format = "normal",
+		.output_format	= "normal",
 	};
 
 	OPT_ARGS(opts) = {
-		OPT_FMT("output-format",  'o', &cfg.output_format,   output_format),
+		OPT_FMT("output-format", 'o', &cfg.output_format,   output_format),
 		OPT_END()
 	};
 
@@ -2397,13 +2754,156 @@ static int nvm_id_ctrl(int argc, char **argv, struct command *cmd,
 	if (flags < 0)
 		goto close_fd;
 
-	err = nvme_identify_ctrl_nvm(fd, &ctrl_nvm);
+	err = nvme_nvm_identify_ctrl(fd, &ctrl_nvm);
 	if (!err)
 		nvme_show_id_ctrl_nvm(&ctrl_nvm, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("nvm identify controller");
+		fprintf(stderr, "nvm identify controller: %s\n", nvme_strerror(errno));
+close_fd:
+	close(fd);
+ret:
+	return err;
+}
+
+static int nvm_id_ns(int argc, char **argv, struct command *cmd,
+	struct plugin *plugin)
+{
+	const char *desc = "Send an Identify Namespace NVM Command Set "\
+		"command to the given device and report information about "\
+		"the specified namespace in various formats.";
+	const char *namespace_id = "identifier of desired namespace";
+	const char *uuid_index = "UUID index";
+	const char *verbose = "Increase output verbosity";
+	enum nvme_print_flags flags;
+	struct nvme_nvm_id_ns id_ns;
+	struct nvme_id_ns ns;
+	int fd, err = -1;
+
+	struct config {
+		__u32	namespace_id;
+		__u8	uuid_index;
+		char	*output_format;
+		bool	verbose;
+	};
+
+	struct config cfg = {
+		.namespace_id	= 0,
+		.uuid_index	= NVME_UUID_NONE,
+		.output_format	= "normal",
+		.verbose	= false,
+	};
+
+	OPT_ARGS(opts) = {
+		OPT_UINT("namespace-id", 'n', &cfg.namespace_id,    namespace_id),
+		OPT_BYTE("uuid-index",   'U', &cfg.uuid_index,      uuid_index),
+		OPT_FMT("output-format", 'o', &cfg.output_format,   output_format),
+		OPT_FLAG("verbose",      'v', &cfg.verbose,         verbose),
+		OPT_END()
+	};
+
+	fd = parse_and_open(argc, argv, desc, opts);
+	if (fd < 0)
+		goto ret;
+
+	err = flags = validate_output_format(cfg.output_format);
+	if (flags < 0)
+		goto close_fd;
+
+	if (cfg.verbose)
+		flags |= VERBOSE;
+
+	if (!cfg.namespace_id) {
+		err = nvme_get_nsid(fd, &cfg.namespace_id);
+		if (err < 0) {
+			perror("get-namespace-id");
+			goto close_fd;
+		}
+	}
+
+	err = nvme_identify_ns(fd, cfg.namespace_id, &ns);
+	if (err) {
+		nvme_show_status(err);
+		goto close_fd;
+	}
+
+	err = nvme_identify_ns_csi(fd, cfg.namespace_id, cfg.uuid_index,
+							NVME_CSI_NVM, &id_ns);
+	if (!err)
+		nvme_show_nvm_id_ns(&id_ns, cfg.namespace_id, &ns, 0, false, flags);
+	else if (err > 0)
+		nvme_show_status(err);
+	else
+		perror("nvm identify namespace");
+close_fd:
+	close(fd);
+ret:
+	return nvme_status_to_errno(err, false);
+}
+
+static int nvm_id_ns_lba_format(int argc, char **argv, struct command *cmd, struct plugin *plugin)
+{
+	const char *desc = "Send an NVM Command Set specific Identify Namespace "
+		"command to the given device, returns capability field properties of "
+		"the specified LBA Format index in the specified namespace in various "
+		"formats.";
+	const char *lba_format_index = "The index into the LBA Format list "\
+		"identifying the LBA Format capabilities that are to be returned";
+	const char *uuid_index = "UUID index";
+	const char *verbose = "Increase output verbosity";
+	enum nvme_print_flags flags;
+	struct nvme_id_ns ns;
+	struct nvme_nvm_id_ns nvm_ns;
+	int err = -1, fd;
+
+	struct config {
+		__u16	lba_format_index;
+		__u8	uuid_index;
+		bool	verbose;
+		char	*output_format;
+	};
+
+	struct config cfg = {
+		.lba_format_index	= 0,
+		.uuid_index		= NVME_UUID_NONE,
+		.verbose		= false,
+		.output_format		= "normal",
+	};
+
+	OPT_ARGS(opts) = {
+		OPT_UINT("lba-format-index", 'i', &cfg.lba_format_index, lba_format_index),
+		OPT_BYTE("uuid-index",       'U', &cfg.uuid_index,       uuid_index),
+		OPT_FLAG("verbose",          'v', &cfg.verbose,          verbose),
+		OPT_FMT("output-format",     'o', &cfg.output_format,    output_format),
+		OPT_END()
+	};
+
+	err = fd = parse_and_open(argc, argv, desc, opts);
+	if (fd < 0)
+		goto ret;
+
+	err = flags = validate_output_format(cfg.output_format);
+	if (flags < 0)
+		goto close_fd;
+
+	if (cfg.verbose)
+		flags |= VERBOSE;
+
+	err = nvme_identify_ns(fd, NVME_NSID_ALL, &ns);
+	if (err) {
+		ns.nlbaf = NVME_FEAT_LBA_RANGE_MAX - 1;
+		ns.nulbaf = 0;
+	}
+	err = nvme_identify_iocs_ns_csi_user_data_format(fd, cfg.lba_format_index,
+										cfg.uuid_index, NVME_CSI_NVM, &nvm_ns);
+	if (!err)
+		nvme_show_nvm_id_ns(&nvm_ns, 0, &ns, cfg.lba_format_index, true,
+						flags);
+	else if (err > 0)
+		nvme_show_status(err);
+	else
+		perror("NVM identify namespace for specific LBA format");
 close_fd:
 	close(fd);
 ret:
@@ -2418,18 +2918,19 @@ static int ns_descs(int argc, char **argv, struct command *cmd, struct plugin *p
 	const char *raw = "show descriptors in binary format";
 	const char *namespace_id = "identifier of desired namespace";
 	enum nvme_print_flags flags;
-	int err = -1, fd;
+	int err, fd;
 	void *nsdescs;
 
 	struct config {
-		__u32 namespace_id;
-		int raw_binary;
-		char *output_format;
+		__u32	namespace_id;
+		char	*output_format;
+		bool	raw_binary;
 	};
 
 	struct config cfg = {
-		.namespace_id = 0,
-		.output_format = "normal",
+		.namespace_id	= 0,
+		.output_format	= "normal",
+		.raw_binary	= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -2450,17 +2951,15 @@ static int ns_descs(int argc, char **argv, struct command *cmd, struct plugin *p
 		flags = BINARY;
 
 	if (!cfg.namespace_id) {
-		err = cfg.namespace_id = nvme_get_nsid(fd);
+		err = nvme_get_nsid(fd, &cfg.namespace_id);
 		if (err < 0) {
-			perror("get-namespace-id");
+			fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
 			goto close_fd;
 		}
 	}
 
 	if (posix_memalign(&nsdescs, getpagesize(), 0x1000)) {
-		fprintf(stderr, "can not allocate controller list payload\n");
-		errno = ENOMEM;
-		err = -1;
+		err = -ENOMEM;
 		goto close_fd;
 	}
 
@@ -2470,12 +2969,12 @@ static int ns_descs(int argc, char **argv, struct command *cmd, struct plugin *p
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("identify namespace");
+		fprintf(stderr, "identify namespace: %s\n", nvme_strerror(errno));
 	free(nsdescs);
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int id_ns(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -2492,25 +2991,29 @@ static int id_ns(int argc, char **argv, struct command *cmd, struct plugin *plug
 
 	enum nvme_print_flags flags;
 	struct nvme_id_ns ns;
-	int err = -1, fd;
+	int err, fd;
 
 	struct config {
-		__u32 namespace_id;
-		int   vendor_specific;
-		int   raw_binary;
-		int   human_readable;
-		int   force;
-		char *output_format;
+		__u32	namespace_id;
+		bool	force;
+		bool	vendor_specific;
+		bool	raw_binary;
+		char	*output_format;
+		bool	human_readable;
 	};
 
 	struct config cfg = {
-		.namespace_id    = 0,
-		.output_format = "normal",
+		.namespace_id		= 0,
+		.force			= false,
+		.vendor_specific	= false,
+		.raw_binary		= false,
+		.output_format		= "normal",
+		.human_readable		= false,
 	};
 
 	OPT_ARGS(opts) = {
 		OPT_UINT("namespace-id",    'n', &cfg.namespace_id,    namespace_id),
-		OPT_FLAG("force",           'f', &cfg.force,           force),
+		OPT_FLAG("force",             0, &cfg.force,           force),
 		OPT_FLAG("vendor-specific", 'v', &cfg.vendor_specific, vendor_specific),
 		OPT_FLAG("raw-binary",      'b', &cfg.raw_binary,      raw),
 		OPT_FMT("output-format",    'o', &cfg.output_format,   output_format),
@@ -2533,24 +3036,28 @@ static int id_ns(int argc, char **argv, struct command *cmd, struct plugin *plug
 		flags |= VERBOSE;
 
 	if (!cfg.namespace_id) {
-		err = cfg.namespace_id = nvme_get_nsid(fd);
+		err = nvme_get_nsid(fd, &cfg.namespace_id);
 		if (err < 0) {
-			perror("get-namespace-id");
+			fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
 			goto close_fd;
 		}
 	}
 
-	err = nvme_identify_ns(fd, cfg.namespace_id, cfg.force, &ns);
+	if (cfg.force)
+		err = nvme_identify_allocated_ns(fd, cfg.namespace_id, &ns);
+	else
+		err = nvme_identify_ns(fd, cfg.namespace_id, &ns);
+
 	if (!err)
-		nvme_show_id_ns(&ns, cfg.namespace_id, flags);
+		nvme_show_id_ns(&ns, cfg.namespace_id, 0, false, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("identify namespace");
+		fprintf(stderr, "identify namespace: %s\n", nvme_strerror(errno));
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int cmd_set_independent_id_ns(int argc, char **argv,
@@ -2564,19 +3071,21 @@ static int cmd_set_independent_id_ns(int argc, char **argv,
 	const char *namespace_id = "identifier of desired namespace";
 
 	enum nvme_print_flags flags;
-	struct nvme_cmd_set_independent_id_ns ns;
+	struct nvme_id_independent_id_ns ns;
 	int err = -1, fd;
 
 	struct config {
-		__u32 namespace_id;
-		int   raw_binary;
-		int   human_readable;
-		char *output_format;
+		__u32	namespace_id;
+		bool	raw_binary;
+		char	*output_format;
+		bool	human_readable;
 	};
 
 	struct config cfg = {
-		.namespace_id    = 0,
-		.output_format = "normal",
+		.namespace_id	= 0,
+		.raw_binary	= false,
+		.output_format	= "normal",
+		.human_readable	= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -2600,24 +3109,24 @@ static int cmd_set_independent_id_ns(int argc, char **argv,
 		flags |= VERBOSE;
 
 	if (!cfg.namespace_id) {
-		err = cfg.namespace_id = nvme_get_nsid(fd);
+		err = cfg.namespace_id = nvme_get_nsid(fd, &cfg.namespace_id);
 		if (err < 0) {
 			perror("get-namespace-id");
 			goto close_fd;
 		}
 	}
 
-	err = nvme_cmd_set_independent_identify_ns(fd, cfg.namespace_id, &ns);
+	err = nvme_identify_independent_identify_ns(fd, cfg.namespace_id, &ns);
 	if (!err)
 		nvme_show_cmd_set_independent_id_ns(&ns, cfg.namespace_id, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("I/O command set independent identify namespace");
+		fprintf(stderr, "I/O command set independent identify namespace: %s\n", nvme_strerror(errno));
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int id_ns_granularity(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -2628,14 +3137,14 @@ static int id_ns_granularity(int argc, char **argv, struct command *cmd, struct
 
 	struct nvme_id_ns_granularity_list *granularity_list;
 	enum nvme_print_flags flags;
-	int err = -1, fd;
+	int err, fd;
 
 	struct config {
-		char *output_format;
+		char	*output_format;
 	};
 
 	struct config cfg = {
-		.output_format = "normal",
+		.output_format	= "normal",
 	};
 
 	OPT_ARGS(opts) = {
@@ -2653,8 +3162,7 @@ static int id_ns_granularity(int argc, char **argv, struct command *cmd, struct
 
 	if (posix_memalign((void *)&granularity_list, getpagesize(), NVME_IDENTIFY_DATA_SIZE)) {
 		fprintf(stderr, "can not allocate granularity list payload\n");
-		errno = ENOMEM;
-		err = -1;
+		err = -ENOMEM;
 		goto close_fd;
 	}
 
@@ -2664,12 +3172,12 @@ static int id_ns_granularity(int argc, char **argv, struct command *cmd, struct
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("identify namespace granularity");
+		fprintf(stderr, "identify namespace granularity: %s\n", nvme_strerror(errno));
 
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int id_nvmset(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -2680,18 +3188,18 @@ static int id_nvmset(int argc, char **argv, struct command *cmd, struct plugin *
 		"in either binary format or json format";
 	const char *nvmset_id = "NVM Set Identify value";
 
-	struct nvme_id_nvmset nvmset;
+	struct nvme_id_nvmset_list nvmset;
 	enum nvme_print_flags flags;
-	int err = -1, fd;
+	int err, fd;
 
 	struct config {
-		__u16 nvmset_id;
-		char *output_format;
+		__u16	nvmset_id;
+		char	*output_format;
 	};
 
 	struct config cfg = {
-		.nvmset_id = 0,
-		.output_format = "normal",
+		.nvmset_id	= 0,
+		.output_format	= "normal",
 	};
 
 	OPT_ARGS(opts) = {
@@ -2708,18 +3216,18 @@ static int id_nvmset(int argc, char **argv, struct command *cmd, struct plugin *
 	if (flags < 0)
 		goto close_fd;
 
-	err = nvme_identify_nvmset(fd, cfg.nvmset_id, &nvmset);
+	err = nvme_identify_nvmset_list(fd, cfg.nvmset_id, &nvmset);
 	if (!err)
 		nvme_show_id_nvmset(&nvmset, cfg.nvmset_id, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("identify nvm set list");
+		fprintf(stderr, "identify nvm set list: %s\n", nvme_strerror(errno));
 
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int id_uuid(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -2732,16 +3240,18 @@ static int id_uuid(int argc, char **argv, struct command *cmd, struct plugin *pl
 
 	struct nvme_id_uuid_list uuid_list;
 	enum nvme_print_flags flags;
-	int err = -1, fd;
+	int err, fd;
 
 	struct config {
-		int   raw_binary;
-		int   human_readable;
-		char *output_format;
+		char	*output_format;
+		bool	raw_binary;
+		bool	human_readable;
 	};
 
 	struct config cfg = {
-		.output_format = "normal",
+		.output_format	= "normal",
+		.raw_binary	= false,
+		.human_readable	= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -2769,11 +3279,11 @@ static int id_uuid(int argc, char **argv, struct command *cmd, struct plugin *pl
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("identify UUID list");
+		fprintf(stderr, "identify UUID list: %s\n", nvme_strerror(errno));
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);;
+	return err;;
 }
 
 static int id_iocs(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -2782,26 +3292,19 @@ static int id_iocs(int argc, char **argv, struct command *cmd, struct plugin *pl
 		"given device, returns properties of the specified controller "\
 		"in either human-readable or binary format.";
 	const char *controller_id = "identifier of desired controller";
-	const char *human_readable = "show info in human readable format";
 	struct nvme_id_iocs iocs;
-	enum nvme_print_flags flags;
 	int err, fd;
 
 	struct config {
-		__u16 cntid;
-		char *output_format;
-		int human_readable;
+		__u16	cntid;
 	};
 
 	struct config cfg = {
-		.cntid = 0xffff,
-		.output_format = "normal",
+		.cntid	= 0xffff,
 	};
 
 	OPT_ARGS(opts) = {
-		OPT_SHRT("controller-id",  'c', &cfg.cntid,          controller_id),
-		OPT_FMT("output-format",   'o', &cfg.output_format,  output_format),
-		OPT_FLAG("human-readable", 'H', &cfg.human_readable, human_readable),
+		OPT_SHRT("controller-id", 'c', &cfg.cntid, controller_id),
 		OPT_END()
 	};
 
@@ -2811,25 +3314,18 @@ static int id_iocs(int argc, char **argv, struct command *cmd, struct plugin *pl
 		goto ret;
 	}
 
-	err = flags = validate_output_format(cfg.output_format);
-	if (flags < 0)
-		goto close_fd;
-	if (cfg.human_readable)
-		flags |= VERBOSE;
-
 	err = nvme_identify_iocs(fd, cfg.cntid, &iocs);
 	if (!err) {
 		printf("NVMe Identify I/O Command Set:\n");
-		nvme_show_id_iocs(&iocs, flags);
+		nvme_show_id_iocs(&iocs);
 	} else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("NVMe Identify I/O Command Set");
+		fprintf(stderr, "NVMe Identify I/O Command Set: %s\n", nvme_strerror(errno));
 
-close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int id_domain(int argc, char **argv, struct command *cmd, struct plugin *plugin) {
@@ -2842,13 +3338,13 @@ static int id_domain(int argc, char **argv, struct command *cmd, struct plugin *
 	int err, fd;
 
 	struct config {
-		__u16 dom_id;
-		char *output_format;
+		__u16	dom_id;
+		char	*output_format;
 	};
 
 	struct config cfg = {
-		.dom_id = 0xffff,
-		.output_format = "normal",
+		.dom_id		= 0xffff,
+		.output_format	= "normal",
 	};
 
 	OPT_ARGS(opts) = {
@@ -2875,18 +3371,19 @@ static int id_domain(int argc, char **argv, struct command *cmd, struct plugin *
 	} else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("NVMe Identify Domain List");
+		fprintf(stderr, "NVMe Identify Domain List: %s\n", nvme_strerror(errno));
 
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int get_ns_id(int argc, char **argv, struct command *cmd, struct plugin *plugin)
 {
-	int err = 0, nsid, fd;
-	const char *desc = "Get namespce ID of a the block device.";
+	const char *desc = "Get namespace ID of a the block device.";
+	int err = 0, fd;
+	unsigned int nsid;
 
 	OPT_ARGS(opts) = {
 		OPT_END()
@@ -2896,9 +3393,9 @@ static int get_ns_id(int argc, char **argv, struct command *cmd, struct plugin *
 	if (fd < 0)
 		goto ret;
 
-	nsid = nvme_get_nsid(fd);
-	if (nsid <= 0) {
-		perror(devicename);
+	err = nvme_get_nsid(fd, &nsid);
+	if (err < 0) {
+		fprintf(stderr, "get namespace ID: %s\n", nvme_strerror(errno));
 		err = errno;
 		goto close_fd;
 	}
@@ -2908,7 +3405,7 @@ static int get_ns_id(int argc, char **argv, struct command *cmd, struct plugin *
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int virtual_mgmt(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -2928,21 +3425,21 @@ static int virtual_mgmt(int argc, char **argv, struct command *cmd, struct plugi
 		"8h: Secondary Assign\n"\
 		"9h: Secondary Online";
 	const char *nr = "Number of Controller Resources(NR)";
-	int fd, err = -1;
-	__u32 result, cdw10;
+	int fd, err;
+	__u32 result;
 
 	struct config {
-		__u16   cntlid;
-		__u8    rt;
-		__u8    act;
-		__u16   nr;
+		__u16	cntlid;
+		__u8	rt;
+		__u8	act;
+		__u16	nr;
 	};
 
 	struct config cfg = {
-		.cntlid	  = 0,
-		.rt	  = 0,
-		.act	  = 0,
-		.nr	  = 0,
+		.cntlid	= 0,
+		.rt	= 0,
+		.act	= 0,
+		.nr	= 0,
 	};
 
 	OPT_ARGS(opts) = {
@@ -2957,43 +3454,56 @@ static int virtual_mgmt(int argc, char **argv, struct command *cmd, struct plugi
 	if (fd < 0)
 		goto ret;
 
-	cdw10 = cfg.act | (cfg.rt << 8) | (cfg.cntlid << 16);
-
-	err = nvme_virtual_mgmt(fd, cdw10, cfg.nr, &result);
+	struct nvme_virtual_mgmt_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.act		= cfg.act,
+		.rt		= cfg.rt,
+		.cntlid		= cfg.cntlid,
+		.nr		= cfg.nr,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= &result,
+	};
+	err = nvme_virtual_mgmt(&args);
 	if (!err) {
 		printf("success, Number of Controller Resources Modified "\
 			"(NRM):%#x\n", result);
 	} else if (err > 0) {
 		nvme_show_status(err);
 	} else
-		perror("virt-mgmt");
+		fprintf(stderr, "virt-mgmt: %s\n", nvme_strerror(errno));
 
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int primary_ctrl_caps(int argc, char **argv, struct command *cmd, struct plugin *plugin)
 {
+	const char *cntlid = "Controller ID";
 	const char *desc = "Send an Identify Primary Controller Capabilities "\
 		"command to the given device and report the information in a "\
 		"decoded format (default), json or binary.";
 	const char *human_readable = "show info in readable format";
-	struct nvme_primary_ctrl_caps caps;
+	struct nvme_primary_ctrl_cap caps;
 
-	int err = -1, fd;
+	int err, fd;
 	enum nvme_print_flags flags;
 
 	struct config {
-		char *output_format;
-		int human_readable;
+		__u16	cntlid;
+		char	*output_format;
+		bool	human_readable;
 	};
 
 	struct config cfg = {
-		.output_format = "normal",
+		.cntlid		= 0,
+		.output_format	= "normal",
+		.human_readable	= false,
 	};
 
 	OPT_ARGS(opts) = {
+		OPT_UINT("cntlid",         'c', &cfg.cntlid, cntlid),
 		OPT_FMT("output-format",   'o', &cfg.output_format,  output_format),
 		OPT_FLAG("human-readable", 'H', &cfg.human_readable, human_readable),
 		OPT_END()
@@ -3009,17 +3519,17 @@ static int primary_ctrl_caps(int argc, char **argv, struct command *cmd, struct
 	if (cfg.human_readable)
 		flags |= VERBOSE;
 
-	err = nvme_identify_primary_ctrl_caps(fd, &caps);
+	err = nvme_identify_primary_ctrl(fd, cfg.cntlid, &caps);
 	if (!err)
-		nvme_show_primary_ctrl_caps(&caps, flags);
+		nvme_show_primary_ctrl_cap(&caps, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("identify primary controller capabilities");
+		fprintf(stderr, "identify primary controller capabilities: %s\n", nvme_strerror(errno));
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int list_secondary_ctrl(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -3030,22 +3540,22 @@ static int list_secondary_ctrl(int argc, char **argv, struct command *cmd, struc
 	const char *namespace_id = "optional namespace attached to controller";
 	const char *num_entries = "number of entries to retrieve";
 
-	struct nvme_secondary_controllers_list *sc_list;
+	struct nvme_secondary_ctrl_list *sc_list;
 	enum nvme_print_flags flags;
-	int err = -1, fd;
+	int err, fd;
 
 	struct config {
-		__u16 cntid;
-		__u32 num_entries;
-		__u32 namespace_id;
-		char *output_format;
+		__u16	cntid;
+		__u32	namespace_id;
+		__u32	num_entries;
+		char	*output_format;
 	};
 
 	struct config cfg = {
-		.cntid = 0,
-		.namespace_id = 0,
-		.output_format = "normal",
-		.num_entries = ARRAY_SIZE(sc_list->sc_entry),
+		.cntid		= 0,
+		.namespace_id	= 0,
+		.num_entries	= ARRAY_SIZE(sc_list->sc_entry),
+		.output_format	= "normal",
 	};
 
 	OPT_ARGS(opts) = {
@@ -3066,15 +3576,13 @@ static int list_secondary_ctrl(int argc, char **argv, struct command *cmd, struc
 
 	if (!cfg.num_entries) {
 		fprintf(stderr, "non-zero num-entries is required param\n");
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
 	if (posix_memalign((void *)&sc_list, getpagesize(), sizeof(*sc_list))) {
 		fprintf(stderr, "can not allocate controller list payload\n");
-		errno = ENOMEM;
-		err = -1;
+		err = -ENOMEM;
 		goto close_fd;
 	}
 
@@ -3084,14 +3592,14 @@ static int list_secondary_ctrl(int argc, char **argv, struct command *cmd, struc
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("id secondary controller list");
+		fprintf(stderr, "id secondary controller list: %s\n", nvme_strerror(errno));
 
 	free(sc_list);
 
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int device_self_test(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -3105,16 +3613,16 @@ static int device_self_test(int argc, char **argv, struct command *cmd, struct p
 		"2h Start a extended device self-test operation\n"\
 		"eh Start a vendor specific device self-test operation\n"\
 		"fh abort the device self-test operation\n";
-	int fd, err = -1;
+	int fd, err;
 
 	struct config {
-		__u32 namespace_id;
-		__u8 stc;
+		__u32	namespace_id;
+		__u8	stc;
 	};
 
 	struct config cfg = {
-		.namespace_id  = NVME_NSID_ALL,
-		.stc = 0,
+		.namespace_id	= NVME_NSID_ALL,
+		.stc		= 0,
 	};
 
 	OPT_ARGS(opts) = {
@@ -3127,7 +3635,15 @@ static int device_self_test(int argc, char **argv, struct command *cmd, struct p
 	if (fd < 0)
 		goto ret;
 
-	err = nvme_self_test_start(fd, cfg.namespace_id, cfg.stc);
+	struct nvme_dev_self_test_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.nsid		= cfg.namespace_id,
+		.stc		= cfg.stc,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= NULL,
+	};
+	err = nvme_dev_self_test(&args);
 	if (!err) {
 		if (cfg.stc == 0xf)
 			printf("Aborting device self-test operation\n");
@@ -3138,11 +3654,11 @@ static int device_self_test(int argc, char **argv, struct command *cmd, struct p
 	} else if (err > 0) {
 		nvme_show_status(err);
 	} else
-		perror("Device self-test");
+		fprintf(stderr, "Device self-test: %s\n", nvme_strerror(errno));
 
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int self_test_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -3154,20 +3670,20 @@ static int self_test_log(int argc, char **argv, struct command *cmd, struct plug
 			"by default all the 20 entries will be retrieved";
 	const char *verbose = "Increase output verbosity";
 
-	struct nvme_self_test_log self_test_log;
+	struct nvme_self_test_log log;
 	enum nvme_print_flags flags;
-	int err = -1, fd;
-	__u32 log_size;
+	int err, fd;
 
 	struct config {
-		__u8 dst_entries;
-		char *output_format;
-		int verbose;
+		__u8	dst_entries;
+		char	*output_format;
+		bool	verbose;
 	};
 
 	struct config cfg = {
-		.dst_entries = NVME_ST_REPORTS,
-		.output_format = "normal",
+		.dst_entries	= NVME_LOG_ST_MAX_RESULTS,
+		.output_format	= "normal",
+		.verbose	= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -3187,22 +3703,146 @@ static int self_test_log(int argc, char **argv, struct command *cmd, struct plug
 	if (cfg.verbose)
 		flags |= VERBOSE;
 
-	log_size = NVME_ST_LOG_HEAD_SIZE + cfg.dst_entries * NVME_ST_LOG_ENTRY_SIZE;
-	err = nvme_self_test_log(fd, log_size, &self_test_log);
+	err = nvme_get_log_device_self_test(fd, &log);
 	if (!err)
-		nvme_show_self_test_log(&self_test_log, cfg.dst_entries, log_size,
+		nvme_show_self_test_log(&log, cfg.dst_entries, 0,
 			devicename, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("self test log");
+		fprintf(stderr, "self test log: %s\n", nvme_strerror(errno));
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
-static int get_feature(int argc, char **argv, struct command *cmd, struct plugin *plugin)
+static int get_feature_id(int fd, struct feat_cfg *cfg, void **buf,
+			  __u32 *result)
+{
+	if (!cfg->data_len)
+		nvme_get_feature_length(cfg->feature_id, cfg->cdw11,
+					&cfg->data_len);
+
+	/* check for Extended Host Identifier */
+	if (cfg->feature_id == NVME_FEAT_FID_HOST_ID && (cfg->cdw11 & 0x1))
+		cfg->data_len = 16;
+
+	if (cfg->sel == 3)
+		cfg->data_len = 0;
+
+	if (cfg->data_len) {
+		if (posix_memalign(buf, getpagesize(), cfg->data_len)) {
+			return -1;
+		}
+		memset(*buf, 0, cfg->data_len);
+	}
+
+	struct nvme_get_features_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.fid		= cfg->feature_id,
+		.nsid		= cfg->namespace_id,
+		.sel		= cfg->sel,
+		.cdw11		= cfg->cdw11,
+		.uuidx		= cfg->uuid_index,
+		.data_len	= cfg->data_len,
+		.data		= *buf,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= result,
+	};
+	return nvme_get_features(&args);
+}
+
+static void get_feature_id_print(struct feat_cfg cfg, int err, __u32 result,
+				 void *buf)
+{
+	if (!err) {
+		if (!cfg.raw_binary || !buf) {
+			printf("get-feature:%#0*x (%s), %s value:%#0*x\n",
+			       cfg.feature_id ? 4 : 2, cfg.feature_id,
+			       nvme_feature_to_string(cfg.feature_id),
+			       nvme_select_to_string(cfg.sel), result ? 10 : 8,
+			       result);
+			if (cfg.sel == 3)
+				nvme_show_select_result(result);
+			else if (cfg.human_readable)
+				nvme_feature_show_fields(cfg.feature_id, result,
+							 buf);
+			else if (buf)
+				d(buf, cfg.data_len, 16, 1);
+		} else if (buf) {
+			d_raw(buf, cfg.data_len);
+		}
+	} else if (err > 0) {
+		if (err != NVME_SC_INVALID_FIELD)
+			nvme_show_status(err);
+	} else {
+		fprintf(stderr, "get-feature: %s\n", nvme_strerror(errno));
+	}
+}
+
+static int get_feature_id_changed(int fd, struct feat_cfg cfg, bool changed)
+{
+	int err;
+	int err_def = 0;
+	__u32 result;
+	__u32 result_def;
+	void *buf = NULL;
+	void *buf_def = NULL;
+
+	if (changed)
+		cfg.sel = 0;
+
+	err = get_feature_id(fd, &cfg, &buf, &result);
+
+	if (!err && changed) {
+		cfg.sel = 1;
+		err_def = get_feature_id(fd, &cfg, &buf_def, &result_def);
+	}
+
+	if (changed)
+		cfg.sel = 8;
+
+	if (err || !changed || err_def || result != result_def ||
+	    (buf && buf_def && !strcmp(buf, buf_def)))
+		get_feature_id_print(cfg, err, result, buf);
+
+	free(buf);
+	free(buf_def);
+
+	return err;
+}
+
+static int get_feature_ids(int fd, struct feat_cfg cfg)
+{
+	int err = 0;
+	int i;
+	int feat_max = 0x100;
+	int feat_num = 0;
+	bool changed = false;
+
+	if (cfg.sel == 8)
+		changed = true;
+
+	if (cfg.feature_id)
+		feat_max = cfg.feature_id + 1;
+
+	for (i = cfg.feature_id; i < feat_max; i++, feat_num++) {
+		cfg.feature_id = i;
+		err = get_feature_id_changed(fd, cfg, changed);
+		if (err && err != NVME_SC_INVALID_FIELD)
+			break;
+	}
+
+	if (err == NVME_SC_INVALID_FIELD && feat_num == 1)
+		nvme_show_status(err);
+
+	return err;
+}
+
+static int get_feature(int argc, char **argv, struct command *cmd,
+		       struct plugin *plugin)
 {
 	const char *desc = "Read operating parameters of the "\
 		"specified controller. Operating parameters are grouped "\
@@ -3214,40 +3854,30 @@ static int get_feature(int argc, char **argv, struct command *cmd, struct plugin
 		"are vendor-specific and not changeable. Use set-feature to "\
 		"change saveable Features.";
 	const char *raw = "show feature in binary format";
-	const char *namespace_id = "identifier of desired namespace";
 	const char *feature_id = "feature identifier";
-	const char *sel = "[0-3]: current/default/saved/supported";
+	const char *namespace_id = "identifier of desired namespace";
+	const char *sel = "[0-3,8]: current/default/saved/supported/changed";
 	const char *data_len = "buffer len if data is returned through host memory buffer";
 	const char *cdw11 = "dword 11 for interrupt vector config";
 	const char *human_readable = "show feature in readable format";
 	const char *uuid_index = "specify uuid index";
-	int err = -1, fd;
-	__u32 result;
-	void *buf = NULL;
-
-	struct config {
-		__u32 namespace_id;
-		__u8  feature_id;
-		__u8  sel;
-		__u32 cdw11;
-		__u8  uuid_index;
-		__u32 data_len;
-		int  raw_binary;
-		int  human_readable;
-	};
+	int err;
+	int fd;
 
-	struct config cfg = {
-		.namespace_id = 0,
-		.feature_id   = 0,
-		.sel          = 0,
-		.cdw11        = 0,
-		.uuid_index   = 0,
-		.data_len     = 0,
+	struct feat_cfg cfg = {
+		.feature_id	= 0,
+		.namespace_id	= 0,
+		.sel		= 0,
+		.data_len	= 0,
+		.raw_binary	= false,
+		.cdw11		= 0,
+		.uuid_index	= 0,
+		.human_readable	= false,
 	};
 
 	OPT_ARGS(opts) = {
-		OPT_UINT("namespace-id",  'n', &cfg.namespace_id,   namespace_id),
 		OPT_BYTE("feature-id",    'f', &cfg.feature_id,     feature_id),
+		OPT_UINT("namespace-id",  'n', &cfg.namespace_id,   namespace_id),
 		OPT_BYTE("sel",           's', &cfg.sel,            sel),
 		OPT_UINT("data-len",      'l', &cfg.data_len,       data_len),
 		OPT_FLAG("raw-binary",    'b', &cfg.raw_binary,     raw),
@@ -3262,85 +3892,35 @@ static int get_feature(int argc, char **argv, struct command *cmd, struct plugin
 		goto ret;
 
 	if (!cfg.namespace_id) {
-		err = cfg.namespace_id = nvme_get_nsid(fd);
+		err = nvme_get_nsid(fd, &cfg.namespace_id);
 		if (err < 0) {
 			if (errno != ENOTTY) {
-				perror("get-namespace-id");
+				fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
 				goto close_fd;
 			}
-
 			cfg.namespace_id = NVME_NSID_ALL;
 		}
 	}
 
-	if (cfg.sel > 7) {
+	if (cfg.sel > 8) {
 		fprintf(stderr, "invalid 'select' param:%d\n", cfg.sel);
-		errno = EINVAL;
-		err = -1;
-		goto close_fd;
-	}
-	if (!cfg.feature_id) {
-		fprintf(stderr, "feature-id required param\n");
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
 	if (cfg.uuid_index > 128) {
 		fprintf(stderr, "invalid uuid index param: %u\n", cfg.uuid_index);
-		errno = EINVAL;
 		err = -1;
 		goto close_fd;
 	}
 
-	if (!cfg.data_len)
-		cfg.data_len = nvme_feat_buf_len[cfg.feature_id];
-
-	/* check for Extended Host Identifier */
-	if (cfg.feature_id == NVME_FEAT_HOST_ID && (cfg.cdw11 & 0x1))
-		cfg.data_len = 16;
-
-	if (cfg.sel == 3)
-		cfg.data_len = 0;
-
-	if (cfg.data_len) {
-		if (posix_memalign(&buf, getpagesize(), cfg.data_len)) {
-			fprintf(stderr, "can not allocate feature payload\n");
-			errno = ENOMEM;
-			err = -1;
-			goto close_fd;
-		}
-		memset(buf, 0, cfg.data_len);
-	}
-
-	err = nvme_get_feature(fd, cfg.namespace_id, cfg.feature_id, cfg.sel, cfg.cdw11,
-			cfg.uuid_index, cfg.data_len, buf, &result);
-	if (!err) {
-		if (!cfg.raw_binary || !buf) {
-			printf("get-feature:%#0*x (%s), %s value:%#0*x\n",
-			       cfg.feature_id ? 4 : 2, cfg.feature_id,
-			       nvme_feature_to_string(cfg.feature_id),
-			       nvme_select_to_string(cfg.sel), result ? 10 : 8,
-			       result);
-			if (cfg.sel == 3)
-				nvme_show_select_result(result);
-			else if (cfg.human_readable)
-				nvme_feature_show_fields(cfg.feature_id, result, buf);
-			else if (buf)
-				d(buf, cfg.data_len, 16, 1);
-		} else if (buf)
-			d_raw(buf, cfg.data_len);
-	} else if (err > 0) {
-		nvme_show_status(err);
-	} else
-		perror("get-feature");
-
-	free(buf);
+	err = get_feature_ids(fd, cfg);
 
 close_fd:
 	close(fd);
+
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int fw_download(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -3356,22 +3936,22 @@ static int fw_download(int argc, char **argv, struct command *cmd, struct plugin
 	const char *fw = "firmware file (required)";
 	const char *xfer = "transfer chunksize limit";
 	const char *offset = "starting dword offset, default 0";
-	int err = -1, fd, fw_fd = -1;
+	int err, fd, fw_fd = -1;
 	unsigned int fw_size;
 	struct stat sb;
 	void *fw_buf, *buf;
 	bool huge;
 
 	struct config {
-		char  *fw;
-		__u32 xfer;
-		__u32 offset;
+		char	*fw;
+		__u32	xfer;
+		__u32	offset;
 	};
 
 	struct config cfg = {
-		.fw     = "",
-		.xfer   = 4096,
-		.offset = 0,
+		.fw	= "",
+		.xfer	= 4096,
+		.offset	= 0,
 	};
 
 	OPT_ARGS(opts) = {
@@ -3390,8 +3970,7 @@ static int fw_download(int argc, char **argv, struct command *cmd, struct plugin
 	if (fw_fd < 0) {
 		fprintf(stderr, "Failed to open firmware file %s: %s\n",
 				cfg.fw, strerror(errno));
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
@@ -3404,8 +3983,7 @@ static int fw_download(int argc, char **argv, struct command *cmd, struct plugin
 	fw_size = sb.st_size;
 	if ((fw_size & 0x3) || (fw_size == 0)) {
 		fprintf(stderr, "Invalid size:%d for f/w image\n", fw_size);
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fw_fd;
 	}
 
@@ -3418,9 +3996,7 @@ static int fw_download(int argc, char **argv, struct command *cmd, struct plugin
 		fw_buf = nvme_alloc(fw_size, &huge);
 
 	if (!fw_buf) {
-		perror("No memory for f/w size:\n");
-		errno = ENOMEM;
-		err = -1;
+		err = -ENOMEM;
 		goto close_fw_fd;
 	}
 
@@ -3434,9 +4010,18 @@ static int fw_download(int argc, char **argv, struct command *cmd, struct plugin
 	while (fw_size > 0) {
 		cfg.xfer = min(cfg.xfer, fw_size);
 
-		err = nvme_fw_download(fd, cfg.offset, cfg.xfer, fw_buf);
+		struct nvme_fw_download_args args = {
+			.args_size	= sizeof(args),
+			.fd		= fd,
+			.offset		= cfg.offset,
+			.data_len	= cfg.xfer,
+			.data		= fw_buf,
+			.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+			.result		= NULL,
+		};
+		err = nvme_fw_download(&args);
 		if (err < 0) {
-			perror("fw-download");
+			fprintf(stderr, "fw-download: %s\n", nvme_strerror(errno));
 			break;
 		} else if (err != 0) {
 			nvme_show_status(err);
@@ -3456,7 +4041,7 @@ close_fw_fd:
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static char *nvme_fw_status_reset_type(__u16 status)
@@ -3479,19 +4064,19 @@ static int fw_commit(int argc, char **argv, struct command *cmd, struct plugin *
 	const char *slot = "[0-7]: firmware slot for commit action";
 	const char *action = "[0-7]: commit action";
 	const char *bpid = "[0,1]: boot partition identifier, if applicable (default: 0)";
-	int err = -1, fd;
+	int err, fd;
 	__u32 result;
 
 	struct config {
-		__u8 slot;
-		__u8 action;
-		__u8 bpid;
+		__u8	slot;
+		__u8	action;
+		__u8	bpid;
 	};
 
 	struct config cfg = {
-		.slot   = 0,
-		.action = 0,
-		.bpid   = 0,
+		.slot	= 0,
+		.action	= 0,
+		.bpid	= 0,
 	};
 
 	OPT_ARGS(opts) = {
@@ -3507,26 +4092,32 @@ static int fw_commit(int argc, char **argv, struct command *cmd, struct plugin *
 
 	if (cfg.slot > 7) {
 		fprintf(stderr, "invalid slot:%d\n", cfg.slot);
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 	if (cfg.action > 7 || cfg.action == 4 || cfg.action == 5) {
 		fprintf(stderr, "invalid action:%d\n", cfg.action);
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 	if (cfg.bpid > 1) {
 		fprintf(stderr, "invalid boot partition id:%d\n", cfg.bpid);
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
-	err = nvme_fw_commit(fd, cfg.slot, cfg.action, cfg.bpid, &result);
+	struct nvme_fw_commit_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.slot		= cfg.slot,
+		.action		= cfg.action,
+		.bpid		= cfg.bpid,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= &result,
+	};
+	err = nvme_fw_commit(&args);
 	if (err < 0)
-		perror("fw-commit");
+		fprintf(stderr, "fw-commit: %s\n", nvme_strerror(errno));
 	else if (err != 0)
 		switch (err & 0x7ff) {
 		case NVME_SC_FW_NEEDS_CONV_RESET:
@@ -3563,13 +4154,13 @@ static int fw_commit(int argc, char **argv, struct command *cmd, struct plugin *
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int subsystem_reset(int argc, char **argv, struct command *cmd, struct plugin *plugin)
 {
 	const char *desc = "Resets the NVMe subsystem\n";
-	int err = -1, fd;
+	int err, fd;
 
 	OPT_ARGS(opts) = {
 		OPT_END()
@@ -3585,18 +4176,18 @@ static int subsystem_reset(int argc, char **argv, struct command *cmd, struct pl
 			fprintf(stderr,
 				"Subsystem-reset: NVM Subsystem Reset not supported.\n");
 		else
-			perror("Subsystem-reset");
+			fprintf(stderr, "Subsystem-reset: %s\n", nvme_strerror(errno));
 	}
 
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int reset(int argc, char **argv, struct command *cmd, struct plugin *plugin)
 {
 	const char *desc = "Resets the NVMe controller\n";
-	int err = -1, fd;
+	int err, fd;
 
 	OPT_ARGS(opts) = {
 		OPT_END()
@@ -3606,13 +4197,13 @@ static int reset(int argc, char **argv, struct command *cmd, struct plugin *plug
 	if (fd < 0)
 		goto ret;
 
-	err = nvme_reset_controller(fd);
+	err = nvme_ctrl_reset(fd);
 	if (err < 0)
-		perror("Reset");
+		fprintf(stderr, "Reset: %s\n", nvme_strerror(errno));
 
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int ns_rescan(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -3630,11 +4221,11 @@ static int ns_rescan(int argc, char **argv, struct command *cmd, struct plugin *
 
 	err = nvme_ns_rescan(fd);
 	if (err < 0)
-		perror("Namespace Rescan");
+		fprintf(stderr, "Namespace Rescan");
 
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int sanitize(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -3646,25 +4237,24 @@ static int sanitize(int argc, char **argv, struct command *cmd, struct plugin *p
 	const char *ause_desc = "Allow unrestricted sanitize exit.";
 	const char *sanact_desc = "Sanitize action.";
 	const char *ovrpat_desc = "Overwrite pattern.";
-
-	int fd, ret = -1;
+	int fd, err;
 
 	struct config {
-		int    no_dealloc;
-		int    oipbp;
-		__u8   owpass;
-		int    ause;
-		__u8   sanact;
-		__u32  ovrpat;
+		bool	no_dealloc;
+		bool	oipbp;
+		__u8	owpass;
+		bool	ause;
+		__u8	sanact;
+		__u32	ovrpat;
 	};
 
 	struct config cfg = {
-		.no_dealloc = 0,
-		.oipbp = 0,
-		.owpass = 0,
-		.ause = 0,
-		.sanact = 0,
-		.ovrpat = 0,
+		.no_dealloc	= false,
+		.oipbp		= false,
+		.owpass		= 0,
+		.ause		= false,
+		.sanact		= 0,
+		.ovrpat		= 0,
 	};
 
 	OPT_ARGS(opts) = {
@@ -3677,59 +4267,149 @@ static int sanitize(int argc, char **argv, struct command *cmd, struct plugin *p
 		OPT_END()
 	};
 
-	ret = fd = parse_and_open(argc, argv, desc, opts);
+	err = fd = parse_and_open(argc, argv, desc, opts);
 	if (fd < 0)
 		goto ret;
 
 	switch (cfg.sanact) {
-	case NVME_SANITIZE_ACT_CRYPTO_ERASE:
-	case NVME_SANITIZE_ACT_BLOCK_ERASE:
-	case NVME_SANITIZE_ACT_EXIT:
-	case NVME_SANITIZE_ACT_OVERWRITE:
+	case NVME_SANITIZE_SANACT_EXIT_FAILURE:
+	case NVME_SANITIZE_SANACT_START_BLOCK_ERASE:
+	case NVME_SANITIZE_SANACT_START_OVERWRITE:
+	case NVME_SANITIZE_SANACT_START_CRYPTO_ERASE:
 		break;
 	default:
 		fprintf(stderr, "Invalid Sanitize Action\n");
-		errno = EINVAL;
-		ret = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
-	if (cfg.sanact == NVME_SANITIZE_ACT_EXIT) {
+	if (cfg.sanact == NVME_SANITIZE_SANACT_EXIT_FAILURE) {
 	       if (cfg.ause || cfg.no_dealloc) {
 			fprintf(stderr, "SANACT is Exit Failure Mode\n");
-			errno = EINVAL;
-			ret = -1;
+			err = -EINVAL;
 			goto close_fd;
 	       }
 	}
 
-	if (cfg.sanact == NVME_SANITIZE_ACT_OVERWRITE) {
-		if (cfg.owpass >= 16) {
-			fprintf(stderr, "OWPASS out of range [0-15]\n");
-			errno = EINVAL;
-			ret = -1;
+	if (cfg.sanact == NVME_SANITIZE_SANACT_START_OVERWRITE) {
+		if (cfg.owpass > 16) {
+			fprintf(stderr, "OWPASS out of range [0-16]\n");
+			err = -EINVAL;
 			goto close_fd;
 		}
 	} else {
 		if (cfg.owpass || cfg.oipbp || cfg.ovrpat) {
 			fprintf(stderr, "SANACT is not Overwrite\n");
-			errno = EINVAL;
-			ret = -1;
+			err = -EINVAL;
 			goto close_fd;
 		}
 	}
 
-	ret = nvme_sanitize(fd, cfg.sanact, cfg.ause, cfg.owpass, cfg.oipbp,
-			    cfg.no_dealloc, cfg.ovrpat);
-	if (ret < 0)
-		perror("sanitize");
-	else if (ret > 0)
-		nvme_show_status(ret);
+	struct nvme_sanitize_nvm_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.sanact		= cfg.sanact,
+		.ause		= cfg.ause,
+		.owpass		= cfg.owpass,
+		.oipbp		= cfg.oipbp,
+		.nodas		= cfg.no_dealloc,
+		.ovrpat		= cfg.ovrpat,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= NULL,
+	};
+	err = nvme_sanitize_nvm(&args);
+	if (err < 0)
+		fprintf(stderr, "sanitize: %s\n", nvme_strerror(errno));
+	else if (err > 0)
+		nvme_show_status(err);
 
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(ret, false);
+	return err;
+}
+
+static int nvme_get_properties(int fd, void **pbar)
+{
+	int offset, err, size = getpagesize();
+	__u64 value;
+
+	*pbar = malloc(size);
+	if (!*pbar) {
+		fprintf(stderr, "malloc: %s\n", strerror(errno));
+		return -1;
+	}
+
+	memset(*pbar, 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 (err > 0 && (err & 0xff) == NVME_SC_INVALID_FIELD) {
+			err = 0;
+			value = -1;
+		} else if (err) {
+			free(*pbar);
+			break;
+		}
+		if (nvme_is_64bit_reg(offset)) {
+			*(uint64_t *)(*pbar + offset) = value;
+			offset += 8;
+		} else {
+			*(uint32_t *)(*pbar + offset) = value;
+			offset += 4;
+		}
+	}
+
+	return err;
+}
+
+static void *mmap_registers(nvme_root_t r, const char *dev)
+{
+	nvme_ctrl_t c = NULL;
+	nvme_ns_t n = NULL;
+
+	char path[512];
+	void *membase;
+	int fd;
+
+	c = nvme_scan_ctrl(r, devicename);
+	if (c) {
+		snprintf(path, sizeof(path), "%s/device/resource0",
+			nvme_ctrl_get_sysfs_dir(c));
+		nvme_free_ctrl(c);
+	} else {
+		n = nvme_scan_namespace(devicename);
+		if (!n) {
+			fprintf(stderr, "Unable to find %s\n", devicename);
+			return NULL;
+		}
+		snprintf(path, sizeof(path), "%s/device/device/resource0",
+			nvme_ns_get_sysfs_dir(n));
+		nvme_free_ns(n);
+	}
+
+	fd = open(path, O_RDONLY);
+	if (fd < 0) {
+		fprintf(stderr, "%s did not find a pci resource, open failed %s\n",
+				devicename, strerror(errno));
+		return NULL;
+	}
+
+	membase = mmap(NULL, getpagesize(), PROT_READ, MAP_SHARED, fd, 0);
+	if (membase == MAP_FAILED) {
+		fprintf(stderr, "%s failed to map. ", devicename);
+		fprintf(stderr, "Did your kernel enable CONFIG_IO_STRICT_DEVMEM?\n");
+		membase = NULL;
+	}
+
+	close(fd);
+	return membase;
 }
 
 static int show_registers(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -3740,18 +4420,19 @@ static int show_registers(int argc, char **argv, struct command *cmd, struct plu
 					"output_format == normal";
 
 	enum nvme_print_flags flags;
+	nvme_root_t r;
 	bool fabrics = true;
-	int fd, err = -1;
+	int fd, err;
 	void *bar;
 
 	struct config {
-		int human_readable;
-		char *output_format;
+		char	*output_format;
+		bool	human_readable;
 	};
 
 	struct config cfg = {
-		.human_readable = 0,
-		.output_format = "normal",
+		.output_format	= "normal",
+		.human_readable	= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -3764,6 +4445,7 @@ static int show_registers(int argc, char **argv, struct command *cmd, struct plu
 	if (fd < 0)
 		goto ret;
 
+	r = nvme_scan(NULL);
 	err = flags = validate_output_format(cfg.output_format);
 	if (flags < 0)
 		goto close_fd;
@@ -3772,7 +4454,7 @@ static int show_registers(int argc, char **argv, struct command *cmd, struct plu
 
 	err = nvme_get_properties(fd, &bar);
 	if (err) {
-		bar = mmap_registers(devicename);
+		bar = mmap_registers(r, devicename);
 		fabrics = false;
 		if (bar)
 			err = 0;
@@ -3787,8 +4469,9 @@ static int show_registers(int argc, char **argv, struct command *cmd, struct plu
 		munmap(bar, getpagesize());
 close_fd:
 	close(fd);
+	nvme_free_tree(r);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int get_property(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -3799,17 +4482,17 @@ static int get_property(int argc, char **argv, struct command *cmd, struct plugi
 	const char *offset = "offset of the requested property";
 	const char *human_readable = "show property in readable format";
 
-	int fd, err = -1;
-	uint64_t value;
+	int fd, err;
+	__u64 value;
 
 	struct config {
-		int offset;
-		int human_readable;
+		int	offset;
+		bool	human_readable;
 	};
 
 	struct config cfg = {
-		.offset = -1,
-		.human_readable = 0,
+		.offset		= -1,
+		.human_readable	= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -3824,14 +4507,20 @@ static int get_property(int argc, char **argv, struct command *cmd, struct plugi
 
 	if (cfg.offset == -1) {
 		fprintf(stderr, "offset required param\n");
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
-	err = nvme_get_property(fd, cfg.offset, &value);
+	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 < 0) {
-		perror("get-property");
+		fprintf(stderr, "get-property: %s\n", nvme_strerror(errno));
 	} else if (!err) {
 		nvme_show_single_property(cfg.offset, value, cfg.human_readable);
 	} else if (err > 0) {
@@ -3841,7 +4530,7 @@ static int get_property(int argc, char **argv, struct command *cmd, struct plugi
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int set_property(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -3850,16 +4539,16 @@ static int set_property(int argc, char **argv, struct command *cmd, struct plugi
 			   "for NVMe ove Fabric";
 	const char *offset = "the offset of the property";
 	const char *value = "the value of the property to be set";
-	int fd, err = -1;
+	int fd, err;
 
 	struct config {
-		int offset;
-		int value;
+		int	offset;
+		int	value;
 	};
 
 	struct config cfg = {
-		.offset = -1,
-		.value = -1,
+		.offset	= -1,
+		.value	= -1,
 	};
 
 	OPT_ARGS(opts) = {
@@ -3874,20 +4563,26 @@ static int set_property(int argc, char **argv, struct command *cmd, struct plugi
 
 	if (cfg.offset == -1) {
 		fprintf(stderr, "offset required param\n");
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 	if (cfg.value == -1) {
 		fprintf(stderr, "value required param\n");
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
-	err = nvme_set_property(fd, cfg.offset, cfg.value);
+	struct nvme_set_property_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.offset		= cfg.offset,
+		.value		= cfg.value,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= NULL,
+	};
+	err = nvme_set_property(&args);
 	if (err < 0) {
-		perror("set-property");
+		fprintf(stderr, "set-property: %s\n", nvme_strerror(errno));
 	} else if (!err) {
 		printf("set-property: %02x (%s), value: %#08x\n", cfg.offset,
 				nvme_register_to_string(cfg.offset), cfg.value);
@@ -3898,7 +4593,7 @@ static int set_property(int argc, char **argv, struct command *cmd, struct plugi
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int format(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -3908,8 +4603,7 @@ static int format(int argc, char **argv, struct command *cmd, struct plugin *plu
 		"data erase) or delete data encryption key if specified. "\
 		"Can also be used to change LBAF to change the namespaces reported physical block format.";
 	const char *namespace_id = "identifier of desired namespace";
-	const char *lbaf = "[0-63]: LBA format lower (LBAFL) and upper (LBAFU), "\
-		"mention directly LBAF format that needs be applied (required)";
+	const char *lbaf = "LBA format to apply (required)";
 	const char *ses = "[0-2]: secure erase";
 	const char *pil = "[0-1]: protection info location last/first 8 bytes of metadata";
 	const char *pi = "[0-3]: protection info off/Type 1/Type 2/Type 3";
@@ -3920,32 +4614,34 @@ static int format(int argc, char **argv, struct command *cmd, struct plugin *plu
 	const char *force = "The \"I know what I'm doing\" flag, skip confirmation before sending command";
 	struct nvme_id_ns ns;
 	struct nvme_id_ctrl ctrl;
-	int err = -1, fd, i;
+	int err, fd, i;
 	int block_size;
 	__u8 prev_lbaf = 0;
 
 	struct config {
-		__u32 namespace_id;
-		__u32 timeout;
-		__u8  lbaf;
-		__u8  ses;
-		__u8  pi;
-		__u8  pil;
-		__u8  ms;
-		__u64 bs;
-		int reset;
-		int force;
+		__u32	namespace_id;
+		__u32	timeout;
+		__u8	lbaf;
+		__u8	ses;
+		__u8	pi;
+		__u8	pil;
+		__u8	ms;
+		bool	reset;
+		bool	force;
+		__u64	bs;
 	};
 
 	struct config cfg = {
-		.namespace_id = 0,
-		.timeout      = 600000,
-		.lbaf         = 0xff,
-		.ses          = 0,
-		.pi           = 0,
-		.reset        = 0,
-		.force        = 0,
-		.bs           = 0,
+		.namespace_id	= 0,
+		.timeout	= 600000,
+		.lbaf		= 0xff,
+		.ses		= 0,
+		.pi		= 0,
+		.pil		= 0,
+		.ms		= 0,
+		.reset		= false,
+		.force		= false,
+		.bs		= 0,
 	};
 
 	OPT_ARGS(opts) = {
@@ -3957,20 +4653,35 @@ static int format(int argc, char **argv, struct command *cmd, struct plugin *plu
 		OPT_BYTE("pil",          'p', &cfg.pil,          pil),
 		OPT_BYTE("ms",           'm', &cfg.ms,           ms),
 		OPT_FLAG("reset",        'r', &cfg.reset,        reset),
-		OPT_FLAG("force",        'f', &cfg.force,        force),
+		OPT_FLAG("force",          0, &cfg.force,        force),
 		OPT_SUFFIX("block-size", 'b', &cfg.bs,           bs),
 		OPT_END()
 	};
 
-	err = fd = parse_and_open(argc, argv, desc, opts);
-	if (fd < 0)
+	err = argconfig_parse(argc, argv, desc, opts);
+	if (err)
+		goto ret;
+
+	err = fd = open_exclusive(argc, argv, cfg.force);
+	if (fd < 0) {
+		if (errno == EBUSY) {
+			fprintf(stderr, "Failed to open %s.\n",
+		                basename(argv[optind]));
+			fprintf(stderr,
+				"Namespace is currently busy.\n");
+			if (!cfg.force)
+				fprintf(stderr,
+				"Use the force [--force] option to ignore that.\n");
+		} else {
+			argconfig_print_help(desc, opts);
+		}
 		goto ret;
+	}
 
 	if (cfg.lbaf != 0xff && cfg.bs !=0) {
 		fprintf(stderr,
 			"Invalid specification of both LBAF and Block Size, please specify only one\n");
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 	if (cfg.bs) {
@@ -3978,15 +4689,14 @@ static int format(int argc, char **argv, struct command *cmd, struct plugin *plu
 			fprintf(stderr,
 				"Invalid value for block size (%"PRIu64"), must be a power of two\n",
 				       (uint64_t) cfg.bs);
-			errno = EINVAL;
-			err = -1;
+			err = -EINVAL;
 			goto close_fd;
 		}
 	}
 
 	err = nvme_identify_ctrl(fd, &ctrl);
 	if (err) {
-		perror("identify-ctrl");
+		fprintf(stderr, "identify-ctrl: %s\n", nvme_strerror(errno));
 		goto close_fd;
 	}
 
@@ -3998,9 +4708,9 @@ static int format(int argc, char **argv, struct command *cmd, struct plugin *plu
 		 */
 		cfg.namespace_id = NVME_NSID_ALL;
 	} else if (!cfg.namespace_id) {
-		err = cfg.namespace_id = nvme_get_nsid(fd);
+		err = nvme_get_nsid(fd, &cfg.namespace_id);
 		if (err < 0) {
-			perror("get-namespace-id");
+			fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
 			goto close_fd;
 		}
 	}
@@ -4010,23 +4720,22 @@ static int format(int argc, char **argv, struct command *cmd, struct plugin *plu
 			"Invalid namespace ID, "
 			"specify a namespace to format or use '-n 0xffffffff' "
 			"to format all namespaces on this controller.\n");
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
 	if (cfg.namespace_id != NVME_NSID_ALL) {
-		err = nvme_identify_ns(fd, cfg.namespace_id, 0, &ns);
+		err = nvme_identify_ns(fd, cfg.namespace_id, &ns);
 		if (err) {
 			if (err < 0)
-				perror("identify-namespace");
+				fprintf(stderr, "identify-namespace: %s\n", nvme_strerror(errno));
 			else {
 				fprintf(stderr, "identify failed\n");
 				nvme_show_status(err);
 			}
 			goto close_fd;
 		}
-		prev_lbaf = ns.flbas & 0xf;
+		nvme_id_ns_flbas_to_lbaf_inuse(ns.flbas, &prev_lbaf);
 
 		if (cfg.bs) {
 			for (i = 0; i < 16; ++i) {
@@ -4042,8 +4751,7 @@ static int format(int argc, char **argv, struct command *cmd, struct plugin *plu
 					(uint64_t)cfg.bs);
 				fprintf(stderr,
 					"Please correct block size, or specify LBAF directly\n");
-				errno = EINVAL;
-				err = -1;
+				err = -EINVAL;
 				goto close_fd;
 			}
 		} else  if (cfg.lbaf == 0xff)
@@ -4055,32 +4763,27 @@ static int format(int argc, char **argv, struct command *cmd, struct plugin *plu
 	/* ses & pi checks set to 7 for forward-compatibility */
 	if (cfg.ses > 7) {
 		fprintf(stderr, "invalid secure erase settings:%d\n", cfg.ses);
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
-	if (cfg.lbaf > 63) {
+	if (cfg.lbaf > 15) {
 		fprintf(stderr, "invalid lbaf:%d\n", cfg.lbaf);
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 	if (cfg.pi > 7) {
 		fprintf(stderr, "invalid pi:%d\n", cfg.pi);
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 	if (cfg.pil > 1) {
 		fprintf(stderr, "invalid pil:%d\n", cfg.pil);
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 	if (cfg.ms > 1) {
 		fprintf(stderr, "invalid ms:%d\n", cfg.ms);
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
@@ -4091,15 +4794,26 @@ static int format(int argc, char **argv, struct command *cmd, struct plugin *plu
 		nvme_show_relatives(devicename);
 		fprintf(stderr, "WARNING: Format may irrevocably delete this device's data.\n"
 			"You have 10 seconds to press Ctrl-C to cancel this operation.\n\n"
-			"Use the force [--force|-f] option to suppress this warning.\n");
+			"Use the force [--force] option to suppress this warning.\n");
 		sleep(10);
 		fprintf(stderr, "Sending format operation ... \n");
 	}
 
-	err = nvme_format(fd, cfg.namespace_id, cfg.lbaf, cfg.ses, cfg.pi,
-				cfg.pil, cfg.ms, cfg.timeout);
+	struct nvme_format_nvm_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.nsid		= cfg.namespace_id,
+		.lbaf		= cfg.lbaf,
+		.mset		= cfg.ms,
+		.pi		= cfg.pi,
+		.pil		= cfg.pil,
+		.ses		= cfg.ses,
+		.timeout	= cfg.timeout,
+		.result		= NULL,
+	};
+	err = nvme_format_nvm(&args);
 	if (err < 0)
-		perror("format");
+		fprintf(stderr, "format: %s\n", nvme_strerror(errno));
 	else if (err != 0)
 		nvme_show_status(err);
 	else {
@@ -4136,13 +4850,13 @@ static int format(int argc, char **argv, struct command *cmd, struct plugin *plu
 			}
 		}
 		if (cfg.reset && is_chardev())
-			nvme_reset_controller(fd);
+			nvme_ctrl_reset(fd);
 	}
 
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 #define STRTOUL_AUTO_BASE              (0)
@@ -4167,30 +4881,30 @@ static int set_feature(int argc, char **argv, struct command *cmd, struct plugin
 	const char *cdw12 = "feature cdw12, if used";
 	const char *save = "specifies that the controller shall save the attribute";
 	const char *uuid_index = "specify uuid index";
-	int err = -1;
+	int err;
 	__u32 result;
 	void *buf = NULL;
 	int fd, ffd = STDIN_FILENO;
 
 	struct config {
-		char *file;
-		__u32 namespace_id;
-		__u8  feature_id;
-		__u64 value;
-		__u32 cdw12;
-		__u8  uuid_index;
-		__u32 data_len;
-		int   save;
+		__u32	namespace_id;
+		__u8	feature_id;
+		__u64	value;
+		__u32	cdw12;
+		__u8	uuid_index;
+		__u32	data_len;
+		char	*file;
+		bool	save;
 	};
 
 	struct config cfg = {
-		.file         = "",
-		.namespace_id = 0,
-		.feature_id   = 0,
-		.value        = 0,
-		.uuid_index   = 0,
-		.data_len     = 0,
-		.save         = 0,
+		.namespace_id	= 0,
+		.feature_id	= 0,
+		.value		= 0,
+		.uuid_index	= 0,
+		.data_len	= 0,
+		.file		= "",
+		.save		= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -4210,10 +4924,10 @@ static int set_feature(int argc, char **argv, struct command *cmd, struct plugin
 		goto ret;
 
 	if (!cfg.namespace_id) {
-		err = cfg.namespace_id = nvme_get_nsid(fd);
+		err = nvme_get_nsid(fd, &cfg.namespace_id);
 		if (err < 0) {
 			if (errno != ENOTTY) {
-				perror("get-namespace-id");
+				fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
 				goto close_fd;
 			}
 
@@ -4223,26 +4937,24 @@ static int set_feature(int argc, char **argv, struct command *cmd, struct plugin
 
 	if (!cfg.feature_id) {
 		fprintf(stderr, "feature-id required param\n");
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
 	if (cfg.uuid_index > 128) {
 		fprintf(stderr, "invalid uuid index param: %u\n", cfg.uuid_index);
-		errno = EINVAL;
 		err = -1;
 		goto close_fd;
 	}
 
 	if (!cfg.data_len)
-		cfg.data_len = nvme_feat_buf_len[cfg.feature_id];
+		nvme_get_feature_length(cfg.feature_id, cfg.value,
+					&cfg.data_len);
 
 	if (cfg.data_len) {
 		if (posix_memalign(&buf, getpagesize(), cfg.data_len)) {
 			fprintf(stderr, "can not allocate feature payload\n");
-			errno = ENOMEM;
-			err = -1;
+			err = -ENOMEM;
 			goto close_fd;
 		}
 		memset(buf, 0, cfg.data_len);
@@ -4255,16 +4967,15 @@ static int set_feature(int argc, char **argv, struct command *cmd, struct plugin
 		 * should use the buffer method if the value exceeds this
 		 * length.
 		 */
-		if (NVME_FEAT_TIMESTAMP == cfg.feature_id && cfg.value) {
+		if (NVME_FEAT_FID_TIMESTAMP == cfg.feature_id && cfg.value) {
 			memcpy(buf, &cfg.value, NVME_FEAT_TIMESTAMP_DATA_SIZE);
 		} else {
 			if (strlen(cfg.file)) {
 				ffd = open(cfg.file, O_RDONLY);
 				if (ffd <= 0) {
-					errno = EINVAL;
 					fprintf(stderr, "Failed to open file %s: %s\n",
-					cfg.file, strerror(errno));
-					err = -1;
+						cfg.file, strerror(errno));
+					err = -EINVAL;
 					goto free;
 				}
 			}
@@ -4279,21 +4990,35 @@ static int set_feature(int argc, char **argv, struct command *cmd, struct plugin
 		}
 	}
 
-	err = nvme_set_feature(fd, cfg.namespace_id, cfg.feature_id, cfg.value,
-			       cfg.cdw12, cfg.save, cfg.uuid_index, cfg.data_len, buf, &result);
+	struct nvme_set_features_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.fid		= cfg.feature_id,
+		.nsid		= cfg.namespace_id,
+		.cdw11		= cfg.value,
+		.cdw12		= cfg.cdw12,
+		.save		= cfg.save,
+		.uuidx		= cfg.uuid_index,
+		.cdw15		= 0,
+		.data_len	= cfg.data_len,
+		.data		= buf,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= &result,
+	};
+	err = nvme_set_features(&args);
 	if (err < 0) {
-		perror("set-feature");
+		fprintf(stderr, "set-feature: %s\n", nvme_strerror(errno));
 	} else if (!err) {
 		printf("set-feature:%#0*x (%s), value:%#0*"PRIx64", cdw12:%#0*x, save:%#x\n",
 		       cfg.feature_id ? 4 : 2, cfg.feature_id,
 		       nvme_feature_to_string(cfg.feature_id),
 		       cfg.value ? 10 : 8, (uint64_t)cfg.value,
 		       cfg.cdw12 ? 10 : 8, cfg.cdw12, cfg.save);
-		if (cfg.feature_id == NVME_LBA_STATUS_INFO) {
+		if (cfg.feature_id == NVME_FEAT_FID_LBA_STS_INTERVAL) {
 			nvme_show_lba_status_info(result);
 		}
 		if (buf) {
-			if (cfg.feature_id == NVME_FEAT_LBA_RANGE)
+			if (cfg.feature_id == NVME_FEAT_FID_LBA_RANGE)
 				nvme_show_lba_range((struct nvme_lba_range_type *)buf,
 								result);
 			else
@@ -4309,7 +5034,7 @@ free:
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int sec_send(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -4326,24 +5051,26 @@ static int sec_send(int argc, char **argv, struct command *cmd, struct plugin *p
 	const char *tl = "transfer length (cf. SPC-4)";
 	const char *namespace_id = "desired namespace";
 	const char *nssf = "NVMe Security Specific Field";
-	int err = -1, fd, sec_fd = -1;
+	int err, fd, sec_fd = STDIN_FILENO;
 	void *sec_buf;
 	unsigned int sec_size;
 
 	struct config {
-		__u32 namespace_id;
-		char  *file;
-		__u8  nssf;
-		__u8  secp;
-		__u16 spsp;
-		__u32 tl;
+		__u32	namespace_id;
+		char	*file;
+		__u8	nssf;
+		__u8	secp;
+		__u16	spsp;
+		__u32	tl;
 	};
 
 	struct config cfg = {
-		.file = "",
-		.secp = 0,
-		.spsp = 0,
-		.tl   = 0,
+		.namespace_id	= 0,
+		.file		= "",
+		.nssf		= 0,
+		.secp		= 0,
+		.spsp		= 0,
+		.tl		= 0,
 	};
 
 	OPT_ARGS(opts) = {
@@ -4365,16 +5092,6 @@ static int sec_send(int argc, char **argv, struct command *cmd, struct plugin *p
 		err = -EINVAL;
 		goto close_fd;
 	}
-
-	sec_fd = open(cfg.file, O_RDONLY);
-	if (sec_fd < 0) {
-		fprintf(stderr, "Failed to open %s: %s\n",
-				cfg.file, strerror(errno));
-		errno = EINVAL;
-		err = -1;
-		goto close_fd;
-	}
-
 	if ((cfg.tl & 3) != 0)
 		fprintf(stderr, "WARNING: --tl not dword aligned; unaligned bytes may be truncated\n");
 
@@ -4399,15 +5116,13 @@ static int sec_send(int argc, char **argv, struct command *cmd, struct plugin *p
 		sec_size = cfg.tl > sb.st_size ? cfg.tl : sb.st_size;
 	}
 
-	sec_size = sb.st_size;
-	if (posix_memalign(&sec_buf, getpagesize(), sec_size)) {
-		fprintf(stderr, "No memory for security size:%d\n", sec_size);
-		errno = ENOMEM;
-		err = -1;
+	if (posix_memalign(&sec_buf, getpagesize(), cfg.tl)) {
+		fprintf(stderr, "No memory for security size:%d\n", cfg.tl);
+		err = -ENOMEM;
 		goto close_sec_fd;
 	}
 
-	memset(sec_buf, 0, cfg.tl); // ensure zero fill if cfg.tl > sec_size
+	memset(sec_buf, 0, cfg.tl); // ensure zero fill if buf_size > sec_size
 
 	err = read(sec_fd, sec_buf, sec_size);
 	if (err < 0) {
@@ -4417,10 +5132,23 @@ static int sec_send(int argc, char **argv, struct command *cmd, struct plugin *p
 		goto free;
 	}
 
-	err = nvme_sec_send(fd, cfg.namespace_id, cfg.nssf, cfg.spsp, cfg.secp,
-			cfg.tl, sec_buf);
+	struct nvme_security_send_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.nsid		= cfg.namespace_id,
+		.nssf		= cfg.nssf,
+		.spsp0		= cfg.spsp & 0xff,
+		.spsp1		= cfg.spsp >> 8,
+		.secp		= cfg.secp,
+		.tl		= cfg.tl,
+		.data_len	= cfg.tl,
+		.data		= sec_buf,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= NULL,
+	};
+	err = nvme_security_send(&args);
 	if (err < 0)
-		perror("security-send");
+		fprintf(stderr, "security-send: %s\n", nvme_strerror(errno));
 	else if (err != 0)
 		nvme_show_status(err);
 	else
@@ -4433,7 +5161,7 @@ close_sec_fd:
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int dir_send(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -4449,34 +5177,37 @@ static int dir_send(int argc, char **argv, struct command *cmd, struct plugin *p
 	const char *endir = "directive enable";
 	const char *ttype = "target directive type to be enabled/disabled";
 	const char *human_readable = "show directive in readable format";
-	int err = -1, fd;
+	const char *input = "write/send file (default stdin)";
+	int err, fd;
 	__u32 result;
 	__u32 dw12 = 0;
 	void *buf = NULL;
 	int ffd = STDIN_FILENO;
 
 	struct config {
-		char *file;
-		__u32 namespace_id;
-		__u32 data_len;
-		__u16 dspec;
-		__u8  dtype;
-		__u8  doper;
-		__u16 endir;
-		__u8  ttype;
-		int  raw_binary;
-		int  human_readable;
+		__u32	namespace_id;
+		__u32	data_len;
+		__u8	dtype;
+		__u8	ttype;
+		__u16	dspec;
+		__u8	doper;
+		__u16	endir;
+		bool	human_readable;
+		bool	raw_binary;
+		char	*file;
 	};
 
 	struct config cfg = {
-		.file         = "",
-		.namespace_id = 1,
-		.data_len     = 0,
-		.dspec        = 0,
-		.dtype        = 0,
-		.ttype        = 0,
-		.doper        = 0,
-		.endir        = 1,
+		.namespace_id	= 1,
+		.data_len	= 0,
+		.dtype		= 0,
+		.ttype		= 0,
+		.dspec		= 0,
+		.doper		= 0,
+		.endir		= 1,
+		.human_readable	= false,
+		.raw_binary	= false,
+		.file		= "",
 	};
 
 	OPT_ARGS(opts) = {
@@ -4489,6 +5220,7 @@ static int dir_send(int argc, char **argv, struct command *cmd, struct plugin *p
 		OPT_SHRT("endir",         'e', &cfg.endir,          endir),
 		OPT_FLAG("human-readable",'H', &cfg.human_readable, human_readable),
 		OPT_FLAG("raw-binary",    'b', &cfg.raw_binary,     raw),
+		OPT_FILE("input-file",    'i', &cfg.file,	    input),
 		OPT_END()
 	};
 
@@ -4497,48 +5229,43 @@ static int dir_send(int argc, char **argv, struct command *cmd, struct plugin *p
 		goto ret;
 
 	switch (cfg.dtype) {
-	case NVME_DIR_IDENTIFY:
+	case NVME_DIRECTIVE_DTYPE_IDENTIFY:
 		switch (cfg.doper) {
-		case NVME_DIR_SND_ID_OP_ENABLE:
+		case NVME_DIRECTIVE_SEND_IDENTIFY_DOPER_ENDIR:
 			if (!cfg.ttype) {
 				fprintf(stderr, "target-dir required param\n");
-				errno = EINVAL;
-				err = -1;
+				err = -EINVAL;
 				goto close_fd;
 			}
 			dw12 = cfg.ttype << 8 | cfg.endir;
 			break;
 		default:
 			fprintf(stderr, "invalid directive operations for Identify Directives\n");
-			errno = EINVAL;
-			err = -1;
+			err = -EINVAL;
 			goto close_fd;
 		}
 		break;
-	case NVME_DIR_STREAMS:
+	case NVME_DIRECTIVE_DTYPE_STREAMS:
 		switch (cfg.doper) {
-		case NVME_DIR_SND_ST_OP_REL_ID:
-		case NVME_DIR_SND_ST_OP_REL_RSC:
+		case NVME_DIRECTIVE_SEND_STREAMS_DOPER_RELEASE_IDENTIFIER:
+		case NVME_DIRECTIVE_SEND_STREAMS_DOPER_RELEASE_RESOURCE:
 			break;
 		default:
 			fprintf(stderr, "invalid directive operations for Streams Directives\n");
-			errno = EINVAL;
-			err = -1;
+			err = -EINVAL;
 			goto close_fd;
 		}
 		break;
 	default:
 		fprintf(stderr, "invalid directive type\n");
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
 
 	if (cfg.data_len) {
 		if (posix_memalign(&buf, getpagesize(), cfg.data_len)) {
-			errno = ENOMEM;
-			err = -1;
+			err = -ENOMEM;
 			goto close_fd;
 		}
 		memset(buf, 0, cfg.data_len);
@@ -4550,8 +5277,7 @@ static int dir_send(int argc, char **argv, struct command *cmd, struct plugin *p
 			if (ffd <= 0) {
 				fprintf(stderr, "Failed to open file %s: %s\n",
 						cfg.file, strerror(errno));
-				errno = EINVAL;
-				err = -1;
+				err = -EINVAL;
 				goto free;
 			}
 		}
@@ -4564,10 +5290,22 @@ static int dir_send(int argc, char **argv, struct command *cmd, struct plugin *p
 		}
 	}
 
-	err = nvme_dir_send(fd, cfg.namespace_id, cfg.dspec, cfg.dtype, cfg.doper,
-			cfg.data_len, dw12, buf, &result);
+	struct nvme_directive_send_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.nsid		= cfg.namespace_id,
+		.dspec		= cfg.dspec,
+		.doper		= cfg.doper,
+		.dtype		= cfg.dtype,
+		.cdw12		= dw12,
+		.data_len	= cfg.data_len,
+		.data		= buf,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= &result,
+	};
+	err = nvme_directive_send(&args);
 	if (err < 0) {
-		perror("dir-send");
+		fprintf(stderr, "dir-send: %s\n", nvme_strerror(errno));
 		goto close_ffd;
 	}
 	if (!err) {
@@ -4589,12 +5327,12 @@ free:
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int write_uncor(int argc, char **argv, struct command *cmd, struct plugin *plugin)
 {
-	int err = -1, fd;
+	int err, fd;
 	const char *desc = "The Write Uncorrectable command is used to set a "\
 			"range of logical blocks to invalid.";
 	const char *namespace_id = "desired namespace";
@@ -4602,15 +5340,15 @@ static int write_uncor(int argc, char **argv, struct command *cmd, struct plugin
 	const char *block_count = "number of blocks (zeroes based) on device to access";
 
 	struct config {
-		__u64 start_block;
-		__u32 namespace_id;
-		__u16 block_count;
+		__u32	namespace_id;
+		__u64	start_block;
+		__u16	block_count;
 	};
 
 	struct config cfg = {
-		.start_block     = 0,
-		.namespace_id    = 0,
-		.block_count     = 0,
+		.namespace_id	= 0,
+		.start_block	= 0,
+		.block_count	= 0,
 	};
 
 	OPT_ARGS(opts) = {
@@ -4625,17 +5363,25 @@ static int write_uncor(int argc, char **argv, struct command *cmd, struct plugin
 		goto ret;
 
 	if (!cfg.namespace_id) {
-		err = cfg.namespace_id = nvme_get_nsid(fd);
+		err = nvme_get_nsid(fd, &cfg.namespace_id);
 		if (err < 0) {
-			perror("get-namespace-id");
+			fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
 			goto close_fd;
 		}
 	}
 
-	err = nvme_write_uncorrectable(fd, cfg.namespace_id, cfg.start_block,
-					cfg.block_count);
+	struct nvme_io_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.nsid		= cfg.namespace_id,
+		.slba		= cfg.start_block,
+		.nlb		= cfg.block_count,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= NULL,
+	};
+	err = nvme_write_uncorrectable(&args);
 	if (err < 0)
-		perror("write uncorrectable");
+		fprintf(stderr, "write uncorrectable: %s\n", nvme_strerror(errno));
 	else if (err != 0)
 		nvme_show_status(err);
 	else
@@ -4644,12 +5390,12 @@ static int write_uncor(int argc, char **argv, struct command *cmd, struct plugin
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int write_zeroes(int argc, char **argv, struct command *cmd, struct plugin *plugin)
 {
-	int err = -1, fd;
+	int err, fd;
 	__u16 control = 0;
 	const char *desc = "The Write Zeroes command is used to set a "\
 			"range of logical blocks to zero.";
@@ -4657,7 +5403,7 @@ static int write_zeroes(int argc, char **argv, struct command *cmd, struct plugi
 	const char *start_block = "64-bit LBA of first block to access";
 	const char *block_count = "number of blocks (zeroes based) on device to access";
 	const char *limited_retry = "limit media access attempts";
-	const char *force = "force device to commit data before command completes";
+	const char *force_unit_access = "force device to commit data before command completes";
 	const char *prinfo = "PI and check field";
 	const char *ref_tag = "reference tag (for end to end PI)";
 	const char *app_tag_mask = "app tag mask (for end to end PI)";
@@ -4669,29 +5415,33 @@ static int write_zeroes(int argc, char **argv, struct command *cmd, struct plugi
 		"part of end-to-end data protection processing";
 
 	struct config {
-		__u64 start_block;
-		__u32 namespace_id;
-		__u32 ref_tag;
-		__u16 app_tag;
-		__u16 app_tag_mask;
-		__u16 block_count;
-		__u8  prinfo;
-		__u64 storage_tag;
-		int   deac;
-		int   limited_retry;
-		int   force_unit_access;
-		int   storage_tag_check;
+		__u32	namespace_id;
+		__u64	start_block;
+		__u16	block_count;
+		bool	deac;
+		bool	limited_retry;
+		bool	force_unit_access;
+		__u8	prinfo;
+		__u32	ref_tag;
+		__u16	app_tag_mask;
+		__u16	app_tag;
+		__u64	storage_tag;
+		bool	storage_tag_check;
 	};
 
 	struct config cfg = {
-		.start_block     	= 0,
-		.block_count     	= 0,
-		.prinfo          	= 0,
-		.ref_tag         	= 0,
-		.app_tag_mask    	= 0,
-		.app_tag         	= 0,
-		.storage_tag	 	= 0,
-		.storage_tag_check 	= 0,
+		.namespace_id		= 0,
+		.start_block		= 0,
+		.block_count		= 0,
+		.deac			= false,
+		.limited_retry		= false,
+		.force_unit_access	= false,
+		.prinfo			= 0,
+		.ref_tag		= 0,
+		.app_tag_mask		= 0,
+		.app_tag		= 0,
+		.storage_tag		= 0,
+		.storage_tag_check	= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -4700,7 +5450,7 @@ static int write_zeroes(int argc, char **argv, struct command *cmd, struct plugi
 		OPT_SHRT("block-count",       'c', &cfg.block_count,       block_count),
 		OPT_FLAG("deac",              'd', &cfg.deac,              deac),
 		OPT_FLAG("limited-retry",     'l', &cfg.limited_retry,     limited_retry),
-		OPT_FLAG("force-unit-access", 'f', &cfg.force_unit_access, force),
+		OPT_FLAG("force-unit-access", 'f', &cfg.force_unit_access, force_unit_access),
 		OPT_BYTE("prinfo",            'p', &cfg.prinfo,            prinfo),
 		OPT_UINT("ref-tag",           'r', &cfg.ref_tag,           ref_tag),
 		OPT_SHRT("app-tag-mask",      'm', &cfg.app_tag_mask,      app_tag_mask),
@@ -4715,33 +5465,44 @@ static int write_zeroes(int argc, char **argv, struct command *cmd, struct plugi
 		goto ret;
 
 	if (cfg.prinfo > 0xf) {
-		fprintf(stderr, "invalid prinfo: %u\n", cfg.prinfo);
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
 	control |= (cfg.prinfo << 10);
 	if (cfg.limited_retry)
-		control |= NVME_RW_LR;
+		control |= NVME_IO_LR;
 	if (cfg.force_unit_access)
-		control |= NVME_RW_FUA;
+		control |= NVME_IO_FUA;
 	if (cfg.deac)
-		control |= NVME_RW_DEAC;
+		control |= NVME_IO_DEAC;
 	if (cfg.storage_tag_check)
-		control |= NVME_RW_STORAGE_TAG_CHECK;
+		control |= NVME_SC_STORAGE_TAG_CHECK;
 	if (!cfg.namespace_id) {
-		err = cfg.namespace_id = nvme_get_nsid(fd);
+		err = nvme_get_nsid(fd, &cfg.namespace_id);
 		if (err < 0) {
-			perror("get-namespace-id");
+			fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
 			goto close_fd;
 		}
 	}
 
-	err = nvme_write_zeros(fd, cfg.namespace_id, cfg.start_block, cfg.block_count,
-			control, cfg.ref_tag, cfg.app_tag, cfg.app_tag_mask, cfg.storage_tag);
+	struct nvme_io_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.nsid		= cfg.namespace_id,
+		.slba		= cfg.start_block,
+		.nlb		= cfg.block_count,
+		.control	= control,
+		.reftag		= cfg.ref_tag,
+		.apptag		= cfg.app_tag,
+		.appmask	= cfg.app_tag_mask,
+		.storage_tag	= cfg.storage_tag,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= NULL,
+	};
+	err = nvme_write_zeros(&args);
 	if (err < 0)
-		perror("write-zeroes");
+		fprintf(stderr, "write-zeroes: %s\n", nvme_strerror(errno));
 	else if (err != 0)
 		nvme_show_status(err);
 	else
@@ -4750,7 +5511,7 @@ static int write_zeroes(int argc, char **argv, struct command *cmd, struct plugi
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int dsm(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -4768,43 +5529,43 @@ static int dsm(int argc, char **argv, struct command *cmd, struct plugin *plugin
 	const char *idr = "Attribute Integral Dataset for Read";
 	const char *cdw11 = "All the command DWORD 11 attributes. Use instead of specifying individual attributes";
 
-	int err = -1, fd;
+	int err, fd;
 	uint16_t nr, nc, nb, ns;
-	int ctx_attrs[256] = {0,};
-	int nlbs[256] = {0,};
-	unsigned long long slbas[256] = {0,};
-	struct nvme_dsm_range *dsm;
+	__u32 ctx_attrs[256] = {0,};
+	__u32 nlbs[256] = {0,};
+	__u64 slbas[256] = {0,};
+	struct nvme_dsm_range dsm[256];
 
 	struct config {
-		char  *ctx_attrs;
-		char  *blocks;
-		char  *slbas;
-		int   ad;
-		int   idw;
-		int   idr;
-		__u32 cdw11;
-		__u32 namespace_id;
+		__u32	namespace_id;
+		char	*ctx_attrs;
+		char	*blocks;
+		char	*slbas;
+		bool	ad;
+		bool	idw;
+		bool	idr;
+		__u32	cdw11;
 	};
 
 	struct config cfg = {
-		.ctx_attrs = "",
-		.blocks = "",
-		.slbas = "",
-		.namespace_id = 0,
-		.ad = 0,
-		.idw = 0,
-		.idr = 0,
-		.cdw11 = 0,
+		.namespace_id	= 0,
+		.ctx_attrs	= "",
+		.blocks		= "",
+		.slbas		= "",
+		.ad		= false,
+		.idw		= false,
+		.idr		= false,
+		.cdw11		= 0,
 	};
 
 	OPT_ARGS(opts) = {
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace_id),
 		OPT_LIST("ctx-attrs",    'a', &cfg.ctx_attrs,    context_attrs),
-		OPT_LIST("blocks", 	 'b', &cfg.blocks,       blocks),
-		OPT_LIST("slbs", 	 's', &cfg.slbas,        starting_blocks),
-		OPT_FLAG("ad", 	         'd', &cfg.ad,           ad),
-		OPT_FLAG("idw", 	 'w', &cfg.idw,          idw),
-		OPT_FLAG("idr", 	 'r', &cfg.idr,          idr),
+		OPT_LIST("blocks",	 'b', &cfg.blocks,       blocks),
+		OPT_LIST("slbs",	 's', &cfg.slbas,        starting_blocks),
+		OPT_FLAG("ad",	         'd', &cfg.ad,           ad),
+		OPT_FLAG("idw",		 'w', &cfg.idw,          idw),
+		OPT_FLAG("idr",		 'r', &cfg.idr,          idr),
 		OPT_UINT("cdw11",        'c', &cfg.cdw11,        cdw11),
 		OPT_END()
 	};
@@ -4813,49 +5574,49 @@ static int dsm(int argc, char **argv, struct command *cmd, struct plugin *plugin
 	if (fd < 0)
 		goto ret;
 
-	nc = argconfig_parse_comma_sep_array(cfg.ctx_attrs, ctx_attrs, ARRAY_SIZE(ctx_attrs));
-	nb = argconfig_parse_comma_sep_array(cfg.blocks, nlbs, ARRAY_SIZE(nlbs));
-	ns = argconfig_parse_comma_sep_array_long(cfg.slbas, slbas, ARRAY_SIZE(slbas));
+	nc = argconfig_parse_comma_sep_array(cfg.ctx_attrs, (int *)ctx_attrs, ARRAY_SIZE(ctx_attrs));
+	nb = argconfig_parse_comma_sep_array(cfg.blocks, (int *)nlbs, ARRAY_SIZE(nlbs));
+	ns = argconfig_parse_comma_sep_array_long(cfg.slbas, (unsigned long long *)slbas, ARRAY_SIZE(slbas));
 	nr = max(nc, max(nb, ns));
 	if (!nr || nr > 256) {
 		fprintf(stderr, "No range definition provided\n");
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
 	if (!cfg.namespace_id) {
-		err = cfg.namespace_id = nvme_get_nsid(fd);
+		err = nvme_get_nsid(fd, &cfg.namespace_id);
 		if (err < 0) {
-			perror("get-namespace-id");
+			fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
 			goto close_fd;
 		}
 	}
 	if (!cfg.cdw11)
 		cfg.cdw11 = (cfg.ad << 2) | (cfg.idw << 1) | (cfg.idr << 0);
 
-	dsm = nvme_setup_dsm_range(ctx_attrs, nlbs, slbas, nr);
-	if (!dsm) {
-		fprintf(stderr, "failed to allocate data set payload\n");
-		errno = ENOMEM;
-		err = -1;
-		goto close_fd;
-	}
-
-	err = nvme_dsm(fd, cfg.namespace_id, cfg.cdw11, dsm, nr);
+	nvme_init_dsm_range(dsm, ctx_attrs, nlbs, slbas, nr);
+	struct nvme_dsm_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.nsid		= cfg.namespace_id,
+		.attrs		= cfg.cdw11,
+		.nr_ranges	= nr,
+		.dsm		= dsm,
+		.timeout        = NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= NULL,
+	};
+	err = nvme_dsm(&args);
 	if (err < 0)
-		perror("data-set management");
+		fprintf(stderr, "data-set management: %s\n", nvme_strerror(errno));
 	else if (err != 0)
 		nvme_show_status(err);
 	else
 		printf("NVMe DSM: success\n");
 
-	free(dsm);
-
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int copy(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -4883,62 +5644,73 @@ static int copy(int argc, char **argv, struct command *cmd, struct plugin *plugi
 	const char *d_dspec = "directive specific (write part)";
 	const char *d_format = "source range entry format";
 
-	int err = -1, fd;
+	int err, fd;
 	uint16_t nr, nb, ns, nrts, natms, nats;
-	int nlbs[128] = { 0 };
+	__u16 nlbs[128] = { 0 };
 	unsigned long long slbas[128] = {0,};
-	int eilbrts[128] = { 0 };
-	int elbatms[128] = { 0 };
-	int elbats[128] = { 0 };
-	struct nvme_copy_range *copy;
+	__u32 eilbrts[128] = { 0 };
+	__u32 elbatms[128] = { 0 };
+	__u32 elbats[128] = { 0 };
+	struct nvme_copy_range copy[128];
 
 	struct config {
-		__u32 namespace_id;
-		__u64 sdlba;
-		char  *nlbs;
-		char  *slbas;
-		__u32 ilbrt;
-		char  *eilbrts;
-		__u16 lbatm;
-		char  *elbatms;
-		__u16 lbat;
-		char  *elbats;
-		__u8  prinfow;
-		__u8  prinfor;
-		int   lr;
-		int   fua;
-		__u8  dtype;
-		__u16 dspec;
-		__u8  format;
+		__u32	namespace_id;
+		__u64	sdlba;
+		char	*slbas;
+		char	*nlbs;
+		bool	lr;
+		bool	fua;
+		__u8	prinfow;
+		__u8	prinfor;
+		__u32	ilbrt;
+		char	*eilbrts;
+		__u16	lbat;
+		char	*elbatms;
+		__u16	lbatm;
+		char	*elbats;
+		__u8	dtype;
+		__u16	dspec;
+		__u8	format;
 	};
 
 	struct config cfg = {
-		.namespace_id = 0,
-		.nlbs    = "",
-		.slbas   = "",
-		.eilbrts = "",
-		.elbatms = "",
-		.elbats  = "",
+		.namespace_id	= 0,
+		.sdlba		= 0,
+		.slbas		= "",
+		.nlbs		= "",
+		.lr		= false,
+		.fua		= false,
+		.prinfow	= 0,
+		.prinfor	= 0,
+		.ilbrt		= 0,
+		.eilbrts	= "",
+		.lbat		= 0,
+		.elbats		= "",
+		.lbatm		= 0,
+		.elbatms	= "",
+		.dtype		= 0,
+		.dspec		= 0,
+		.format		= 0,
 	};
 
 	OPT_ARGS(opts) = {
-		OPT_UINT("namespace-id",	   'n', &cfg.namespace_id, 	d_nsid),
-		OPT_SUFFIX("sdlba",                'd', &cfg.sdlba,   		d_sdlba),
-		OPT_LIST("slbs",                   's', &cfg.slbas,   		d_slbas),
-		OPT_LIST("blocks",                 'b', &cfg.nlbs,    		d_nlbs),
-		OPT_FLAG("limited-retry",          'l', &cfg.lr,      		d_lr),
-		OPT_FLAG("force-unit-access",      'f', &cfg.fua,     		d_fua),
-		OPT_BYTE("prinfow",                'p', &cfg.prinfow, 		d_prinfow),
-		OPT_BYTE("prinfor",                'P', &cfg.prinfor, 		d_prinfor),
-		OPT_UINT("ref-tag",                'r', &cfg.ilbrt,   		d_ilbrt),
-		OPT_LIST("expected-ref-tags",      'R', &cfg.eilbrts, 		d_eilbrts),
-		OPT_SHRT("app-tag",                'a', &cfg.lbat,    		d_lbat),
-		OPT_LIST("expected-app-tags",      'A', &cfg.elbats,  		d_elbats),
-		OPT_SHRT("app-tag-mask",           'm', &cfg.lbatm,   		d_lbatm),
-		OPT_LIST("expected-app-tag-masks", 'M', &cfg.elbatms, 		d_elbatms),
-		OPT_BYTE("dir-type",               'T', &cfg.dtype,   		d_dtype),
-		OPT_SHRT("dir-spec",               'S', &cfg.dspec,   		d_dspec),
-		OPT_BYTE("format",                 'F', &cfg.format,  		d_format),
+		OPT_UINT("namespace-id",	   'n', &cfg.namespace_id,	d_nsid),
+		OPT_SUFFIX("sdlba",                'd', &cfg.sdlba,		d_sdlba),
+		OPT_LIST("slbs",                   's', &cfg.slbas,		d_slbas),
+		OPT_LIST("blocks",                 'b', &cfg.nlbs,		d_nlbs),
+		OPT_FLAG("limited-retry",          'l', &cfg.lr,		d_lr),
+		OPT_FLAG("force-unit-access",      'f', &cfg.fua,		d_fua),
+		OPT_BYTE("prinfow",                'p', &cfg.prinfow,		d_prinfow),
+		OPT_BYTE("prinfor",                'P', &cfg.prinfor,		d_prinfor),
+		OPT_UINT("ref-tag",                'r', &cfg.ilbrt,		d_ilbrt),
+		OPT_LIST("expected-ref-tags",      'R', &cfg.eilbrts,		d_eilbrts),
+		OPT_SHRT("app-tag",                'a', &cfg.lbat,		d_lbat),
+		OPT_LIST("expected-app-tags",      'A', &cfg.elbats,		d_elbats),
+		OPT_SHRT("app-tag-mask",           'm', &cfg.lbatm,		d_lbatm),
+		OPT_LIST("expected-app-tag-masks", 'M', &cfg.elbatms,		d_elbatms),
+		OPT_BYTE("dir-type",               'T', &cfg.dtype,		d_dtype),
+		OPT_SHRT("dir-spec",               'S', &cfg.dspec,		d_dspec),
+		OPT_BYTE("format",                 'F', &cfg.format,		d_format),
 		OPT_END()
 	};
 
@@ -4948,52 +5720,61 @@ static int copy(int argc, char **argv, struct command *cmd, struct plugin *plugi
 		goto ret;
 	}
 
-	nb = argconfig_parse_comma_sep_array(cfg.nlbs, nlbs, ARRAY_SIZE(nlbs));
+	nb = argconfig_parse_comma_sep_array(cfg.nlbs, (int *)nlbs, ARRAY_SIZE(nlbs));
 	ns = argconfig_parse_comma_sep_array_long(cfg.slbas, slbas, ARRAY_SIZE(slbas));
-	nrts = argconfig_parse_comma_sep_array(cfg.eilbrts, eilbrts, ARRAY_SIZE(eilbrts));
-	natms = argconfig_parse_comma_sep_array(cfg.elbatms, elbatms, ARRAY_SIZE(elbatms));
-	nats = argconfig_parse_comma_sep_array(cfg.elbats, elbats, ARRAY_SIZE(elbats));
+	nrts = argconfig_parse_comma_sep_array(cfg.eilbrts, (int *)eilbrts, ARRAY_SIZE(eilbrts));
+	natms = argconfig_parse_comma_sep_array(cfg.elbatms, (int *)elbatms, ARRAY_SIZE(elbatms));
+	nats = argconfig_parse_comma_sep_array(cfg.elbats, (int *)elbats, ARRAY_SIZE(elbats));
 
 	nr = max(nb, max(ns, max(nrts, max(natms, nats))));
 	if (!nr || nr > 128) {
 		fprintf(stderr, "invalid range\n");
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
 	if (!cfg.namespace_id) {
-		err = cfg.namespace_id = nvme_get_nsid(fd);
+		err = nvme_get_nsid(fd, &cfg.namespace_id);
 		if (err < 0) {
-			perror("get-namespace-id");
+			fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
 			goto close_fd;
 		}
 	}
 
-	copy = nvme_setup_copy_range(nlbs, slbas, eilbrts, elbatms, elbats, nr);
-	if (!copy) {
-		fprintf(stderr, "failed to allocate payload\n");
-		errno = ENOMEM;
-		err = -1;
-		goto close_fd;
-	}
-
-	err = nvme_copy(fd, cfg.namespace_id, copy, cfg.sdlba, nr, cfg.prinfor,
-			cfg.prinfow, cfg.dtype, cfg.dspec, cfg.format, cfg.lr,
-			cfg.fua, cfg.ilbrt, cfg.lbatm, cfg.lbat);
+	nvme_init_copy_range(copy, nlbs, (__u64 *)slbas, eilbrts, elbatms, elbats, nr);
+
+	struct nvme_copy_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.nsid		= cfg.namespace_id,
+		.copy		= copy,
+		.sdlba		= cfg.sdlba,
+		.nr		= nr,
+		.prinfor	= cfg.prinfor,
+		.prinfow	= cfg.prinfow,
+		.dtype		= cfg.dtype,
+		.dspec		= cfg.dspec,
+		.format		= cfg.format,
+		.lr		= cfg.lr,
+		.fua		= cfg.fua,
+		.ilbrt		= cfg.ilbrt,
+		.lbatm		= cfg.lbatm,
+		.lbat		= cfg.lbat,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= NULL,
+	};
+	err = nvme_copy(&args);
 	if (err < 0)
-		perror("NVMe Copy");
+		fprintf(stderr, "NVMe Copy: %s\n", nvme_strerror(errno));
 	else if (err != 0)
 		nvme_show_status(err);
 	else
 		printf("NVMe Copy: success\n");
 
-	free(copy);
-
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int flush(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -5004,14 +5785,14 @@ static int flush(int argc, char **argv, struct command *cmd, struct plugin *plug
 		"flushed by the controller, from any namespace, depending on controller and "\
 		"associated namespace status.";
 	const char *namespace_id = "identifier of desired namespace";
-	int err = -1, fd;
+	int err, fd;
 
 	struct config {
-		__u32 namespace_id;
+		__u32	namespace_id;
 	};
 
 	struct config cfg = {
-		.namespace_id = 0,
+		.namespace_id	= 0,
 	};
 
 	OPT_ARGS(opts) = {
@@ -5024,16 +5805,16 @@ static int flush(int argc, char **argv, struct command *cmd, struct plugin *plug
 		goto ret;
 
 	if (!cfg.namespace_id) {
-		err = cfg.namespace_id = nvme_get_nsid(fd);
+		err = nvme_get_nsid(fd, &cfg.namespace_id);
 		if (err < 0) {
-			perror("get-namespace-id");
+			fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
 			goto close_fd;
 		}
 	}
 
 	err = nvme_flush(fd, cfg.namespace_id);
 	if (err < 0)
-		perror("flush");
+		fprintf(stderr, "flush: %s\n", nvme_strerror(errno));
 	else if (err != 0)
 		nvme_show_status(err);
 	else
@@ -5041,7 +5822,7 @@ static int flush(int argc, char **argv, struct command *cmd, struct plugin *plug
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int resv_acquire(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -5058,23 +5839,24 @@ static int resv_acquire(int argc, char **argv, struct command *cmd, struct plugi
 	const char *rtype = "reservation type";
 	const char *racqa = "reservation acquire action";
 	const char *iekey = "ignore existing res. key";
-	int err = -1, fd;
+	int err, fd;
 
 	struct config {
-		__u32 namespace_id;
-		__u64 crkey;
-		__u64 prkey;
-		__u8  rtype;
-		__u8  racqa;
-		int   iekey;
+		__u32	namespace_id;
+		__u64	crkey;
+		__u64	prkey;
+		__u8	rtype;
+		__u8	racqa;
+		bool	iekey;
 	};
 
 	struct config cfg = {
-		.namespace_id = 0,
-		.crkey        = 0,
-		.prkey        = 0,
-		.rtype        = 0,
-		.racqa        = 0,
+		.namespace_id	= 0,
+		.crkey		= 0,
+		.prkey		= 0,
+		.rtype		= 0,
+		.racqa		= 0,
+		.iekey		= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -5092,23 +5874,33 @@ static int resv_acquire(int argc, char **argv, struct command *cmd, struct plugi
 		goto ret;
 
 	if (!cfg.namespace_id) {
-		err = cfg.namespace_id = nvme_get_nsid(fd);
+		err = nvme_get_nsid(fd, &cfg.namespace_id);
 		if (err < 0) {
-			perror("get-namespace-id");
+			fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
 			goto close_fd;
 		}
 	}
 	if (cfg.racqa > 7) {
 		fprintf(stderr, "invalid racqa:%d\n", cfg.racqa);
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
-	err = nvme_resv_acquire(fd, cfg.namespace_id, cfg.rtype, cfg.racqa,
-				!!cfg.iekey, cfg.crkey, cfg.prkey);
+	struct nvme_resv_acquire_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.nsid		= cfg.namespace_id,
+		.rtype		= cfg.rtype,
+		.racqa		= cfg.racqa,
+		.iekey		= !!cfg.iekey,
+		.crkey		= cfg.crkey,
+		.nrkey		= cfg.prkey,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= NULL,
+	};
+	err = nvme_resv_acquire(&args);
 	if (err < 0)
-		perror("reservation acquire");
+		fprintf(stderr, "reservation acquire: %s\n", nvme_strerror(errno));
 	else if (err != 0)
 		nvme_show_status(err);
 	else
@@ -5117,7 +5909,7 @@ static int resv_acquire(int argc, char **argv, struct command *cmd, struct plugi
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int resv_register(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -5131,23 +5923,23 @@ static int resv_register(int argc, char **argv, struct command *cmd, struct plug
 	const char *nrkey = "new reservation key";
 	const char *rrega = "reservation registration action";
 	const char *cptpl = "change persistence through power loss setting";
-	int err = -1, fd;
+	int err, fd;
 
 	struct config {
-		__u32 namespace_id;
-		__u64 crkey;
-		__u64 nrkey;
-		__u8  rrega;
-		__u8  cptpl;
-		int   iekey;
+		__u32	namespace_id;
+		__u64	crkey;
+		__u64	nrkey;
+		__u8	rrega;
+		__u8	cptpl;
+		bool	iekey;
 	};
 
 	struct config cfg = {
-		.namespace_id = 0,
-		.crkey        = 0,
-		.nrkey        = 0,
-		.rrega        = 0,
-		.cptpl        = 0,
+		.namespace_id	= 0,
+		.crkey		= 0,
+		.nrkey		= 0,
+		.rrega		= 0,
+		.cptpl		= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -5165,30 +5957,39 @@ static int resv_register(int argc, char **argv, struct command *cmd, struct plug
 		goto ret;
 
 	if (!cfg.namespace_id) {
-		err = cfg.namespace_id = nvme_get_nsid(fd);
+		err = nvme_get_nsid(fd, &cfg.namespace_id);
 		if (err < 0) {
-			perror("get-namespace-id");
+			fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
 			goto close_fd;
 		}
 	}
 	if (cfg.cptpl > 3) {
 		fprintf(stderr, "invalid cptpl:%d\n", cfg.cptpl);
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
 	if (cfg.rrega > 7) {
 		fprintf(stderr, "invalid rrega:%d\n", cfg.rrega);
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
-	err = nvme_resv_register(fd, cfg.namespace_id, cfg.rrega, cfg.cptpl,
-				!!cfg.iekey, cfg.crkey, cfg.nrkey);
+	struct nvme_resv_register_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.nsid		= cfg.namespace_id,
+		.rrega		= cfg.rrega,
+		.cptpl		= cfg.cptpl,
+		.iekey		= !!cfg.iekey,
+		.crkey		= cfg.crkey,
+		.nrkey		= cfg.nrkey,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= NULL,
+	};
+	err = nvme_resv_register(&args);
 	if (err < 0)
-		perror("reservation register");
+		fprintf(stderr, "reservation register: %s\n", nvme_strerror(errno));
 	else if (err != 0)
 		nvme_show_status(err);
 	else
@@ -5197,7 +5998,7 @@ static int resv_register(int argc, char **argv, struct command *cmd, struct plug
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int resv_release(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -5215,22 +6016,22 @@ static int resv_release(int argc, char **argv, struct command *cmd, struct plugi
 	const char *iekey = "ignore existing res. key";
 	const char *rtype = "reservation type";
 	const char *rrela = "reservation release action";
-	int err = -1, fd;
+	int err, fd;
 
 	struct config {
-		__u32 namespace_id;
-		__u64 crkey;
-		__u8  rtype;
-		__u8  rrela;
-		__u8  iekey;
+		__u32	namespace_id;
+		__u64	crkey;
+		__u8	rtype;
+		__u8	rrela;
+		__u8	iekey;
 	};
 
 	struct config cfg = {
-		.namespace_id = 0,
-		.crkey        = 0,
-		.rtype        = 0,
-		.rrela        = 0,
-		.iekey        = 0,
+		.namespace_id	= 0,
+		.crkey		= 0,
+		.rtype		= 0,
+		.rrela		= 0,
+		.iekey		= 0,
 	};
 
 	OPT_ARGS(opts) = {
@@ -5247,23 +6048,32 @@ static int resv_release(int argc, char **argv, struct command *cmd, struct plugi
 		goto ret;
 
 	if (!cfg.namespace_id) {
-		err = cfg.namespace_id = nvme_get_nsid(fd);
+		err = nvme_get_nsid(fd, &cfg.namespace_id);
 		if (err < 0) {
-			perror("get-namespace-id");
+			fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
 			goto close_fd;
 		}
 	}
 	if (cfg.rrela > 7) {
 		fprintf(stderr, "invalid rrela:%d\n", cfg.rrela);
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
-	err = nvme_resv_release(fd, cfg.namespace_id, cfg.rtype, cfg.rrela,
-				!!cfg.iekey, cfg.crkey);
+	struct nvme_resv_release_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.nsid		= cfg.namespace_id,
+		.rtype		= cfg.rtype,
+		.rrela		= cfg.rrela,
+		.iekey		= !!cfg.iekey,
+		.crkey		= cfg.crkey,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= NULL,
+	};
+	err = nvme_resv_release(&args);
 	if (err < 0)
-		perror("reservation release");
+		fprintf(stderr, "reservation release: %s\n", nvme_strerror(errno));
 	else if (err != 0)
 		nvme_show_status(err);
 	else
@@ -5272,7 +6082,7 @@ static int resv_release(int argc, char **argv, struct command *cmd, struct plugi
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int resv_report(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -5284,32 +6094,33 @@ static int resv_report(int argc, char **argv, struct command *cmd, struct plugin
 		"namespace.";
 	const char *namespace_id = "identifier of desired namespace";
 	const char *numd = "number of dwords to transfer";
-	const char *cdw11 = "command dword 11 value";
+	const char *eds = "request extended data structure";
 	const char *raw = "dump output in binary format";
 
-	struct nvme_reservation_status *status;
+	struct nvme_resv_status *status;
 	enum nvme_print_flags flags;
-	int err = -1, fd, size;
+	int err, fd, size;
 
 	struct config {
-		__u32 namespace_id;
-		__u32 numd;
-		__u32 cdw11;
-		int   raw_binary;
-		char *output_format;
+		__u32	namespace_id;
+		__u32	numd;
+		__u8	eds;
+		char	*output_format;
+		bool	raw_binary;
 	};
 
 	struct config cfg = {
-		.namespace_id = 0,
-		.numd         = 0,
-		.cdw11	      = 0,
-		.output_format = "normal",
+		.namespace_id	= 0,
+		.numd		= 0,
+		.eds		= false,
+		.output_format	= "normal",
+		.raw_binary	= false,
 	};
 
 	OPT_ARGS(opts) = {
 		OPT_UINT("namespace-id",  'n', &cfg.namespace_id,   namespace_id),
 		OPT_UINT("numd",          'd', &cfg.numd,           numd),
-		OPT_UINT("cdw11",         'c', &cfg.cdw11,          cdw11),
+		OPT_FLAG("eds",           'e', &cfg.eds,            eds),
 		OPT_FMT("output-format",  'o', &cfg.output_format,  output_format),
 		OPT_FLAG("raw-binary",    'b', &cfg.raw_binary,     raw),
 		OPT_END()
@@ -5326,9 +6137,9 @@ static int resv_report(int argc, char **argv, struct command *cmd, struct plugin
 		flags = BINARY;
 
 	if (!cfg.namespace_id) {
-		err = cfg.namespace_id = nvme_get_nsid(fd);
+		err = nvme_get_nsid(fd, &cfg.namespace_id);
 		if (err < 0) {
-			perror("get-namespace-id");
+			fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
 			goto close_fd;
 		}
 	}
@@ -5342,24 +6153,33 @@ static int resv_report(int argc, char **argv, struct command *cmd, struct plugin
 
 	if (posix_memalign((void **)&status, getpagesize(), size)) {
 		fprintf(stderr, "No memory for resv report:%d\n", size);
-		errno = ENOMEM;
-		err = -1;
+		err = -ENOMEM;
 		goto close_fd;
 	}
 	memset(status, 0, size);
 
-	err = nvme_resv_report(fd, cfg.namespace_id, cfg.numd, cfg.cdw11, status);
+	struct nvme_resv_report_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.nsid		= cfg.namespace_id,
+		.eds		= cfg.eds,
+		.len		= size,
+		.report		= status,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= NULL,
+	};
+	err = nvme_resv_report(&args);
 	if (!err)
-		nvme_show_resv_report(status, size, cfg.cdw11, flags);
+		nvme_show_resv_report(status, size, cfg.eds, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("reservation report");
+		fprintf(stderr, "reservation report: %s\n", nvme_strerror(errno));
 	free(status);
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 unsigned long long elapsed_utime(struct timeval start_time,
@@ -5375,19 +6195,19 @@ static int submit_io(int opcode, char *command, const char *desc,
 {
 	struct timeval start_time, end_time;
 	void *buffer, *mbuffer = NULL;
-	int err = -1;
+	int err = 0;
 	int dfd, mfd, fd;
 	int flags = opcode & 1 ? O_RDONLY : O_WRONLY | O_CREAT;
 	int mode = S_IRUSR | S_IWUSR |S_IRGRP | S_IWGRP| S_IROTH;
 	__u16 control = 0;
-	__u32 dsmgmt = 0, nsid = 0;
+	__u32 dsmgmt = 0;
 	int logical_block_size = 0;
 	long long buffer_size = 0, mbuffer_size = 0;
 	bool huge;
 	struct nvme_id_ns ns;
 	__u8 lba_index, ms = 0;
 
-	const char *namespace_id = "desired namespace";
+	const char *namespace_id = "Identifier of desired namespace";
 	const char *start_block = "64-bit addr of first block to access";
 	const char *block_count = "number of blocks (zeroes based) on device to access";
 	const char *data_size = "size of data in bytes";
@@ -5400,55 +6220,66 @@ static int submit_io(int opcode, char *command, const char *desc,
 	const char *app_tag = "app tag (for end to end PI)";
 	const char *limited_retry = "limit num. media access attempts";
 	const char *latency = "output latency statistics";
-	const char *force = "force device to commit data before command completes";
+	const char *force_unit_access = "force device to commit data before command completes";
 	const char *show = "show command before sending";
 	const char *dry = "show command instead of sending";
 	const char *dtype = "directive type (for write-only)";
 	const char *dspec = "directive specific (for write-only)";
-	const char *dsm = "dataset management attributes (lower 16 bits)";
+	const char *dsm = "dataset management attributes (lower 8 bits)";
 	const char *storage_tag_check = "This bit specifies the Storage Tag field shall be " \
 		"checked as part of end-to-end data protection processing";
 	const char *storage_tag = "storage tag, CDW2 and CDW3 (00:47) bits "\
 		"(for end to end PI)";
+	const char *force = "The \"I know what I'm doing\" flag, do not enforce exclusive access for write";
 
 	struct config {
-		__u32 namespace_id;
-		__u64 start_block;
-		__u16 block_count;
-		__u64 data_size;
-		__u64 metadata_size;
-		__u32 ref_tag;
-		char  *data;
-		char  *metadata;
-		__u8  prinfo;
-		__u8 dtype;
-		__u16 dspec;
-		__u16 dsmgmt;
-		__u16 app_tag_mask;
-		__u16 app_tag;
-		__u64 storage_tag;
-		int   limited_retry;
-		int   force_unit_access;
-		int   storage_tag_check;
-		int   show;
-		int   dry_run;
-		int   latency;
+		__u32	namespace_id;
+		__u64	start_block;
+		__u16	block_count;
+		__u64	data_size;
+		__u64	metadata_size;
+		__u32	ref_tag;
+		char	*data;
+		char	*metadata;
+		__u8	prinfo;
+		__u16	app_tag_mask;
+		__u16	app_tag;
+		__u64	storage_tag;
+		bool	limited_retry;
+		bool	force_unit_access;
+		bool	storage_tag_check;
+		__u8	dtype;
+		__u16	dspec;
+		__u8	dsmgmt;
+		bool	show;
+		bool	dry_run;
+		bool	latency;
+		bool	force;
 	};
 
 	struct config cfg = {
 		.namespace_id		= 0,
-		.start_block     	= 0,
-		.block_count     	= 0,
-		.data_size       	= 0,
-		.metadata_size   	= 0,
-		.ref_tag         	= 0,
-		.data            	= "",
-		.metadata        	= "",
-		.prinfo          	= 0,
-		.app_tag_mask    	= 0,
-		.app_tag         	= 0,
-		.storage_tag_check 	= 0,
+		.start_block		= 0,
+		.block_count		= 0,
+		.data_size		= 0,
+		.metadata_size		= 0,
+		.ref_tag		= 0,
+		.data			= "",
+		.metadata		= "",
+		.prinfo			= 0,
+		.app_tag_mask		= 0,
+		.app_tag		= 0,
 		.storage_tag		= 0,
+		.limited_retry		= false,
+		.force_unit_access	= false,
+		.storage_tag_check	= false,
+		.dtype			= 0,
+		.dspec			= 0,
+		.dsmgmt			= 0,
+		.show			= false,
+		.dry_run		= false,
+		.latency		= false,
+		.force			= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -5465,50 +6296,70 @@ static int submit_io(int opcode, char *command, const char *desc,
 		OPT_SHRT("app-tag",           'a', &cfg.app_tag,           app_tag),
 		OPT_SUFFIX("storage-tag",     'g', &cfg.storage_tag,       storage_tag),
 		OPT_FLAG("limited-retry",     'l', &cfg.limited_retry,     limited_retry),
-		OPT_FLAG("force-unit-access", 'f', &cfg.force_unit_access, force),
+		OPT_FLAG("force-unit-access", 'f', &cfg.force_unit_access, force_unit_access),
 		OPT_FLAG("storage-tag-check", 'C', &cfg.storage_tag_check, storage_tag_check),
 		OPT_BYTE("dir-type",          'T', &cfg.dtype,             dtype),
 		OPT_SHRT("dir-spec",          'S', &cfg.dspec,             dspec),
-		OPT_SHRT("dsm",               'D', &cfg.dsmgmt,            dsm),
+		OPT_BYTE("dsm",               'D', &cfg.dsmgmt,            dsm),
 		OPT_FLAG("show-command",      'v', &cfg.show,              show),
 		OPT_FLAG("dry-run",           'w', &cfg.dry_run,           dry),
 		OPT_FLAG("latency",           't', &cfg.latency,           latency),
+		OPT_FLAG("force",	        0, &cfg.force,             force),
 		OPT_END()
 	};
 
-	err = fd = parse_and_open(argc, argv, desc, opts);
-	if (fd < 0)
-		goto ret;
+	if (opcode != nvme_cmd_write) {
+		err = fd = parse_and_open(argc, argv, desc, opts);
+		if (fd < 0)
+			goto ret;
+	} else {
+		err = argconfig_parse(argc, argv, desc, opts);
+		if (err)
+			goto ret;
+		err = fd = open_exclusive(argc, argv, cfg.force);
+		if (err < 0) {
+			if (errno == EBUSY) {
+				fprintf(stderr, "Failed to open %s.\n",
+					basename(argv[optind]));
+				fprintf(stderr,
+					"Namespace is currently busy.\n");
+				if (!cfg.force)
+					fprintf(stderr,
+					"Use the force [--force] option to ignore that.\n");
+			} else {
+				argconfig_print_help(desc, opts);
+			}
+			goto ret;
+		}
+	}
 
 	if (!cfg.namespace_id) {
-		err = cfg.namespace_id = nvme_get_nsid(fd);
+		err = nvme_get_nsid(fd, &cfg.namespace_id);
 		if (err < 0) {
-			perror("get-namespace-id");
+			fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
 			goto close_fd;
 		}
 	}
 
 	dfd = mfd = opcode & 1 ? STDIN_FILENO : STDOUT_FILENO;
 	if (cfg.prinfo > 0xf) {
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
 	dsmgmt = cfg.dsmgmt;
 	control |= (cfg.prinfo << 10);
 	if (cfg.limited_retry)
-		control |= NVME_RW_LR;
+		control |= NVME_IO_LR;
 	if (cfg.force_unit_access)
-		control |= NVME_RW_FUA;
+		control |= NVME_IO_FUA;
 	if (cfg.storage_tag_check)
-		control |= NVME_RW_STORAGE_TAG_CHECK;
+		control |= NVME_SC_STORAGE_TAG_CHECK;
 	if (cfg.dtype) {
 		if (cfg.dtype > 0xf) {
 			fprintf(stderr, "Invalid directive type, %x\n",
 				cfg.dtype);
-			errno = EINVAL;
-			err = -1;
+			err = -EINVAL;
 			goto close_fd;
 		}
 		control |= cfg.dtype << 4;
@@ -5519,36 +6370,29 @@ static int submit_io(int opcode, char *command, const char *desc,
 		dfd = open(cfg.data, flags, mode);
 		if (dfd < 0) {
 			perror(cfg.data);
-			errno = EINVAL;
-			err = -1;
+			err = -EINVAL;
 			goto close_fd;
 		}
-		mfd = dfd;
 	}
+
 	if (strlen(cfg.metadata)) {
 		mfd = open(cfg.metadata, flags, mode);
 		if (mfd < 0) {
 			perror(cfg.metadata);
-			errno = EINVAL;
-			err = -1;
+			err = -EINVAL;
 			goto close_dfd;
 		}
 	}
 
 	if (!cfg.data_size)	{
 		fprintf(stderr, "data size not provided\n");
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_mfd;
 	}
 
-	if (is_ns_chardev()) {
-		logical_block_size =
-			nvme_logical_block_size_from_ns_char(devicename);
-	} else {
-		if (ioctl(fd, BLKSSZGET, &logical_block_size) < 0)
+	if (nvme_get_logical_block_size(fd, cfg.namespace_id,
+					&logical_block_size) < 0)
 			goto close_mfd;
-	}
 
 	buffer_size = (cfg.block_count + 1) * logical_block_size;
 	if (cfg.data_size < buffer_size) {
@@ -5560,27 +6404,20 @@ static int submit_io(int opcode, char *command, const char *desc,
 
 	buffer = nvme_alloc(buffer_size, &huge);
 	if (!buffer) {
-		perror("can not allocate io payload\n");
-		errno = ENOMEM;
-		err = -1;
+		err = -ENOMEM;
 		goto close_mfd;
 	}
 
 	if (cfg.metadata_size) {
-		err = nsid = nvme_get_nsid(fd);
-		if (err < 0) {
-			perror("get-namespace-id");
-			goto close_mfd;
-		}
-		err = nvme_identify_ns(fd, nsid, false, &ns);
+		err = nvme_identify_ns(fd, cfg.namespace_id, &ns);
 		if (err) {
 			nvme_show_status(err);
 			goto free_buffer;
 		} else if (err < 0) {
-			perror("identify namespace");
+			fprintf(stderr, "identify namespace: %s\n", nvme_strerror(errno));
 			goto free_buffer;
 		}
-		lba_index = ns.flbas & NVME_NS_FLBAS_LBA_MASK;
+		nvme_id_ns_flbas_to_lbaf_inuse(ns.flbas, &lba_index);
 		ms = ns.lbaf[lba_index].ms;
 		mbuffer_size = (cfg.block_count + 1) * ms;
 		if (ms && cfg.metadata_size < mbuffer_size) {
@@ -5591,9 +6428,7 @@ static int submit_io(int opcode, char *command, const char *desc,
 		}
 		mbuffer = malloc(mbuffer_size);
 		if (!mbuffer) {
-			perror("can not allocate buf for io metadata payload\n");
-			errno = ENOMEM;
-			err = -1;
+			err = -ENOMEM;
 			goto free_buffer;
 		}
 		memset(mbuffer, 0, mbuffer_size);
@@ -5619,48 +6454,68 @@ static int submit_io(int opcode, char *command, const char *desc,
 		}
 	}
 
-	if (cfg.show) {
-		printf("opcode       	: %02x\n", opcode);
-		printf("nsid         	: %02x\n", cfg.namespace_id);
-		printf("control      	: %04x\n", control);
-		printf("nblocks      	: %04x\n", cfg.block_count);
-		printf("metadata     	: %"PRIx64"\n", (uint64_t)(uintptr_t)mbuffer);
-		printf("addr         	: %"PRIx64"\n", (uint64_t)(uintptr_t)buffer);
-		printf("slba         	: %"PRIx64"\n", (uint64_t)cfg.start_block);
-		printf("dsmgmt       	: %08x\n", dsmgmt);
-		printf("reftag       	: %08x\n", cfg.ref_tag);
-		printf("apptag       	: %04x\n", cfg.app_tag);
-		printf("appmask      	: %04x\n", cfg.app_tag_mask);
+	if (cfg.show || cfg.dry_run) {
+		printf("opcode       : %02x\n", opcode);
+		printf("nsid         : %02x\n", cfg.namespace_id);
+		printf("flags        : %02x\n", 0);
+		printf("control      : %04x\n", control);
+		printf("nblocks      : %04x\n", cfg.block_count);
+		printf("metadata     : %"PRIx64"\n", (uint64_t)(uintptr_t)mbuffer);
+		printf("addr         : %"PRIx64"\n", (uint64_t)(uintptr_t)buffer);
+		printf("slba         : %"PRIx64"\n", (uint64_t)cfg.start_block);
+		printf("dsmgmt       : %08x\n", dsmgmt);
+		printf("reftag       : %08x\n", cfg.ref_tag);
+		printf("apptag       : %04x\n", cfg.app_tag);
+		printf("appmask      : %04x\n", cfg.app_tag_mask);
 		printf("storagetagcheck : %04x\n", cfg.storage_tag_check);
 		printf("storagetag      : %"PRIx64"\n", (uint64_t)cfg.storage_tag);
 	}
 	if (cfg.dry_run)
 		goto free_mbuffer;
 
+	struct nvme_io_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.nsid		= cfg.namespace_id,
+		.slba		= cfg.start_block,
+		.nlb		= cfg.block_count,
+		.control	= control,
+		.dsm		= cfg.dsmgmt,
+		.dspec		= cfg.dspec,
+		.reftag		= cfg.ref_tag,
+		.apptag		= cfg.app_tag,
+		.appmask	= cfg.app_tag_mask,
+		.storage_tag	= cfg.storage_tag,
+		.data_len	= buffer_size,
+		.data		= buffer,
+		.metadata_len	= cfg.metadata_size,
+		.metadata	= mbuffer,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= NULL,
+	};
 	gettimeofday(&start_time, NULL);
-	err = nvme_io(fd, opcode, cfg.namespace_id, cfg.start_block, cfg.block_count,
-			 control, dsmgmt, cfg.ref_tag, cfg.app_tag, cfg.app_tag_mask,
-			 cfg.storage_tag, buffer, buffer_size, mbuffer, mbuffer_size);
+	if (opcode & 1)
+		err = nvme_write(&args);
+	else
+		err = nvme_read(&args);
 	gettimeofday(&end_time, NULL);
 	if (cfg.latency)
 		printf(" latency: %s: %llu us\n",
 			command, elapsed_utime(start_time, end_time));
 	if (err < 0)
-		perror("submit-io");
+		fprintf(stderr, "submit-io: %s\n", nvme_strerror(errno));
 	else if (err)
 		nvme_show_status(err);
 	else {
 		if (!(opcode & 1) && write(dfd, (void *)buffer, cfg.data_size) < 0) {
 			fprintf(stderr, "write: %s: failed to write buffer to output file\n",
 					strerror(errno));
-			errno = EINVAL;
-			err = -1;
+			err = -EINVAL;
 		} else if (!(opcode & 1) && cfg.metadata_size &&
 				write(mfd, (void *)mbuffer, mbuffer_size) < 0) {
 			fprintf(stderr, "write: %s: failed to write meta-data buffer to output file\n",
 					strerror(errno));
-			errno = EINVAL;
-			err = -1;
+			err = -EINVAL;
 		} else
 			fprintf(stderr, "%s: Success\n", command);
 	}
@@ -5677,7 +6532,7 @@ close_dfd:
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int compare(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -5705,14 +6560,14 @@ static int write_cmd(int argc, char **argv, struct command *cmd, struct plugin *
 
 static int verify_cmd(int argc, char **argv, struct command *cmd, struct plugin *plugin)
 {
-	int err = -1, fd;
+	int err, fd;
 	__u16 control = 0;
 	const char *desc = "Verify specified logical blocks on the given device.";
 	const char *namespace_id = "desired namespace";
 	const char *start_block = "64-bit LBA of first block to access";
 	const char *block_count = "number of blocks (zeroes based) on device to access";
 	const char *limited_retry = "limit media access attempts";
-	const char *force = "force device to commit cached data before performing the verify operation";
+	const char *force_unit_access = "force device to commit cached data before performing the verify operation";
 	const char *prinfo = "PI and check field";
 	const char *ref_tag = "reference tag (for end to end PI)";
 	const char *app_tag_mask = "app tag mask (for end to end PI)";
@@ -5723,31 +6578,31 @@ static int verify_cmd(int argc, char **argv, struct command *cmd, struct plugin
 		"be checked as part of Verify operation";
 
 	struct config {
-		__u64 start_block;
-		__u32 namespace_id;
-		__u32 ref_tag;
-		__u16 app_tag;
-		__u16 app_tag_mask;
-		__u16 block_count;
-		__u8  prinfo;
-		__u64 storage_tag;
-		int   storage_tag_check;
-		int   limited_retry;
-		int   force_unit_access;
+		__u32	namespace_id;
+		__u64	start_block;
+		__u16	block_count;
+		bool	limited_retry;
+		bool	force_unit_access;
+		__u8	prinfo;
+		__u32	ref_tag;
+		__u16	app_tag;
+		__u16	app_tag_mask;
+		__u64	storage_tag;
+		bool	storage_tag_check;
 	};
 
 	struct config cfg = {
-		.namespace_id      = 0,
-		.start_block       = 0,
-		.block_count       = 0,
-		.prinfo            = 0,
-		.ref_tag           = 0,
-		.app_tag           = 0,
-		.app_tag_mask      = 0,
-		.limited_retry     = 0,
-		.force_unit_access = 0,
-		.storage_tag	   = 0,
-		.storage_tag_check = 0,
+		.namespace_id		= 0,
+		.start_block		= 0,
+		.block_count		= 0,
+		.limited_retry		= false,
+		.force_unit_access	= false,
+		.prinfo			= 0,
+		.ref_tag		= 0,
+		.app_tag		= 0,
+		.app_tag_mask		= 0,
+		.storage_tag		= 0,
+		.storage_tag_check	= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -5755,7 +6610,7 @@ static int verify_cmd(int argc, char **argv, struct command *cmd, struct plugin
 		OPT_SUFFIX("start-block",     's', &cfg.start_block,       start_block),
 		OPT_SHRT("block-count",       'c', &cfg.block_count,       block_count),
 		OPT_FLAG("limited-retry",     'l', &cfg.limited_retry,     limited_retry),
-		OPT_FLAG("force-unit-access", 'f', &cfg.force_unit_access, force),
+		OPT_FLAG("force-unit-access", 'f', &cfg.force_unit_access, force_unit_access),
 		OPT_BYTE("prinfo",            'p', &cfg.prinfo,            prinfo),
 		OPT_UINT("ref-tag",           'r', &cfg.ref_tag,           ref_tag),
 		OPT_SHRT("app-tag",           'a', &cfg.app_tag,           app_tag),
@@ -5770,32 +6625,43 @@ static int verify_cmd(int argc, char **argv, struct command *cmd, struct plugin
 		goto ret;
 
 	if (cfg.prinfo > 0xf) {
-		fprintf(stderr, "invalid 'prinfo' param:%u\n", cfg.prinfo);
-		errno = EINVAL;
-		err = -1;
+		err = EINVAL;
 		goto close_fd;
 	}
 
 	control |= (cfg.prinfo << 10);
 	if (cfg.limited_retry)
-		control |= NVME_RW_LR;
+		control |= NVME_IO_LR;
 	if (cfg.force_unit_access)
-		control |= NVME_RW_FUA;
+		control |= NVME_IO_FUA;
 	if (cfg.storage_tag_check)
-		control |= NVME_RW_STORAGE_TAG_CHECK;
+		control |= NVME_SC_STORAGE_TAG_CHECK;
 
 	if (!cfg.namespace_id) {
-		err = cfg.namespace_id = nvme_get_nsid(fd);
+		err = nvme_get_nsid(fd, &cfg.namespace_id);
 		if (err < 0) {
-			perror("get-namespace-id");
+			fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
 			goto close_fd;
 		}
 	}
 
-	err = nvme_verify(fd, cfg.namespace_id, cfg.start_block, cfg.block_count,
-				control, cfg.ref_tag, cfg.app_tag, cfg.app_tag_mask, cfg.storage_tag);
+	struct nvme_io_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.nsid		= cfg.namespace_id,
+		.slba		= cfg.start_block,
+		.nlb		= cfg.block_count,
+		.control	= control,
+		.reftag		= cfg.ref_tag,
+		.apptag		= cfg.app_tag,
+		.appmask	= cfg.app_tag_mask,
+		.storage_tag	= cfg.storage_tag,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= NULL,
+	};
+	err = nvme_verify(&args);
 	if (err < 0)
-		perror("verify");
+		fprintf(stderr, "verify: %s\n", nvme_strerror(errno));
 	else if (err != 0)
 		nvme_show_status(err);
 	else
@@ -5804,7 +6670,7 @@ static int verify_cmd(int argc, char **argv, struct command *cmd, struct plugin
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);;
+	return err;
 }
 
 static int sec_recv(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -5822,24 +6688,27 @@ static int sec_recv(int argc, char **argv, struct command *cmd, struct plugin *p
 	const char *raw = "dump output in binary format";
 	const char *namespace_id = "desired namespace";
 	const char *nssf = "NVMe Security Specific Field";
-	int err = -1, fd;
+	int err, fd;
 	void *sec_buf = NULL;
 
 	struct config {
-		__u32 namespace_id;
-		__u32 size;
-		__u8  secp;
-		__u8  nssf;
-		__u16 spsp;
-		__u32 al;
-		int   raw_binary;
+		__u32	namespace_id;
+		__u32	size;
+		__u8	nssf;
+		__u8	secp;
+		__u16	spsp;
+		__u32	al;
+		bool	raw_binary;
 	};
 
 	struct config cfg = {
-		.size = 0,
-		.secp = 0,
-		.spsp = 0,
-		.al   = 0,
+		.namespace_id	= 0,
+		.size		= 0,
+		.nssf		= 0,
+		.secp		= 0,
+		.spsp		= 0,
+		.al		= 0,
+		.raw_binary	= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -5861,16 +6730,28 @@ static int sec_recv(int argc, char **argv, struct command *cmd, struct plugin *p
 		if (posix_memalign(&sec_buf, getpagesize(), cfg.size)) {
 			fprintf(stderr, "No memory for security size:%d\n",
 								cfg.size);
-			errno = ENOMEM;
-			err = -1;
+			err = -ENOMEM;
 			goto close_fd;
 		}
 	}
 
-	err = nvme_sec_recv(fd, cfg.namespace_id, cfg.nssf, cfg.spsp,
-			cfg.secp, cfg.al, cfg.size, sec_buf);
+	struct nvme_security_receive_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.nsid		= cfg.namespace_id,
+		.nssf		= cfg.nssf,
+		.spsp0		= cfg.spsp & 0xff,
+		.spsp1		= cfg.spsp >> 8,
+		.secp		= cfg.secp,
+		.al		= cfg.al,
+		.data_len	= cfg.size,
+		.data		= sec_buf,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= NULL,
+	};
+	err = nvme_security_receive(&args);
 	if (err < 0)
-		perror("security receive");
+		fprintf(stderr, "security receive: %s\n", nvme_strerror(errno));
 	else if (err != 0)
 		nvme_show_status(err);
 	else {
@@ -5886,7 +6767,7 @@ static int sec_recv(int argc, char **argv, struct command *cmd, struct plugin *p
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int get_lba_status(int argc, char **argv, struct command *cmd,
@@ -5907,27 +6788,27 @@ static int get_lba_status(int argc, char **argv, struct command *cmd,
 
 	enum nvme_print_flags flags;
 	unsigned long buf_len;
-	int err = -1, fd;
+	int err, fd;
 	void *buf;
 
 	struct config {
-		__u32 namespace_id;
-		__u64 slba;
-		__u32 mndw;
-		__u8 atype;
-		__u16 rl;
-		__u32 timeout;
-		char *output_format;
+		__u32	namespace_id;
+		__u64	slba;
+		__u32	mndw;
+		__u8	atype;
+		__u16	rl;
+		__u32	timeout;
+		char	*output_format;
 	};
 
 	struct config cfg = {
-		.namespace_id = 0,
-		.slba = 0,
-		.mndw = 0,
-		.atype = 0,
-		.rl = 0,
-		.timeout      = 0,
-		.output_format = "normal",
+		.namespace_id	= 0,
+		.slba		= 0,
+		.mndw		= 0,
+		.atype		= 0,
+		.rl		= 0,
+		.timeout	= 0,
+		.output_format	= "normal",
 	};
 
 	OPT_ARGS(opts) = {
@@ -5951,33 +6832,41 @@ static int get_lba_status(int argc, char **argv, struct command *cmd,
 
 	if (!cfg.atype) {
 		fprintf(stderr, "action type (--action) has to be given\n");
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
 	buf_len = (cfg.mndw + 1) * 4;
 	buf = calloc(1, buf_len);
 	if (!buf) {
-		perror("could not alloc memory for get lba status");
-		errno = ENOMEM;
-		err = -1;
+		err = -ENOMEM;
 		goto close_fd;
 	}
 
-	err = nvme_get_lba_status(fd, cfg.namespace_id, cfg.slba, cfg.mndw,
-			cfg.atype, cfg.rl, buf, cfg.timeout);
+	struct nvme_get_lba_status_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.nsid		= cfg.namespace_id,
+		.slba		= cfg.slba,
+		.mndw		= cfg.mndw,
+		.rl		= cfg.rl,
+		.atype		= cfg.atype,
+		.lbas		= buf,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= NULL,
+	};
+	err = nvme_get_lba_status(&args);
 	if (!err)
 		nvme_show_lba_status(buf, buf_len, flags);
 	else if (err > 0)
 		nvme_show_status(err);
 	else
-		perror("get lba status");
+		fprintf(stderr, "get lba status: %s\n", nvme_strerror(errno));
 	free(buf);
 close_fd:
 	close(fd);
 err:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int capacity_mgmt(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -5997,23 +6886,23 @@ static int capacity_mgmt(int argc, char **argv, struct command *cmd, struct plug
 	__u32 result;
 
 	struct config {
-		__u8  operation;
-		__u16 element_id;
-		__u32 dw11;
-		__u32 dw12;
+		__u8	operation;
+		__u16	element_id;
+		__u32	dw11;
+		__u32	dw12;
 	};
 
 	struct config cfg = {
-		.operation  = 0xff,
-		.element_id = 0xffff,
-		.dw11       = 0,
-		.dw12       = 0,
+		.operation	= 0xff,
+		.element_id	= 0xffff,
+		.dw11		= 0,
+		.dw12		= 0,
 	};
 
 	OPT_ARGS(opts) = {
 		OPT_BYTE("operation",   'o', &cfg.operation,    operation),
 		OPT_SHRT("element-id",  'i', &cfg.element_id,   element_id),
-		OPT_UINT("cap-lower",   'l', &cfg.dw11,     	cap_lower),
+		OPT_UINT("cap-lower",   'l', &cfg.dw11,		cap_lower),
 		OPT_UINT("cap-upper",   'u', &cfg.dw12,         cap_upper),
 		OPT_END()
 	};
@@ -6024,13 +6913,21 @@ static int capacity_mgmt(int argc, char **argv, struct command *cmd, struct plug
 
 	if (cfg.operation > 0xf) {
 		fprintf(stderr, "invalid operation field: %u\n", cfg.operation);
-		errno = EINVAL;
 		err = -1;
 		goto close_fd;
 	}
 
-	err = nvme_cap_mgmt(fd, cfg.operation, cfg.element_id, cfg.dw11,
-		cfg.dw12, &result);
+	struct nvme_capacity_mgmt_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.op		= cfg.operation,
+		.element_id	= cfg.element_id,
+		.cdw11		= cfg.dw11,
+		.cdw12		= cfg.dw12,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= &result,
+	};
+	err = nvme_capacity_mgmt(&args);
 	if (!err) {
 		printf("Capacity Management Command is Success\n");
 		if (cfg.operation == 1) {
@@ -6041,12 +6938,12 @@ static int capacity_mgmt(int argc, char **argv, struct command *cmd, struct plug
 	} else if (err > 0)
 		nvme_show_status(err);
 	else if (err < 0)
-		perror("capacity management");
+		fprintf(stderr, "capacity management: %s\n", nvme_strerror(errno));
 
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int dir_receive(int argc, char **argv, struct command *cmd, struct plugin *plugin)
@@ -6063,29 +6960,31 @@ static int dir_receive(int argc, char **argv, struct command *cmd, struct plugin
 	const char *human_readable = "show directive in readable format";
 
 	enum nvme_print_flags flags = NORMAL;
-	int err = -1, fd;
+	int err, fd;
 	__u32 result;
 	__u32 dw12 = 0;
 	void *buf = NULL;
 
 	struct config {
-		__u32 namespace_id;
-		__u32 data_len;
-		__u16 dspec;
-		__u8  dtype;
-		__u8  doper;
-		__u16 nsr; /* dw12 for NVME_DIR_ST_RCVOP_STATUS */
-		int  raw_binary;
-		int  human_readable;
+		__u32	namespace_id;
+		__u32	data_len;
+		bool	raw_binary;
+		__u8	dtype;
+		__u16	dspec;
+		__u8	doper;
+		__u16	nsr; /* dw12 for NVME_DIR_ST_RCVOP_STATUS */
+		bool	human_readable;
 	};
 
 	struct config cfg = {
-		.namespace_id = 1,
-		.data_len     = 0,
-		.dspec        = 0,
-		.dtype        = 0,
-		.doper        = 0,
-		.nsr          = 0,
+		.namespace_id	= 1,
+		.data_len	= 0,
+		.raw_binary	= false,
+		.dtype		= 0,
+		.dspec		= 0,
+		.doper		= 0,
+		.nsr		= 0,
+		.human_readable	= false,
 	};
 
 	OPT_ARGS(opts) = {
@@ -6110,57 +7009,65 @@ static int dir_receive(int argc, char **argv, struct command *cmd, struct plugin
 		flags = BINARY;
 
 	switch (cfg.dtype) {
-	case NVME_DIR_IDENTIFY:
+	case NVME_DIRECTIVE_DTYPE_IDENTIFY:
 		switch (cfg.doper) {
-		case NVME_DIR_RCV_ID_OP_PARAM:
+		case NVME_DIRECTIVE_RECEIVE_IDENTIFY_DOPER_PARAM:
 			if (!cfg.data_len)
 				cfg.data_len = 4096;
 			break;
 		default:
 			fprintf(stderr, "invalid directive operations for Identify Directives\n");
-			errno = EINVAL;
-			err = -1;
+			err = -EINVAL;
 			goto close_fd;
 		}
 		break;
-	case NVME_DIR_STREAMS:
+	case NVME_DIRECTIVE_DTYPE_STREAMS:
 		switch (cfg.doper) {
-		case NVME_DIR_RCV_ST_OP_PARAM:
+		case NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_PARAM:
 			if (!cfg.data_len)
 				cfg.data_len = 32;
 			break;
-		case NVME_DIR_RCV_ST_OP_STATUS:
+		case NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_STATUS:
 			if (!cfg.data_len)
 				cfg.data_len = 128 * 1024;
 			break;
-		case NVME_DIR_RCV_ST_OP_RESOURCE:
+		case NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_RESOURCE:
 			dw12 = cfg.nsr;
 			break;
 		default:
 			fprintf(stderr, "invalid directive operations for Streams Directives\n");
-			errno = EINVAL;
-			err = -1;
+			err = -EINVAL;
 			goto close_fd;
 		}
 		break;
 	default:
 		fprintf(stderr, "invalid directive type\n");
-		errno = EINVAL;
-		err = -1;
+		err = -EINVAL;
 		goto close_fd;
 	}
 
 	if (cfg.data_len) {
 		if (posix_memalign(&buf, getpagesize(), cfg.data_len)) {
-			errno = ENOMEM;
-			err = -1;
+			err = -ENOMEM;
 			goto close_fd;
 		}
 		memset(buf, 0, cfg.data_len);
 	}
 
-	err = nvme_dir_recv(fd, cfg.namespace_id, cfg.dspec, cfg.dtype, cfg.doper,
-			cfg.data_len, dw12, buf, &result);
+	struct nvme_directive_recv_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.nsid		= cfg.namespace_id,
+		.dspec		= cfg.dspec,
+		.doper		= cfg.doper,
+		.dtype		= cfg.dtype,
+		.cdw12		= dw12,
+		.data_len	= cfg.data_len,
+		.data		= buf,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= &result,
+	};
+	err = nvme_directive_recv(&args);
 	if (!err)
 		nvme_directive_show(cfg.dtype, cfg.doper, cfg.dspec,
 				    cfg.namespace_id, result, buf, cfg.data_len,
@@ -6168,13 +7075,13 @@ static int dir_receive(int argc, char **argv, struct command *cmd, struct plugin
 	else if (err > 0)
 		nvme_show_status(err);
 	else if (err < 0)
-		perror("dir-receive");
+		fprintf(stderr, "dir-receive: %s\n", nvme_strerror(errno));
 
 	free(buf);
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 /* rpmb_cmd_option is defined in nvme-rpmb.c */
@@ -6208,23 +7115,23 @@ static int lockdown_cmd(int argc, char **argv, struct command *cmd, struct plugi
 	int fd, err = -1;
 
 	struct config {
-		__u8    ofi;
-		__u8    ifc;
-		__u8    prhbt;
-		__u8    scp;
-		__u8    uuid;
+		__u8	ofi;
+		__u8	ifc;
+		__u8	prhbt;
+		__u8	scp;
+		__u8	uuid;
 	};
 
 	struct config cfg = {
-		.ofi = 0,
-		.ifc = 0,
-		.prhbt = 0,
-		.scp = 0,
-		.uuid = 0,
+		.ofi	= 0,
+		.ifc	= 0,
+		.prhbt	= 0,
+		.scp	= 0,
+		.uuid	= 0,
 	};
 
 	OPT_ARGS(opts) = {
-		OPT_BYTE("ofi",		'o', &cfg.ofi, 		ofi_desc),
+		OPT_BYTE("ofi",		'o', &cfg.ofi,      ofi_desc),
 		OPT_BYTE("ifc",		'f', &cfg.ifc,      ifc_desc),
 		OPT_BYTE("prhbt",	'p', &cfg.prhbt,    prhbt_desc),
 		OPT_BYTE("scp",		's', &cfg.scp,      scp_desc),
@@ -6239,34 +7146,39 @@ static int lockdown_cmd(int argc, char **argv, struct command *cmd, struct plugi
 	/* check for input arguement limit */
 	if (cfg.ifc > 3) {
 		fprintf(stderr, "invalid interface settings:%d\n", cfg.ifc);
-		errno = EINVAL;
 		err = -1;
 		goto close_fd;
 	}
 	if (cfg.prhbt > 1) {
 		fprintf(stderr, "invalid prohibit settings:%d\n", cfg.prhbt);
-		errno = EINVAL;
 		err = -1;
 		goto close_fd;
 	}
 	if (cfg.scp > 15) {
 		fprintf(stderr, "invalid scope settings:%d\n", cfg.scp);
-		errno = EINVAL;
 		err = -1;
 		goto close_fd;
 	}
 	if (cfg.uuid > 127) {
 		fprintf(stderr, "invalid UUID index settings:%d\n", cfg.uuid);
-		errno = EINVAL;
 		err = -1;
 		goto close_fd;
 	}
 
-	err = nvme_lockdown(fd, cfg.scp,cfg.prhbt,cfg.ifc,cfg.ofi,
-			cfg.uuid);
-
+	struct nvme_lockdown_args args = {
+		.args_size	= sizeof(args),
+		.fd		= fd,
+		.scp		= cfg.scp,
+		.prhbt		= cfg.prhbt,
+		.ifc		= cfg.ifc,
+		.ofi		= cfg.ofi,
+		.uuidx		= cfg.uuid,
+		.timeout	= NVME_DEFAULT_IOCTL_TIMEOUT,
+		.result		= NULL,
+	};
+	err = nvme_lockdown(&args);
 	if (err < 0)
-		perror("lockdown");
+		fprintf(stderr, "lockdown: %s\n", nvme_strerror(errno));
 	else if (err > 0)
 		nvme_show_status(err);
 	else
@@ -6275,18 +7187,19 @@ static int lockdown_cmd(int argc, char **argv, struct command *cmd, struct plugi
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
-static int passthru(int argc, char **argv, int ioctl_cmd, uint8_t cmd_type,
-	const char *desc, struct command *cmd)
+static int passthru(int argc, char **argv, bool admin,
+		const char *desc, struct command *cmd)
 {
 	const char *opcode = "opcode (required)";
-	const char *flags = "command flags";
+	const char *cflags = "command flags";
 	const char *rsvd = "value for reserved field";
 	const char *namespace_id = "desired namespace";
 	const char *data_len = "data I/O length (bytes)";
 	const char *metadata_len = "metadata seg. length (bytes)";
+	const char *metadata = "metadata input or output file";
 	const char *timeout = "timeout value, in milliseconds";
 	const char *cdw2 = "command dword 2 value";
 	const char *cdw3 = "command dword 3 value";
@@ -6296,7 +7209,7 @@ static int passthru(int argc, char **argv, int ioctl_cmd, uint8_t cmd_type,
 	const char *cdw13 = "command dword 13 value";
 	const char *cdw14 = "command dword 14 value";
 	const char *cdw15 = "command dword 15 value";
-	const char *input = "write/send file (default stdin)";
+	const char *input = "data input or output file";
 	const char *raw_binary = "dump output in binary format";
 	const char *show = "print command before sending";
 	const char *dry = "show command instead of sending";
@@ -6305,62 +7218,72 @@ static int passthru(int argc, char **argv, int ioctl_cmd, uint8_t cmd_type,
 	const char *prefill = "prefill buffers with known byte-value, default 0";
 	const char *latency = "output latency statistics";
 
-	void *data = NULL, *metadata = NULL;
-	int err = -1, wfd = STDIN_FILENO, fd;
+	int flags;
+	int mode = S_IRUSR | S_IWUSR |S_IRGRP | S_IWGRP| S_IROTH;
+	void *data = NULL, *mdata = NULL;
+	int err = 0, dfd, mfd, fd;
 	__u32 result;
-	bool huge;
+	bool huge = false;
 	const char *cmd_name = NULL;
 	struct timeval start_time, end_time;
 
 	struct config {
-		__u8  opcode;
-		__u8  flags;
-		__u16 rsvd;
-		__u32 namespace_id;
-		__u32 data_len;
-		__u32 metadata_len;
-		__u32 timeout;
-		__u32 cdw2;
-		__u32 cdw3;
-		__u32 cdw10;
-		__u32 cdw11;
-		__u32 cdw12;
-		__u32 cdw13;
-		__u32 cdw14;
-		__u32 cdw15;
-		char  *input_file;
-		int   raw_binary;
-		int   show_command;
-		int   dry_run;
-		int   read;
-		int   write;
-		__u8  prefill;
-		int   latency;
+		__u8	opcode;
+		__u8	flags;
+		__u16	rsvd;
+		__u32	namespace_id;
+		__u32	data_len;
+		__u32	metadata_len;
+		__u32	timeout;
+		__u32	cdw2;
+		__u32	cdw3;
+		__u32	cdw10;
+		__u32	cdw11;
+		__u32	cdw12;
+		__u32	cdw13;
+		__u32	cdw14;
+		__u32	cdw15;
+		char	*input_file;
+		char	*metadata;
+		bool	raw_binary;
+		bool	show_command;
+		bool	dry_run;
+		bool	read;
+		bool	write;
+		__u8	prefill;
+		bool	latency;
 	};
 
 	struct config cfg = {
-		.opcode       = 0,
-		.flags        = 0,
-		.rsvd         = 0,
-		.namespace_id = 0,
-		.data_len     = 0,
-		.metadata_len = 0,
-		.timeout      = 0,
-		.cdw2         = 0,
-		.cdw3         = 0,
-		.cdw10        = 0,
-		.cdw11        = 0,
-		.cdw12        = 0,
-		.cdw13        = 0,
-		.cdw14        = 0,
-		.cdw15        = 0,
-		.input_file   = "",
-		.prefill      = 0,
+		.opcode		= 0,
+		.flags		= 0,
+		.prefill	= 0,
+		.rsvd		= 0,
+		.namespace_id	= 0,
+		.data_len	= 0,
+		.metadata_len	= 0,
+		.timeout	= 0,
+		.cdw2		= 0,
+		.cdw3		= 0,
+		.cdw10		= 0,
+		.cdw11		= 0,
+		.cdw12		= 0,
+		.cdw13		= 0,
+		.cdw14		= 0,
+		.cdw15		= 0,
+		.input_file	= "",
+		.metadata	= "",
+		.raw_binary	= false,
+		.show_command	= false,
+		.dry_run	= false,
+		.read		= false,
+		.write		= false,
+		.latency	= false,
 	};
 
 	OPT_ARGS(opts) = {
 		OPT_BYTE("opcode",       'o', &cfg.opcode,       opcode),
-		OPT_BYTE("flags",        'f', &cfg.flags,        flags),
+		OPT_BYTE("flags",        'f', &cfg.flags,        cflags),
 		OPT_BYTE("prefill",      'p', &cfg.prefill,      prefill),
 		OPT_SHRT("rsvd",         'R', &cfg.rsvd,         rsvd),
 		OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace_id),
@@ -6376,6 +7299,7 @@ static int passthru(int argc, char **argv, int ioctl_cmd, uint8_t cmd_type,
 		OPT_UINT("cdw14",        '8', &cfg.cdw14,        cdw14),
 		OPT_UINT("cdw15",        '9', &cfg.cdw15,        cdw15),
 		OPT_FILE("input-file",   'i', &cfg.input_file,   input),
+		OPT_FILE("metadata",     'M', &cfg.metadata,     metadata),
 		OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,   raw_binary),
 		OPT_FLAG("show-command", 's', &cfg.show_command, show),
 		OPT_FLAG("dry-run",      'd', &cfg.dry_run,      dry),
@@ -6389,33 +7313,47 @@ static int passthru(int argc, char **argv, int ioctl_cmd, uint8_t cmd_type,
 	if (fd < 0)
 		goto ret;
 
+	flags = cfg.opcode & 1 ? O_RDONLY : O_WRONLY | O_CREAT;
+	dfd = mfd = cfg.opcode & 1 ? STDIN_FILENO : STDOUT_FILENO;
 	if (strlen(cfg.input_file)) {
-		wfd = open(cfg.input_file, O_RDONLY,
-			   S_IRUSR | S_IRGRP | S_IROTH);
-		if (wfd < 0) {
+		dfd = open(cfg.input_file, flags, mode);
+		if (dfd < 0) {
 			perror(cfg.input_file);
-			errno = EINVAL;
-			err = -1;
+			err = -EINVAL;
 			goto close_fd;
 		}
 	}
 
+	if (cfg.metadata && strlen(cfg.metadata)) {
+		mfd = open(cfg.metadata, flags, mode);
+		if (mfd < 0) {
+			perror(cfg.metadata);
+			err = -EINVAL;
+			goto close_dfd;
+		}
+	}
+
 	if (cfg.metadata_len) {
-		metadata = malloc(cfg.metadata_len);
-		if (!metadata) {
-			perror("can not allocate metadata payload\n");
-			errno = ENOMEM;
-			err = -1;
-			goto close_wfd;
+		mdata = malloc(cfg.metadata_len);
+		if (!mdata) {
+			err = -ENOMEM;
+			goto close_mfd;
 		}
-		memset(metadata, cfg.prefill, cfg.metadata_len);
+
+		if (cfg.write) {
+			if (read(mfd, mdata, cfg.metadata_len) < 0) {
+				err = -errno;
+				perror("failed to read metadata write buffer");
+				goto free_metadata;
+			}
+		} else
+			memset(mdata, cfg.prefill, cfg.metadata_len);
 	}
+
 	if (cfg.data_len) {
 		data = nvme_alloc(cfg.data_len, &huge);
 		if (!data) {
-			perror("can not allocate data payload\n");
-			errno = ENOMEM;
-			err = -1;
+			err = -ENOMEM;
 			goto free_metadata;
 		}
 
@@ -6430,11 +7368,10 @@ static int passthru(int argc, char **argv, int ioctl_cmd, uint8_t cmd_type,
 		memset(data, cfg.prefill, cfg.data_len);
 		if (!cfg.read && !cfg.write) {
 			fprintf(stderr, "data direction not given\n");
-			errno = EINVAL;
-			err = -1;
+			err = -EINVAL;
 			goto free_data;
 		} else if (cfg.write) {
-			if (read(wfd, data, cfg.data_len) < 0) {
+			if (read(dfd, data, cfg.data_len) < 0) {
 				err = -errno;
 				fprintf(stderr, "failed to read write buffer "
 						"%s\n", strerror(errno));
@@ -6443,7 +7380,7 @@ static int passthru(int argc, char **argv, int ioctl_cmd, uint8_t cmd_type,
 		}
 	}
 
-	if (cfg.show_command) {
+	if (cfg.show_command || cfg.dry_run) {
 		printf("opcode       : %02x\n", cfg.opcode);
 		printf("flags        : %02x\n", cfg.flags);
 		printf("rsvd1        : %04x\n", cfg.rsvd);
@@ -6453,7 +7390,7 @@ static int passthru(int argc, char **argv, int ioctl_cmd, uint8_t cmd_type,
 		printf("data_len     : %08x\n", cfg.data_len);
 		printf("metadata_len : %08x\n", cfg.metadata_len);
 		printf("addr         : %"PRIx64"\n", (uint64_t)(uintptr_t)data);
-		printf("metadata     : %"PRIx64"\n", (uint64_t)(uintptr_t)metadata);
+		printf("metadata     : %"PRIx64"\n", (uint64_t)(uintptr_t)mdata);
 		printf("cdw10        : %08x\n", cfg.cdw10);
 		printf("cdw11        : %08x\n", cfg.cdw11);
 		printf("cdw12        : %08x\n", cfg.cdw12);
@@ -6467,86 +7404,90 @@ static int passthru(int argc, char **argv, int ioctl_cmd, uint8_t cmd_type,
 
 	gettimeofday(&start_time, NULL);
 
-	err = nvme_passthru(fd, ioctl_cmd, cfg.opcode, cfg.flags, cfg.rsvd,
+	if (admin)
+		err = nvme_admin_passthru(fd, cfg.opcode, cfg.flags, cfg.rsvd,
 				cfg.namespace_id, cfg.cdw2, cfg.cdw3, cfg.cdw10,
-				cfg.cdw11, cfg.cdw12, cfg.cdw13, cfg.cdw14, cfg.cdw15,
-				cfg.data_len, data, cfg.metadata_len, metadata,
-				cfg.timeout, &result);
+				cfg.cdw11, cfg.cdw12, cfg.cdw13, cfg.cdw14,
+				cfg.cdw15, cfg.data_len, data, cfg.metadata_len,
+				mdata, cfg.timeout, &result);
+	else
+		err = nvme_io_passthru(fd, cfg.opcode, cfg.flags, cfg.rsvd,
+				cfg.namespace_id, cfg.cdw2, cfg.cdw3, cfg.cdw10,
+				cfg.cdw11, cfg.cdw12, cfg.cdw13, cfg.cdw14,
+				cfg.cdw15, cfg.data_len, data, cfg.metadata_len,
+				mdata, cfg.timeout, &result);
 
 	gettimeofday(&end_time, NULL);
-	cmd_name = nvme_cmd_to_string(cmd_type, cfg.opcode);
+	cmd_name = nvme_cmd_to_string(admin, cfg.opcode);
 	if (cfg.latency)
 		printf("%s Command %s latency: %llu us\n",
-			cmd_type ? "Admin": "IO",
+			admin ? "Admin": "IO",
 			strcmp(cmd_name, "Unknown") ? cmd_name: "Vendor Specific",
 			elapsed_utime(start_time, end_time));
 
 	if (err < 0)
-		perror("passthru");
+		fprintf(stderr, "passthru: %s\n", nvme_strerror(errno));
 	else if (err)
 		nvme_show_status(err);
 	else  {
 		fprintf(stderr, "%s Command %s is Success and result: 0x%08x\n",
-				cmd_type ? "Admin": "IO",
+				admin ? "Admin": "IO",
 				strcmp(cmd_name, "Unknown") ? cmd_name: "Vendor Specific",
 				result);
-		if (!cfg.raw_binary) {
+		if (cfg.read && cfg.input_file) {
+			if (write(dfd, (void *)data, cfg.data_len) < 0)
+				perror("failed to write data buffer");
+			if (cfg.metadata_len && cfg.metadata)
+				if (write(mfd, (void *)mdata, cfg.metadata_len) < 0)
+					perror("failed to write metadata buffer");
+		} else if (!cfg.raw_binary) {
 			if (data && cfg.read && !err)
 				d((unsigned char *)data, cfg.data_len, 16, 1);
 		} else if (data && cfg.read)
 			d_raw((unsigned char *)data, cfg.data_len);
 	}
+free_metadata:
+	free(mdata);
 free_data:
 	nvme_free(data, huge);
-free_metadata:
-	free(metadata);
-close_wfd:
+close_dfd:
 	if (strlen(cfg.input_file))
-		close(wfd);
+		close(dfd);
+close_mfd:
+	if (strlen(cfg.metadata))
+		close(mfd);
 close_fd:
 	close(fd);
 ret:
-	return nvme_status_to_errno(err, false);
+	return err;
 }
 
 static int io_passthru(int argc, char **argv, struct command *cmd, struct plugin *plugin)
 {
 	const char *desc = "Send a user-defined IO command to the specified "\
 		"device via IOCTL passthrough, return results.";
-	return passthru(argc, argv, NVME_IOCTL_IO_CMD, 0, desc, cmd);
+	return passthru(argc, argv, false, desc, cmd);
 }
 
 static int admin_passthru(int argc, char **argv, struct command *cmd, struct plugin *plugin)
 {
 	const char *desc = "Send a user-defined Admin command to the specified "\
 		"device via IOCTL passthrough, return results.";
-	return passthru(argc, argv, NVME_IOCTL_ADMIN_CMD, 1, desc, cmd);
+	return passthru(argc, argv, true, desc, cmd);
 }
 
 static int gen_hostnqn_cmd(int argc, char **argv, struct command *command, struct plugin *plugin)
 {
-	int ret;
-	char uuid_str[37]; /* e.g. 1b4e28ba-2fa1-11d2-883f-0016d3cca427 + \0 */
-#ifdef LIBUUID
-	uuid_t uuid;
-#endif
+	char *hostnqn;
 
-	ret = uuid_from_dmi(uuid_str);
-	if (ret < 0)
-		ret = uuid_from_systemd(uuid_str);
-#ifdef LIBUUID
-	if (ret < 0) {
-		uuid_generate_random(uuid);
-		uuid_unparse_lower(uuid, uuid_str);
-		ret = 0;
-	}
-#endif
-	if (ret < 0) {
+	hostnqn = nvmf_hostnqn_generate();
+	if (!hostnqn) {
 		fprintf(stderr, "\"%s\" not supported. Install lib uuid and rebuild.\n",
 			command->name);
 		return -ENOTSUP;
 	}
-	printf("nqn.2014-08.org.nvmexpress:uuid:%s\n", uuid_str);
+	printf("%s\n", hostnqn);
+	free(hostnqn);
 	return 0;
 }
 
@@ -6554,45 +7495,468 @@ static int show_hostnqn_cmd(int argc, char **argv, struct command *command, stru
 {
 	char *hostnqn;
 
-	hostnqn = hostnqn_read();
-	if (hostnqn) {
-		fputs(hostnqn, stdout);
-		free(hostnqn);
-		return 0;
-	} else {
+	hostnqn = nvmf_hostnqn_from_file();
+	if (!hostnqn)
+		hostnqn =  nvmf_hostnqn_generate();
+
+	if (!hostnqn) {
 		fprintf(stderr, "hostnqn is not available -- use nvme gen-hostnqn\n");
-		return -ENOENT;
+		return ENOENT;
+	}
+
+	fprintf(stdout, "%s\n", hostnqn);
+	free(hostnqn);
+
+	return 0;
+}
+
+
+static int gen_dhchap_key(int argc, char **argv, struct command *command, struct plugin *plugin)
+{
+	const char *desc = "Generate a DH-HMAC-CHAP host key usable "\
+		"for NVMe In-Band Authentication.";
+	const char *secret = "Optional secret (in hexadecimal characters) "\
+		"to be used to initialize the host key.";
+	const char *key_len = "Length of the resulting key "\
+		"(32, 48, or 64 bytes).";
+	const char *hmac = "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;
+	unsigned char key[68];
+	char encoded_key[128];
+	unsigned long crc = crc32(0L, NULL, 0);
+	int err = 0;
+
+	struct config {
+		char		*secret;
+		unsigned int	key_len;
+		char		*nqn;
+		unsigned int	hmac;
+	};
+
+	struct config cfg = {
+		.secret		= NULL,
+		.key_len	= 0,
+		.nqn		= NULL,
+		.hmac		= 0,
+	};
+
+	OPT_ARGS(opts) = {
+		OPT_STR("secret",	's', &cfg.secret,	secret),
+		OPT_UINT("key-length",	'l', &cfg.key_len,	key_len),
+		OPT_STR("nqn",		'n', &cfg.nqn,		nqn),
+		OPT_UINT("hmac",	'm', &cfg.hmac,		hmac),
+		OPT_END()
+	};
+
+	err = argconfig_parse(argc, argv, desc, opts);
+	if (err)
+		return err;
+
+	if (cfg.hmac > 3) {
+		fprintf(stderr, "Invalid HMAC identifier %u\n", cfg.hmac);
+		return -EINVAL;
+	}
+	if (cfg.hmac > 0) {
+		switch (cfg.hmac) {
+		case 1:
+			if (!cfg.key_len)
+				cfg.key_len = 32;
+			else if (cfg.key_len != 32) {
+				fprintf(stderr, "Invalid key length %d for SHA(256)\n",
+					cfg.key_len);
+				return -EINVAL;
+			}
+			break;
+		case 2:
+			if (!cfg.key_len)
+				cfg.key_len = 48;
+			else if (cfg.key_len != 48) {
+				fprintf(stderr, "Invalid key length %d for SHA(384)\n",
+					cfg.key_len);
+				return -EINVAL;
+			}
+			break;
+		case 3:
+			if (!cfg.key_len)
+				cfg.key_len = 64;
+			else if (cfg.key_len != 64) {
+				fprintf(stderr, "Invalid key length %d for SHA(512)\n",
+					cfg.key_len);
+				return -EINVAL;
+			}
+			break;
+		default:
+			break;
+		}
+	} else if (!cfg.key_len)
+		cfg.key_len = 32;
+
+	if (cfg.key_len != 32 && cfg.key_len != 48 && cfg.key_len != 64) {
+		fprintf(stderr, "Invalid key length %u\n", cfg.key_len);
+		return -EINVAL;
+	}
+	raw_secret = malloc(cfg.key_len);
+	if (!raw_secret)
+		return -ENOMEM;
+	if (!cfg.secret) {
+		if (getrandom_bytes(raw_secret, cfg.key_len) < 0)
+			return -errno;
+	} else {
+		int secret_len = 0, i;
+		unsigned int c;
+
+		for (i = 0; i < strlen(cfg.secret); i+=2) {
+			if (sscanf(&cfg.secret[i], "%02x", &c) != 1) {
+				fprintf(stderr, "Invalid secret '%s'\n",
+					cfg.secret);
+				return -EINVAL;
+			}
+			raw_secret[secret_len++] = (unsigned char)c;
+		}
+		if (secret_len != cfg.key_len) {
+			fprintf(stderr, "Invalid key length (%d bytes)\n",
+				secret_len);
+			return -EINVAL;
+		}
+	}
+
+	if (!cfg.nqn) {
+		cfg.nqn = nvmf_hostnqn_from_file();
+		if (!cfg.nqn) {
+			fprintf(stderr, "Could not read host NQN\n");
+			return -ENOENT;
+		}
+	}
+
+	if (nvme_gen_dhchap_key(cfg.nqn, cfg.hmac, cfg.key_len,
+				raw_secret, key) < 0)
+		return -errno;
+
+	crc = crc32(crc, key, cfg.key_len);
+	key[cfg.key_len++] = crc & 0xff;
+	key[cfg.key_len++] = (crc >> 8) & 0xff;
+	key[cfg.key_len++] = (crc >> 16) & 0xff;
+	key[cfg.key_len++] = (crc >> 24) & 0xff;
+
+	memset(encoded_key, 0, sizeof(encoded_key));
+	base64_encode(key, cfg.key_len, encoded_key);
+
+	printf("DHHC-1:%02x:%s:\n", cfg.hmac, encoded_key);
+	return 0;
+}
+
+static int check_dhchap_key(int argc, char **argv, struct command *command, struct plugin *plugin)
+{
+	const char *desc = "Check a DH-HMAC-CHAP host key for usability "\
+		"for NVMe In-Band Authentication.";
+	const char *key = "DH-HMAC-CHAP key (in hexadecimal characters) "\
+		"to be validated.";
+
+	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;
+	struct config {
+		char	*key;
+	};
+
+	struct config cfg = {
+		.key	= NULL,
+	};
+
+	OPT_ARGS(opts) = {
+		OPT_STR("key", 'k', &cfg.key, key),
+		OPT_END()
+	};
+
+	err = argconfig_parse(argc, argv, desc, opts);
+	if (err)
+		return err;
+
+	if (!cfg.key) {
+		fprintf(stderr, "Key not specified\n");
+		return -EINVAL;
+	}
+
+	if (sscanf(cfg.key, "DHHC-1:%02x:*s", &hmac) != 1) {
+		fprintf(stderr, "Invalid key header '%s'\n", cfg.key);
+		return -EINVAL;
+	}
+	switch (hmac) {
+	case 0:
+		break;
+	case 1:
+		if (strlen(cfg.key) != 59) {
+			fprintf(stderr, "Invalid key length for SHA(256)\n");
+			return -EINVAL;
+		}
+		break;
+	case 2:
+		if (strlen(cfg.key) != 83) {
+			fprintf(stderr, "Invalid key length for SHA(384)\n");
+			return -EINVAL;
+		}
+		break;
+	case 3:
+		if (strlen(cfg.key) != 103) {
+			fprintf(stderr, "Invalid key length for SHA(512)\n");
+			return -EINVAL;
+		}
+		break;
+	default:
+		fprintf(stderr, "Invalid HMAC identifier %d\n", hmac);
+		return -EINVAL;
+		break;
+	}
+
+	err = base64_decode(cfg.key + 10, strlen(cfg.key) - 11,
+			    decoded_key);
+	if (err < 0) {
+		fprintf(stderr, "Base64 decoding failed, error %d\n",
+			err);
+		return err;
+	}
+	decoded_len = err;
+	if (decoded_len < 32) {
+		fprintf(stderr, "Base64 decoding failed (%s, size %u)\n",
+			cfg.key + 10, decoded_len);
+		return -EINVAL;
+	}
+	decoded_len -= 4;
+	if (decoded_len != 32 && decoded_len != 48 && decoded_len != 64) {
+		fprintf(stderr, "Invalid key length %d\n", 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) {
+		fprintf(stderr, "CRC mismatch (key %08x, crc %08x)\n",
+			key_crc, crc);
+		return -EINVAL;
+	}
+	printf("Key is valid (HMAC %d, length %d, CRC %08x)\n",
+	       hmac, decoded_len, crc);
+	return 0;
+}
+
+static int gen_tls_key(int argc, char **argv, struct command *command, struct plugin *plugin)
+{
+	const char *desc = "Generate a TLS key in NVMe PSK Interchange format.";
+	const char *secret = "Optional secret (in hexadecimal characters) "\
+		"to be used for the TLS key.";
+	const char *hmac = "HMAC function to use for the retained key "\
+		"(1 = SHA-256, 2 = SHA-384).";
+
+	unsigned char *raw_secret;
+	char encoded_key[128];
+	int key_len = 32;
+	unsigned long crc = crc32(0L, NULL, 0);
+	int err = 0;
+
+	struct config {
+		char		*secret;
+		unsigned int	hmac;
+	};
+
+	struct config cfg = {
+		.secret		= NULL,
+		.hmac		= 1,
+	};
+
+	OPT_ARGS(opts) = {
+		OPT_STR("secret",	's', &cfg.secret,	secret),
+		OPT_UINT("hmac",	'm', &cfg.hmac,		hmac),
+		OPT_END()
+	};
+
+	err = argconfig_parse(argc, argv, desc, opts);
+	if (err)
+		return err;
+	if (cfg.hmac < 1 || cfg.hmac > 3) {
+		fprintf(stderr, "Invalid HMAC identifier %u\n", cfg.hmac);
+		return -EINVAL;
+	}
+
+	if (cfg.hmac == 2)
+		key_len = 48;
+
+	raw_secret = malloc(key_len + 4);
+	if (!raw_secret)
+		return -ENOMEM;
+	if (!cfg.secret) {
+		if (getrandom_bytes(raw_secret, key_len) < 0)
+			return -errno;
+	} else {
+		int secret_len = 0, i;
+		unsigned int c;
+
+		for (i = 0; i < strlen(cfg.secret); i+=2) {
+			if (sscanf(&cfg.secret[i], "%02x", &c) != 1) {
+				fprintf(stderr, "Invalid secret '%s'\n",
+					cfg.secret);
+				return -EINVAL;
+			}
+			if (i >= key_len) {
+				fprintf(stderr,
+					"Skipping excess secret bytes\n");
+				break;
+			}
+			raw_secret[secret_len++] = (unsigned char)c;
+		}
+		if (secret_len != key_len) {
+			fprintf(stderr, "Invalid key length (%d bytes)\n",
+				secret_len);
+			return -EINVAL;
+		}
+	}
+
+	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;
+}
+
+static int check_tls_key(int argc, char **argv, struct command *command, struct plugin *plugin)
+{
+	const char *desc = "Check a TLS key for NVMe PSK Interchange format.\n";
+	const char *key = "TLS key (in PSK Interchange format) "\
+		"to be validated.";
+
+	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;
+	struct config {
+		char	*key;
+	};
+
+	struct config cfg = {
+		.key	= NULL,
+	};
+
+	OPT_ARGS(opts) = {
+		OPT_STR("key", 'k', &cfg.key, key),
+		OPT_END()
+	};
+
+	err = argconfig_parse(argc, argv, desc, opts);
+	if (err)
+		return err;
+
+	if (!cfg.key) {
+		fprintf(stderr, "Key not specified\n");
+		return -EINVAL;
+	}
+
+	if (sscanf(cfg.key, "NVMeTLSkey-1:%02x:*s", &hmac) != 1) {
+		fprintf(stderr, "Invalid key header '%s'\n", cfg.key);
+		return -EINVAL;
+	}
+	switch (hmac) {
+	case 1:
+		if (strlen(cfg.key) != 65) {
+			fprintf(stderr, "Invalid key length %lu for SHA(256)\n",
+				strlen(cfg.key));
+			return -EINVAL;
+		}
+		break;
+	case 2:
+		if (strlen(cfg.key) != 89) {
+			fprintf(stderr, "Invalid key length %lu for SHA(384)\n",
+				strlen(cfg.key));
+			return -EINVAL;
+		}
+		break;
+	default:
+		fprintf(stderr, "Invalid HMAC identifier %d\n", hmac);
+		return -EINVAL;
+		break;
+	}
+
+	err = base64_decode(cfg.key + 16, strlen(cfg.key) - 17,
+			    decoded_key);
+	if (err < 0) {
+		fprintf(stderr, "Base64 decoding failed (%s, error %d)\n",
+			cfg.key + 16, err);
+		return err;
+	}
+	decoded_len = err;
+	decoded_len -= 4;
+	if (decoded_len != 32 && decoded_len != 48) {
+		fprintf(stderr, "Invalid key length %d\n", 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) {
+		fprintf(stderr, "CRC mismatch (key %08x, crc %08x)\n",
+			key_crc, crc);
+		return -EINVAL;
+	}
+	printf("Key is valid (HMAC %d, length %d, CRC %08x)\n",
+	       hmac, decoded_len, crc);
+	return 0;
 }
 
 static int discover_cmd(int argc, char **argv, struct command *command, struct plugin *plugin)
 {
 	const char *desc = "Send Get Log Page request to Discovery Controller.";
-	return fabrics_discover(desc, argc, argv, false);
+	return nvmf_discover(desc, argc, argv, false);
 }
 
 static int connect_all_cmd(int argc, char **argv, struct command *command, struct plugin *plugin)
 {
 	const char *desc = "Discover NVMeoF subsystems and connect to them";
-	return fabrics_discover(desc, argc, argv, true);
+	return nvmf_discover(desc, argc, argv, true);
 }
 
 static int connect_cmd(int argc, char **argv, struct command *command, struct plugin *plugin)
 {
 	const char *desc = "Connect to NVMeoF subsystem";
-	return fabrics_connect(desc, argc, argv);
+	return nvmf_connect(desc, argc, argv);
 }
 
 static int disconnect_cmd(int argc, char **argv, struct command *command, struct plugin *plugin)
 {
 	const char *desc = "Disconnect from NVMeoF subsystem";
-	return fabrics_disconnect(desc, argc, argv);
+	return nvmf_disconnect(desc, argc, argv);
 }
 
-static int disconnect_all_cmd(int argc, char **argv, struct command *command, struct plugin *plugin)
+int disconnect_all_cmd(int argc, char **argv, struct command *command,
+	struct plugin *plugin)
 {
 	const char *desc = "Disconnect from all connected NVMeoF subsystems";
-	return fabrics_disconnect_all(desc, argc, argv);
+	return nvmf_disconnect_all(desc, argc, argv);
+}
+
+static int config_cmd(int argc, char **argv, struct command *command, struct plugin *plugin)
+{
+	const char *desc = "Configuration of NVMeoF subsystems";
+	return nvmf_config(desc, argc, argv);
+}
+
+static int dim_cmd(int argc, char **argv, struct command *command, struct plugin *plugin)
+{
+	const char *desc = "Send Discovery Information Management command to a Discovery Controller (DC)";
+	return nvmf_dim(desc, argc, argv);
 }
 
 void register_extension(struct plugin *plugin)
@@ -6617,5 +7981,5 @@ int main(int argc, char **argv)
 	if (err == -ENOTTY)
 		general_help(&builtin);
 
-	return err;
+	return err ? 1 : 0;
 }
diff --git a/nvme.control.in b/nvme.control.in
index 46714d4..74d36aa 100644
--- a/nvme.control.in
+++ b/nvme.control.in
@@ -1,9 +1,9 @@
 Package: nvme
-Version: @@VERSION@@
+Version: @VERSION@
 Section: base
 Priority: optional
 Architecture: amd64
-Depends: @@DEPENDS@@
+Depends: @DEPENDS@
 Maintainer: Keith Busch <kbusch@kernel.org>
 Description: NVM-Express Command Line Interface
  The nvme management tool