Adding upstream version 2.7.1.upstream/2.7.1

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

1 files changed, 680 insertions, 307 deletions

diff --git a/nvme-print-stdout.c b/nvme-print-stdout.c
index 877ba75..e3c9a74 100644
--- a/nvme-print-stdout.c
+++ b/nvme-print-stdout.c
@@ -7,6 +7,11 @@
 #include <time.h>
 #include <sys/stat.h>
 
+#include <ccan/ccan/strset/strset.h>
+#include <ccan/ccan/htable/htable_type.h>
+#include <ccan/ccan/htable/htable.h>
+#include <ccan/ccan/hash/hash.h>
+
 #include "nvme.h"
 #include "libnvme.h"
 #include "nvme-print.h"
@@ -21,15 +26,139 @@ static const char dash[100] = {[0 ... 99] = '-'};
 
 static struct print_ops stdout_print_ops;
 
-struct nvme_bar_cap {
-	__u16	mqes;
-	__u8	ams_cqr;
-	__u8	to;
-	__u16	bps_css_nssrs_dstrd;
-	__u8	mpsmax_mpsmin;
-	__u8	rsvd_crms_nsss_cmbs_pmrs;
+static const char *subsys_key(const struct nvme_subsystem *s)
+{
+	return nvme_subsystem_get_name((nvme_subsystem_t)s);
+}
+
+static const char *ctrl_key(const struct nvme_ctrl *c)
+{
+	return nvme_ctrl_get_name((nvme_ctrl_t)c);
+}
+
+static const char *ns_key(const struct nvme_ns *n)
+{
+	return nvme_ns_get_name((nvme_ns_t)n);
+}
+
+static bool subsys_cmp(const struct nvme_subsystem *s, const char *name)
+{
+	return !strcmp(nvme_subsystem_get_name((nvme_subsystem_t)s), name);
+}
+
+static bool ctrl_cmp(const struct nvme_ctrl *c, const char *name)
+{
+	return !strcmp(nvme_ctrl_get_name((nvme_ctrl_t)c), name);
+}
+
+static bool ns_cmp(const struct nvme_ns *n, const char *name)
+{
+	return !strcmp(nvme_ns_get_name((nvme_ns_t)n), name);
+}
+
+HTABLE_DEFINE_TYPE(struct nvme_subsystem, subsys_key, hash_string,
+		   subsys_cmp, htable_subsys);
+HTABLE_DEFINE_TYPE(struct nvme_ctrl, ctrl_key, hash_string,
+		   ctrl_cmp, htable_ctrl);
+HTABLE_DEFINE_TYPE(struct nvme_ns, ns_key, hash_string,
+		   ns_cmp, htable_ns);
+
+static void htable_ctrl_add_unique(struct htable_ctrl *ht, nvme_ctrl_t c)
+{
+	if (htable_ctrl_get(ht, nvme_ctrl_get_name(c)))
+		return;
+
+	htable_ctrl_add(ht, c);
+}
+
+static void htable_ns_add_unique(struct htable_ns *ht, nvme_ns_t n)
+{
+	struct htable_ns_iter it;
+	nvme_ns_t _n;
+
+	/*
+	 * Test if namespace pointer is already in the hash, and thus avoid
+	 * inserting severaltimes the same pointer.
+	 */
+	for (_n = htable_ns_getfirst(ht, nvme_ns_get_name(n), &it);
+	     _n;
+	     _n = htable_ns_getnext(ht, nvme_ns_get_name(n), &it)) {
+		if (_n == n)
+			return;
+	}
+	htable_ns_add(ht, n);
+}
+
+struct nvme_resources {
+	nvme_root_t r;
+
+	struct htable_subsys ht_s;
+	struct htable_ctrl ht_c;
+	struct htable_ns ht_n;
+	struct strset subsystems;
+	struct strset ctrls;
+	struct strset namespaces;
 };
 
+static int nvme_resources_init(nvme_root_t r, struct nvme_resources *res)
+{
+	nvme_host_t h;
+	nvme_subsystem_t s;
+	nvme_ctrl_t c;
+	nvme_ns_t n;
+	nvme_path_t p;
+
+	res->r = r;
+	htable_subsys_init(&res->ht_s);
+	htable_ctrl_init(&res->ht_c);
+	htable_ns_init(&res->ht_n);
+	strset_init(&res->subsystems);
+	strset_init(&res->ctrls);
+	strset_init(&res->namespaces);
+
+	nvme_for_each_host(r, h) {
+		nvme_for_each_subsystem(h, s) {
+			htable_subsys_add(&res->ht_s, s);
+			strset_add(&res->subsystems, nvme_subsystem_get_name(s));
+
+			nvme_subsystem_for_each_ctrl(s, c) {
+				htable_ctrl_add_unique(&res->ht_c, c);
+				strset_add(&res->ctrls, nvme_ctrl_get_name(c));
+
+				nvme_ctrl_for_each_ns(c, n) {
+					htable_ns_add_unique(&res->ht_n, n);
+					strset_add(&res->namespaces, nvme_ns_get_name(n));
+				}
+
+				nvme_ctrl_for_each_path(c, p) {
+					n = nvme_path_get_ns(p);
+					if (n) {
+						htable_ns_add_unique(&res->ht_n, n);
+						strset_add(&res->namespaces, nvme_ns_get_name(n));
+					}
+				}
+			}
+
+			nvme_subsystem_for_each_ns(s, n) {
+				htable_ns_add_unique(&res->ht_n, n);
+				strset_add(&res->namespaces, nvme_ns_get_name(n));
+			}
+		}
+	}
+
+	return 0;
+}
+
+static void nvme_resources_free(struct nvme_resources *res)
+{
+	strset_clear(&res->namespaces);
+	strset_clear(&res->ctrls);
+	strset_clear(&res->subsystems);
+	htable_ns_clear(&res->ht_n);
+	htable_ctrl_clear(&res->ht_c);
+	htable_subsys_clear(&res->ht_s);
+}
+
 static void stdout_feature_show_fields(enum nvme_features_id fid,
 				       unsigned int result,
 				       unsigned char *buf);
@@ -388,6 +517,7 @@ static void stdout_persistent_event_log(void *pevent_log_info,
 			break;
 		default:
 			printf("Reserved Event\n\n");
+			break;
 		}
 		offset += le16_to_cpu(pevent_entry_head->el);
 		printf("\n");
@@ -567,6 +697,112 @@ static void stdout_boot_part_log(void *bp_log, const char *devname,
 	printf("Active BPID: %u\n", (le32_to_cpu(hdr->bpinfo) >> 31) & 0x1);
 }
 
+static const char *eomip_to_string(__u8 eomip)
+{
+	const char *string;
+	switch (eomip) {
+	case NVME_PHY_RX_EOM_NOT_STARTED:
+		string = "Not Started";
+		break;
+	case NVME_PHY_RX_EOM_IN_PROGRESS:
+		string = "In Progress";
+		break;
+	case NVME_PHY_RX_EOM_COMPLETED:
+		string = "Completed";
+		break;
+	default:
+		string = "Unknown";
+		break;
+	}
+	return string;
+}
+
+static void stdout_phy_rx_eom_odp(uint8_t odp)
+{
+	__u8 rsvd = (odp >> 2) & 0x3F;
+	__u8 edfp = (odp >> 1) & 0x1;
+	__u8 pefp = odp & 0x1;
+
+	if (rsvd)
+		printf("  [7:2] : %#x\tReserved\n", rsvd);
+	printf("  [1:1] : %#x\tEye Data Field %sPresent\n",
+		edfp, edfp ? "" : "Not ");
+	printf("  [0:0] : %#x\tPrintable Eye Field %sPresent\n",
+		pefp, pefp ? "" : "Not ");
+}
+
+static void stdout_eom_printable_eye(struct nvme_eom_lane_desc *lane)
+{
+	char *eye = (char *)lane->eye_desc;
+	int i, j;
+	for (i = 0; i < lane->nrows; i++) {
+		for (j = 0; j < lane->ncols; j++)
+			printf("%c", eye[i * lane->ncols + j]);
+		printf("\n");
+	}
+}
+
+static void stdout_phy_rx_eom_descs(struct nvme_phy_rx_eom_log *log)
+{
+	void *p = log->descs;
+	int i;
+
+	for (i = 0; i < log->nd; i++) {
+		struct nvme_eom_lane_desc *desc = p;
+
+		printf("Measurement Status: %s\n",
+			desc->mstatus ? "Successful" : "Not Successful");
+		printf("Lane: %u\n", desc->lane);
+		printf("Eye: %u\n", desc->eye);
+		printf("Top: %u\n", le16_to_cpu(desc->top));
+		printf("Bottom: %u\n", le16_to_cpu(desc->bottom));
+		printf("Left: %u\n", le16_to_cpu(desc->left));
+		printf("Right: %u\n", le16_to_cpu(desc->right));
+		printf("Number of Rows: %u\n", le16_to_cpu(desc->nrows));
+		printf("Number of Columns: %u\n", le16_to_cpu(desc->ncols));
+		printf("Eye Data Length: %u\n", le16_to_cpu(desc->edlen));
+
+		if (log->odp & NVME_EOM_PRINTABLE_EYE_PRESENT)
+			stdout_eom_printable_eye(desc);
+
+		/* Eye Data field is vendor specific */
+
+		p += log->dsize;
+	}
+}
+
+static void stdout_phy_rx_eom_log(struct nvme_phy_rx_eom_log *log, __u16 controller)
+{
+	int human = stdout_print_ops.flags & VERBOSE;
+
+	printf("Physical Interface Receiver Eye Opening Measurement Log for controller ID: %u\n", controller);
+	printf("Log ID: %u\n", log->lid);
+	printf("EOM In Progress: %s\n", eomip_to_string(log->eomip));
+	printf("Header Size: %u\n", le16_to_cpu(log->hsize));
+	printf("Result Size: %u\n", le32_to_cpu(log->rsize));
+	printf("EOM Data Generation Number: %u\n", log->eomdgn);
+	printf("Log Revision: %u\n", log->lr);
+	printf("Optional Data Present: %u\n", log->odp);
+	if (human)
+		stdout_phy_rx_eom_odp(log->odp);
+	printf("Lanes: %u\n", log->lanes);
+	printf("Eyes Per Lane: %u\n", log->epl);
+	printf("Log Specific Parameter Field Copy: %u\n", log->lspfc);
+	printf("Link Information: %u\n", log->li);
+	printf("Log Specific Identifier Copy: %u\n", le16_to_cpu(log->lsic));
+	printf("Descriptor Size: %u\n", le32_to_cpu(log->dsize));
+	printf("Number of Descriptors: %u\n", le16_to_cpu(log->nd));
+	printf("Maximum Top Bottom: %u\n", le16_to_cpu(log->maxtb));
+	printf("Maximum Left Right: %u\n", le16_to_cpu(log->maxlr));
+	printf("Estimated Time for Good Quality: %u\n", le16_to_cpu(log->etgood));
+	printf("Estimated Time for Better Quality: %u\n", le16_to_cpu(log->etbetter));
+	printf("Estimated Time for Best Quality: %u\n", le16_to_cpu(log->etbest));
+
+	if (log->eomip == NVME_PHY_RX_EOM_COMPLETED) {
+		stdout_phy_rx_eom_descs(log);
+	}
+}
+
 static void stdout_media_unit_stat_log(struct nvme_media_unit_stat_log *mus_log)
 {
 	int i;
@@ -597,7 +833,7 @@ static void stdout_media_unit_stat_log(struct nvme_media_unit_stat_log *mus_log)
 static void stdout_fdp_config_fdpa(uint8_t fdpa)
 {
 	__u8 valid = (fdpa >> 7) & 0x1;
-	__u8 rsvd = (fdpa >> 5) >> 0x3;
+	__u8 rsvd = (fdpa >> 5) & 0x3;
 	__u8 fdpvwc = (fdpa >> 4) & 0x1;
 	__u8 rgif = fdpa & 0xf;
 
@@ -826,13 +1062,24 @@ static void stdout_subsystem_ctrls(nvme_subsystem_t s)
 static void stdout_subsystem(nvme_root_t r, bool show_ana)
 {
 	nvme_host_t h;
+	bool first = true;
 
 	nvme_for_each_host(r, h) {
 		nvme_subsystem_t s;
 
 		nvme_for_each_subsystem(h, s) {
+			int len = strlen(nvme_subsystem_get_name(s));
+
+			if (!first)
+				printf("\n");
+			first = false;
+
 			printf("%s - NQN=%s\n", nvme_subsystem_get_name(s),
 			       nvme_subsystem_get_nqn(s));
+			printf("%*s   hostnqn=%s\n", len, " ",
+			       nvme_host_get_hostnqn(nvme_subsystem_get_host(s)));
+			printf("%*s   iopolicy=%s\n", len, " ",
+			       nvme_subsystem_get_iopolicy(s));
 			printf("\\\n");
 
 			if (!show_ana || !stdout_subsystem_multipath(s))
@@ -849,39 +1096,33 @@ static void stdout_subsystem_list(nvme_root_t r, bool show_ana)
 static void stdout_registers_cap(struct nvme_bar_cap *cap)
 {
 	printf("\tController Ready With Media Support (CRWMS): %s\n",
-		((cap->rsvd_crms_nsss_cmbs_pmrs & 0x08) >> 3) ? "Supported" : "Not Supported");
+	       cap->crwms ? "Supported" : "Not Supported");
 	printf("\tController Ready Independent of Media Support (CRIMS): %s\n",
-		((cap->rsvd_crms_nsss_cmbs_pmrs & 0x10) >> 4) ? "Supported" : "Not Supported");
+	       cap->crims ? "Supported" : "Not Supported");
+	printf("\tNVM Subsystem Shutdown Supported   (NSSS): %s\n", cap->nsss ? "Supported" : "Not Supported");
 	printf("\tController Memory Buffer Supported (CMBS): The Controller Memory Buffer is %s\n",
-		((cap->rsvd_crms_nsss_cmbs_pmrs & 0x02) >> 1) ? "Supported" :
-			"Not Supported");
+	       cap->cmbs ? "Supported" : "Not Supported");
 	printf("\tPersistent Memory Region Supported (PMRS): The Persistent Memory Region is %s\n",
-		(cap->rsvd_crms_nsss_cmbs_pmrs & 0x01) ? "Supported" : "Not Supported");
-	printf("\tMemory Page Size Maximum         (MPSMAX): %u bytes\n",
-		1 <<  (12 + ((cap->mpsmax_mpsmin & 0xf0) >> 4)));
-	printf("\tMemory Page Size Minimum         (MPSMIN): %u bytes\n",
-		1 <<  (12 + (cap->mpsmax_mpsmin & 0x0f)));
-	printf("\tBoot Partition Support              (BPS): %s\n",
-		(cap->bps_css_nssrs_dstrd & 0x2000) ? "Yes":"No");
+	       cap->pmrs ? "Supported" : "Not Supported");
+	printf("\tMemory Page Size Maximum         (MPSMAX): %u bytes\n", 1 << (12 + cap->mpsmax));
+	printf("\tMemory Page Size Minimum         (MPSMIN): %u bytes\n", 1 << (12 + cap->mpsmin));
+	printf("\tController Power Scope              (CPS): %s\n",
+	       !cap->cps ? "Not Reported" : cap->cps == 1 ? "Controller scope" :
+	       cap->cps == 2 ? "Domain scope" : "NVM subsystem scope");
+	printf("\tBoot Partition Support              (BPS): %s\n", cap->bps ? "Yes" : "No");
 	printf("\tCommand Sets Supported              (CSS): NVM command set is %s\n",
-		(cap->bps_css_nssrs_dstrd & 0x0020) ? "Supported" : "Not Supported");
+	       cap->css & 0x01 ? "Supported" : "Not Supported");
 	printf("\t                                           One or more I/O Command Sets are %s\n",
-		(cap->bps_css_nssrs_dstrd & 0x0800) ? "Supported" : "Not Supported");
+	       cap->css & 0x40 ? "Supported" : "Not Supported");
 	printf("\t                                           %s\n",
-		(cap->bps_css_nssrs_dstrd & 0x1000) ? "Only Admin Command Set Supported" :
-		"I/O Command Set is Supported");
-	printf("\tNVM Subsystem Reset Supported     (NSSRS): %s\n",
-		(cap->bps_css_nssrs_dstrd & 0x0010) ? "Yes":"No");
-	printf("\tDoorbell Stride                   (DSTRD): %u bytes\n",
-		1 << (2 + (cap->bps_css_nssrs_dstrd & 0x000f)));
-	printf("\tTimeout                              (TO): %u ms\n",
-		cap->to * 500);
+	       cap->css & 0x80 ? "Only Admin Command Set Supported" : "I/O Command Set is Supported");
+	printf("\tNVM Subsystem Reset Supported     (NSSRS): %s\n", cap->nssrs ? "Yes" : "No");
+	printf("\tDoorbell Stride                   (DSTRD): %u bytes\n", 1 << (2 + cap->dstrd));
+	printf("\tTimeout                              (TO): %u ms\n", cap->to * 500);
 	printf("\tArbitration Mechanism Supported     (AMS): Weighted Round Robin with Urgent Priority Class is %s\n",
-		(cap->ams_cqr & 0x02) ? "supported":"not supported");
-	printf("\tContiguous Queues Required          (CQR): %s\n",
-		(cap->ams_cqr & 0x01) ? "Yes":"No");
-	printf("\tMaximum Queue Entries Supported    (MQES): %u\n\n",
-		cap->mqes + 1);
+	       cap->ams & 0x02 ? "Supported" : "Not supported");
+	printf("\tContiguous Queues Required          (CQR): %s\n", cap->cqr ? "Yes" : "No");
+	printf("\tMaximum Queue Entries Supported    (MQES): %u\n\n", cap->mqes + 1);
 }
 
 static void stdout_registers_version(__u32 vs)
@@ -905,6 +1146,7 @@ static void stdout_registers_cc_ams (__u8 ams)
 		break;
 	default:
 		printf("Reserved\n");
+		break;
 	}
 }
 
@@ -923,13 +1165,14 @@ static void stdout_registers_cc_shn (__u8 shn)
 		break;
 	default:
 		printf("Reserved\n");
+		break;
 	}
 }
 
 static void stdout_registers_cc(__u32 cc)
 {
 	printf("\tController Ready Independent of Media Enable (CRIME): %s\n",
-		NVME_CC_CRIME(cc) ? "Enabled":"Disabled");
+		NVME_CC_CRIME(cc) ? "Enabled" : "Disabled");
 
 	printf("\tI/O Completion Queue Entry Size (IOCQES): %u bytes\n",
 		1 << ((cc & 0x00f00000) >> NVME_CC_IOCQES_SHIFT));
@@ -944,7 +1187,7 @@ static void stdout_registers_cc(__u32 cc)
 		(cc & 0x00000070) == 0x60 ? "All supported I/O Command Sets" :
 		(cc & 0x00000070) == 0x70 ? "Admin Command Set only" : "Reserved");
 	printf("\tEnable                              (EN): %s\n\n",
-		(cc & 0x00000001) ? "Yes":"No");
+		(cc & 0x00000001) ? "Yes" : "No");
 }
 
 static void stdout_registers_csts_shst(__u8 shst)
@@ -962,29 +1205,28 @@ static void stdout_registers_csts_shst(__u8 shst)
 		break;
 	default:
 		printf("Reserved\n");
+		break;
 	}
 }
 
 static void stdout_registers_csts(__u32 csts)
 {
 	printf("\tProcessing Paused               (PP): %s\n",
-		(csts & 0x00000020) ? "Yes":"No");
+		(csts & 0x00000020) ? "Yes" : "No");
 	printf("\tNVM Subsystem Reset Occurred (NSSRO): %s\n",
-		(csts & 0x00000010) ? "Yes":"No");
+		(csts & 0x00000010) ? "Yes" : "No");
 	stdout_registers_csts_shst((csts & 0x0000000c) >> 2);
 	printf("\tController Fatal Status        (CFS): %s\n",
-		(csts & 0x00000002) ? "True":"False");
+		(csts & 0x00000002) ? "True" : "False");
 	printf("\tReady                          (RDY): %s\n\n",
-		(csts & 0x00000001) ? "Yes":"No");
+		(csts & 0x00000001) ? "Yes" : "No");
 
 }
 
 static void stdout_registers_crto(__u32 crto)
 {
-	printf("\tCRIMT                               : %d secs\n",
-		NVME_CRTO_CRIMT(crto)/2 );
-	printf("\tCRWMT                               : %d secs\n",
-		NVME_CRTO_CRWMT(crto)/2 );
+	printf("\tCRIMT                               : %d secs\n", NVME_CRTO_CRIMT(crto) / 2);
+	printf("\tCRWMT                               : %d secs\n", NVME_CRTO_CRWMT(crto) / 2);
 }
 
 static void stdout_registers_aqa(__u32 aqa)
@@ -1005,28 +1247,28 @@ static void stdout_registers_cmbloc(__u32 cmbloc, __u32 cmbsz)
 		return;
 	}
 	printf("\tOffset                                                        (OFST): 0x%x (See cmbsz.szu for granularity)\n",
-			(cmbloc & 0xfffff000) >> 12);
+	       (cmbloc & 0xfffff000) >> 12);
 
 	printf("\tCMB Queue Dword Alignment                                     (CQDA): %d\n",
-			(cmbloc & 0x00000100) >> 8);
+	       (cmbloc & 0x00000100) >> 8);
 
 	printf("\tCMB Data Metadata Mixed Memory Support                      (CDMMMS): %s\n",
-			enforced[(cmbloc & 0x00000080) >> 7]);
+	       enforced[(cmbloc & 0x00000080) >> 7]);
 
 	printf("\tCMB Data Pointer and Command Independent Locations Support (CDPCILS): %s\n",
-			enforced[(cmbloc & 0x00000040) >> 6]);
+	       enforced[(cmbloc & 0x00000040) >> 6]);
 
 	printf("\tCMB Data Pointer Mixed Locations Support                    (CDPMLS): %s\n",
-			enforced[(cmbloc & 0x00000020) >> 5]);
+	       enforced[(cmbloc & 0x00000020) >> 5]);
 
 	printf("\tCMB Queue Physically Discontiguous Support                   (CQPDS): %s\n",
-			enforced[(cmbloc & 0x00000010) >> 4]);
+	       enforced[(cmbloc & 0x00000010) >> 4]);
 
 	printf("\tCMB Queue Mixed Memory Support                               (CQMMS): %s\n",
-			enforced[(cmbloc & 0x00000008) >> 3]);
+	       enforced[(cmbloc & 0x00000008) >> 3]);
 
 	printf("\tBase Indicator Register                                        (BIR): 0x%x\n\n",
-			(cmbloc & 0x00000007));
+	       (cmbloc & 0x00000007));
 }
 
 static void stdout_registers_cmbsz(__u32 cmbsz)
@@ -1035,20 +1277,19 @@ static void stdout_registers_cmbsz(__u32 cmbsz)
 		printf("\tController Memory Buffer feature is not supported\n\n");
 		return;
 	}
-	printf("\tSize                      (SZ): %u\n",
-		(cmbsz & 0xfffff000) >> 12);
+	printf("\tSize                      (SZ): %u\n", (cmbsz & 0xfffff000) >> 12);
 	printf("\tSize Units               (SZU): %s\n",
-		nvme_register_szu_to_string((cmbsz & 0x00000f00) >> 8));
+	       nvme_register_szu_to_string((cmbsz & 0x00000f00) >> 8));
 	printf("\tWrite Data Support       (WDS): Write Data and metadata transfer in Controller Memory Buffer is %s\n",
-			(cmbsz & 0x00000010) ? "Supported":"Not supported");
+	       (cmbsz & 0x00000010) ? "Supported" : "Not supported");
 	printf("\tRead Data Support        (RDS): Read Data and metadata transfer in Controller Memory Buffer is %s\n",
-			(cmbsz & 0x00000008) ? "Supported":"Not supported");
+	       (cmbsz & 0x00000008) ? "Supported" : "Not supported");
 	printf("\tPRP SGL List Support   (LISTS): PRP/SG Lists in Controller Memory Buffer is %s\n",
-			(cmbsz & 0x00000004) ? "Supported":"Not supported");
+	       (cmbsz & 0x00000004) ? "Supported" : "Not supported");
 	printf("\tCompletion Queue Support (CQS): Admin and I/O Completion Queues in Controller Memory Buffer is %s\n",
-			(cmbsz & 0x00000002) ? "Supported":"Not supported");
+	       (cmbsz & 0x00000002) ? "Supported" : "Not supported");
 	printf("\tSubmission Queue Support (SQS): Admin and I/O Submission Queues in Controller Memory Buffer is %s\n\n",
-			(cmbsz & 0x00000001) ? "Supported":"Not supported");
+	       (cmbsz & 0x00000001) ? "Supported" : "Not supported");
 }
 
 static void stdout_registers_bpinfo_brs(__u8 brs)
@@ -1069,6 +1310,7 @@ static void stdout_registers_bpinfo_brs(__u8 brs)
 		break;
 	default:
 		printf("Invalid\n");
+		break;
 	}
 }
 
@@ -1093,7 +1335,6 @@ static void stdout_registers_bprsel(__u32 bprsel)
 
 static void stdout_registers_bpmbl(uint64_t bpmbl)
 {
-
 	printf("\tBoot Partition Memory Buffer Base Address (BMBBA): %"PRIx64"\n",
 		bpmbl);
 }
@@ -1125,13 +1366,13 @@ static void stdout_registers_pmrcap(__u32 pmrcap)
 	printf("\tPersistent Memory Region Write Barrier Mechanisms (PMRWBM): %x\n",
 		(pmrcap & 0x00003c00) >> 10);
 	printf("\tPersistent Memory Region Time Units                (PMRTU): PMR time unit is %s\n",
-		(pmrcap & 0x00000300) >> 8 ? "minutes":"500 milliseconds");
+		(pmrcap & 0x00000300) >> 8 ? "minutes" : "500 milliseconds");
 	printf("\tBase Indicator Register                              (BIR): %x\n",
 		(pmrcap & 0x000000e0) >> 5);
 	printf("\tWrite Data Support                                   (WDS): Write data to the PMR is %s\n",
-		(pmrcap & 0x00000010) ? "supported":"not supported");
+		(pmrcap & 0x00000010) ? "supported" : "not supported");
 	printf("\tRead Data Support                                    (RDS): Read data from the PMR is %s\n",
-		(pmrcap & 0x00000008) ? "supported":"not supported");
+		(pmrcap & 0x00000008) ? "supported" : "not supported");
 }
 
 static void stdout_registers_pmrctl(__u32 pmrctl)
@@ -1150,7 +1391,7 @@ static void stdout_registers_pmrsts(__u32 pmrsts, __u32 pmrctl)
 		"The Persistent Memory Region is %s to process "\
 		"PCI Express memory read and write requests\n",
 			(pmrsts & 0x00000100) == 0 && (pmrctl & 0x00000001) ?
-				"READY":"Not Ready");
+				"READY" : "Not Ready");
 	printf("\tError                            (ERR): %x\n", (pmrsts & 0x000000ff));
 }
 
@@ -1159,7 +1400,7 @@ static void stdout_registers_pmrebs(__u32 pmrebs)
 	printf("\tPMR Elasticity Buffer Size Base  (PMRWBZ): %x\n", (pmrebs & 0xffffff00) >> 8);
 	printf("\tRead Bypass Behavior                     : memory reads not conflicting with memory writes "\
 	       "in the PMR Elasticity Buffer %s bypass those memory writes\n",
-	       (pmrebs & 0x00000010) ? "SHALL":"MAY");
+	       (pmrebs & 0x00000010) ? "SHALL" : "MAY");
 	printf("\tPMR Elasticity Buffer Size Units (PMRSZU): %s\n",
 		nvme_register_pmr_pmrszu_to_string(pmrebs & 0x0000000f));
 }
@@ -1347,59 +1588,46 @@ void stdout_ctrl_registers(void *bar, bool fabrics)
 static void stdout_single_property(int offset, uint64_t value64)
 {
 	int human = stdout_print_ops.flags & VERBOSE;
-
-	uint32_t value32;
+	uint32_t value32 = (uint32_t)value64;
 
 	if (!human) {
 		if (nvme_is_64bit_reg(offset))
 			printf("property: 0x%02x (%s), value: %"PRIx64"\n",
-				offset, nvme_register_to_string(offset),
-				value64);
+			       offset, nvme_register_to_string(offset), value64);
 		else
 			printf("property: 0x%02x (%s), value: %x\n", offset,
-				   nvme_register_to_string(offset),
-				   (uint32_t) value64);
-
+			       nvme_register_to_string(offset), value32);
 		return;
 	}
 
-	value32 = (uint32_t) value64;
-
 	switch (offset) {
 	case NVME_REG_CAP:
 		printf("cap : %"PRIx64"\n", value64);
 		stdout_registers_cap((struct nvme_bar_cap *)&value64);
 		break;
-
 	case NVME_REG_VS:
 		printf("version : %x\n", value32);
 		stdout_registers_version(value32);
 		break;
-
 	case NVME_REG_CC:
 		printf("cc : %x\n", value32);
 		stdout_registers_cc(value32);
 		break;
-
 	case NVME_REG_CSTS:
 		printf("csts : %x\n", value32);
 		stdout_registers_csts(value32);
 		break;
-
 	case NVME_REG_NSSR:
 		printf("nssr : %x\n", value32);
-		printf("\tNVM Subsystem Reset Control (NSSRC): %u\n\n",
-			value32);
+		printf("\tNVM Subsystem Reset Control (NSSRC): %u\n\n", value32);
 		break;
-
 	case NVME_REG_CRTO:
 		printf("crto : %x\n", value32);
 		stdout_registers_crto(value32);
 		break;
-
 	default:
 		printf("unknown property: 0x%02x (%s), value: %"PRIx64"\n",
-			offset, nvme_register_to_string(offset), value64);
+		       offset, nvme_register_to_string(offset), value64);
 		break;
 	}
 }
@@ -1437,6 +1665,13 @@ static void stdout_status(int status)
 	}
 }
 
+static void stdout_error_status(int status, const char *msg, va_list ap)
+{
+	vfprintf(stderr, msg, ap);
+	fprintf(stderr, ": ");
+	stdout_status(status);
+}
+
 static void stdout_id_ctrl_cmic(__u8 cmic)
 {
 	__u8 rsvd = (cmic & 0xF0) >> 4;
@@ -1908,19 +2143,25 @@ static void stdout_id_ctrl_cqes(__u8 cqes)
 static void stdout_id_ctrl_oncs(__le16 ctrl_oncs)
 {
 	__u16 oncs = le16_to_cpu(ctrl_oncs);
-	__u16 rsvd = (oncs & 0xFE00) >> 9;
-	__u16 copy = (oncs & 0x100) >> 8;
-	__u16 vrfy = (oncs & 0x80) >> 7;
-	__u16 tmst = (oncs & 0x40) >> 6;
-	__u16 resv = (oncs & 0x20) >> 5;
-	__u16 save = (oncs & 0x10) >> 4;
-	__u16 wzro = (oncs & 0x8) >> 3;
-	__u16 dsms = (oncs & 0x4) >> 2;
-	__u16 wunc = (oncs & 0x2) >> 1;
-	__u16 cmp = oncs & 0x1;
+	__u16 rsvd = oncs >> 11;
+	bool afc  = !!(oncs & NVME_CTRL_ONCS_ALL_FAST_COPY);
+	bool csa  = !!(oncs & NVME_CTRL_ONCS_COPY_SINGLE_ATOMICITY);
+	bool copy = !!(oncs & NVME_CTRL_ONCS_COPY);
+	bool vrfy = !!(oncs & NVME_CTRL_ONCS_VERIFY);
+	bool tmst = !!(oncs & NVME_CTRL_ONCS_TIMESTAMP);
+	bool resv = !!(oncs & NVME_CTRL_ONCS_RESERVATIONS);
+	bool save = !!(oncs & NVME_CTRL_ONCS_SAVE_FEATURES);
+	bool wzro = !!(oncs & NVME_CTRL_ONCS_WRITE_ZEROES);
+	bool dsms = !!(oncs & NVME_CTRL_ONCS_DSM);
+	bool wunc = !!(oncs & NVME_CTRL_ONCS_WRITE_UNCORRECTABLE);
+	bool cmp  = !!(oncs & NVME_CTRL_ONCS_COMPARE);
 
 	if (rsvd)
-		printf(" [15:9] : %#x\tReserved\n", rsvd);
+		printf(" [15:11] : %#x\tReserved\n", rsvd);
+	printf("  [10:10] : %#x\tAll Fast Copy %sSupported\n",
+		afc, afc ? "" : "Not ");
+	printf("  [9:9] : %#x\tCopy Single Atomicity %sSupported\n",
+		csa, csa ? "" : "Not ");
 	printf("  [8:8] : %#x\tCopy %sSupported\n",
 		copy, copy ? "" : "Not ");
 	printf("  [7:7] : %#x\tVerify %sSupported\n",
@@ -2029,15 +2270,16 @@ static void stdout_id_ctrl_nwpc(__u8 nwpc)
 static void stdout_id_ctrl_ocfs(__le16 ctrl_ocfs)
 {
 	__u16 ocfs = le16_to_cpu(ctrl_ocfs);
-	__u16 rsvd = (ocfs & 0xfffc) >> 2;
-	__u8 copy_fmt_1 = (ocfs >> 1) & 0x1;
-	__u8 copy_fmt_0 = ocfs & 0x1;
+	__u16 rsvd = ocfs >> 4;
+	__u8 copy_fmt_supported;
+	int copy_fmt;
 	if (rsvd)
-		printf("  [15:2] : %#x\tReserved\n", rsvd);
-	printf("  [1:1] : %#x\tController Copy Format 1h %sSupported\n",
-		copy_fmt_1, copy_fmt_1 ? "" : "Not ");
-	printf("  [0:0] : %#x\tController Copy Format 0h %sSupported\n",
-		copy_fmt_0, copy_fmt_0 ? "" : "Not ");
+		printf("  [15:4] : %#x\tReserved\n", rsvd);
+	for (copy_fmt = 3; copy_fmt >= 0; copy_fmt--) {
+		copy_fmt_supported = ocfs >> copy_fmt & 1;
+		printf("  [%d:%d] : %#x\tController Copy Format %xh %sSupported\n", copy_fmt, copy_fmt,
+			copy_fmt_supported, copy_fmt, copy_fmt_supported ? "" : "Not ");
+	}
 	printf("\n");
 }
 
@@ -2184,9 +2426,9 @@ static void stdout_id_ns_dpc(__u8 dpc)
 	__u8 pit1 = dpc & 0x1;
 	if (rsvd)
 		printf("  [7:5] : %#x\tReserved\n", rsvd);
-	printf("  [4:4] : %#x\tProtection Information Transferred as Last 8 Bytes of Metadata %sSupported\n",
+	printf("  [4:4] : %#x\tProtection Information Transferred as Last Bytes of Metadata %sSupported\n",
 		pil8, pil8 ? "" : "Not ");
-	printf("  [3:3] : %#x\tProtection Information Transferred as First 8 Bytes of Metadata %sSupported\n",
+	printf("  [3:3] : %#x\tProtection Information Transferred as First Bytes of Metadata %sSupported\n",
 		pif8, pif8 ? "" : "Not ");
 	printf("  [2:2] : %#x\tProtection Information Type 3 %sSupported\n",
 		pit3, pit3 ? "" : "Not ");
@@ -2204,7 +2446,7 @@ static void stdout_id_ns_dps(__u8 dps)
 	__u8 pit = dps & 0x7;
 	if (rsvd)
 		printf("  [7:4] : %#x\tReserved\n", rsvd);
-	printf("  [3:3] : %#x\tProtection Information is Transferred as %s 8 Bytes of Metadata\n",
+	printf("  [3:3] : %#x\tProtection Information is Transferred as %s Bytes of Metadata\n",
 		pif8, pif8 ? "First" : "Last");
 	printf("  [2:0] : %#x\tProtection Information %s\n", pit,
 		pit == 3 ? "Type 3 Enabled" :
@@ -2531,19 +2773,17 @@ static void print_psd_workload(__u8 apw)
 		/* Unknown or not provided */
 		printf("-");
 		break;
-
 	case 1:
 		/* Extended idle period with burst of random write */
 		printf("1MiB 32 RW, 30s idle");
 		break;
-
 	case 2:
 		/* Heavy sequential writes */
 		printf("80K 128KiB SW");
 		break;
-
 	default:
 		printf("reserved");
+		break;
 	}
 }
 
@@ -2556,19 +2796,17 @@ static void print_ps_power_and_scale(__le16 ctr_power, __u8 scale)
 		/* Not reported for this power state */
 		printf("-");
 		break;
-
 	case NVME_PSD_PS_100_MICRO_WATT:
 		/* Units of 0.0001W */
 		printf("%01u.%04uW", power / 10000, power % 10000);
 		break;
-
 	case NVME_PSD_PS_10_MILLI_WATT:
 		/* Units of 0.01W */
 		printf("%01u.%02uW", power / 100, power % 100);
 		break;
-
 	default:
 		printf("reserved");
+		break;
 	}
 }
 
@@ -2765,6 +3003,7 @@ static void stdout_id_ctrl(struct nvme_id_ctrl *ctrl,
 	printf("maxdna    : %s\n",
 		uint128_t_to_l10n_string(le128_to_cpu(ctrl->maxdna)));
 	printf("maxcna    : %u\n", le32_to_cpu(ctrl->maxcna));
+	printf("oaqd      : %u\n", le32_to_cpu(ctrl->oaqd));
 	printf("subnqn    : %-.*s\n", (int)sizeof(ctrl->subnqn), ctrl->subnqn);
 	printf("ioccsz    : %u\n", le32_to_cpu(ctrl->ioccsz));
 	printf("iorcsz    : %u\n", le32_to_cpu(ctrl->iorcsz));
@@ -2846,7 +3085,7 @@ static void stdout_nvm_id_ns(struct nvme_nvm_id_ns *nvm_ns, unsigned int nsid,
 					pif == 1 ? "32b Guard" : "16b Guard",
 					pif, sts, i == (ns->flbas & 0xf) ? in_use : "");
 		else
-			printf("elbaf %2d : pif:%d lbads:%-2d %s\n", i,
+			printf("elbaf %2d : pif:%d sts:%-2d %s\n", i,
 				pif, sts, i == (ns->flbas & 0xf) ? in_use : "");
 	}
 }
@@ -3000,6 +3239,11 @@ static void stdout_list_ns(struct nvme_ns_list *ns_list)
 	}
 }
 
+static void stdout_zns_start_zone_list(__u64 nr_zones, struct json_object **zone_list)
+{
+	printf("nr_zones: %"PRIu64"\n", (uint64_t)le64_to_cpu(nr_zones));
+}
+
 static void stdout_zns_changed(struct nvme_zns_changed_zone_log *log)
 {
 	uint16_t nrzid;
@@ -3021,7 +3265,7 @@ static void stdout_zns_changed(struct nvme_zns_changed_zone_log *log)
 static void stdout_zns_report_zone_attributes(__u8 za, __u8 zai)
 {
 	const char *const recommended_limit[4] = {"","1","2","3"};
-	printf("Attrs: Zone Descriptor Extension is %sVaild\n", 
+	printf("Attrs: Zone Descriptor Extension is %sVaild\n",
 		(za & NVME_ZNS_ZA_ZDEV)? "" : "Not ");
 	if(za & NVME_ZNS_ZA_RZR) {
 		printf("       Reset Zone Recommended with Reset Recommended Limit%s\n",
@@ -3057,8 +3301,7 @@ static void stdout_zns_report_zones(void *report, __u32 descs,
 				(uint64_t)le64_to_cpu(desc->zcap), nvme_zone_state_to_string(desc->zs >> 4),
 				nvme_zone_type_to_string(desc->zt));
 			stdout_zns_report_zone_attributes(desc->za, desc->zai);
-		}
-		else {
+		} else {
 			printf("SLBA: %#-10"PRIx64" WP: %#-10"PRIx64" Cap: %#-10"PRIx64" State: %#-4x Type: %#-4x Attrs: %#-4x AttrsInfo: %#-4x\n",
 				(uint64_t)le64_to_cpu(desc->zslba), (uint64_t)le64_to_cpu(desc->wp),
 				(uint64_t)le64_to_cpu(desc->zcap), desc->zs, desc->zt,
@@ -3079,9 +3322,8 @@ static void stdout_list_ctrl(struct nvme_ctrl_list *ctrl_list)
 	int i;
 
 	printf("num of ctrls present: %u\n", num);
-	for (i = 0; i < min(num, 2047); i++) {
+	for (i = 0; i < min(num, 2047); i++)
 		printf("[%4u]:%#x\n", i, le16_to_cpu(ctrl_list->identifier[i]));
-	}
 }
 
 static void stdout_id_nvmset(struct nvme_id_nvmset_list *nvmset,
@@ -3207,8 +3449,8 @@ static void stdout_id_uuid_list(const struct nvme_id_uuid_list *uuid_list)
 {
 	int i, human = stdout_print_ops.flags & VERBOSE;
 
-	/* The 0th entry is reserved */
 	printf("NVME Identify UUID:\n");
+
 	for (i = 0; i < NVME_ID_UUID_LIST_MAX; i++) {
 		__u8 uuid[NVME_UUID_LEN];
 		char *association = "";
@@ -3279,7 +3521,7 @@ static void stdout_id_iocs(struct nvme_id_iocs *iocs)
 {
 	__u16 i;
 
-	for (i = 0; i < 512; i++)
+	for (i = 0; i < ARRAY_SIZE(iocs->iocsc); i++)
 		if (iocs->iocsc[i])
 			printf("I/O Command Set Combination[%u]:%"PRIx64"\n", i,
 				(uint64_t)le64_to_cpu(iocs->iocsc[i]));
@@ -3560,41 +3802,36 @@ static void stdout_supported_log(struct nvme_supported_log_pages *support_log,
 	}
 }
 
-static void stdout_endurance_log(struct nvme_endurance_group_log *endurance_log,
-				 __u16 group_id, const char *devname)
+static void stdout_endurance_log(struct nvme_endurance_group_log *endurance_log, __u16 group_id,
+				 const char *devname)
 {
-	printf("Endurance Group Log for NVME device:%s Group ID:%x\n", devname,
-		group_id);
-	printf("critical warning	: %u\n",
-		endurance_log->critical_warning);
+	printf("Endurance Group Log for NVME device:%s Group ID:%x\n", devname, group_id);
+	printf("critical_warning	: %u\n", endurance_log->critical_warning);
+	printf("endurance_group_features: %u\n", endurance_log->endurance_group_features);
 	printf("avl_spare		: %u\n", endurance_log->avl_spare);
-	printf("avl_spare_threshold	: %u\n",
-		endurance_log->avl_spare_threshold);
+	printf("avl_spare_threshold	: %u\n", endurance_log->avl_spare_threshold);
 	printf("percent_used		: %u%%\n", endurance_log->percent_used);
+	printf("domain_identifier	: %u\n", endurance_log->domain_identifier);
 	printf("endurance_estimate	: %s\n",
-		uint128_t_to_l10n_string(
-			le128_to_cpu(endurance_log->endurance_estimate)));
+	       uint128_t_to_l10n_string(le128_to_cpu(endurance_log->endurance_estimate)));
 	printf("data_units_read		: %s\n",
-		uint128_t_to_l10n_string(
-			le128_to_cpu(endurance_log->data_units_read)));
+	       uint128_t_to_l10n_string(le128_to_cpu(endurance_log->data_units_read)));
 	printf("data_units_written	: %s\n",
-		uint128_t_to_l10n_string(
-			le128_to_cpu(endurance_log->data_units_written)));
+	       uint128_t_to_l10n_string(le128_to_cpu(endurance_log->data_units_written)));
 	printf("media_units_written	: %s\n",
-		uint128_t_to_l10n_string(
-			le128_to_cpu(endurance_log->media_units_written)));
+	       uint128_t_to_l10n_string(le128_to_cpu(endurance_log->media_units_written)));
 	printf("host_read_cmds		: %s\n",
-		uint128_t_to_l10n_string(
-			le128_to_cpu(endurance_log->host_read_cmds)));
+	       uint128_t_to_l10n_string(le128_to_cpu(endurance_log->host_read_cmds)));
 	printf("host_write_cmds		: %s\n",
-		uint128_t_to_l10n_string(
-			le128_to_cpu(endurance_log->host_write_cmds)));
+	       uint128_t_to_l10n_string(le128_to_cpu(endurance_log->host_write_cmds)));
 	printf("media_data_integrity_err: %s\n",
-		uint128_t_to_l10n_string(
-			le128_to_cpu(endurance_log->media_data_integrity_err)));
+	       uint128_t_to_l10n_string(le128_to_cpu(endurance_log->media_data_integrity_err)));
 	printf("num_err_info_log_entries: %s\n",
-		uint128_t_to_l10n_string(
-			le128_to_cpu(endurance_log->num_err_info_log_entries)));
+	       uint128_t_to_l10n_string(le128_to_cpu(endurance_log->num_err_info_log_entries)));
+	printf("total_end_grp_cap	: %s\n",
+	       uint128_t_to_l10n_string(le128_to_cpu(endurance_log->total_end_grp_cap)));
+	printf("unalloc_end_grp_cap	: %s\n",
+	       uint128_t_to_l10n_string(le128_to_cpu(endurance_log->unalloc_end_grp_cap)));
 }
 
 static void stdout_smart_log(struct nvme_smart_log *smart, unsigned int nsid,
@@ -3876,7 +4113,7 @@ static void stdout_sanitize_log(struct nvme_sanitize_log_page *sanitize,
 		le32_to_cpu(sanitize->etcend));
 }
 
-static void stdout_select_result(__u32 result)
+static void stdout_select_result(enum nvme_features_id fid, __u32 result)
 {
 	if (result & 0x1)
 		printf("  Feature is saveable\n");
@@ -3903,7 +4140,7 @@ static void stdout_lba_range(struct nvme_lba_range_type *lbrt, int nr_ranges)
 		printf("\tslba       : %#"PRIx64"\n", le64_to_cpu(lbrt->entry[i].slba));
 		printf("\tnlb        : %#"PRIx64"\n", le64_to_cpu(lbrt->entry[i].nlb));
 		printf("\tguid       : ");
-		for (j = 0; j < 16; j++)
+		for (j = 0; j < ARRAY_SIZE(lbrt->entry[i].guid); j++)
 			printf("%02x", lbrt->entry[i].guid[j]);
 		printf("\n");
 	}
@@ -3916,15 +4153,15 @@ static void stdout_auto_pst(struct nvme_feat_auto_pst *apst)
 
 	printf( "\tAuto PST Entries");
 	printf("\t.................\n");
-	for (i = 0; i < 32; i++) {
+	for (i = 0; i < ARRAY_SIZE(apst->apst_entry); i++) {
 		value = le64_to_cpu(apst->apst_entry[i]);
 
 		printf("\tEntry[%2d]   \n", i);
 		printf("\t.................\n");
 		printf("\tIdle Time Prior to Transition (ITPT): %u ms\n",
-			(__u32)(value >> NVME_APST_ENTRY_ITPT_SHIFT) & NVME_APST_ENTRY_ITPT_MASK);
+		       (__u32)NVME_GET(value, APST_ENTRY_ITPT));
 		printf("\tIdle Transition Power State   (ITPS): %u\n",
-			(__u32)(value >> NVME_APST_ENTRY_ITPS_SHIFT ) & NVME_APST_ENTRY_ITPS_MASK);
+		       (__u32)NVME_GET(value, APST_ENTRY_ITPS));
 		printf("\t.................\n");
 	}
 }
@@ -3976,11 +4213,11 @@ static void stdout_directive_show_fields(__u8 dtype, __u8 doper,
 		case NVME_DIRECTIVE_RECEIVE_IDENTIFY_DOPER_PARAM:
 			printf("\tDirective support \n");
 			printf("\t\tIdentify Directive       : %s\n",
-				(*field & 0x1) ? "supported":"not supported");
+				(*field & 0x1) ? "supported" : "not supported");
 			printf("\t\tStream Directive         : %s\n",
-				(*field & 0x2) ? "supported":"not supported");
+				(*field & 0x2) ? "supported" : "not supported");
 			printf("\t\tData Placement Directive : %s\n",
-				(*field & 0x4) ? "supported":"not supported");
+				(*field & 0x4) ? "supported" : "not supported");
 			printf("\tDirective enabled \n");
 			printf("\t\tIdentify Directive       : %s\n",
 				(*(field + 32) & 0x1) ? "enabled" : "disabled");
@@ -3995,40 +4232,39 @@ static void stdout_directive_show_fields(__u8 dtype, __u8 doper,
 				(*(field + 32) & 0x2) ? "enabled" : "disabled");
 			printf("\t\tData Placement Directive : %s\n",
 				(*(field + 32) & 0x4) ? "enabled" : "disabled");
-
 			break;
 		default:
 			fprintf(stderr,
 				"invalid directive operations for Identify Directives\n");
+			break;
 		}
 		break;
 	case NVME_DIRECTIVE_DTYPE_STREAMS:
 		switch (doper) {
 		case NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_PARAM:
 			printf("\tMax Streams Limit                          (MSL): %u\n",
-				*(__u16 *) field);
+				*(__u16 *)field);
 			printf("\tNVM Subsystem Streams Available           (NSSA): %u\n",
-				*(__u16 *) (field + 2));
+				*(__u16 *)(field + 2));
 			printf("\tNVM Subsystem Streams Open                (NSSO): %u\n",
-				*(__u16 *) (field + 4));
+				*(__u16 *)(field + 4));
 			printf("\tNVM Subsystem Stream Capability           (NSSC): %u\n",
-				*(__u16 *) (field + 6));
+				*(__u16 *)(field + 6));
 			printf("\tStream Write Size (in unit of LB size)     (SWS): %u\n",
-				*(__u32 *) (field + 16));
+				*(__u32 *)(field + 16));
 			printf("\tStream Granularity Size (in unit of SWS)   (SGS): %u\n",
-				*(__u16 *) (field + 20));
+				*(__u16 *)(field + 20));
 			printf("\tNamespace Streams Allocated                (NSA): %u\n",
-				*(__u16 *) (field + 22));
+				*(__u16 *)(field + 22));
 			printf("\tNamespace Streams Open                     (NSO): %u\n",
-				*(__u16 *) (field + 24));
+				*(__u16 *)(field + 24));
 			break;
 		case NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_STATUS:
-			count = *(__u16 *) field;
-			printf("\tOpen Stream Count  : %u\n", *(__u16 *) field);
-			for ( i = 0; i < count; i++ ) {
+			count = *(__u16 *)field;
+			printf("\tOpen Stream Count  : %u\n", *(__u16 *)field);
+			for (i = 0; i < count; i++)
 				printf("\tStream Identifier %.6u : %u\n", i + 1,
-					*(__u16 *) (field + ((i + 1) * 2)));
-			}
+					*(__u16 *)(field + ((i + 1) * 2)));
 			break;
 		case NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_RESOURCE:
 			printf("\tNamespace Streams Allocated (NSA): %u\n",
@@ -4037,13 +4273,13 @@ static void stdout_directive_show_fields(__u8 dtype, __u8 doper,
 		default:
 			fprintf(stderr,
 				"invalid directive operations for Streams Directives\n");
+			break;
 		}
 		break;
 	default:
 		fprintf(stderr, "invalid directive type\n");
 		break;
 	}
-	return;
 }
 
 static void stdout_directive_show(__u8 type, __u8 oper, __u16 spec, __u32 nsid, __u32 result,
@@ -4063,6 +4299,41 @@ static void stdout_lba_status_info(__u32 result)
 	printf("\tLBA Status Information Report Interval (LSIRI): %u\n", result & 0xffff);
 }
 
+void stdout_d(unsigned char *buf, int len, int width, int group)
+{
+	int i, offset = 0;
+	char ascii[32 + 1] = { 0 };
+
+	assert(width < sizeof(ascii));
+
+	printf("     ");
+
+	for (i = 0; i <= 15; i++)
+		printf("%3x", i);
+
+	for (i = 0; i < len; i++) {
+		if (!(i % width))
+			printf( "\n%04x:", offset);
+		if (i % group)
+			printf( "%02x", buf[i]);
+		else
+			printf( " %02x", buf[i]);
+		ascii[i % width] = (buf[i] >= '!' && buf[i] <= '~') ? buf[i] : '.';
+		if (!((i + 1) % width)) {
+			printf( " \"%.*s\"", width, ascii);
+			offset += width;
+			memset(ascii, 0, sizeof(ascii));
+		}
+	}
+
+	if (strlen(ascii)) {
+		unsigned b = width - (i % width);
+		printf( " %*s \"%.*s\"", 2 * b + b / group + (b % group ? 1 : 0), "", width, ascii);
+	}
+
+	printf( "\n");
+}
+
 static void stdout_plm_config(struct nvme_plm_config *plmcfg)
 {
 	printf("\tEnable Event          :%04x\n", le16_to_cpu(plmcfg->ee));
@@ -4074,26 +4345,31 @@ static void stdout_plm_config(struct nvme_plm_config *plmcfg)
 static void stdout_host_metadata(enum nvme_features_id fid,
 				 struct nvme_host_metadata *data)
 {
-       struct nvme_metadata_element_desc *desc = &data->descs[0];
-       int i;
-       char val[4096];
-       __u16 len;
+	struct nvme_metadata_element_desc *desc = &data->descs[0];
+	int i;
+	char val[4096];
+	__u16 len;
 
-       printf("\tNum Metadata Element Descriptors: %d\n", data->ndesc);
-       for (i = 0; i < data->ndesc; i++) {
-	       len = le16_to_cpu(desc->len);
-	       strncpy(val, (char *)desc->val, min(sizeof(val) - 1, len));
+	printf("\tNum Metadata Element Descriptors: %d\n", data->ndesc);
+	for (i = 0; i < data->ndesc; i++) {
+		len = le16_to_cpu(desc->len);
+		strncpy(val, (char *)desc->val, min(sizeof(val) - 1, len));
 
-	       printf("\tElement[%-3d]:\n", i);
-	       printf("\t\tType	    : 0x%02x (%s)\n", desc->type,
+		printf("\tElement[%-3d]:\n", i);
+		printf("\t\tType	    : 0x%02x (%s)\n", desc->type,
 		       nvme_host_metadata_type_to_string(fid, desc->type));
-	       printf("\t\tRevision : %d\n", desc->rev);
-	       printf("\t\tLength   : %d\n", len);
-	       printf("\t\tValue    : %s\n", val);
+		printf("\t\tRevision : %d\n", desc->rev);
+		printf("\t\tLength   : %d\n", len);
+		printf("\t\tValue    : %s\n", val);
+
+		desc = (struct nvme_metadata_element_desc *)&desc->val[desc->len];
+	}
+}
 
-	       desc = (struct nvme_metadata_element_desc *)
-		       &desc->val[desc->len];
-       }
+static void stdout_feature_show(enum nvme_features_id fid, int sel, unsigned int result)
+{
+	printf("get-feature:%#0*x (%s), %s value:%#0*x\n", fid ? 4 : 2, fid,
+	       nvme_feature_to_string(fid), nvme_select_to_string(sel), result ? 10 : 8, result);
 }
 
 static void stdout_feature_show_fields(enum nvme_features_id fid,
@@ -4116,8 +4392,8 @@ static void stdout_feature_show_fields(enum nvme_features_id fid,
 		break;
 	case NVME_FEAT_FID_POWER_MGMT:
 		field = (result & 0x000000E0) >> 5;
-		printf("\tWorkload Hint (WH): %u - %s\n",  field, nvme_feature_wl_hints_to_string(field));
-		printf("\tPower State   (PS): %u\n",  result & 0x0000001f);
+		printf("\tWorkload Hint (WH): %u - %s\n", field, nvme_feature_wl_hints_to_string(field));
+		printf("\tPower State   (PS): %u\n", result & 0x0000001f);
 		break;
 	case NVME_FEAT_FID_LBA_RANGE:
 		field = result & 0x0000003f;
@@ -4137,56 +4413,56 @@ static void stdout_feature_show_fields(enum nvme_features_id fid,
 		break;
 	case NVME_FEAT_FID_ERR_RECOVERY:
 		printf("\tDeallocated or Unwritten Logical Block Error Enable (DULBE): %s\n",
-			((result & 0x00010000) >> 16) ? "Enabled":"Disabled");
+			((result & 0x00010000) >> 16) ? "Enabled" : "Disabled");
 		printf("\tTime Limited Error Recovery                          (TLER): %u ms\n",
 			(result & 0x0000ffff) * 100);
 		break;
 	case NVME_FEAT_FID_VOLATILE_WC:
-		printf("\tVolatile Write Cache Enable (WCE): %s\n", (result & 0x00000001) ? "Enabled":"Disabled");
+		printf("\tVolatile Write Cache Enable (WCE): %s\n", (result & 0x00000001) ? "Enabled" : "Disabled");
 		break;
 	case NVME_FEAT_FID_NUM_QUEUES:
 		printf("\tNumber of IO Completion Queues Allocated (NCQA): %u\n", ((result & 0xffff0000) >> 16) + 1);
-		printf("\tNumber of IO Submission Queues Allocated (NSQA): %u\n",  (result & 0x0000ffff) + 1);
+		printf("\tNumber of IO Submission Queues Allocated (NSQA): %u\n", (result & 0x0000ffff) + 1);
 		break;
 	case NVME_FEAT_FID_IRQ_COALESCE:
 		printf("\tAggregation Time     (TIME): %u usec\n", ((result & 0x0000ff00) >> 8) * 100);
-		printf("\tAggregation Threshold (THR): %u\n",  (result & 0x000000ff) + 1);
+		printf("\tAggregation Threshold (THR): %u\n", (result & 0x000000ff) + 1);
 		break;
 	case NVME_FEAT_FID_IRQ_CONFIG:
-		printf("\tCoalescing Disable (CD): %s\n", ((result & 0x00010000) >> 16) ? "True":"False");
-		printf("\tInterrupt Vector   (IV): %u\n",  result & 0x0000ffff);
+		printf("\tCoalescing Disable (CD): %s\n", ((result & 0x00010000) >> 16) ? "True" : "False");
+		printf("\tInterrupt Vector   (IV): %u\n", result & 0x0000ffff);
 		break;
 	case NVME_FEAT_FID_WRITE_ATOMIC:
-		printf("\tDisable Normal (DN): %s\n", (result & 0x00000001) ? "True":"False");
+		printf("\tDisable Normal (DN): %s\n", (result & 0x00000001) ? "True" : "False");
 		break;
 	case NVME_FEAT_FID_ASYNC_EVENT:
 		printf("\tDiscovery Log Page Change Notices                         : %s\n",
-			((result & 0x80000000) >> 31) ? "Send async event":"Do not send async event");
+			((result & 0x80000000) >> 31) ? "Send async event" : "Do not send async event");
 		printf("\tEndurance Group Event Aggregate Log Change Notices        : %s\n",
-			((result & 0x00004000) >> 14) ? "Send async event":"Do not send async event");
+			((result & 0x00004000) >> 14) ? "Send async event" : "Do not send async event");
 		printf("\tLBA Status Information Notices                            : %s\n",
-			((result & 0x00002000) >> 13) ? "Send async event":"Do not send async event");
+			((result & 0x00002000) >> 13) ? "Send async event" : "Do not send async event");
 		printf("\tPredictable Latency Event Aggregate Log Change Notices    : %s\n",
-			((result & 0x00001000) >> 12) ? "Send async event":"Do not send async event");
+			((result & 0x00001000) >> 12) ? "Send async event" : "Do not send async event");
 		printf("\tAsymmetric Namespace Access Change Notices                : %s\n",
-			((result & 0x00000800) >> 11) ? "Send async event":"Do not send async event");
+			((result & 0x00000800) >> 11) ? "Send async event" : "Do not send async event");
 		printf("\tTelemetry Log Notices                                     : %s\n",
-			((result & 0x00000400) >> 10) ? "Send async event":"Do not send async event");
+			((result & 0x00000400) >> 10) ? "Send async event" : "Do not send async event");
 		printf("\tFirmware Activation Notices                               : %s\n",
-			((result & 0x00000200) >> 9) ? "Send async event":"Do not send async event");
+			((result & 0x00000200) >> 9) ? "Send async event" : "Do not send async event");
 		printf("\tNamespace Attribute Notices                               : %s\n",
-			((result & 0x00000100) >> 8) ? "Send async event":"Do not send async event");
+			((result & 0x00000100) >> 8) ? "Send async event" : "Do not send async event");
 		printf("\tSMART / Health Critical Warnings                          : %s\n",
-			(result & 0x000000ff) ? "Send async event":"Do not send async event");
+			(result & 0x000000ff) ? "Send async event" : "Do not send async event");
 		break;
 	case NVME_FEAT_FID_AUTO_PST:
 		printf("\tAutonomous Power State Transition Enable (APSTE): %s\n",
-			(result & 0x00000001) ? "Enabled":"Disabled");
+			(result & 0x00000001) ? "Enabled" : "Disabled");
 		if (buf)
 			stdout_auto_pst((struct nvme_feat_auto_pst *)buf);
 		break;
 	case NVME_FEAT_FID_HOST_MEM_BUF:
-		printf("\tEnable Host Memory (EHM): %s\n", (result & 0x00000001) ? "Enabled":"Disabled");
+		printf("\tEnable Host Memory (EHM): %s\n", (result & 0x00000001) ? "Enabled" : "Disabled");
 		if (buf)
 			stdout_host_mem_buffer((struct nvme_host_mem_buf_attrs *)buf);
 		break;
@@ -4211,7 +4487,7 @@ static void stdout_feature_show_fields(enum nvme_features_id fid,
 		printf("\tRead Recovery Level (RRL): %u\n", result & 0xf);
 		break;
 	case NVME_FEAT_FID_PLM_CONFIG:
-		printf("\tPredictable Latency Window Enabled: %s\n", result & 0x1 ? "True":"False");
+		printf("\tPredictable Latency Window Enabled: %s\n", result & 0x1 ? "True" : "False");
 		if (buf)
 			stdout_plm_config((struct nvme_plm_config *)buf);
 		break;
@@ -4222,8 +4498,20 @@ static void stdout_feature_show_fields(enum nvme_features_id fid,
 		stdout_lba_status_info(result);
 		break;
 	case NVME_FEAT_FID_HOST_BEHAVIOR:
-		if (buf)
-			printf("\tHost Behavior Support: %s\n", (buf[0] & 0x1) ? "True" : "False");
+		if (buf) {
+			struct nvme_feat_host_behavior *host_behavior =
+				(struct nvme_feat_host_behavior *)buf;
+			printf("\tAdvanced Command Retry Enable (ACRE): %s\n",
+			       host_behavior->acre ? "True" : "False");
+			printf("\tExtended Telemetry Data Area 4 Supported (ETDAS): %s\n",
+			       host_behavior->etdas ? "True" : "False");
+			printf("\tLBA Format Extension Enable (LBAFEE): %s\n",
+			       host_behavior->lbafee ? "True" : "False");
+			printf("\tCopy Descriptor Format 2h Enabled (CDFE): %s\n",
+			       host_behavior->cdfe & (1 << 2) ? "True" : "False");
+			printf("\tCopy Descriptor Format 3h Enabled (CDFE): %s\n",
+			       host_behavior->cdfe & (1 << 3) ? "True" : "False");
+		}
 		break;
 	case NVME_FEAT_FID_SANITIZE:
 		printf("\tNo-Deallocate Response Mode (NODRM) : %u\n", result & 0x1);
@@ -4233,13 +4521,15 @@ static void stdout_feature_show_fields(enum nvme_features_id fid,
 		printf("\tEndurance Group Critical Warnings  : %u\n", (result >> 16) & 0xff);
 		break;
 	case NVME_FEAT_FID_IOCS_PROFILE:
-		printf("\tI/O Command Set Profile: %s\n", result & 0x1 ? "True":"False");
+		printf("\tI/O Command Set Profile: %s\n", result & 0x1 ? "True" : "False");
 		break;
 	case NVME_FEAT_FID_SPINUP_CONTROL:
 		printf("\tSpinup control feature Enabled: %s\n", (result & 1) ? "True" : "False");
 		break;
 	case NVME_FEAT_FID_ENH_CTRL_METADATA:
+		fallthrough;
 	case NVME_FEAT_FID_CTRL_METADATA:
+		fallthrough;
 	case NVME_FEAT_FID_NS_METADATA:
 		if (buf)
 			stdout_host_metadata(fid, (struct nvme_host_metadata *)buf);
@@ -4257,14 +4547,14 @@ static void stdout_feature_show_fields(enum nvme_features_id fid,
 		break;
 	case NVME_FEAT_FID_RESV_MASK:
 		printf("\tMask Reservation Preempted Notification  (RESPRE): %s\n",
-			((result & 0x00000008) >> 3) ? "True":"False");
+			((result & 0x00000008) >> 3) ? "True" : "False");
 		printf("\tMask Reservation Released Notification   (RESREL): %s\n",
-			((result & 0x00000004) >> 2) ? "True":"False");
+			((result & 0x00000004) >> 2) ? "True" : "False");
 		printf("\tMask Registration Preempted Notification (REGPRE): %s\n",
-			((result & 0x00000002) >> 1) ? "True":"False");
+			((result & 0x00000002) >> 1) ? "True" : "False");
 		break;
 	case NVME_FEAT_FID_RESV_PERSIST:
-		printf("\tPersist Through Power Loss (PTPL): %s\n", (result & 0x00000001) ? "True":"False");
+		printf("\tPersist Through Power Loss (PTPL): %s\n", (result & 0x00000001) ? "True" : "False");
 		break;
 	case NVME_FEAT_FID_WRITE_PROTECT:
 		printf("\tNamespace Write Protect: %s\n", nvme_ns_wp_cfg_to_string(result));
@@ -4284,6 +4574,7 @@ static void stdout_feature_show_fields(enum nvme_features_id fid,
 			printf("\t%-53s: %sEnabled\n", nvme_fdp_event_to_string(d->evt),
 					d->evta & 0x1 ? "" : "Not ");
 		}
+		break;
 	default:
 		break;
 	}
@@ -4309,6 +4600,8 @@ static void stdout_lba_status(struct nvme_lba_status *list,
 			"\tnumber of logical blocks specified in the\n"\
 			"\tRange Length field\n");
 		break;
+	default:
+		break;
 	}
 
 	for (idx = 0; idx < list->nlsd; idx++) {
@@ -4387,28 +4680,30 @@ static void stdout_list_item(nvme_ns_t n)
 		nvme_ns_get_firmware(n));
 }
 
-static void stdout_simple_list(nvme_root_t r)
+static bool stdout_simple_ns(const char *name, void *arg)
 {
-	nvme_host_t h;
-	nvme_subsystem_t s;
-	nvme_ctrl_t c;
+	struct nvme_resources *res = arg;
 	nvme_ns_t n;
 
+	n = htable_ns_get(&res->ht_n, name);
+	stdout_list_item(n);
+
+	return true;
+}
+
+static void stdout_simple_list(nvme_root_t r)
+{
+	struct nvme_resources res;
+
+	nvme_resources_init(r, &res);
+
 	printf("%-21s %-21s %-20s %-40s %-10s %-26s %-16s %-8s\n",
-	    "Node", "Generic", "SN", "Model", "Namespace", "Usage", "Format", "FW Rev");
+	       "Node", "Generic", "SN", "Model", "Namespace", "Usage", "Format", "FW Rev");
 	printf("%-.21s %-.21s %-.20s %-.40s %-.10s %-.26s %-.16s %-.8s\n",
-		dash, dash, dash, dash, dash, dash, dash, dash);
-
-	nvme_for_each_host(r, h) {
-		nvme_for_each_subsystem(h, s) {
-			nvme_subsystem_for_each_ns(s, n)
-				stdout_list_item(n);
+	       dash, dash, dash, dash, dash, dash, dash, dash);
+	strset_iterate(&res.namespaces, stdout_simple_ns, &res);
 
-			nvme_subsystem_for_each_ctrl(s, c)
-				nvme_ctrl_for_each_ns(c, n)
-				stdout_list_item(n);
-		}
-	}
+	nvme_resources_free(&res);
 }
 
 static void stdout_ns_details(nvme_ns_t n)
@@ -4435,100 +4730,153 @@ static void stdout_ns_details(nvme_ns_t n)
 		genname, nvme_ns_get_nsid(n), usage, format);
 }
 
-static void stdout_detailed_list(nvme_root_t r)
+static bool stdout_detailed_name(const char *name, void *arg)
 {
-	nvme_host_t h;
+	bool *first = arg;
+
+	printf("%s%s", *first ? "" : ", ", name);
+	*first = false;
+
+	return true;
+}
+
+static bool stdout_detailed_subsys(const char *name, void *arg)
+{
+	struct nvme_resources *res = arg;
+	struct htable_subsys_iter it;
+	struct strset ctrls;
 	nvme_subsystem_t s;
 	nvme_ctrl_t c;
+	bool first;
+
+	strset_init(&ctrls);
+	first = true;
+	for (s = htable_subsys_getfirst(&res->ht_s, name, &it);
+	     s;
+	     s = htable_subsys_getnext(&res->ht_s, name, &it)) {
+		if (first) {
+			printf("%-16s %-96s ", name, nvme_subsystem_get_nqn(s));
+			first = false;
+		}
+
+		nvme_subsystem_for_each_ctrl(s, c)
+			strset_add(&ctrls, nvme_ctrl_get_name(c));
+	}
+
+	first = true;
+	strset_iterate(&ctrls, stdout_detailed_name, &first);
+	strset_clear(&ctrls);
+	printf("\n");
+
+	return true;
+}
+
+static bool stdout_detailed_ctrl(const char *name, void *arg)
+{
+	struct nvme_resources *res = arg;
+	struct strset namespaces;
+	nvme_ctrl_t c;
 	nvme_path_t p;
 	nvme_ns_t n;
+	bool first;
+
+	c = htable_ctrl_get(&res->ht_c, name);
+	assert(c);
+
+	printf("%-8s %-20s %-40s %-8s %-6s %-14s %-6s %-12s ",
+	       nvme_ctrl_get_name(c),
+	       nvme_ctrl_get_serial(c),
+	       nvme_ctrl_get_model(c),
+	       nvme_ctrl_get_firmware(c),
+	       nvme_ctrl_get_transport(c),
+	       nvme_ctrl_get_address(c),
+	       nvme_ctrl_get_phy_slot(c),
+	       nvme_subsystem_get_name(nvme_ctrl_get_subsystem(c)));
+
+	strset_init(&namespaces);
+
+	nvme_ctrl_for_each_ns(c, n)
+		strset_add(&namespaces, nvme_ns_get_name(n));
+	nvme_ctrl_for_each_path(c, p) {
+		n = nvme_path_get_ns(p);
+		if (!n)
+			continue;
+		strset_add(&namespaces, nvme_ns_get_name(n));
+	}
 
-	printf("%-16s %-96s %-.16s\n", "Subsystem", "Subsystem-NQN", "Controllers");
-	printf("%-.16s %-.96s %-.16s\n", dash, dash, dash);
+	first = true;
+	strset_iterate(&namespaces, stdout_detailed_name, &first);
+	strset_clear(&namespaces);
 
-	nvme_for_each_host(r, h) {
-		nvme_for_each_subsystem(h, s) {
-			bool first = true;
-			printf("%-16s %-96s ", nvme_subsystem_get_name(s),
-			       nvme_subsystem_get_nqn(s));
+	printf("\n");
 
-			nvme_subsystem_for_each_ctrl(s, c) {
-				printf("%s%s", first ? "": ", ",
-				       nvme_ctrl_get_name(c));
-				first = false;
-			}
-			printf("\n");
+	return true;
+}
+
+static bool stdout_detailed_ns(const char *name, void *arg)
+{
+	struct nvme_resources *res = arg;
+	struct htable_ns_iter it;
+	struct strset ctrls;
+	nvme_ctrl_t c;
+	nvme_path_t p;
+	nvme_ns_t n;
+	bool first;
+
+	strset_init(&ctrls);
+	first = true;
+	for (n = htable_ns_getfirst(&res->ht_n, name, &it);
+	     n;
+	     n = htable_ns_getnext(&res->ht_n, name, &it)) {
+		if (first) {
+			stdout_ns_details(n);
+			first = false;
+		}
+
+		if (nvme_ns_get_ctrl(n)) {
+			printf("%s\n", nvme_ctrl_get_name(nvme_ns_get_ctrl(n)));
+			return true;
+		}
+
+		nvme_namespace_for_each_path(n, p) {
+			c = nvme_path_get_ctrl(p);
+			strset_add(&ctrls, nvme_ctrl_get_name(c));
 		}
 	}
-	printf("\n");
 
-	printf("%-8s %-20s %-40s %-8s %-6s %-14s %-6s %-12s %-16s\n", "Device",
-		"SN", "MN", "FR", "TxPort", "Address", "Slot", "Subsystem", "Namespaces");
-	printf("%-.8s %-.20s %-.40s %-.8s %-.6s %-.14s %-.6s %-.12s %-.16s\n", dash,
-		dash, dash, dash, dash, dash, dash, dash, dash);
+	first = true;
+	strset_iterate(&ctrls, stdout_detailed_name, &first);
+	strset_clear(&ctrls);
 
-	nvme_for_each_host(r, h) {
-		nvme_for_each_subsystem(h, s) {
-			nvme_subsystem_for_each_ctrl(s, c) {
-				bool first = true;
+	printf("\n");
+	return true;
+}
 
-				printf("%-8s %-20s %-40s %-8s %-6s %-14s %-6s %-12s ",
-				       nvme_ctrl_get_name(c),
-				       nvme_ctrl_get_serial(c),
-				       nvme_ctrl_get_model(c),
-				       nvme_ctrl_get_firmware(c),
-				       nvme_ctrl_get_transport(c),
-				       nvme_ctrl_get_address(c),
-				       nvme_ctrl_get_phy_slot(c),
-				       nvme_subsystem_get_name(s));
+static void stdout_detailed_list(nvme_root_t r)
+{
+	struct nvme_resources res;
 
-				nvme_ctrl_for_each_ns(c, n) {
-					printf("%s%s", first ? "": ", ",
-					       nvme_ns_get_name(n));
-					first = false;
-				}
+	nvme_resources_init(r, &res);
 
-				nvme_ctrl_for_each_path(c, p) {
-					n = nvme_path_get_ns(p);
-					if (!n)
-						continue;
-					printf("%s%s", first ? "": ", ",
-					       nvme_ns_get_name(n));
-					first = false;
-				}
-				printf("\n");
-			}
-		}
-	}
+	printf("%-16s %-96s %-.16s\n", "Subsystem", "Subsystem-NQN", "Controllers");
+	printf("%-.16s %-.96s %-.16s\n", dash, dash, dash);
+	strset_iterate(&res.subsystems, stdout_detailed_subsys, &res);
+	printf("\n");
+
+	printf("%-8s %-20s %-40s %-8s %-6s %-14s %-6s %-12s %-16s\n", "Device",
+		"SN", "MN", "FR", "TxPort", "Asdress", "Slot", "Subsystem", "Namespaces");
+	printf("%-.8s %-.20s %-.40s %-.8s %-.6s %-.14s %-.6s %-.12s %-.16s\n", dash,
+		dash, dash, dash, dash, dash, dash, dash, dash);
+	strset_iterate(&res.ctrls, stdout_detailed_ctrl, &res);
 	printf("\n");
 
 	printf("%-12s %-12s %-10s %-26s %-16s %-16s\n", "Device", "Generic",
 		"NSID", "Usage", "Format", "Controllers");
 	printf("%-.12s %-.12s %-.10s %-.26s %-.16s %-.16s\n", dash, dash, dash,
 		dash, dash, dash);
+	strset_iterate(&res.namespaces, stdout_detailed_ns, &res);
 
-	nvme_for_each_host(r, h) {
-		nvme_for_each_subsystem(h, s) {
-			nvme_subsystem_for_each_ctrl(s, c) {
-				nvme_ctrl_for_each_ns(c, n) {
-					stdout_ns_details(n);
-					printf("%s\n", nvme_ctrl_get_name(c));
-				}
-			}
-
-			nvme_subsystem_for_each_ns(s, n) {
-				bool first = true;
-
-				stdout_ns_details(n);
-				nvme_subsystem_for_each_ctrl(s, c) {
-					printf("%s%s", first ? "" : ", ",
-					       nvme_ctrl_get_name(c));
-					first = false;
-				}
-				printf("\n");
-			}
-		}
-	}
+	nvme_resources_free(&res);
 }
 
 static void stdout_list_items(nvme_root_t r)
@@ -4560,6 +4908,9 @@ static void stdout_subsystem_topology_multipath(nvme_subsystem_t s,
 
 	if (ranking == NVME_CLI_TOPO_NAMESPACE) {
 		nvme_subsystem_for_each_ns(s, n) {
+			if (!nvme_namespace_first_path(n))
+				continue;
+
 			printf(" +- ns %d\n", nvme_ns_get_nsid(n));
 			printf(" \\\n");
 
@@ -4638,12 +4989,22 @@ static void stdout_simple_topology(nvme_root_t r,
 {
 	nvme_host_t h;
 	nvme_subsystem_t s;
+	bool first = true;
 
 	nvme_for_each_host(r, h) {
 		nvme_for_each_subsystem(h, s) {
+			int len = strlen(nvme_subsystem_get_name(s));
+
+			if (!first)
+				printf("\n");
+			first = false;
 
 			printf("%s - NQN=%s\n", nvme_subsystem_get_name(s),
 			       nvme_subsystem_get_nqn(s));
+			printf("%*s   hostnqn=%s\n", len, " ",
+			       nvme_host_get_hostnqn(nvme_subsystem_get_host(s)));
+			printf("%*s   iopolicy=%s\n", len, " ",
+			       nvme_subsystem_get_iopolicy(s));
 			printf("\\\n");
 
 			if (nvme_is_multipath(s))
@@ -4668,7 +5029,7 @@ static void stdout_message(bool error, const char *msg, va_list ap)
 {
 	vfprintf(error ? stderr : stdout, msg, ap);
 
-	printf("\n");
+	fprintf(error ? stderr : stdout, "\n");
 }
 
 static void stdout_perror(const char *msg)
@@ -4721,12 +5082,14 @@ static void stdout_discovery_log(struct nvmf_discovery_log *log, int numrec)
 
 static void stdout_connect_msg(nvme_ctrl_t c)
 {
-	printf("device: %s\n", nvme_ctrl_get_name(c));
+	printf("connecting to device: %s\n", nvme_ctrl_get_name(c));
 }
 
 static struct print_ops stdout_print_ops = {
+	/* libnvme types.h print functions */
 	.ana_log			= stdout_ana_log,
 	.boot_part_log			= stdout_boot_part_log,
+	.phy_rx_eom_log			= stdout_phy_rx_eom_log,
 	.ctrl_list			= stdout_list_ctrl,
 	.ctrl_registers			= stdout_ctrl_registers,
 	.directive			= stdout_directive_show,
@@ -4745,7 +5108,6 @@ static struct print_ops stdout_print_ops = {
 	.fw_log				= stdout_fw_log,
 	.id_ctrl			= stdout_id_ctrl,
 	.id_ctrl_nvm			= stdout_id_ctrl_nvm,
-	.id_ctrl_rpmbs			= stdout_id_ctrl_rpmbs,
 	.id_domain_list			= stdout_id_domain_list,
 	.id_independent_id_ns		= stdout_cmd_set_independent_id_ns,
 	.id_iocs			= stdout_id_iocs,
@@ -4754,9 +5116,7 @@ static struct print_ops stdout_print_ops = {
 	.id_ns_granularity_list		= stdout_id_ns_granularity_list,
 	.id_nvmset_list			= stdout_id_nvmset,
 	.id_uuid_list			= stdout_id_uuid_list,
-	.lba_range			= stdout_lba_range,
 	.lba_status			= stdout_lba_status,
-	.lba_status_info		= stdout_lba_status_info,
 	.lba_status_log			= stdout_lba_status_log,
 	.media_unit_stat_log		= stdout_media_unit_stat_log,
 	.mi_cmd_support_effects_log	= stdout_mi_cmd_support_effects_log,
@@ -4773,25 +5133,38 @@ static struct print_ops stdout_print_ops = {
 	.secondary_ctrl_list		= stdout_list_secondary_ctrl,
 	.select_result			= stdout_select_result,
 	.self_test_log 			= stdout_self_test_log,
-	.show_feature_fields		= stdout_feature_show_fields,
 	.single_property		= stdout_single_property,
 	.smart_log			= stdout_smart_log,
 	.supported_cap_config_list_log	= stdout_supported_cap_config_log,
 	.supported_log_pages		= stdout_supported_log,
+	.zns_start_zone_list		= stdout_zns_start_zone_list,
 	.zns_changed_zone_log		= stdout_zns_changed,
+	.zns_finish_zone_list		= NULL,
 	.zns_id_ctrl			= stdout_zns_id_ctrl,
 	.zns_id_ns			= stdout_zns_id_ns,
 	.zns_report_zones		= stdout_zns_report_zones,
+	.show_feature			= stdout_feature_show,
+	.show_feature_fields		= stdout_feature_show_fields,
+	.id_ctrl_rpmbs			= stdout_id_ctrl_rpmbs,
+	.lba_range			= stdout_lba_range,
+	.lba_status_info		= stdout_lba_status_info,
+	.d				= stdout_d,
+	.show_init			= NULL,
+	.show_finish			= NULL,
 
+	/* libnvme tree print functions */
+	.list_item			= stdout_list_item,
 	.list_items			= stdout_list_items,
 	.print_nvme_subsystem_list	= stdout_subsystem_list,
 	.topology_ctrl			= stdout_topology_ctrl,
 	.topology_namespace		= stdout_topology_namespace,
 
-	.show_status			= stdout_status,
+	/* status and error messages */
+	.connect_msg			= stdout_connect_msg,
 	.show_message			= stdout_message,
 	.show_perror			= stdout_perror,
-	.connect_msg			= stdout_connect_msg,
+	.show_status			= stdout_status,
+	.show_error_status		= stdout_error_status,
 };
 
 struct print_ops *nvme_get_stdout_print_ops(enum nvme_print_flags flags)