diff --git a/src/bio/bio_config.c b/src/bio/bio_config.c
index 13b449b4fcc..663997bb8a2 100644
--- a/src/bio/bio_config.c
+++ b/src/bio/bio_config.c
@@ -6,15 +6,20 @@
 #define D_LOGFAC	DD_FAC(bio)
 
 #include <spdk/file.h>
+#include <spdk/string.h>
 #include <spdk/util.h>
 #include <spdk/json.h>
 #include <spdk/thread.h>
 #include <spdk/nvme.h>
 #include <spdk/nvmf_spec.h>
+#include <daos_srv/control.h>
+
 #include "bio_internal.h"
 
 /* JSON tags should match encode/decode logic in src/control/server/storage/bdev/backend_json.go */
 
+#define JSON_MAX_CHARS 4096
+
 struct
 json_config_ctx {
 	/* Current "subsystems" array */
@@ -181,7 +186,8 @@ is_addr_in_allowlist(char *pci_addr, const struct spdk_pci_addr *allowlist,
 static int
 traddr_to_vmd(char *dst, const char *src)
 {
-	char		*traddr_tmp = NULL, *vmd_addr = NULL;
+	char            *traddr_tmp = NULL;
+	char            *vmd_addr   = NULL;
 	char		*ptr;
 	const char	 ch = ':';
 	char		 addr_split[3];
@@ -189,13 +195,17 @@ traddr_to_vmd(char *dst, const char *src)
 	int		 iteration;
 	int		 n, rc = 0;
 	int		 vmd_addr_left_len;
+	int              len;
 
 	D_ALLOC(vmd_addr, SPDK_NVMF_TRADDR_MAX_LEN + 1);
 	if (vmd_addr == NULL)
 		return -DER_NOMEM;
 
 	strncat(vmd_addr, "0000:", SPDK_NVMF_TRADDR_MAX_LEN);
-	vmd_addr_left_len = SPDK_NVMF_TRADDR_MAX_LEN - strlen(vmd_addr);
+	len = strnlen(vmd_addr, SPDK_NVMF_TRADDR_MAX_LEN);
+	if ((len == 0) || (len == SPDK_NVMF_TRADDR_MAX_LEN))
+		return -DER_INVAL;
+	vmd_addr_left_len = SPDK_NVMF_TRADDR_MAX_LEN - len;
 
 	D_STRNDUP(traddr_tmp, src, SPDK_NVMF_TRADDR_MAX_LEN);
 	if (traddr_tmp == NULL) {
@@ -320,15 +330,14 @@ read_config(const char *config_file, struct json_config_ctx *ctx)
 
 	json = read_file(config_file, &json_size);
 	if (!json) {
-		D_ERROR("Read config file %s failed: '%s'\n",
-			config_file, strerror(errno));
+		D_ERROR("Read config file %s failed: '%s'\n", config_file, spdk_strerror(errno));
 		return -DER_INVAL;
 	}
 
 	rc = spdk_json_parse(json, json_size, NULL, 0, &end,
 			     SPDK_JSON_PARSE_FLAG_ALLOW_COMMENTS);
 	if (rc < 0) {
-		D_ERROR("Parsing config failed: %s\n", strerror(-rc));
+		D_ERROR("Parsing config failed: %s\n", spdk_strerror(-rc));
 		D_GOTO(free_json, rc = -DER_INVAL);
 	}
 
@@ -376,11 +385,12 @@ load_vmd_subsystem_config(struct json_config_ctx *ctx, bool *vmd_enabled)
 
 	D_ASSERT(ctx->config_it != NULL);
 	D_ASSERT(vmd_enabled != NULL);
+	D_ASSERT(*vmd_enabled == false);
 
 	rc = spdk_json_decode_object(ctx->config_it, config_entry_decoders,
 				     SPDK_COUNTOF(config_entry_decoders), &cfg);
 	if (rc < 0) {
-		D_ERROR("Failed to decode config entry: %s\n", strerror(-rc));
+		D_ERROR("Failed to decode config entry: %s\n", spdk_strerror(-rc));
 		return -DER_INVAL;
 	}
 
@@ -405,7 +415,7 @@ add_traddrs_from_bdev_subsys(struct json_config_ctx *ctx, bool vmd_enabled,
 	rc = spdk_json_decode_object(ctx->config_it, config_entry_decoders,
 				     SPDK_COUNTOF(config_entry_decoders), &cfg);
 	if (rc < 0) {
-		D_ERROR("Failed to decode config entry: %s\n", strerror(-rc));
+		D_ERROR("Failed to decode config entry: %s\n", spdk_strerror(-rc));
 		return -DER_INVAL;
 	}
 
@@ -491,7 +501,7 @@ check_name_from_bdev_subsys(struct json_config_ctx *ctx)
 	rc = spdk_json_decode_object(ctx->config_it, config_entry_decoders,
 				     SPDK_COUNTOF(config_entry_decoders), &cfg);
 	if (rc < 0) {
-		D_ERROR("Failed to decode config entry: %s\n", strerror(-rc));
+		D_ERROR("Failed to decode config entry: %s\n", spdk_strerror(-rc));
 		return -DER_INVAL;
 	}
 
@@ -552,7 +562,7 @@ decode_subsystem_configs(struct spdk_json_val *json_val, struct json_config_ctx
 	rc = spdk_json_decode_object(json_val, subsystem_decoders, SPDK_COUNTOF(subsystem_decoders),
 				     ctx);
 	if (rc < 0) {
-		D_ERROR("Failed to parse vmd subsystem: %s\n", strerror(-rc));
+		D_ERROR("Failed to parse vmd subsystem: %s\n", spdk_strerror(-rc));
 		return -DER_INVAL;
 	}
 
@@ -615,11 +625,12 @@ check_vmd_status(struct json_config_ctx *ctx, struct spdk_json_val *vmd_ss, bool
 {
 	int	rc;
 
+	D_ASSERT(vmd_enabled != NULL);
+	D_ASSERT(*vmd_enabled == false);
+
 	if (vmd_ss == NULL)
 		return 0;
 
-	D_ASSERT(vmd_enabled != NULL);
-
 	rc = decode_subsystem_configs(vmd_ss, ctx);
 	if (rc != 0)
 		return rc;
@@ -642,20 +653,23 @@ check_vmd_status(struct json_config_ctx *ctx, struct spdk_json_val *vmd_ss, bool
  * \param[in]	nvme_conf	JSON config file path
  * \param[out]	opts		SPDK environment options
  * \param[out]	roles		global nvme bdev roles
+ * \param[out]	vmd_enabled	global VMD-enablement flag
  *
  * \returns	 Zero on success, negative on failure (DER)
  */
 int
-bio_add_allowed_alloc(const char *nvme_conf, struct spdk_env_opts *opts, int *roles)
+bio_add_allowed_alloc(const char *nvme_conf, struct spdk_env_opts *opts, int *roles,
+		      bool *vmd_enabled)
 {
 	struct json_config_ctx	*ctx;
 	struct spdk_json_val	*bdev_ss = NULL;
-	struct spdk_json_val	*vmd_ss = NULL;
-	bool			 vmd_enabled = false;
+	struct spdk_json_val    *vmd_ss  = NULL;
 	int			 rc = 0;
 
 	D_ASSERT(nvme_conf != NULL);
 	D_ASSERT(opts != NULL);
+	D_ASSERT(vmd_enabled != NULL);
+	D_ASSERT(*vmd_enabled == false);
 
 	D_ALLOC_PTR(ctx);
 	if (ctx == NULL)
@@ -668,7 +682,7 @@ bio_add_allowed_alloc(const char *nvme_conf, struct spdk_env_opts *opts, int *ro
 	/* Capture subsystems array */
 	rc = spdk_json_find_array(ctx->values, "subsystems", NULL, &ctx->subsystems);
 	if (rc < 0) {
-		D_ERROR("Failed to find subsystems key: %s\n", strerror(-rc));
+		D_ERROR("Failed to find subsystems key: %s\n", spdk_strerror(-rc));
 		D_GOTO(out, rc = -DER_INVAL);
 	}
 
@@ -684,14 +698,15 @@ bio_add_allowed_alloc(const char *nvme_conf, struct spdk_env_opts *opts, int *ro
 		rc = spdk_json_decode_object(ctx->subsystems_it, subsystem_decoders,
 					     SPDK_COUNTOF(subsystem_decoders), ctx);
 		if (rc < 0) {
-			D_ERROR("Failed to parse subsystem configuration: %s\n", strerror(-rc));
+			D_ERROR("Failed to parse subsystem configuration: %s\n",
+				spdk_strerror(-rc));
 			D_GOTO(out, rc = -DER_INVAL);
 		}
 
 		if (spdk_json_strequal(ctx->subsystem_name, "bdev"))
 			bdev_ss = ctx->subsystems_it;
 
-		if (spdk_json_strequal(ctx->subsystem_name, BIO_DEV_TYPE_VMD))
+		if (spdk_json_strequal(ctx->subsystem_name, NVME_PCI_DEV_TYPE_VMD))
 			vmd_ss = ctx->subsystems_it;
 
 		/* Move on to next subsystem */
@@ -703,7 +718,7 @@ bio_add_allowed_alloc(const char *nvme_conf, struct spdk_env_opts *opts, int *ro
 		D_GOTO(out, rc = -DER_INVAL);
 	}
 
-	rc = check_vmd_status(ctx, vmd_ss, &vmd_enabled);
+	rc = check_vmd_status(ctx, vmd_ss, vmd_enabled);
 	if (rc < 0)
 		goto out;
 
@@ -712,7 +727,7 @@ bio_add_allowed_alloc(const char *nvme_conf, struct spdk_env_opts *opts, int *ro
 		goto out;
 	*roles = rc;
 
-	rc = add_bdevs_to_opts(ctx, bdev_ss, vmd_enabled, opts);
+	rc = add_bdevs_to_opts(ctx, bdev_ss, *vmd_enabled, opts);
 out:
 	free_json_config_ctx(ctx);
 	return rc;
@@ -740,7 +755,7 @@ decode_daos_data(const char *nvme_conf, const char *method_name, struct config_e
 	rc = spdk_json_find(ctx->values, "daos_data", NULL, &daos_data,
 			    SPDK_JSON_VAL_OBJECT_BEGIN);
 	if (rc < 0) {
-		D_ERROR("Failed to find 'daos_data' key: %s\n", strerror(-rc));
+		D_ERROR("Failed to find 'daos_data' key: %s\n", spdk_strerror(-rc));
 		D_GOTO(out, rc = -DER_INVAL);
 	}
 
@@ -748,7 +763,7 @@ decode_daos_data(const char *nvme_conf, const char *method_name, struct config_e
 	rc = spdk_json_decode_object(daos_data, daos_data_decoders,
 				     SPDK_COUNTOF(daos_data_decoders), ctx);
 	if (rc < 0) {
-		D_ERROR("Failed to parse 'daos_data' entry: %s\n", strerror(-rc));
+		D_ERROR("Failed to parse 'daos_data' entry: %s\n", spdk_strerror(-rc));
 		D_GOTO(out, rc = -DER_INVAL);
 	}
 
@@ -763,7 +778,7 @@ decode_daos_data(const char *nvme_conf, const char *method_name, struct config_e
 		rc = spdk_json_decode_object(ctx->config_it, config_entry_decoders,
 					     SPDK_COUNTOF(config_entry_decoders), cfg);
 		if (rc < 0) {
-			D_ERROR("Failed to decode 'config' entry: %s\n", strerror(-rc));
+			D_ERROR("Failed to decode 'config' entry: %s\n", spdk_strerror(-rc));
 			D_GOTO(out, rc = -DER_INVAL);
 		}
 
@@ -798,7 +813,7 @@ get_hotplug_busid_range(const char *nvme_conf)
 				     &hotplug_busid_range);
 	if (rc < 0) {
 		D_ERROR("Failed to decode '%s' entry: %s)\n", NVME_CONF_SET_HOTPLUG_RANGE,
-			strerror(-rc));
+			spdk_strerror(-rc));
 		D_GOTO(out, rc = -DER_INVAL);
 	}
 
@@ -873,7 +888,7 @@ bio_read_accel_props(const char *nvme_conf)
 				     &accel_props);
 	if (rc < 0) {
 		D_ERROR("Failed to decode '%s' entry (%s)\n", NVME_CONF_SET_ACCEL_PROPS,
-			strerror(-rc));
+			spdk_strerror(-rc));
 		D_GOTO(out, rc = -DER_INVAL);
 	}
 
@@ -915,7 +930,7 @@ bio_read_rpc_srv_settings(const char *nvme_conf, bool *enable, const char **sock
 				     &rpc_srv_settings);
 	if (rc < 0) {
 		D_ERROR("Failed to decode '%s' entry: %s)\n", NVME_CONF_SET_SPDK_RPC_SERVER,
-			strerror(-rc));
+			spdk_strerror(-rc));
 		D_GOTO(out, rc = -DER_INVAL);
 	}
 
@@ -931,3 +946,139 @@ bio_read_rpc_srv_settings(const char *nvme_conf, bool *enable, const char **sock
 		rc = 0;
 	return rc;
 }
+
+struct json_bdev_nvme_ctx {
+	struct spdk_json_val *pci_address;
+	struct spdk_json_val *ctrlr_data;
+	struct spdk_json_val *ns_data;
+	struct spdk_json_val *values;
+	size_t                values_cnt;
+};
+
+static struct spdk_json_object_decoder nvme_decoders[] = {
+    {"pci_address", offsetof(struct json_bdev_nvme_ctx, pci_address), cap_string},
+    {"ctrlr_data", offsetof(struct json_bdev_nvme_ctx, ctrlr_data), cap_object, false},
+    {"ns_data", offsetof(struct json_bdev_nvme_ctx, ns_data), cap_object, false}};
+
+static struct spdk_json_object_decoder nvme_ctrlr_decoders[] = {
+    {"model_number", offsetof(struct ctrlr_t, model), spdk_json_decode_string},
+    {"serial_number", offsetof(struct ctrlr_t, serial), spdk_json_decode_string},
+    {"firmware_revision", offsetof(struct ctrlr_t, fw_rev), spdk_json_decode_string},
+    {"vendor_id", offsetof(struct ctrlr_t, vendor_id), spdk_json_decode_string}};
+
+static struct spdk_json_object_decoder nvme_ns_decoders[] = {
+    {"id", offsetof(struct ns_t, id), spdk_json_decode_uint32}};
+
+/**
+ * Fetch bdev controller parameters from spdk_bdev_dump_info_json output.
+ *
+ * \param[out] *b_info		Device info struct to populate
+ * \param[in]	json		Raw JSON to parse
+ * \param[in]	json_size	Number of JSON chars
+ *
+ * \returns	 Zero on success, negative on failure (DER)
+ */
+int
+bio_decode_bdev_params(struct bio_dev_info *b_info, const void *json, int json_size)
+{
+	char                      *tmp       = NULL;
+	char                      *end1      = NULL;
+	ssize_t                    rc        = 0;
+	char                      *json_data = NULL;
+	struct json_bdev_nvme_ctx *ctx;
+	void                      *end;
+
+	D_ASSERT(b_info != NULL);
+	D_ASSERT(b_info->bdi_ctrlr != NULL);
+	D_ASSERT(b_info->bdi_ctrlr->nss != NULL);
+	D_ASSERT(json != NULL);
+	D_ASSERT(json_size > 0);
+
+	/* Check input is null-terminated */
+	if (strnlen(json, JSON_MAX_CHARS) == JSON_MAX_CHARS)
+		return -DER_INVAL;
+
+	/* Trim chars to get single valid "nvme" object from array. */
+	tmp = strstr(json, "{");
+	if (tmp == NULL)
+		return -DER_INVAL;
+	end1 = strchr(tmp, ']');
+	if (end1 == NULL)
+		return -DER_INVAL;
+
+	/* Copy input JSON so we don't mutate the original. */
+	D_STRNDUP(json_data, tmp, end1 - tmp);
+	if (json_data == NULL)
+		return -DER_NOMEM;
+	json_data[end1 - tmp - 1] = '\0';
+
+	D_ALLOC_PTR(ctx);
+	if (ctx == NULL)
+		return -DER_NOMEM;
+
+	/* Calculate number of values in tree before mem alloc. */
+	rc = spdk_json_parse(json_data, strnlen(json_data, json_size), NULL, 0, &end,
+			     SPDK_JSON_PARSE_FLAG_ALLOW_COMMENTS);
+	if (rc < 0) {
+		D_ERROR("Parsing bdev-nvme dump failed: %s\n", spdk_strerror(-rc));
+		D_GOTO(free_ctx, rc = -DER_INVAL);
+	}
+
+	ctx->values_cnt = rc;
+	D_ALLOC_ARRAY(ctx->values, ctx->values_cnt);
+	if (ctx->values == NULL)
+		D_GOTO(free_ctx, rc = -DER_NOMEM);
+
+	/* Populate tree of keys and values from JSON. */
+	rc = spdk_json_parse(json_data, strnlen(json_data, json_size), ctx->values, ctx->values_cnt,
+			     &end, SPDK_JSON_PARSE_FLAG_ALLOW_COMMENTS);
+	if (rc < 0) {
+		D_ERROR("Parsing bdev-nvme dump failed: %s\n", spdk_strerror(-rc));
+		D_GOTO(free_values, rc = -DER_INVAL);
+	}
+	if (rc != ctx->values_cnt) {
+		D_ERROR("Parsing bdev-nvme dump failed, want %zd values got %zd\n", ctx->values_cnt,
+			rc);
+		D_GOTO(free_values, rc = -DER_INVAL);
+	}
+
+	rc = spdk_json_decode_object_relaxed(ctx->values, nvme_decoders,
+					     SPDK_COUNTOF(nvme_decoders), ctx);
+	if (rc < 0) {
+		D_ERROR("Failed to decode nvme entry (%s)\n", spdk_strerror(-rc));
+		D_GOTO(free_values, rc = -DER_INVAL);
+	}
+
+	D_ASSERT(ctx->pci_address != NULL);
+	D_ASSERT(ctx->ctrlr_data != NULL);
+	D_ASSERT(ctx->ns_data != NULL);
+
+	rc = spdk_json_decode_string(ctx->pci_address, &b_info->bdi_traddr);
+	if (rc < 0) {
+		D_ERROR("Failed to decode string value for pci_address: %s\n", spdk_strerror(-rc));
+		D_GOTO(free_values, rc = -DER_INVAL);
+	}
+
+	rc = spdk_json_decode_object_relaxed(ctx->ctrlr_data, nvme_ctrlr_decoders,
+					     SPDK_COUNTOF(nvme_ctrlr_decoders), b_info->bdi_ctrlr);
+	if (rc < 0) {
+		D_ERROR("Failed to decode nvme ctrlr_data entry (%s)\n", spdk_strerror(-rc));
+		D_GOTO(free_values, rc = -DER_INVAL);
+	}
+
+	rc = spdk_json_decode_object_relaxed(
+	    ctx->ns_data, nvme_ns_decoders, SPDK_COUNTOF(nvme_ns_decoders), b_info->bdi_ctrlr->nss);
+	if (rc < 0) {
+		D_ERROR("Failed to decode nvme ns_data entry (%s)\n", spdk_strerror(-rc));
+		D_GOTO(free_values, rc = -DER_INVAL);
+	}
+
+	rc = 0;
+free_values:
+	D_FREE(ctx->values);
+free_ctx:
+	D_FREE(ctx);
+	D_FREE(json_data);
+
+	return rc;
+}
diff --git a/src/bio/bio_device.c b/src/bio/bio_device.c
index ffac4b2aef4..a08e03d956a 100644
--- a/src/bio/bio_device.c
+++ b/src/bio/bio_device.c
@@ -13,21 +13,13 @@
 #include <spdk/likely.h>
 #include <spdk/env.h>
 #include <spdk/vmd.h>
+#include <spdk/nvme.h>
 
 #include "smd.pb-c.h"
 
 #define LED_STATE_NAME(s) (ctl__led_state__descriptor.values[s].name)
 #define LED_ACTION_NAME(a) (ctl__led_action__descriptor.values[a].name)
 
-struct led_opts {
-	struct spdk_pci_addr	pci_addr;
-	bool			all_devices;
-	bool			finished;
-	Ctl__LedAction		action;
-	Ctl__LedState		led_state;
-	int			status;
-};
-
 static int
 revive_dev(struct bio_xs_context *xs_ctxt, struct bio_bdev *d_bdev)
 {
@@ -468,11 +460,46 @@ bio_replace_dev(struct bio_xs_context *xs_ctxt, uuid_t old_dev_id,
 }
 
 static int
-json_write_cb(void *cb_ctx, const void *data, size_t size)
+json_write_bdev_cb(void *cb_ctx, const void *json, size_t json_size)
 {
-	struct bio_dev_info	*b_info = cb_ctx;
-	char			*prefix = "traddr\": \"";
-	char			*traddr, *end;
+	struct bio_dev_info *b_info = cb_ctx;
+
+	return bio_decode_bdev_params(b_info, json, (int)json_size);
+}
+
+static int
+json_find_bdev_params(struct spdk_bdev *bdev, struct bio_dev_info *b_info)
+{
+	struct spdk_json_write_ctx *json;
+	int                         rc;
+
+	json = spdk_json_write_begin(json_write_bdev_cb, b_info, SPDK_JSON_WRITE_FLAG_FORMATTED);
+	if (json == NULL) {
+		D_ERROR("Failed to alloc SPDK json context\n");
+		return -DER_NOMEM;
+	}
+
+	rc = spdk_bdev_dump_info_json(bdev, json);
+	if (rc != 0) {
+		D_ERROR("Failed to dump config from SPDK bdev (%s)\n", spdk_strerror(-rc));
+		return daos_errno2der(-rc);
+	}
+
+	rc = spdk_json_write_end(json);
+	if (rc != 0) {
+		D_ERROR("Failed to write JSON (%s)\n", spdk_strerror(-rc));
+		return daos_errno2der(-rc);
+	}
+
+	return rc;
+}
+
+static int
+json_write_traddr_cb(void *cb_ctx, const void *data, size_t size)
+{
+	struct bio_dev_info *b_info = cb_ctx;
+	char                *prefix = "traddr\": \"";
+	char                *traddr, *end;
 
 	D_ASSERT(b_info != NULL);
 	/* traddr is already generated */
@@ -503,7 +530,7 @@ int
 fill_in_traddr(struct bio_dev_info *b_info, char *dev_name)
 {
 	struct spdk_bdev		*bdev;
-	struct spdk_json_write_ctx	*json;
+	struct spdk_json_write_ctx      *json;
 	int				 rc;
 
 	D_ASSERT(dev_name != NULL);
@@ -519,8 +546,7 @@ fill_in_traddr(struct bio_dev_info *b_info, char *dev_name)
 	if (get_bdev_type(bdev) != BDEV_CLASS_NVME)
 		return 0;
 
-	json = spdk_json_write_begin(json_write_cb, b_info,
-				     SPDK_JSON_WRITE_FLAG_FORMATTED);
+	json = spdk_json_write_begin(json_write_traddr_cb, b_info, SPDK_JSON_WRITE_FLAG_FORMATTED);
 	if (json == NULL) {
 		D_ERROR("Failed to alloc SPDK json context\n");
 		return -DER_NOMEM;
@@ -546,7 +572,7 @@ static struct bio_dev_info *
 alloc_dev_info(uuid_t dev_id, char *dev_name, struct smd_dev_info *s_info)
 {
 	struct bio_dev_info	*info;
-	int			 tgt_cnt = 0, i, rc;
+	int                      tgt_cnt = 0, i;
 
 	D_ALLOC_PTR(info);
 	if (info == NULL)
@@ -559,14 +585,6 @@ alloc_dev_info(uuid_t dev_id, char *dev_name, struct smd_dev_info *s_info)
 			info->bdi_flags |= NVME_DEV_FL_FAULTY;
 	}
 
-	if (dev_name != NULL) {
-		rc = fill_in_traddr(info, dev_name);
-		if (rc != 0) {
-			bio_free_dev_info(info);
-			return NULL;
-		}
-	}
-
 	if (tgt_cnt != 0) {
 		D_ALLOC_ARRAY(info->bdi_tgts, tgt_cnt);
 		if (info->bdi_tgts == NULL) {
@@ -597,6 +615,132 @@ find_smd_dev(uuid_t dev_id, d_list_t *s_dev_list)
 	return NULL;
 }
 
+struct pci_dev_opts {
+	struct spdk_pci_addr pci_addr;
+	bool                 finished;
+	int                 *socket_id;
+	char               **pci_type;
+	int                  status;
+};
+
+static void
+pci_device_cb(void *ctx, struct spdk_pci_device *pci_device)
+{
+	struct pci_dev_opts *opts = ctx;
+	const char          *device_type;
+	int                  len;
+
+	if (opts->status != 0)
+		return;
+	if (opts->finished)
+		return;
+
+	if (spdk_pci_addr_compare(&opts->pci_addr, &pci_device->addr) != 0)
+		return;
+	opts->finished = true;
+
+	/* Populate pci_dev_type and socket_id */
+
+	*opts->socket_id = spdk_pci_device_get_socket_id(pci_device);
+
+	device_type = spdk_pci_device_get_type(pci_device);
+	if (device_type == NULL) {
+		D_ERROR("spdk_pci_device_get_type returned nil\n");
+		opts->status = -DER_INVAL;
+		return;
+	}
+	len = strlen(device_type);
+	if (len == 0) {
+		D_ERROR("spdk_pci_device_get_type returned empty\n");
+		opts->status = -DER_INVAL;
+		return;
+	}
+	D_STRNDUP(*opts->pci_type, device_type, len);
+	if (*opts->pci_type == NULL) {
+		opts->status = -DER_NOMEM;
+		return;
+	}
+}
+
+static int
+fetch_pci_dev_info(struct ctrlr_t *w_ctrlr, const char *tr_addr)
+{
+	struct pci_dev_opts  opts = {0};
+	struct spdk_pci_addr pci_addr;
+	int                  rc;
+
+	rc = spdk_pci_addr_parse(&pci_addr, tr_addr);
+	if (rc != 0) {
+		D_ERROR("Unable to parse PCI address for device %s (%s)\n", tr_addr,
+			spdk_strerror(-rc));
+		return -DER_INVAL;
+	}
+
+	opts.finished  = false;
+	opts.status    = 0;
+	opts.pci_addr  = pci_addr;
+	opts.socket_id = &w_ctrlr->socket_id;
+	opts.pci_type  = &w_ctrlr->pci_type;
+
+	spdk_pci_for_each_device(&opts, pci_device_cb);
+
+	return opts.status;
+}
+
+static int
+alloc_ctrlr_info(uuid_t dev_id, char *dev_name, struct bio_dev_info *b_info)
+{
+	struct spdk_bdev *bdev;
+	uint32_t          blk_sz;
+	uint64_t          nr_blks;
+	int               rc;
+
+	D_ASSERT(b_info != NULL);
+	D_ASSERT(b_info->bdi_ctrlr == NULL);
+
+	if (dev_name == NULL) {
+		D_DEBUG(DB_MGMT, "missing bdev device name, skipping ctrlr info fetch\n");
+		return 0;
+	}
+
+	bdev = spdk_bdev_get_by_name(dev_name);
+	if (bdev == NULL) {
+		D_ERROR("Failed to get SPDK bdev for %s\n", dev_name);
+		return -DER_NONEXIST;
+	}
+
+	if (get_bdev_type(bdev) != BDEV_CLASS_NVME)
+		return 0;
+
+	D_ALLOC_PTR(b_info->bdi_ctrlr);
+	if (b_info->bdi_ctrlr == NULL)
+		return -DER_NOMEM;
+
+	D_ALLOC_PTR(b_info->bdi_ctrlr->nss);
+	if (b_info->bdi_ctrlr->nss == NULL)
+		return -DER_NOMEM;
+
+	/* Namespace capacity by direct query of SPDK bdev object */
+	blk_sz                       = spdk_bdev_get_block_size(bdev);
+	nr_blks                      = spdk_bdev_get_num_blocks(bdev);
+	b_info->bdi_ctrlr->nss->size = nr_blks * (uint64_t)blk_sz;
+
+	/* Controller details and namespace ID by parsing SPDK bdev JSON info */
+	rc = json_find_bdev_params(bdev, b_info);
+	if (rc != 0) {
+		D_ERROR("Failed to get bdev json params for %s\n", dev_name);
+		return rc;
+	}
+
+	/* Fetch socket ID and PCI device type by enumerating spdk_pci_device list */
+	rc = fetch_pci_dev_info(b_info->bdi_ctrlr, b_info->bdi_traddr);
+	if (rc != 0) {
+		return rc;
+	}
+
+	return 0;
+}
+
 int
 bio_dev_list(struct bio_xs_context *xs_ctxt, d_list_t *dev_list, int *dev_cnt)
 {
@@ -637,6 +781,13 @@ bio_dev_list(struct bio_xs_context *xs_ctxt, d_list_t *dev_list, int *dev_cnt)
 			b_info->bdi_flags |= NVME_DEV_FL_PLUGGED;
 		if (d_bdev->bb_faulty)
 			b_info->bdi_flags |= NVME_DEV_FL_FAULTY;
+
+		rc = alloc_ctrlr_info(d_bdev->bb_uuid, dev_name, b_info);
+		if (rc) {
+			DL_ERROR(rc, "Failed to get ctrlr details");
+			goto out;
+		}
+
 		d_list_add_tail(&b_info->bdi_link, dev_list);
 		(*dev_cnt)++;
 
@@ -684,6 +835,15 @@ bio_dev_list(struct bio_xs_context *xs_ctxt, d_list_t *dev_list, int *dev_cnt)
 	return rc;
 }
 
+struct led_opts {
+	struct spdk_pci_addr pci_addr;
+	bool                 all_devices;
+	bool                 finished;
+	Ctl__LedAction       action;
+	Ctl__LedState        led_state;
+	int                  status;
+};
+
 static void
 led_device_action(void *ctx, struct spdk_pci_device *pci_device)
 {
@@ -718,7 +878,7 @@ led_device_action(void *ctx, struct spdk_pci_device *pci_device)
 		return;
 	}
 
-	if (strncmp(pci_dev_type, BIO_DEV_TYPE_VMD, strlen(BIO_DEV_TYPE_VMD)) != 0) {
+	if (strncmp(pci_dev_type, NVME_PCI_DEV_TYPE_VMD, strlen(NVME_PCI_DEV_TYPE_VMD)) != 0) {
 		D_DEBUG(DB_MGMT, "Found non-VMD device type (%s:%s), can't manage LED\n",
 			pci_dev_type, addr_buf);
 		opts->status = -DER_NOSYS;
@@ -1012,21 +1172,33 @@ bio_led_manage(struct bio_xs_context *xs_ctxt, char *tr_addr, uuid_t dev_uuid, u
 	       unsigned int *state, uint64_t duration)
 {
 	struct spdk_pci_addr	pci_addr;
+	int                     addr_len = 0;
 	int			rc;
 
+	/* LED management on NVMe devices currently only supported when VMD is enabled. */
+	if (!is_vmd_enabled())
+		return 0;
+
 	/**
 	 * If tr_addr is already provided, convert to a PCI address. If tr_addr is NULL or empty,
 	 * derive PCI address from the provided UUID and if tr_addr is an empty string buffer then
 	 * populate with the derived address.
 	 */
 
-	if ((tr_addr == NULL) || (strlen(tr_addr) == 0)) {
+	if (tr_addr != NULL) {
+		addr_len = strnlen(tr_addr, SPDK_NVMF_TRADDR_MAX_LEN);
+		if (addr_len == SPDK_NVMF_TRADDR_MAX_LEN)
+			return -DER_INVAL;
+	}
+
+	if (addr_len == 0) {
 		rc = dev_uuid2pci_addr(&pci_addr, dev_uuid);
 		if (rc != 0)
 			return rc;
 
 		if (tr_addr != NULL) {
-			rc = spdk_pci_addr_fmt(tr_addr, ADDR_STR_MAX_LEN + 1, &pci_addr);
+			/* Populate tr_addr buffer to return address */
+			rc = spdk_pci_addr_fmt(tr_addr, addr_len, &pci_addr);
 			if (rc != 0) {
 				D_ERROR("Failed to write VMD's PCI address (%s)\n",
 					spdk_strerror(-rc));
diff --git a/src/bio/bio_internal.h b/src/bio/bio_internal.h
index 8a329c2915d..75ee9db791f 100644
--- a/src/bio/bio_internal.h
+++ b/src/bio/bio_internal.h
@@ -19,7 +19,6 @@
 
 #include "smd.pb-c.h"
 
-#define BIO_DEV_TYPE_VMD	"vmd"
 #define BIO_DMA_PAGE_SHIFT	12	/* 4K */
 #define BIO_DMA_PAGE_SZ		(1UL << BIO_DMA_PAGE_SHIFT)
 #define BIO_XS_CNT_MAX		BIO_MAX_VOS_TGT_CNT /* Max VOS xstreams per blobstore */
@@ -31,6 +30,14 @@
 #define NVME_MONITOR_PERIOD	    (60ULL * (NSEC_PER_SEC / NSEC_PER_USEC))
 #define NVME_MONITOR_SHORT_PERIOD   (3ULL * (NSEC_PER_SEC / NSEC_PER_USEC))
 
+static bool bio_vmd_enabled;
+
+static inline bool
+is_vmd_enabled(void)
+{
+	return bio_vmd_enabled;
+}
+
 struct bio_bulk_args {
 	void		*ba_bulk_ctxt;
 	unsigned int	 ba_bulk_perm;
@@ -655,8 +662,12 @@ int bio_bs_state_set(struct bio_blobstore *bbs, enum bio_bs_state new_state);
 int fill_in_traddr(struct bio_dev_info *b_info, char *dev_name);
 
 /* bio_config.c */
-int bio_add_allowed_alloc(const char *nvme_conf, struct spdk_env_opts *opts, int *roles);
+int
+    bio_add_allowed_alloc(const char *nvme_conf, struct spdk_env_opts *opts, int *roles,
+			  bool *vmd_enabled);
 int bio_set_hotplug_filter(const char *nvme_conf);
 int bio_read_accel_props(const char *nvme_conf);
 int bio_read_rpc_srv_settings(const char *nvme_conf, bool *enable, const char **sock_addr);
+int
+bio_decode_bdev_params(struct bio_dev_info *b_info, const void *json, int json_size);
 #endif /* __BIO_INTERNAL_H__ */
diff --git a/src/bio/bio_xstream.c b/src/bio/bio_xstream.c
index d2d6a223521..28ad31dcfb3 100644
--- a/src/bio/bio_xstream.c
+++ b/src/bio/bio_xstream.c
@@ -93,6 +93,7 @@ bio_spdk_env_init(void)
 {
 	struct spdk_env_opts	opts;
 	bool			enable_rpc_srv = false;
+	bool                    vmd_enabled    = false;
 	int			rc;
 	int			roles = 0;
 
@@ -111,13 +112,14 @@ bio_spdk_env_init(void)
 	 */
 
 	if (bio_nvme_configured(SMD_DEV_TYPE_MAX)) {
-		rc = bio_add_allowed_alloc(nvme_glb.bd_nvme_conf, &opts, &roles);
+		rc = bio_add_allowed_alloc(nvme_glb.bd_nvme_conf, &opts, &roles, &vmd_enabled);
 		if (rc != 0) {
 			D_ERROR("Failed to add allowed devices to SPDK env, "DF_RC"\n",
 				DP_RC(rc));
 			goto out;
 		}
 		nvme_glb.bd_nvme_roles = roles;
+		bio_vmd_enabled        = vmd_enabled;
 
 		rc = bio_set_hotplug_filter(nvme_glb.bd_nvme_conf);
 		if (rc != 0) {
@@ -990,7 +992,6 @@ init_bio_bdevs(struct bio_xs_context *ctxt)
 			return -DER_EXIST;
 		}
 
-		D_INFO("Resetting LED on dev " DF_UUID " \n", DP_UUID(d_bdev->bb_uuid));
 		rc = bio_led_manage(ctxt, NULL, d_bdev->bb_uuid,
 				    (unsigned int)CTL__LED_ACTION__RESET, NULL, 0);
 		if (rc != 0) {
@@ -1873,6 +1874,10 @@ bio_led_event_monitor(struct bio_xs_context *ctxt, uint64_t now)
 	struct bio_bdev         *d_bdev;
 	int			 rc;
 
+	if (!is_vmd_enabled()) {
+		return;
+	}
+
 	/* Scan all devices present in bio_bdev list */
 	d_list_for_each_entry(d_bdev, bio_bdev_list(), bb_link) {
 		if ((d_bdev->bb_led_expiry_time != 0) && (d_bdev->bb_led_expiry_time < now)) {
diff --git a/src/bio/smd.pb-c.c b/src/bio/smd.pb-c.c
index 4a3da682883..b3ed3284385 100644
--- a/src/bio/smd.pb-c.c
+++ b/src/bio/smd.pb-c.c
@@ -97,6 +97,57 @@ void   ctl__bio_health_resp__free_unpacked
   assert(message->base.descriptor == &ctl__bio_health_resp__descriptor);
   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 }
+void   ctl__nvme_controller__namespace__init
+                     (Ctl__NvmeController__Namespace         *message)
+{
+  static const Ctl__NvmeController__Namespace init_value = CTL__NVME_CONTROLLER__NAMESPACE__INIT;
+  *message = init_value;
+}
+void   ctl__nvme_controller__init
+                     (Ctl__NvmeController         *message)
+{
+  static const Ctl__NvmeController init_value = CTL__NVME_CONTROLLER__INIT;
+  *message = init_value;
+}
+size_t ctl__nvme_controller__get_packed_size
+                     (const Ctl__NvmeController *message)
+{
+  assert(message->base.descriptor == &ctl__nvme_controller__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t ctl__nvme_controller__pack
+                     (const Ctl__NvmeController *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &ctl__nvme_controller__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t ctl__nvme_controller__pack_to_buffer
+                     (const Ctl__NvmeController *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &ctl__nvme_controller__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+Ctl__NvmeController *
+       ctl__nvme_controller__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (Ctl__NvmeController *)
+     protobuf_c_message_unpack (&ctl__nvme_controller__descriptor,
+                                allocator, len, data);
+}
+void   ctl__nvme_controller__free_unpacked
+                     (Ctl__NvmeController *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &ctl__nvme_controller__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
 void   ctl__smd_device__init
                      (Ctl__SmdDevice         *message)
 {
@@ -373,12 +424,6 @@ void   ctl__smd_query_req__free_unpacked
   assert(message->base.descriptor == &ctl__smd_query_req__descriptor);
   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 }
-void   ctl__smd_query_resp__smd_device_with_health__init
-                     (Ctl__SmdQueryResp__SmdDeviceWithHealth         *message)
-{
-  static const Ctl__SmdQueryResp__SmdDeviceWithHealth init_value = CTL__SMD_QUERY_RESP__SMD_DEVICE_WITH_HEALTH__INIT;
-  *message = init_value;
-}
 void   ctl__smd_query_resp__pool__init
                      (Ctl__SmdQueryResp__Pool         *message)
 {
@@ -1393,51 +1438,175 @@ const ProtobufCMessageDescriptor ctl__bio_health_resp__descriptor =
   (ProtobufCMessageInit) ctl__bio_health_resp__init,
   NULL,NULL,NULL    /* reserved[123] */
 };
-static const ProtobufCFieldDescriptor ctl__smd_device__field_descriptors[15] =
+static const ProtobufCFieldDescriptor ctl__nvme_controller__namespace__field_descriptors[3] =
 {
   {
-    "uuid",
+    "id",
     1,
     PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_UINT32,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__NvmeController__Namespace, id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "size",
+    2,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_UINT64,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__NvmeController__Namespace, size),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ctrlr_pci_addr",
+    3,
+    PROTOBUF_C_LABEL_NONE,
     PROTOBUF_C_TYPE_STRING,
     0,   /* quantifier_offset */
-    offsetof(Ctl__SmdDevice, uuid),
+    offsetof(Ctl__NvmeController__Namespace, ctrlr_pci_addr),
     NULL,
     &protobuf_c_empty_string,
     0,             /* flags */
     0,NULL,NULL    /* reserved1,reserved2, etc */
   },
+};
+static const unsigned ctl__nvme_controller__namespace__field_indices_by_name[] = {
+  2,   /* field[2] = ctrlr_pci_addr */
+  0,   /* field[0] = id */
+  1,   /* field[1] = size */
+};
+static const ProtobufCIntRange ctl__nvme_controller__namespace__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 3 }
+};
+const ProtobufCMessageDescriptor ctl__nvme_controller__namespace__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "ctl.NvmeController.Namespace",
+  "Namespace",
+  "Ctl__NvmeController__Namespace",
+  "ctl",
+  sizeof(Ctl__NvmeController__Namespace),
+  3,
+  ctl__nvme_controller__namespace__field_descriptors,
+  ctl__nvme_controller__namespace__field_indices_by_name,
+  1,  ctl__nvme_controller__namespace__number_ranges,
+  (ProtobufCMessageInit) ctl__nvme_controller__namespace__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor ctl__nvme_controller__field_descriptors[12] =
+{
   {
-    "tgt_ids",
-    2,
-    PROTOBUF_C_LABEL_REPEATED,
-    PROTOBUF_C_TYPE_INT32,
-    offsetof(Ctl__SmdDevice, n_tgt_ids),
-    offsetof(Ctl__SmdDevice, tgt_ids),
+    "model",
+    1,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__NvmeController, model),
     NULL,
+    &protobuf_c_empty_string,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "serial",
+    2,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__NvmeController, serial),
     NULL,
+    &protobuf_c_empty_string,
     0,             /* flags */
     0,NULL,NULL    /* reserved1,reserved2, etc */
   },
   {
-    "tr_addr",
+    "pci_addr",
     3,
     PROTOBUF_C_LABEL_NONE,
     PROTOBUF_C_TYPE_STRING,
     0,   /* quantifier_offset */
-    offsetof(Ctl__SmdDevice, tr_addr),
+    offsetof(Ctl__NvmeController, pci_addr),
     NULL,
     &protobuf_c_empty_string,
     0,             /* flags */
     0,NULL,NULL    /* reserved1,reserved2, etc */
   },
   {
-    "dev_state",
+    "fw_rev",
     4,
     PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__NvmeController, fw_rev),
+    NULL,
+    &protobuf_c_empty_string,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "socket_id",
+    5,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_INT32,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__NvmeController, socket_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "health_stats",
+    6,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__NvmeController, health_stats),
+    &ctl__bio_health_resp__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "namespaces",
+    7,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_MESSAGE,
+    offsetof(Ctl__NvmeController, n_namespaces),
+    offsetof(Ctl__NvmeController, namespaces),
+    &ctl__nvme_controller__namespace__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "smd_devices",
+    8,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_MESSAGE,
+    offsetof(Ctl__NvmeController, n_smd_devices),
+    offsetof(Ctl__NvmeController, smd_devices),
+    &ctl__smd_device__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "dev_state",
+    9,
+    PROTOBUF_C_LABEL_NONE,
     PROTOBUF_C_TYPE_ENUM,
     0,   /* quantifier_offset */
-    offsetof(Ctl__SmdDevice, dev_state),
+    offsetof(Ctl__NvmeController, dev_state),
     &ctl__nvme_dev_state__descriptor,
     NULL,
     0,             /* flags */
@@ -1445,16 +1614,101 @@ static const ProtobufCFieldDescriptor ctl__smd_device__field_descriptors[15] =
   },
   {
     "led_state",
-    5,
+    10,
     PROTOBUF_C_LABEL_NONE,
     PROTOBUF_C_TYPE_ENUM,
     0,   /* quantifier_offset */
-    offsetof(Ctl__SmdDevice, led_state),
+    offsetof(Ctl__NvmeController, led_state),
     &ctl__led_state__descriptor,
     NULL,
     0,             /* flags */
     0,NULL,NULL    /* reserved1,reserved2, etc */
   },
+  {
+    "pci_dev_type",
+    11,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__NvmeController, pci_dev_type),
+    NULL,
+    &protobuf_c_empty_string,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "vendor_id",
+    12,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__NvmeController, vendor_id),
+    NULL,
+    &protobuf_c_empty_string,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned ctl__nvme_controller__field_indices_by_name[] = {
+  8,   /* field[8] = dev_state */
+  3,   /* field[3] = fw_rev */
+  5,   /* field[5] = health_stats */
+  9,   /* field[9] = led_state */
+  0,   /* field[0] = model */
+  6,   /* field[6] = namespaces */
+  2,   /* field[2] = pci_addr */
+  10,   /* field[10] = pci_dev_type */
+  1,   /* field[1] = serial */
+  7,   /* field[7] = smd_devices */
+  4,   /* field[4] = socket_id */
+  11,   /* field[11] = vendor_id */
+};
+static const ProtobufCIntRange ctl__nvme_controller__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 12 }
+};
+const ProtobufCMessageDescriptor ctl__nvme_controller__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "ctl.NvmeController",
+  "NvmeController",
+  "Ctl__NvmeController",
+  "ctl",
+  sizeof(Ctl__NvmeController),
+  12,
+  ctl__nvme_controller__field_descriptors,
+  ctl__nvme_controller__field_indices_by_name,
+  1,  ctl__nvme_controller__number_ranges,
+  (ProtobufCMessageInit) ctl__nvme_controller__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor ctl__smd_device__field_descriptors[14] =
+{
+  {
+    "uuid",
+    1,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__SmdDevice, uuid),
+    NULL,
+    &protobuf_c_empty_string,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "tgt_ids",
+    2,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(Ctl__SmdDevice, n_tgt_ids),
+    offsetof(Ctl__SmdDevice, tgt_ids),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
   {
     "total_bytes",
     6,
@@ -1575,28 +1829,52 @@ static const ProtobufCFieldDescriptor ctl__smd_device__field_descriptors[15] =
     0,             /* flags */
     0,NULL,NULL    /* reserved1,reserved2, etc */
   },
+  {
+    "ctrlr",
+    16,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__SmdDevice, ctrlr),
+    &ctl__nvme_controller__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ctrlr_namespace_id",
+    17,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_UINT32,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__SmdDevice, ctrlr_namespace_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
 };
 static const unsigned ctl__smd_device__field_indices_by_name[] = {
-  6,   /* field[6] = avail_bytes */
-  7,   /* field[7] = cluster_size */
-  3,   /* field[3] = dev_state */
-  4,   /* field[4] = led_state */
-  10,   /* field[10] = meta_size */
-  11,   /* field[11] = meta_wal_size */
-  8,   /* field[8] = rank */
-  12,   /* field[12] = rdb_size */
-  13,   /* field[13] = rdb_wal_size */
-  9,   /* field[9] = role_bits */
+  3,   /* field[3] = avail_bytes */
+  4,   /* field[4] = cluster_size */
+  12,   /* field[12] = ctrlr */
+  13,   /* field[13] = ctrlr_namespace_id */
+  7,   /* field[7] = meta_size */
+  8,   /* field[8] = meta_wal_size */
+  5,   /* field[5] = rank */
+  9,   /* field[9] = rdb_size */
+  10,   /* field[10] = rdb_wal_size */
+  6,   /* field[6] = role_bits */
   1,   /* field[1] = tgt_ids */
-  5,   /* field[5] = total_bytes */
-  2,   /* field[2] = tr_addr */
-  14,   /* field[14] = usable_bytes */
+  2,   /* field[2] = total_bytes */
+  11,   /* field[11] = usable_bytes */
   0,   /* field[0] = uuid */
 };
-static const ProtobufCIntRange ctl__smd_device__number_ranges[1 + 1] =
+static const ProtobufCIntRange ctl__smd_device__number_ranges[2 + 1] =
 {
   { 1, 0 },
-  { 0, 15 }
+  { 6, 2 },
+  { 0, 14 }
 };
 const ProtobufCMessageDescriptor ctl__smd_device__descriptor =
 {
@@ -1606,10 +1884,10 @@ const ProtobufCMessageDescriptor ctl__smd_device__descriptor =
   "Ctl__SmdDevice",
   "ctl",
   sizeof(Ctl__SmdDevice),
-  15,
+  14,
   ctl__smd_device__field_descriptors,
   ctl__smd_device__field_indices_by_name,
-  1,  ctl__smd_device__number_ranges,
+  2,  ctl__smd_device__number_ranges,
   (ProtobufCMessageInit) ctl__smd_device__init,
   NULL,NULL,NULL    /* reserved[123] */
 };
@@ -1905,57 +2183,6 @@ const ProtobufCMessageDescriptor ctl__smd_query_req__descriptor =
   (ProtobufCMessageInit) ctl__smd_query_req__init,
   NULL,NULL,NULL    /* reserved[123] */
 };
-static const ProtobufCFieldDescriptor ctl__smd_query_resp__smd_device_with_health__field_descriptors[2] =
-{
-  {
-    "details",
-    1,
-    PROTOBUF_C_LABEL_NONE,
-    PROTOBUF_C_TYPE_MESSAGE,
-    0,   /* quantifier_offset */
-    offsetof(Ctl__SmdQueryResp__SmdDeviceWithHealth, details),
-    &ctl__smd_device__descriptor,
-    NULL,
-    0,             /* flags */
-    0,NULL,NULL    /* reserved1,reserved2, etc */
-  },
-  {
-    "health",
-    2,
-    PROTOBUF_C_LABEL_NONE,
-    PROTOBUF_C_TYPE_MESSAGE,
-    0,   /* quantifier_offset */
-    offsetof(Ctl__SmdQueryResp__SmdDeviceWithHealth, health),
-    &ctl__bio_health_resp__descriptor,
-    NULL,
-    0,             /* flags */
-    0,NULL,NULL    /* reserved1,reserved2, etc */
-  },
-};
-static const unsigned ctl__smd_query_resp__smd_device_with_health__field_indices_by_name[] = {
-  0,   /* field[0] = details */
-  1,   /* field[1] = health */
-};
-static const ProtobufCIntRange ctl__smd_query_resp__smd_device_with_health__number_ranges[1 + 1] =
-{
-  { 1, 0 },
-  { 0, 2 }
-};
-const ProtobufCMessageDescriptor ctl__smd_query_resp__smd_device_with_health__descriptor =
-{
-  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
-  "ctl.SmdQueryResp.SmdDeviceWithHealth",
-  "SmdDeviceWithHealth",
-  "Ctl__SmdQueryResp__SmdDeviceWithHealth",
-  "ctl",
-  sizeof(Ctl__SmdQueryResp__SmdDeviceWithHealth),
-  2,
-  ctl__smd_query_resp__smd_device_with_health__field_descriptors,
-  ctl__smd_query_resp__smd_device_with_health__field_indices_by_name,
-  1,  ctl__smd_query_resp__smd_device_with_health__number_ranges,
-  (ProtobufCMessageInit) ctl__smd_query_resp__smd_device_with_health__init,
-  NULL,NULL,NULL    /* reserved[123] */
-};
 static const ProtobufCFieldDescriptor ctl__smd_query_resp__pool__field_descriptors[3] =
 {
   {
@@ -2041,7 +2268,7 @@ static const ProtobufCFieldDescriptor ctl__smd_query_resp__rank_resp__field_desc
     PROTOBUF_C_TYPE_MESSAGE,
     offsetof(Ctl__SmdQueryResp__RankResp, n_devices),
     offsetof(Ctl__SmdQueryResp__RankResp, devices),
-    &ctl__smd_query_resp__smd_device_with_health__descriptor,
+    &ctl__smd_device__descriptor,
     NULL,
     0,             /* flags */
     0,NULL,NULL    /* reserved1,reserved2, etc */
diff --git a/src/bio/smd.pb-c.h b/src/bio/smd.pb-c.h
index 45d159907ca..19ac9fc3d14 100644
--- a/src/bio/smd.pb-c.h
+++ b/src/bio/smd.pb-c.h
@@ -17,6 +17,8 @@ PROTOBUF_C__BEGIN_DECLS
 
 typedef struct _Ctl__BioHealthReq Ctl__BioHealthReq;
 typedef struct _Ctl__BioHealthResp Ctl__BioHealthResp;
+typedef struct _Ctl__NvmeController Ctl__NvmeController;
+typedef struct _Ctl__NvmeController__Namespace Ctl__NvmeController__Namespace;
 typedef struct _Ctl__SmdDevice Ctl__SmdDevice;
 typedef struct _Ctl__SmdDevReq Ctl__SmdDevReq;
 typedef struct _Ctl__SmdDevResp Ctl__SmdDevResp;
@@ -25,7 +27,6 @@ typedef struct _Ctl__SmdPoolResp Ctl__SmdPoolResp;
 typedef struct _Ctl__SmdPoolResp__Pool Ctl__SmdPoolResp__Pool;
 typedef struct _Ctl__SmdQueryReq Ctl__SmdQueryReq;
 typedef struct _Ctl__SmdQueryResp Ctl__SmdQueryResp;
-typedef struct _Ctl__SmdQueryResp__SmdDeviceWithHealth Ctl__SmdQueryResp__SmdDeviceWithHealth;
 typedef struct _Ctl__SmdQueryResp__Pool Ctl__SmdQueryResp__Pool;
 typedef struct _Ctl__SmdQueryResp__RankResp Ctl__SmdQueryResp__RankResp;
 typedef struct _Ctl__LedManageReq Ctl__LedManageReq;
@@ -222,33 +223,107 @@ struct  _Ctl__BioHealthResp
 
 
 /*
- * SmdDevice represents a DAOS BIO device, identified by a UUID written into a label stored on a
- * SPDK blobstore created on a NVMe namespace. Multiple SmdDevices may exist per NVMe controller.
+ * Namespace represents a namespace created on an NvmeController.
  */
-struct  _Ctl__SmdDevice
+struct  _Ctl__NvmeController__Namespace
 {
   ProtobufCMessage base;
   /*
-   * UUID of blobstore
+   * namespace id
    */
-  char *uuid;
+  uint32_t id;
   /*
-   * VOS target IDs
+   * device capacity in bytes
    */
-  size_t n_tgt_ids;
-  int32_t *tgt_ids;
+  uint64_t size;
+  /*
+   * parent controller PCI address
+   */
+  char *ctrlr_pci_addr;
+};
+#define CTL__NVME_CONTROLLER__NAMESPACE__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&ctl__nvme_controller__namespace__descriptor) \
+    , 0, 0, (char *)protobuf_c_empty_string }
+
+
+/*
+ * NvmeController represents an NVMe Controller (SSD).
+ */
+struct  _Ctl__NvmeController
+{
+  ProtobufCMessage base;
+  /*
+   * model name
+   */
+  char *model;
   /*
-   * Transport address of blobstore
+   * serial number
    */
-  char *tr_addr;
+  char *serial;
   /*
-   * NVMe device state
+   * pci address
+   */
+  char *pci_addr;
+  /*
+   * firmware revision
+   */
+  char *fw_rev;
+  /*
+   * NUMA socket ID
+   */
+  int32_t socket_id;
+  /*
+   * controller's health stats
+   */
+  Ctl__BioHealthResp *health_stats;
+  /*
+   * controller's namespaces
+   */
+  size_t n_namespaces;
+  Ctl__NvmeController__Namespace **namespaces;
+  /*
+   * controller's blobstores
+   */
+  size_t n_smd_devices;
+  Ctl__SmdDevice **smd_devices;
+  /*
+   * NVMe device operational state
    */
   Ctl__NvmeDevState dev_state;
   /*
-   * LED state
+   * NVMe device LED state
    */
   Ctl__LedState led_state;
+  /*
+   * PCI device type, vmd or pci
+   */
+  char *pci_dev_type;
+  /*
+   * controller's vendor ID
+   */
+  char *vendor_id;
+};
+#define CTL__NVME_CONTROLLER__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&ctl__nvme_controller__descriptor) \
+    , (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, 0, NULL, 0,NULL, 0,NULL, CTL__NVME_DEV_STATE__UNKNOWN, CTL__LED_STATE__OFF, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string }
+
+
+/*
+ * SmdDevice represents a DAOS BIO device, identified by a UUID written into a label stored on a
+ * SPDK blobstore created on a NVMe namespace. Multiple SmdDevices may exist per NVMe controller.
+ */
+struct  _Ctl__SmdDevice
+{
+  ProtobufCMessage base;
+  /*
+   * UUID of blobstore
+   */
+  char *uuid;
+  /*
+   * VOS target IDs
+   */
+  size_t n_tgt_ids;
+  int32_t *tgt_ids;
   /*
    * blobstore clusters total bytes
    */
@@ -289,10 +364,18 @@ struct  _Ctl__SmdDevice
    * Effective storage available for data
    */
   uint64_t usable_bytes;
+  /*
+   * Backing NVMe controller of SMD device
+   */
+  Ctl__NvmeController *ctrlr;
+  /*
+   * NVMe namespace id hosting SMD blobstore
+   */
+  uint32_t ctrlr_namespace_id;
 };
 #define CTL__SMD_DEVICE__INIT \
  { PROTOBUF_C_MESSAGE_INIT (&ctl__smd_device__descriptor) \
-    , (char *)protobuf_c_empty_string, 0,NULL, (char *)protobuf_c_empty_string, CTL__NVME_DEV_STATE__UNKNOWN, CTL__LED_STATE__OFF, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
+    , (char *)protobuf_c_empty_string, 0,NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, 0 }
 
 
 struct  _Ctl__SmdDevReq
@@ -389,20 +472,6 @@ struct  _Ctl__SmdQueryReq
     , 0, 0, 0, (char *)protobuf_c_empty_string, 0 }
 
 
-struct  _Ctl__SmdQueryResp__SmdDeviceWithHealth
-{
-  ProtobufCMessage base;
-  Ctl__SmdDevice *details;
-  /*
-   * optional BIO health
-   */
-  Ctl__BioHealthResp *health;
-};
-#define CTL__SMD_QUERY_RESP__SMD_DEVICE_WITH_HEALTH__INIT \
- { PROTOBUF_C_MESSAGE_INIT (&ctl__smd_query_resp__smd_device_with_health__descriptor) \
-    , NULL, NULL }
-
-
 struct  _Ctl__SmdQueryResp__Pool
 {
   ProtobufCMessage base;
@@ -437,7 +506,7 @@ struct  _Ctl__SmdQueryResp__RankResp
    * List of devices on the rank
    */
   size_t n_devices;
-  Ctl__SmdQueryResp__SmdDeviceWithHealth **devices;
+  Ctl__SmdDevice **devices;
   /*
    * List of pools on the rank
    */
@@ -659,6 +728,28 @@ Ctl__BioHealthResp *
 void   ctl__bio_health_resp__free_unpacked
                      (Ctl__BioHealthResp *message,
                       ProtobufCAllocator *allocator);
+/* Ctl__NvmeController__Namespace methods */
+void   ctl__nvme_controller__namespace__init
+                     (Ctl__NvmeController__Namespace         *message);
+/* Ctl__NvmeController methods */
+void   ctl__nvme_controller__init
+                     (Ctl__NvmeController         *message);
+size_t ctl__nvme_controller__get_packed_size
+                     (const Ctl__NvmeController   *message);
+size_t ctl__nvme_controller__pack
+                     (const Ctl__NvmeController   *message,
+                      uint8_t             *out);
+size_t ctl__nvme_controller__pack_to_buffer
+                     (const Ctl__NvmeController   *message,
+                      ProtobufCBuffer     *buffer);
+Ctl__NvmeController *
+       ctl__nvme_controller__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   ctl__nvme_controller__free_unpacked
+                     (Ctl__NvmeController *message,
+                      ProtobufCAllocator *allocator);
 /* Ctl__SmdDevice methods */
 void   ctl__smd_device__init
                      (Ctl__SmdDevice         *message);
@@ -776,9 +867,6 @@ Ctl__SmdQueryReq *
 void   ctl__smd_query_req__free_unpacked
                      (Ctl__SmdQueryReq *message,
                       ProtobufCAllocator *allocator);
-/* Ctl__SmdQueryResp__SmdDeviceWithHealth methods */
-void   ctl__smd_query_resp__smd_device_with_health__init
-                     (Ctl__SmdQueryResp__SmdDeviceWithHealth         *message);
 /* Ctl__SmdQueryResp__Pool methods */
 void   ctl__smd_query_resp__pool__init
                      (Ctl__SmdQueryResp__Pool         *message);
@@ -932,6 +1020,12 @@ typedef void (*Ctl__BioHealthReq_Closure)
 typedef void (*Ctl__BioHealthResp_Closure)
                  (const Ctl__BioHealthResp *message,
                   void *closure_data);
+typedef void (*Ctl__NvmeController__Namespace_Closure)
+                 (const Ctl__NvmeController__Namespace *message,
+                  void *closure_data);
+typedef void (*Ctl__NvmeController_Closure)
+                 (const Ctl__NvmeController *message,
+                  void *closure_data);
 typedef void (*Ctl__SmdDevice_Closure)
                  (const Ctl__SmdDevice *message,
                   void *closure_data);
@@ -953,9 +1047,6 @@ typedef void (*Ctl__SmdPoolResp_Closure)
 typedef void (*Ctl__SmdQueryReq_Closure)
                  (const Ctl__SmdQueryReq *message,
                   void *closure_data);
-typedef void (*Ctl__SmdQueryResp__SmdDeviceWithHealth_Closure)
-                 (const Ctl__SmdQueryResp__SmdDeviceWithHealth *message,
-                  void *closure_data);
 typedef void (*Ctl__SmdQueryResp__Pool_Closure)
                  (const Ctl__SmdQueryResp__Pool *message,
                   void *closure_data);
@@ -1000,6 +1091,8 @@ extern const ProtobufCEnumDescriptor    ctl__led_state__descriptor;
 extern const ProtobufCEnumDescriptor    ctl__led_action__descriptor;
 extern const ProtobufCMessageDescriptor ctl__bio_health_req__descriptor;
 extern const ProtobufCMessageDescriptor ctl__bio_health_resp__descriptor;
+extern const ProtobufCMessageDescriptor ctl__nvme_controller__descriptor;
+extern const ProtobufCMessageDescriptor ctl__nvme_controller__namespace__descriptor;
 extern const ProtobufCMessageDescriptor ctl__smd_device__descriptor;
 extern const ProtobufCMessageDescriptor ctl__smd_dev_req__descriptor;
 extern const ProtobufCMessageDescriptor ctl__smd_dev_resp__descriptor;
@@ -1008,7 +1101,6 @@ extern const ProtobufCMessageDescriptor ctl__smd_pool_resp__descriptor;
 extern const ProtobufCMessageDescriptor ctl__smd_pool_resp__pool__descriptor;
 extern const ProtobufCMessageDescriptor ctl__smd_query_req__descriptor;
 extern const ProtobufCMessageDescriptor ctl__smd_query_resp__descriptor;
-extern const ProtobufCMessageDescriptor ctl__smd_query_resp__smd_device_with_health__descriptor;
 extern const ProtobufCMessageDescriptor ctl__smd_query_resp__pool__descriptor;
 extern const ProtobufCMessageDescriptor ctl__smd_query_resp__rank_resp__descriptor;
 extern const ProtobufCMessageDescriptor ctl__led_manage_req__descriptor;
diff --git a/src/control/cmd/dmg/pretty/storage.go b/src/control/cmd/dmg/pretty/storage.go
index 37a3b9769d9..4f2a02fbe9d 100644
--- a/src/control/cmd/dmg/pretty/storage.go
+++ b/src/control/cmd/dmg/pretty/storage.go
@@ -179,7 +179,7 @@ func printSmdDevice(dev *storage.SmdDevice, iw io.Writer, opts ...PrintConfigOpt
 	fc := getPrintConfig(opts...)
 
 	if fc.LEDInfoOnly {
-		if _, err := fmt.Fprintf(iw, "TrAddr:%s", dev.TrAddr); err != nil {
+		if _, err := fmt.Fprintf(iw, "TrAddr:%s", dev.Ctrlr.PciAddr); err != nil {
 			return err
 		}
 		if dev.UUID != "" {
@@ -187,13 +187,13 @@ func printSmdDevice(dev *storage.SmdDevice, iw io.Writer, opts ...PrintConfigOpt
 				return err
 			}
 		}
-		if _, err := fmt.Fprintf(iw, " LED:%s\n", dev.LedState); err != nil {
+		if _, err := fmt.Fprintf(iw, " LED:%s\n", dev.Ctrlr.LedState); err != nil {
 			return err
 		}
 		return nil
 	}
 
-	if _, err := fmt.Fprintf(iw, "UUID:%s [TrAddr:%s]\n", dev.UUID, dev.TrAddr); err != nil {
+	if _, err := fmt.Fprintf(iw, "UUID:%s [TrAddr:%s]\n", dev.UUID, dev.Ctrlr.PciAddr); err != nil {
 		return err
 	}
 
@@ -202,8 +202,8 @@ func printSmdDevice(dev *storage.SmdDevice, iw io.Writer, opts ...PrintConfigOpt
 		hasSysXS = "SysXS "
 	}
 	if _, err := fmt.Fprintf(txtfmt.NewIndentWriter(iw),
-		"Roles:%s %sTargets:%+v Rank:%d State:%s LED:%s\n", dev.Roles.String(), hasSysXS,
-		dev.TargetIDs, dev.Rank, dev.NvmeState.String(), dev.LedState); err != nil {
+		"Roles:%s %sTargets:%+v Rank:%d State:%s LED:%s\n", &dev.Roles, hasSysXS,
+		dev.TargetIDs, dev.Rank, dev.Ctrlr.NvmeState, dev.Ctrlr.LedState); err != nil {
 		return err
 	}
 
@@ -247,13 +247,14 @@ func PrintSmdInfoMap(omitDevs, omitPools bool, hsm control.HostStorageMap, out i
 					if err := printSmdDevice(device, iw1, opts...); err != nil {
 						return err
 					}
-					if device.Health != nil {
-						iw2 := txtfmt.NewIndentWriter(iw1)
-						if err := printNvmeHealth(device.Health, iw2, opts...); err != nil {
-							return err
-						}
-						fmt.Fprintln(out)
+					if device.Ctrlr.HealthStats == nil {
+						continue
 					}
+					if err := printNvmeHealth(device.Ctrlr.HealthStats,
+						txtfmt.NewIndentWriter(iw1), opts...); err != nil {
+						return err
+					}
+					fmt.Fprintln(out)
 				}
 			} else {
 				fmt.Fprintln(iw, "No devices found")
diff --git a/src/control/cmd/dmg/pretty/storage_nvme_test.go b/src/control/cmd/dmg/pretty/storage_nvme_test.go
index 8fba14c0087..60b0f4dcd5c 100644
--- a/src/control/cmd/dmg/pretty/storage_nvme_test.go
+++ b/src/control/cmd/dmg/pretty/storage_nvme_test.go
@@ -366,8 +366,7 @@ host1
 					"host1",
 					&control.HostStorage{
 						NvmeDevices: storage.NvmeControllers{
-							controllerA,
-							controllerB,
+							controllerA, controllerB,
 						},
 					},
 				},
@@ -394,8 +393,7 @@ PCI:%s Model:%s FW:%s Socket:%d Capacity:%s
 					"host1",
 					&control.HostStorage{
 						NvmeDevices: storage.NvmeControllers{
-							controllerC,
-							controllerD,
+							controllerC, controllerD,
 						},
 					},
 				},
@@ -419,15 +417,15 @@ PCI:%s Model:%s FW:%s Socket:%d Capacity:%s
 				controllerC.SocketID, humanize.Bytes(controllerC.Capacity()),
 				controllerC.SmdDevices[0].UUID, controllerC.PciAddr,
 				controllerC.SmdDevices[0].TargetIDs,
-				controllerC.SmdDevices[0].Rank, controllerC.SmdDevices[0].NvmeState.String(),
-				controllerC.SmdDevices[0].LedState.String(),
+				controllerC.SmdDevices[0].Rank,
+				controllerC.NvmeState, controllerC.LedState,
 
 				controllerD.PciAddr, controllerD.Model, controllerD.FwRev,
 				controllerD.SocketID, humanize.Bytes(controllerD.Capacity()),
 				controllerD.SmdDevices[0].UUID, controllerD.PciAddr,
 				controllerD.SmdDevices[0].TargetIDs,
-				controllerD.SmdDevices[0].Rank, controllerD.SmdDevices[0].NvmeState.String(),
-				controllerD.SmdDevices[0].LedState.String()),
+				controllerD.SmdDevices[0].Rank,
+				controllerD.NvmeState, controllerD.LedState),
 		},
 		"multiple smd devices on each controller": {
 			hsm: mockHostStorageMap(t,
@@ -464,23 +462,19 @@ PCI:%s Model:%s FW:%s Socket:%d Capacity:%s
 				controllerE.SocketID, humanize.Bytes(controllerE.Capacity()),
 				controllerE.SmdDevices[0].UUID, controllerE.PciAddr,
 				controllerE.SmdDevices[0].TargetIDs, controllerE.SmdDevices[0].Rank,
-				controllerE.SmdDevices[0].NvmeState.String(),
-				controllerE.SmdDevices[0].LedState.String(),
+				controllerE.NvmeState, controllerE.LedState,
 				controllerE.SmdDevices[1].UUID, controllerE.PciAddr,
 				controllerE.SmdDevices[1].TargetIDs, controllerE.SmdDevices[1].Rank,
-				controllerE.SmdDevices[1].NvmeState.String(),
-				controllerE.SmdDevices[1].LedState.String(),
+				controllerE.NvmeState, controllerE.LedState,
 
 				controllerF.PciAddr, controllerF.Model, controllerF.FwRev,
 				controllerF.SocketID, humanize.Bytes(controllerF.Capacity()),
 				controllerF.SmdDevices[0].UUID, controllerF.PciAddr,
 				controllerF.SmdDevices[0].TargetIDs, controllerF.SmdDevices[0].Rank,
-				controllerF.SmdDevices[0].NvmeState.String(),
-				controllerF.SmdDevices[0].LedState.String(),
+				controllerF.NvmeState, controllerF.LedState,
 				controllerF.SmdDevices[1].UUID, controllerF.PciAddr,
 				controllerF.SmdDevices[1].TargetIDs, controllerF.SmdDevices[1].Rank,
-				controllerF.SmdDevices[1].NvmeState.String(),
-				controllerF.SmdDevices[1].LedState.String()),
+				controllerF.NvmeState, controllerF.LedState),
 		},
 	} {
 		t.Run(name, func(t *testing.T) {
diff --git a/src/control/cmd/dmg/pretty/storage_test.go b/src/control/cmd/dmg/pretty/storage_test.go
index e4e51372260..724031035ee 100644
--- a/src/control/cmd/dmg/pretty/storage_test.go
+++ b/src/control/cmd/dmg/pretty/storage_test.go
@@ -1275,6 +1275,25 @@ NVMe PCI Format Result
 
 func TestPretty_PrintSmdInfoMap(t *testing.T) {
 	mockController := storage.MockNvmeController(1)
+	newCtrlr := storage.NvmeController{
+		PciAddr:   "0000:8a:00.0",
+		NvmeState: storage.NvmeStateNew,
+		LedState:  storage.LedStateNormal,
+	}
+	identCtrlr := storage.NvmeController{
+		PciAddr:   "0000:db:00.0",
+		NvmeState: storage.NvmeStateNormal,
+		LedState:  storage.LedStateIdentify,
+	}
+	faultCtrlr := storage.NvmeController{
+		PciAddr:   "0000:8b:00.0",
+		NvmeState: storage.NvmeStateFaulty,
+		LedState:  storage.LedStateFaulty,
+	}
+	unknoCtrlr := storage.NvmeController{
+		PciAddr:  "0000:da:00.0",
+		LedState: storage.LedStateUnknown,
+	}
 
 	for name, tc := range map[string]struct {
 		noDevs      bool
@@ -1387,40 +1406,31 @@ host1
 							Devices: []*storage.SmdDevice{
 								{
 									UUID:      test.MockUUID(0),
-									TrAddr:    "0000:8a:00.0",
 									TargetIDs: []int32{0, 1, 2},
-									Rank:      0,
-									NvmeState: storage.NvmeStateNew,
-									LedState:  storage.LedStateNormal,
 									HasSysXS:  true,
 									Roles:     storage.BdevRoles{storage.BdevRoleWAL},
+									Ctrlr:     newCtrlr,
 								},
 								{
 									UUID:      test.MockUUID(1),
-									TrAddr:    "0000:8b:00.0",
 									TargetIDs: []int32{3, 4, 5},
-									Rank:      0,
-									NvmeState: storage.NvmeStateFaulty,
-									LedState:  storage.LedStateFaulty,
 									Roles:     storage.BdevRoles{storage.BdevRoleMeta | storage.BdevRoleData},
+									Ctrlr:     faultCtrlr,
 								},
 								{
 									UUID:      test.MockUUID(2),
-									TrAddr:    "0000:da:00.0",
 									TargetIDs: []int32{0, 1, 2},
 									Rank:      1,
-									LedState:  storage.LedStateUnknown,
 									HasSysXS:  true,
 									Roles:     storage.BdevRoles{storage.BdevRoleWAL},
+									Ctrlr:     unknoCtrlr,
 								},
 								{
 									UUID:      test.MockUUID(3),
-									TrAddr:    "0000:db:00.0",
 									TargetIDs: []int32{3, 4, 5},
 									Rank:      1,
-									NvmeState: storage.NvmeStateNormal,
-									LedState:  storage.LedStateIdentify,
 									Roles:     storage.BdevRoles{storage.BdevRoleMeta | storage.BdevRoleData},
+									Ctrlr:     identCtrlr,
 								},
 							},
 						},
@@ -1471,9 +1481,7 @@ host1
 									UUID:      test.MockUUID(0),
 									TargetIDs: []int32{0, 1, 2},
 									Rank:      0,
-									NvmeState: storage.NvmeStateNormal,
-									LedState:  storage.LedStateNormal,
-									Health:    mockController.HealthStats,
+									Ctrlr:     *mockController,
 									Roles:     storage.BdevRoles{storage.BdevRoleAll},
 								},
 							},
@@ -1486,7 +1494,7 @@ host1
 host1
 -----
   Devices
-    UUID:00000000-0000-0000-0000-000000000000 [TrAddr:]
+    UUID:00000000-0000-0000-0000-000000000000 [TrAddr:0000:01:00.0]
       Roles:data,meta,wal Targets:[0 1 2] Rank:0 State:NORMAL LED:OFF
       Health Stats:
         Temperature:%dK(%.02fC)
@@ -1558,9 +1566,8 @@ host1
 						SmdInfo: &control.SmdInfo{
 							Devices: []*storage.SmdDevice{
 								{
-									UUID:     "842c739b-86b5-462f-a7ba-b4a91b674f3d",
-									TrAddr:   "0000:8a:00.0",
-									LedState: storage.LedStateIdentify,
+									UUID:  "842c739b-86b5-462f-a7ba-b4a91b674f3d",
+									Ctrlr: identCtrlr,
 								},
 							},
 						},
@@ -1572,10 +1579,10 @@ host1
 host1
 -----
   Devices
-    TrAddr:0000:8a:00.0 [UUID:842c739b-86b5-462f-a7ba-b4a91b674f3d] LED:QUICK_BLINK
+    TrAddr:0000:db:00.0 [UUID:842c739b-86b5-462f-a7ba-b4a91b674f3d] LED:QUICK_BLINK
 `,
 		},
-		"identify led; transport address specified": {
+		"identify led; no uuid specified": {
 			noPools: true,
 			opts:    []PrintConfigOption{PrintOnlyLEDInfo()},
 			hsm: mockHostStorageMap(t,
@@ -1585,8 +1592,7 @@ host1
 						SmdInfo: &control.SmdInfo{
 							Devices: []*storage.SmdDevice{
 								{
-									TrAddr:   "0000:8a:00.0",
-									LedState: storage.LedStateIdentify,
+									Ctrlr: identCtrlr,
 								},
 							},
 						},
@@ -1598,7 +1604,7 @@ host1
 host1
 -----
   Devices
-    TrAddr:0000:8a:00.0 LED:QUICK_BLINK
+    TrAddr:0000:db:00.0 LED:QUICK_BLINK
 `,
 		},
 	} {
diff --git a/src/control/common/proto/ctl/firmware.pb.go b/src/control/common/proto/ctl/firmware.pb.go
index 53391e4ccf1..3a9bda212c4 100644
--- a/src/control/common/proto/ctl/firmware.pb.go
+++ b/src/control/common/proto/ctl/firmware.pb.go
@@ -6,7 +6,7 @@
 
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.28.1
+// 	protoc-gen-go v1.31.0
 // 	protoc        v3.5.0
 // source: ctl/firmware.proto
 
@@ -590,85 +590,85 @@ var file_ctl_firmware_proto_rawDesc = []byte{
 	0x0a, 0x12, 0x63, 0x74, 0x6c, 0x2f, 0x66, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x2e, 0x70,
 	0x72, 0x6f, 0x74, 0x6f, 0x12, 0x03, 0x63, 0x74, 0x6c, 0x1a, 0x15, 0x63, 0x74, 0x6c, 0x2f, 0x73,
 	0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x63, 0x6d, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x1a, 0x16, 0x63, 0x74, 0x6c, 0x2f, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x6e, 0x76,
-	0x6d, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa6, 0x01, 0x0a, 0x10, 0x46, 0x69, 0x72,
-	0x6d, 0x77, 0x61, 0x72, 0x65, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x12, 0x1a, 0x0a,
-	0x08, 0x71, 0x75, 0x65, 0x72, 0x79, 0x53, 0x63, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52,
-	0x08, 0x71, 0x75, 0x65, 0x72, 0x79, 0x53, 0x63, 0x6d, 0x12, 0x1c, 0x0a, 0x09, 0x71, 0x75, 0x65,
-	0x72, 0x79, 0x4e, 0x76, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x71, 0x75,
-	0x65, 0x72, 0x79, 0x4e, 0x76, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x65, 0x76, 0x69, 0x63,
-	0x65, 0x49, 0x44, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x64, 0x65, 0x76, 0x69,
-	0x63, 0x65, 0x49, 0x44, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x44,
-	0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x44, 0x12,
-	0x20, 0x0a, 0x0b, 0x66, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x52, 0x65, 0x76, 0x18, 0x05,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x66, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x52, 0x65,
-	0x76, 0x22, 0xf2, 0x01, 0x0a, 0x14, 0x53, 0x63, 0x6d, 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72,
-	0x65, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x12, 0x26, 0x0a, 0x06, 0x6d, 0x6f,
-	0x64, 0x75, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x63, 0x74, 0x6c,
-	0x2e, 0x53, 0x63, 0x6d, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x52, 0x06, 0x6d, 0x6f, 0x64, 0x75,
-	0x6c, 0x65, 0x12, 0x24, 0x0a, 0x0d, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x56, 0x65, 0x72, 0x73,
-	0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x61, 0x63, 0x74, 0x69, 0x76,
-	0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x24, 0x0a, 0x0d, 0x73, 0x74, 0x61, 0x67,
-	0x65, 0x64, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x0d, 0x73, 0x74, 0x61, 0x67, 0x65, 0x64, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x2c,
-	0x0a, 0x11, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x4d, 0x61, 0x78, 0x53, 0x69, 0x7a, 0x65, 0x42, 0x79,
-	0x74, 0x65, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x11, 0x69, 0x6d, 0x61, 0x67, 0x65,
-	0x4d, 0x61, 0x78, 0x53, 0x69, 0x7a, 0x65, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x22, 0x0a, 0x0c,
-	0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x05, 0x20, 0x01,
-	0x28, 0x0d, 0x52, 0x0c, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73,
-	0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x44, 0x0a, 0x15, 0x4e, 0x76, 0x6d, 0x65, 0x46, 0x69,
-	0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x12,
-	0x2b, 0x0a, 0x06, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x13, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x4e, 0x76, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f,
-	0x6c, 0x6c, 0x65, 0x72, 0x52, 0x06, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x22, 0x8c, 0x01, 0x0a,
-	0x11, 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65,
-	0x73, 0x70, 0x12, 0x39, 0x0a, 0x0a, 0x73, 0x63, 0x6d, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73,
-	0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x63, 0x6d,
+	0x1a, 0x0d, 0x63, 0x74, 0x6c, 0x2f, 0x73, 0x6d, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22,
+	0xa6, 0x01, 0x0a, 0x10, 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x52, 0x65, 0x71, 0x12, 0x1a, 0x0a, 0x08, 0x71, 0x75, 0x65, 0x72, 0x79, 0x53, 0x63, 0x6d,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x71, 0x75, 0x65, 0x72, 0x79, 0x53, 0x63, 0x6d,
+	0x12, 0x1c, 0x0a, 0x09, 0x71, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x76, 0x6d, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x09, 0x71, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x76, 0x6d, 0x65, 0x12, 0x1c,
+	0x0a, 0x09, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x44, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28,
+	0x09, 0x52, 0x09, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x44, 0x73, 0x12, 0x18, 0x0a, 0x07,
+	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d,
+	0x6f, 0x64, 0x65, 0x6c, 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x66, 0x69, 0x72, 0x6d, 0x77, 0x61,
+	0x72, 0x65, 0x52, 0x65, 0x76, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x66, 0x69, 0x72,
+	0x6d, 0x77, 0x61, 0x72, 0x65, 0x52, 0x65, 0x76, 0x22, 0xf2, 0x01, 0x0a, 0x14, 0x53, 0x63, 0x6d,
 	0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73,
-	0x70, 0x52, 0x0a, 0x73, 0x63, 0x6d, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x3c, 0x0a,
-	0x0b, 0x6e, 0x76, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03,
-	0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x4e, 0x76, 0x6d, 0x65, 0x46, 0x69, 0x72,
-	0x6d, 0x77, 0x61, 0x72, 0x65, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x52, 0x0b,
-	0x6e, 0x76, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0xe9, 0x01, 0x0a, 0x11,
-	0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65,
-	0x71, 0x12, 0x22, 0x0a, 0x0c, 0x66, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x50, 0x61, 0x74,
-	0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x66, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72,
-	0x65, 0x50, 0x61, 0x74, 0x68, 0x12, 0x35, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20,
-	0x01, 0x28, 0x0e, 0x32, 0x21, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61,
-	0x72, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x2e, 0x44, 0x65, 0x76, 0x69,
-	0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x1c, 0x0a, 0x09,
-	0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x44, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52,
-	0x09, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x44, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x6f,
-	0x64, 0x65, 0x6c, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64,
-	0x65, 0x6c, 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x66, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65,
-	0x52, 0x65, 0x76, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x66, 0x69, 0x72, 0x6d, 0x77,
-	0x61, 0x72, 0x65, 0x52, 0x65, 0x76, 0x22, 0x1f, 0x0a, 0x0a, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65,
-	0x54, 0x79, 0x70, 0x65, 0x12, 0x07, 0x0a, 0x03, 0x53, 0x43, 0x4d, 0x10, 0x00, 0x12, 0x08, 0x0a,
-	0x04, 0x4e, 0x56, 0x4d, 0x65, 0x10, 0x01, 0x22, 0x55, 0x0a, 0x15, 0x53, 0x63, 0x6d, 0x46, 0x69,
-	0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70,
-	0x12, 0x26, 0x0a, 0x06, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x0e, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x63, 0x6d, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65,
-	0x52, 0x06, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f,
-	0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x48,
-	0x0a, 0x16, 0x4e, 0x76, 0x6d, 0x65, 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x55, 0x70,
-	0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x63, 0x69, 0x41,
-	0x64, 0x64, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x63, 0x69, 0x41, 0x64,
-	0x64, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x8f, 0x01, 0x0a, 0x12, 0x46, 0x69, 0x72,
+	0x70, 0x12, 0x26, 0x0a, 0x06, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x0e, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x63, 0x6d, 0x4d, 0x6f, 0x64, 0x75, 0x6c,
+	0x65, 0x52, 0x06, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x12, 0x24, 0x0a, 0x0d, 0x61, 0x63, 0x74,
+	0x69, 0x76, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0d, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12,
+	0x24, 0x0a, 0x0d, 0x73, 0x74, 0x61, 0x67, 0x65, 0x64, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x73, 0x74, 0x61, 0x67, 0x65, 0x64, 0x56, 0x65,
+	0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x2c, 0x0a, 0x11, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x4d, 0x61,
+	0x78, 0x53, 0x69, 0x7a, 0x65, 0x42, 0x79, 0x74, 0x65, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d,
+	0x52, 0x11, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x4d, 0x61, 0x78, 0x53, 0x69, 0x7a, 0x65, 0x42, 0x79,
+	0x74, 0x65, 0x73, 0x12, 0x22, 0x0a, 0x0c, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x74, 0x61,
+	0x74, 0x75, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x75, 0x70, 0x64, 0x61, 0x74,
+	0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72,
+	0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x44, 0x0a,
+	0x15, 0x4e, 0x76, 0x6d, 0x65, 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x12, 0x2b, 0x0a, 0x06, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x4e, 0x76, 0x6d,
+	0x65, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x52, 0x06, 0x64, 0x65, 0x76,
+	0x69, 0x63, 0x65, 0x22, 0x8c, 0x01, 0x0a, 0x11, 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x12, 0x39, 0x0a, 0x0a, 0x73, 0x63, 0x6d,
+	0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e,
+	0x63, 0x74, 0x6c, 0x2e, 0x53, 0x63, 0x6d, 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x52, 0x0a, 0x73, 0x63, 0x6d, 0x52, 0x65, 0x73,
+	0x75, 0x6c, 0x74, 0x73, 0x12, 0x3c, 0x0a, 0x0b, 0x6e, 0x76, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x75,
+	0x6c, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x63, 0x74, 0x6c, 0x2e,
+	0x4e, 0x76, 0x6d, 0x65, 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x52, 0x65, 0x73, 0x70, 0x52, 0x0b, 0x6e, 0x76, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c,
+	0x74, 0x73, 0x22, 0xe9, 0x01, 0x0a, 0x11, 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x55,
+	0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x12, 0x22, 0x0a, 0x0c, 0x66, 0x69, 0x72, 0x6d,
+	0x77, 0x61, 0x72, 0x65, 0x50, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c,
+	0x66, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x50, 0x61, 0x74, 0x68, 0x12, 0x35, 0x0a, 0x04,
+	0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x21, 0x2e, 0x63, 0x74, 0x6c,
+	0x2e, 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52,
+	0x65, 0x71, 0x2e, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74,
+	0x79, 0x70, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x44, 0x73,
+	0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x44,
+	0x73, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x66,
+	0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x52, 0x65, 0x76, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0b, 0x66, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x52, 0x65, 0x76, 0x22, 0x1f, 0x0a,
+	0x0a, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x07, 0x0a, 0x03, 0x53,
+	0x43, 0x4d, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x4e, 0x56, 0x4d, 0x65, 0x10, 0x01, 0x22, 0x55,
+	0x0a, 0x15, 0x53, 0x63, 0x6d, 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x55, 0x70, 0x64,
+	0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x26, 0x0a, 0x06, 0x6d, 0x6f, 0x64, 0x75, 0x6c,
+	0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x63,
+	0x6d, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x52, 0x06, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x12,
+	0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05,
+	0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x48, 0x0a, 0x16, 0x4e, 0x76, 0x6d, 0x65, 0x46, 0x69, 0x72,
 	0x6d, 0x77, 0x61, 0x72, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12,
-	0x3a, 0x0a, 0x0a, 0x73, 0x63, 0x6d, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20,
-	0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x63, 0x6d, 0x46, 0x69, 0x72,
-	0x6d, 0x77, 0x61, 0x72, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x52,
-	0x0a, 0x73, 0x63, 0x6d, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x3d, 0x0a, 0x0b, 0x6e,
-	0x76, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b,
-	0x32, 0x1b, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x4e, 0x76, 0x6d, 0x65, 0x46, 0x69, 0x72, 0x6d, 0x77,
-	0x61, 0x72, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x52, 0x0b, 0x6e,
-	0x76, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x39, 0x5a, 0x37, 0x67, 0x69,
-	0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x61, 0x6f, 0x73, 0x2d, 0x73, 0x74,
-	0x61, 0x63, 0x6b, 0x2f, 0x64, 0x61, 0x6f, 0x73, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x63, 0x6f, 0x6e,
-	0x74, 0x72, 0x6f, 0x6c, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x2f, 0x63, 0x74, 0x6c, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x18, 0x0a, 0x07, 0x70, 0x63, 0x69, 0x41, 0x64, 0x64, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x07, 0x70, 0x63, 0x69, 0x41, 0x64, 0x64, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72,
+	0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22,
+	0x8f, 0x01, 0x0a, 0x12, 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x55, 0x70, 0x64, 0x61,
+	0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x3a, 0x0a, 0x0a, 0x73, 0x63, 0x6d, 0x52, 0x65, 0x73,
+	0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x63, 0x74, 0x6c,
+	0x2e, 0x53, 0x63, 0x6d, 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x55, 0x70, 0x64, 0x61,
+	0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x52, 0x0a, 0x73, 0x63, 0x6d, 0x52, 0x65, 0x73, 0x75, 0x6c,
+	0x74, 0x73, 0x12, 0x3d, 0x0a, 0x0b, 0x6e, 0x76, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74,
+	0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x4e, 0x76,
+	0x6d, 0x65, 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65,
+	0x52, 0x65, 0x73, 0x70, 0x52, 0x0b, 0x6e, 0x76, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74,
+	0x73, 0x42, 0x39, 0x5a, 0x37, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f,
+	0x64, 0x61, 0x6f, 0x73, 0x2d, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x2f, 0x64, 0x61, 0x6f, 0x73, 0x2f,
+	0x73, 0x72, 0x63, 0x2f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x2f, 0x63, 0x6f, 0x6d, 0x6d,
+	0x6f, 0x6e, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x74, 0x6c, 0x62, 0x06, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -720,7 +720,7 @@ func file_ctl_firmware_proto_init() {
 		return
 	}
 	file_ctl_storage_scm_proto_init()
-	file_ctl_storage_nvme_proto_init()
+	file_ctl_smd_proto_init()
 	if !protoimpl.UnsafeEnabled {
 		file_ctl_firmware_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*FirmwareQueryReq); i {
diff --git a/src/control/common/proto/ctl/smd.pb.go b/src/control/common/proto/ctl/smd.pb.go
index 87d30921fca..176c1294735 100644
--- a/src/control/common/proto/ctl/smd.pb.go
+++ b/src/control/common/proto/ctl/smd.pb.go
@@ -654,32 +654,28 @@ func (x *BioHealthResp) GetRdbWalSize() uint64 {
 	return 0
 }
 
-// SmdDevice represents a DAOS BIO device, identified by a UUID written into a label stored on a
-// SPDK blobstore created on a NVMe namespace. Multiple SmdDevices may exist per NVMe controller.
-type SmdDevice struct {
+// NvmeController represents an NVMe Controller (SSD).
+type NvmeController struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Uuid        string       `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`                                                // UUID of blobstore
-	TgtIds      []int32      `protobuf:"varint,2,rep,packed,name=tgt_ids,json=tgtIds,proto3" json:"tgt_ids,omitempty"`                      // VOS target IDs
-	TrAddr      string       `protobuf:"bytes,3,opt,name=tr_addr,json=trAddr,proto3" json:"tr_addr,omitempty"`                              // Transport address of blobstore
-	DevState    NvmeDevState `protobuf:"varint,4,opt,name=dev_state,json=devState,proto3,enum=ctl.NvmeDevState" json:"dev_state,omitempty"` // NVMe device state
-	LedState    LedState     `protobuf:"varint,5,opt,name=led_state,json=ledState,proto3,enum=ctl.LedState" json:"led_state,omitempty"`     // LED state
-	TotalBytes  uint64       `protobuf:"varint,6,opt,name=total_bytes,json=totalBytes,proto3" json:"total_bytes,omitempty"`                 // blobstore clusters total bytes
-	AvailBytes  uint64       `protobuf:"varint,7,opt,name=avail_bytes,json=availBytes,proto3" json:"avail_bytes,omitempty"`                 // Available RAW storage for data
-	ClusterSize uint64       `protobuf:"varint,8,opt,name=cluster_size,json=clusterSize,proto3" json:"cluster_size,omitempty"`              // blobstore cluster size in bytes
-	Rank        uint32       `protobuf:"varint,9,opt,name=rank,proto3" json:"rank,omitempty"`                                               // DAOS I/O Engine using controller
-	RoleBits    uint32       `protobuf:"varint,10,opt,name=role_bits,json=roleBits,proto3" json:"role_bits,omitempty"`                      // Device active roles (bitmask)
-	MetaSize    uint64       `protobuf:"varint,11,opt,name=meta_size,json=metaSize,proto3" json:"meta_size,omitempty"`                      // Size of the metadata (i.e. vos file index) blob
-	MetaWalSize uint64       `protobuf:"varint,12,opt,name=meta_wal_size,json=metaWalSize,proto3" json:"meta_wal_size,omitempty"`           // Size of the metadata WAL blob
-	RdbSize     uint64       `protobuf:"varint,13,opt,name=rdb_size,json=rdbSize,proto3" json:"rdb_size,omitempty"`                         // Size of the RDB blob
-	RdbWalSize  uint64       `protobuf:"varint,14,opt,name=rdb_wal_size,json=rdbWalSize,proto3" json:"rdb_wal_size,omitempty"`              // Size of the RDB WAL blob
-	UsableBytes uint64       `protobuf:"varint,15,opt,name=usable_bytes,json=usableBytes,proto3" json:"usable_bytes,omitempty"`             // Effective storage available for data
-}
-
-func (x *SmdDevice) Reset() {
-	*x = SmdDevice{}
+	Model       string                      `protobuf:"bytes,1,opt,name=model,proto3" json:"model,omitempty"`                                              // model name
+	Serial      string                      `protobuf:"bytes,2,opt,name=serial,proto3" json:"serial,omitempty"`                                            // serial number
+	PciAddr     string                      `protobuf:"bytes,3,opt,name=pci_addr,json=pciAddr,proto3" json:"pci_addr,omitempty"`                           // pci address
+	FwRev       string                      `protobuf:"bytes,4,opt,name=fw_rev,json=fwRev,proto3" json:"fw_rev,omitempty"`                                 // firmware revision
+	SocketId    int32                       `protobuf:"varint,5,opt,name=socket_id,json=socketId,proto3" json:"socket_id,omitempty"`                       // NUMA socket ID
+	HealthStats *BioHealthResp              `protobuf:"bytes,6,opt,name=health_stats,json=healthStats,proto3" json:"health_stats,omitempty"`               // controller's health stats
+	Namespaces  []*NvmeController_Namespace `protobuf:"bytes,7,rep,name=namespaces,proto3" json:"namespaces,omitempty"`                                    // controller's namespaces
+	SmdDevices  []*SmdDevice                `protobuf:"bytes,8,rep,name=smd_devices,json=smdDevices,proto3" json:"smd_devices,omitempty"`                  // controller's blobstores
+	DevState    NvmeDevState                `protobuf:"varint,9,opt,name=dev_state,json=devState,proto3,enum=ctl.NvmeDevState" json:"dev_state,omitempty"` // NVMe device operational state
+	LedState    LedState                    `protobuf:"varint,10,opt,name=led_state,json=ledState,proto3,enum=ctl.LedState" json:"led_state,omitempty"`    // NVMe device LED state
+	PciDevType  string                      `protobuf:"bytes,11,opt,name=pci_dev_type,json=pciDevType,proto3" json:"pci_dev_type,omitempty"`               // PCI device type, vmd or pci
+	VendorId    string                      `protobuf:"bytes,12,opt,name=vendor_id,json=vendorId,proto3" json:"vendor_id,omitempty"`                       // controller's vendor ID
+}
+
+func (x *NvmeController) Reset() {
+	*x = NvmeController{}
 	if protoimpl.UnsafeEnabled {
 		mi := &file_ctl_smd_proto_msgTypes[2]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -687,13 +683,13 @@ func (x *SmdDevice) Reset() {
 	}
 }
 
-func (x *SmdDevice) String() string {
+func (x *NvmeController) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*SmdDevice) ProtoMessage() {}
+func (*NvmeController) ProtoMessage() {}
 
-func (x *SmdDevice) ProtoReflect() protoreflect.Message {
+func (x *NvmeController) ProtoReflect() protoreflect.Message {
 	mi := &file_ctl_smd_proto_msgTypes[2]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -705,46 +701,164 @@ func (x *SmdDevice) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use SmdDevice.ProtoReflect.Descriptor instead.
-func (*SmdDevice) Descriptor() ([]byte, []int) {
+// Deprecated: Use NvmeController.ProtoReflect.Descriptor instead.
+func (*NvmeController) Descriptor() ([]byte, []int) {
 	return file_ctl_smd_proto_rawDescGZIP(), []int{2}
 }
 
-func (x *SmdDevice) GetUuid() string {
+func (x *NvmeController) GetModel() string {
 	if x != nil {
-		return x.Uuid
+		return x.Model
 	}
 	return ""
 }
 
-func (x *SmdDevice) GetTgtIds() []int32 {
+func (x *NvmeController) GetSerial() string {
 	if x != nil {
-		return x.TgtIds
+		return x.Serial
 	}
-	return nil
+	return ""
 }
 
-func (x *SmdDevice) GetTrAddr() string {
+func (x *NvmeController) GetPciAddr() string {
 	if x != nil {
-		return x.TrAddr
+		return x.PciAddr
 	}
 	return ""
 }
 
-func (x *SmdDevice) GetDevState() NvmeDevState {
+func (x *NvmeController) GetFwRev() string {
+	if x != nil {
+		return x.FwRev
+	}
+	return ""
+}
+
+func (x *NvmeController) GetSocketId() int32 {
+	if x != nil {
+		return x.SocketId
+	}
+	return 0
+}
+
+func (x *NvmeController) GetHealthStats() *BioHealthResp {
+	if x != nil {
+		return x.HealthStats
+	}
+	return nil
+}
+
+func (x *NvmeController) GetNamespaces() []*NvmeController_Namespace {
+	if x != nil {
+		return x.Namespaces
+	}
+	return nil
+}
+
+func (x *NvmeController) GetSmdDevices() []*SmdDevice {
+	if x != nil {
+		return x.SmdDevices
+	}
+	return nil
+}
+
+func (x *NvmeController) GetDevState() NvmeDevState {
 	if x != nil {
 		return x.DevState
 	}
 	return NvmeDevState_UNKNOWN
 }
 
-func (x *SmdDevice) GetLedState() LedState {
+func (x *NvmeController) GetLedState() LedState {
 	if x != nil {
 		return x.LedState
 	}
 	return LedState_OFF
 }
 
+func (x *NvmeController) GetPciDevType() string {
+	if x != nil {
+		return x.PciDevType
+	}
+	return ""
+}
+
+func (x *NvmeController) GetVendorId() string {
+	if x != nil {
+		return x.VendorId
+	}
+	return ""
+}
+
+// SmdDevice represents a DAOS BIO device, identified by a UUID written into a label stored on a
+// SPDK blobstore created on a NVMe namespace. Multiple SmdDevices may exist per NVMe controller.
+type SmdDevice struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Uuid             string          `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`                                                     // UUID of blobstore
+	TgtIds           []int32         `protobuf:"varint,2,rep,packed,name=tgt_ids,json=tgtIds,proto3" json:"tgt_ids,omitempty"`                           // VOS target IDs
+	TotalBytes       uint64          `protobuf:"varint,6,opt,name=total_bytes,json=totalBytes,proto3" json:"total_bytes,omitempty"`                      // blobstore clusters total bytes
+	AvailBytes       uint64          `protobuf:"varint,7,opt,name=avail_bytes,json=availBytes,proto3" json:"avail_bytes,omitempty"`                      // Available RAW storage for data
+	ClusterSize      uint64          `protobuf:"varint,8,opt,name=cluster_size,json=clusterSize,proto3" json:"cluster_size,omitempty"`                   // blobstore cluster size in bytes
+	Rank             uint32          `protobuf:"varint,9,opt,name=rank,proto3" json:"rank,omitempty"`                                                    // DAOS I/O Engine using controller
+	RoleBits         uint32          `protobuf:"varint,10,opt,name=role_bits,json=roleBits,proto3" json:"role_bits,omitempty"`                           // Device active roles (bitmask)
+	MetaSize         uint64          `protobuf:"varint,11,opt,name=meta_size,json=metaSize,proto3" json:"meta_size,omitempty"`                           // Size of the metadata (i.e. vos file index) blob
+	MetaWalSize      uint64          `protobuf:"varint,12,opt,name=meta_wal_size,json=metaWalSize,proto3" json:"meta_wal_size,omitempty"`                // Size of the metadata WAL blob
+	RdbSize          uint64          `protobuf:"varint,13,opt,name=rdb_size,json=rdbSize,proto3" json:"rdb_size,omitempty"`                              // Size of the RDB blob
+	RdbWalSize       uint64          `protobuf:"varint,14,opt,name=rdb_wal_size,json=rdbWalSize,proto3" json:"rdb_wal_size,omitempty"`                   // Size of the RDB WAL blob
+	UsableBytes      uint64          `protobuf:"varint,15,opt,name=usable_bytes,json=usableBytes,proto3" json:"usable_bytes,omitempty"`                  // Effective storage available for data
+	Ctrlr            *NvmeController `protobuf:"bytes,16,opt,name=ctrlr,proto3" json:"ctrlr,omitempty"`                                                  // Backing NVMe controller of SMD device
+	CtrlrNamespaceId uint32          `protobuf:"varint,17,opt,name=ctrlr_namespace_id,json=ctrlrNamespaceId,proto3" json:"ctrlr_namespace_id,omitempty"` // NVMe namespace id hosting SMD blobstore
+}
+
+func (x *SmdDevice) Reset() {
+	*x = SmdDevice{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_ctl_smd_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *SmdDevice) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SmdDevice) ProtoMessage() {}
+
+func (x *SmdDevice) ProtoReflect() protoreflect.Message {
+	mi := &file_ctl_smd_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SmdDevice.ProtoReflect.Descriptor instead.
+func (*SmdDevice) Descriptor() ([]byte, []int) {
+	return file_ctl_smd_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *SmdDevice) GetUuid() string {
+	if x != nil {
+		return x.Uuid
+	}
+	return ""
+}
+
+func (x *SmdDevice) GetTgtIds() []int32 {
+	if x != nil {
+		return x.TgtIds
+	}
+	return nil
+}
+
 func (x *SmdDevice) GetTotalBytes() uint64 {
 	if x != nil {
 		return x.TotalBytes
@@ -815,6 +929,20 @@ func (x *SmdDevice) GetUsableBytes() uint64 {
 	return 0
 }
 
+func (x *SmdDevice) GetCtrlr() *NvmeController {
+	if x != nil {
+		return x.Ctrlr
+	}
+	return nil
+}
+
+func (x *SmdDevice) GetCtrlrNamespaceId() uint32 {
+	if x != nil {
+		return x.CtrlrNamespaceId
+	}
+	return 0
+}
+
 type SmdDevReq struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -824,7 +952,7 @@ type SmdDevReq struct {
 func (x *SmdDevReq) Reset() {
 	*x = SmdDevReq{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_smd_proto_msgTypes[3]
+		mi := &file_ctl_smd_proto_msgTypes[4]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -837,7 +965,7 @@ func (x *SmdDevReq) String() string {
 func (*SmdDevReq) ProtoMessage() {}
 
 func (x *SmdDevReq) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_smd_proto_msgTypes[3]
+	mi := &file_ctl_smd_proto_msgTypes[4]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -850,7 +978,7 @@ func (x *SmdDevReq) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SmdDevReq.ProtoReflect.Descriptor instead.
 func (*SmdDevReq) Descriptor() ([]byte, []int) {
-	return file_ctl_smd_proto_rawDescGZIP(), []int{3}
+	return file_ctl_smd_proto_rawDescGZIP(), []int{4}
 }
 
 type SmdDevResp struct {
@@ -865,7 +993,7 @@ type SmdDevResp struct {
 func (x *SmdDevResp) Reset() {
 	*x = SmdDevResp{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_smd_proto_msgTypes[4]
+		mi := &file_ctl_smd_proto_msgTypes[5]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -878,7 +1006,7 @@ func (x *SmdDevResp) String() string {
 func (*SmdDevResp) ProtoMessage() {}
 
 func (x *SmdDevResp) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_smd_proto_msgTypes[4]
+	mi := &file_ctl_smd_proto_msgTypes[5]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -891,7 +1019,7 @@ func (x *SmdDevResp) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SmdDevResp.ProtoReflect.Descriptor instead.
 func (*SmdDevResp) Descriptor() ([]byte, []int) {
-	return file_ctl_smd_proto_rawDescGZIP(), []int{4}
+	return file_ctl_smd_proto_rawDescGZIP(), []int{5}
 }
 
 func (x *SmdDevResp) GetStatus() int32 {
@@ -917,7 +1045,7 @@ type SmdPoolReq struct {
 func (x *SmdPoolReq) Reset() {
 	*x = SmdPoolReq{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_smd_proto_msgTypes[5]
+		mi := &file_ctl_smd_proto_msgTypes[6]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -930,7 +1058,7 @@ func (x *SmdPoolReq) String() string {
 func (*SmdPoolReq) ProtoMessage() {}
 
 func (x *SmdPoolReq) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_smd_proto_msgTypes[5]
+	mi := &file_ctl_smd_proto_msgTypes[6]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -943,7 +1071,7 @@ func (x *SmdPoolReq) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SmdPoolReq.ProtoReflect.Descriptor instead.
 func (*SmdPoolReq) Descriptor() ([]byte, []int) {
-	return file_ctl_smd_proto_rawDescGZIP(), []int{5}
+	return file_ctl_smd_proto_rawDescGZIP(), []int{6}
 }
 
 type SmdPoolResp struct {
@@ -958,7 +1086,7 @@ type SmdPoolResp struct {
 func (x *SmdPoolResp) Reset() {
 	*x = SmdPoolResp{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_smd_proto_msgTypes[6]
+		mi := &file_ctl_smd_proto_msgTypes[7]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -971,7 +1099,7 @@ func (x *SmdPoolResp) String() string {
 func (*SmdPoolResp) ProtoMessage() {}
 
 func (x *SmdPoolResp) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_smd_proto_msgTypes[6]
+	mi := &file_ctl_smd_proto_msgTypes[7]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -984,7 +1112,7 @@ func (x *SmdPoolResp) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SmdPoolResp.ProtoReflect.Descriptor instead.
 func (*SmdPoolResp) Descriptor() ([]byte, []int) {
-	return file_ctl_smd_proto_rawDescGZIP(), []int{6}
+	return file_ctl_smd_proto_rawDescGZIP(), []int{7}
 }
 
 func (x *SmdPoolResp) GetStatus() int32 {
@@ -1016,7 +1144,7 @@ type SmdQueryReq struct {
 func (x *SmdQueryReq) Reset() {
 	*x = SmdQueryReq{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_smd_proto_msgTypes[7]
+		mi := &file_ctl_smd_proto_msgTypes[8]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1029,7 +1157,7 @@ func (x *SmdQueryReq) String() string {
 func (*SmdQueryReq) ProtoMessage() {}
 
 func (x *SmdQueryReq) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_smd_proto_msgTypes[7]
+	mi := &file_ctl_smd_proto_msgTypes[8]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1042,7 +1170,7 @@ func (x *SmdQueryReq) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SmdQueryReq.ProtoReflect.Descriptor instead.
 func (*SmdQueryReq) Descriptor() ([]byte, []int) {
-	return file_ctl_smd_proto_rawDescGZIP(), []int{7}
+	return file_ctl_smd_proto_rawDescGZIP(), []int{8}
 }
 
 func (x *SmdQueryReq) GetOmitDevices() bool {
@@ -1092,7 +1220,7 @@ type SmdQueryResp struct {
 func (x *SmdQueryResp) Reset() {
 	*x = SmdQueryResp{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_smd_proto_msgTypes[8]
+		mi := &file_ctl_smd_proto_msgTypes[9]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1105,7 +1233,7 @@ func (x *SmdQueryResp) String() string {
 func (*SmdQueryResp) ProtoMessage() {}
 
 func (x *SmdQueryResp) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_smd_proto_msgTypes[8]
+	mi := &file_ctl_smd_proto_msgTypes[9]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1118,7 +1246,7 @@ func (x *SmdQueryResp) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SmdQueryResp.ProtoReflect.Descriptor instead.
 func (*SmdQueryResp) Descriptor() ([]byte, []int) {
-	return file_ctl_smd_proto_rawDescGZIP(), []int{8}
+	return file_ctl_smd_proto_rawDescGZIP(), []int{9}
 }
 
 func (x *SmdQueryResp) GetStatus() int32 {
@@ -1149,7 +1277,7 @@ type LedManageReq struct {
 func (x *LedManageReq) Reset() {
 	*x = LedManageReq{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_smd_proto_msgTypes[9]
+		mi := &file_ctl_smd_proto_msgTypes[10]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1162,7 +1290,7 @@ func (x *LedManageReq) String() string {
 func (*LedManageReq) ProtoMessage() {}
 
 func (x *LedManageReq) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_smd_proto_msgTypes[9]
+	mi := &file_ctl_smd_proto_msgTypes[10]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1175,7 +1303,7 @@ func (x *LedManageReq) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use LedManageReq.ProtoReflect.Descriptor instead.
 func (*LedManageReq) Descriptor() ([]byte, []int) {
-	return file_ctl_smd_proto_rawDescGZIP(), []int{9}
+	return file_ctl_smd_proto_rawDescGZIP(), []int{10}
 }
 
 func (x *LedManageReq) GetIds() string {
@@ -1219,7 +1347,7 @@ type DevReplaceReq struct {
 func (x *DevReplaceReq) Reset() {
 	*x = DevReplaceReq{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_smd_proto_msgTypes[10]
+		mi := &file_ctl_smd_proto_msgTypes[11]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1232,7 +1360,7 @@ func (x *DevReplaceReq) String() string {
 func (*DevReplaceReq) ProtoMessage() {}
 
 func (x *DevReplaceReq) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_smd_proto_msgTypes[10]
+	mi := &file_ctl_smd_proto_msgTypes[11]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1245,7 +1373,7 @@ func (x *DevReplaceReq) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use DevReplaceReq.ProtoReflect.Descriptor instead.
 func (*DevReplaceReq) Descriptor() ([]byte, []int) {
-	return file_ctl_smd_proto_rawDescGZIP(), []int{10}
+	return file_ctl_smd_proto_rawDescGZIP(), []int{11}
 }
 
 func (x *DevReplaceReq) GetOldDevUuid() string {
@@ -1280,7 +1408,7 @@ type SetFaultyReq struct {
 func (x *SetFaultyReq) Reset() {
 	*x = SetFaultyReq{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_smd_proto_msgTypes[11]
+		mi := &file_ctl_smd_proto_msgTypes[12]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1293,7 +1421,7 @@ func (x *SetFaultyReq) String() string {
 func (*SetFaultyReq) ProtoMessage() {}
 
 func (x *SetFaultyReq) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_smd_proto_msgTypes[11]
+	mi := &file_ctl_smd_proto_msgTypes[12]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1306,7 +1434,7 @@ func (x *SetFaultyReq) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SetFaultyReq.ProtoReflect.Descriptor instead.
 func (*SetFaultyReq) Descriptor() ([]byte, []int) {
-	return file_ctl_smd_proto_rawDescGZIP(), []int{11}
+	return file_ctl_smd_proto_rawDescGZIP(), []int{12}
 }
 
 func (x *SetFaultyReq) GetUuid() string {
@@ -1328,7 +1456,7 @@ type DevManageResp struct {
 func (x *DevManageResp) Reset() {
 	*x = DevManageResp{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_smd_proto_msgTypes[12]
+		mi := &file_ctl_smd_proto_msgTypes[13]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1341,7 +1469,7 @@ func (x *DevManageResp) String() string {
 func (*DevManageResp) ProtoMessage() {}
 
 func (x *DevManageResp) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_smd_proto_msgTypes[12]
+	mi := &file_ctl_smd_proto_msgTypes[13]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1354,7 +1482,7 @@ func (x *DevManageResp) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use DevManageResp.ProtoReflect.Descriptor instead.
 func (*DevManageResp) Descriptor() ([]byte, []int) {
-	return file_ctl_smd_proto_rawDescGZIP(), []int{12}
+	return file_ctl_smd_proto_rawDescGZIP(), []int{13}
 }
 
 func (x *DevManageResp) GetStatus() int32 {
@@ -1387,7 +1515,7 @@ type SmdManageReq struct {
 func (x *SmdManageReq) Reset() {
 	*x = SmdManageReq{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_smd_proto_msgTypes[13]
+		mi := &file_ctl_smd_proto_msgTypes[14]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1400,7 +1528,7 @@ func (x *SmdManageReq) String() string {
 func (*SmdManageReq) ProtoMessage() {}
 
 func (x *SmdManageReq) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_smd_proto_msgTypes[13]
+	mi := &file_ctl_smd_proto_msgTypes[14]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1413,7 +1541,7 @@ func (x *SmdManageReq) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SmdManageReq.ProtoReflect.Descriptor instead.
 func (*SmdManageReq) Descriptor() ([]byte, []int) {
-	return file_ctl_smd_proto_rawDescGZIP(), []int{13}
+	return file_ctl_smd_proto_rawDescGZIP(), []int{14}
 }
 
 func (m *SmdManageReq) GetOp() isSmdManageReq_Op {
@@ -1477,7 +1605,7 @@ type SmdManageResp struct {
 func (x *SmdManageResp) Reset() {
 	*x = SmdManageResp{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_smd_proto_msgTypes[14]
+		mi := &file_ctl_smd_proto_msgTypes[15]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1490,7 +1618,7 @@ func (x *SmdManageResp) String() string {
 func (*SmdManageResp) ProtoMessage() {}
 
 func (x *SmdManageResp) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_smd_proto_msgTypes[14]
+	mi := &file_ctl_smd_proto_msgTypes[15]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1503,7 +1631,7 @@ func (x *SmdManageResp) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SmdManageResp.ProtoReflect.Descriptor instead.
 func (*SmdManageResp) Descriptor() ([]byte, []int) {
-	return file_ctl_smd_proto_rawDescGZIP(), []int{14}
+	return file_ctl_smd_proto_rawDescGZIP(), []int{15}
 }
 
 func (x *SmdManageResp) GetRanks() []*SmdManageResp_RankResp {
@@ -1513,33 +1641,34 @@ func (x *SmdManageResp) GetRanks() []*SmdManageResp_RankResp {
 	return nil
 }
 
-type SmdPoolResp_Pool struct {
+// Namespace represents a namespace created on an NvmeController.
+type NvmeController_Namespace struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Uuid   string   `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`                           // UUID of VOS pool
-	TgtIds []int32  `protobuf:"varint,2,rep,packed,name=tgt_ids,json=tgtIds,proto3" json:"tgt_ids,omitempty"` // VOS target IDs
-	Blobs  []uint64 `protobuf:"varint,3,rep,packed,name=blobs,proto3" json:"blobs,omitempty"`                 // SPDK blobs
+	Id           uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`                                          // namespace id
+	Size         uint64 `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`                                      // device capacity in bytes
+	CtrlrPciAddr string `protobuf:"bytes,3,opt,name=ctrlr_pci_addr,json=ctrlrPciAddr,proto3" json:"ctrlr_pci_addr,omitempty"` // parent controller PCI address
 }
 
-func (x *SmdPoolResp_Pool) Reset() {
-	*x = SmdPoolResp_Pool{}
+func (x *NvmeController_Namespace) Reset() {
+	*x = NvmeController_Namespace{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_smd_proto_msgTypes[15]
+		mi := &file_ctl_smd_proto_msgTypes[16]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *SmdPoolResp_Pool) String() string {
+func (x *NvmeController_Namespace) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*SmdPoolResp_Pool) ProtoMessage() {}
+func (*NvmeController_Namespace) ProtoMessage() {}
 
-func (x *SmdPoolResp_Pool) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_smd_proto_msgTypes[15]
+func (x *NvmeController_Namespace) ProtoReflect() protoreflect.Message {
+	mi := &file_ctl_smd_proto_msgTypes[16]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1550,58 +1679,59 @@ func (x *SmdPoolResp_Pool) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use SmdPoolResp_Pool.ProtoReflect.Descriptor instead.
-func (*SmdPoolResp_Pool) Descriptor() ([]byte, []int) {
-	return file_ctl_smd_proto_rawDescGZIP(), []int{6, 0}
+// Deprecated: Use NvmeController_Namespace.ProtoReflect.Descriptor instead.
+func (*NvmeController_Namespace) Descriptor() ([]byte, []int) {
+	return file_ctl_smd_proto_rawDescGZIP(), []int{2, 0}
 }
 
-func (x *SmdPoolResp_Pool) GetUuid() string {
+func (x *NvmeController_Namespace) GetId() uint32 {
 	if x != nil {
-		return x.Uuid
+		return x.Id
 	}
-	return ""
+	return 0
 }
 
-func (x *SmdPoolResp_Pool) GetTgtIds() []int32 {
+func (x *NvmeController_Namespace) GetSize() uint64 {
 	if x != nil {
-		return x.TgtIds
+		return x.Size
 	}
-	return nil
+	return 0
 }
 
-func (x *SmdPoolResp_Pool) GetBlobs() []uint64 {
+func (x *NvmeController_Namespace) GetCtrlrPciAddr() string {
 	if x != nil {
-		return x.Blobs
+		return x.CtrlrPciAddr
 	}
-	return nil
+	return ""
 }
 
-type SmdQueryResp_SmdDeviceWithHealth struct {
+type SmdPoolResp_Pool struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Details *SmdDevice     `protobuf:"bytes,1,opt,name=details,proto3" json:"details,omitempty"`
-	Health  *BioHealthResp `protobuf:"bytes,2,opt,name=health,proto3" json:"health,omitempty"` // optional BIO health
+	Uuid   string   `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`                           // UUID of VOS pool
+	TgtIds []int32  `protobuf:"varint,2,rep,packed,name=tgt_ids,json=tgtIds,proto3" json:"tgt_ids,omitempty"` // VOS target IDs
+	Blobs  []uint64 `protobuf:"varint,3,rep,packed,name=blobs,proto3" json:"blobs,omitempty"`                 // SPDK blobs
 }
 
-func (x *SmdQueryResp_SmdDeviceWithHealth) Reset() {
-	*x = SmdQueryResp_SmdDeviceWithHealth{}
+func (x *SmdPoolResp_Pool) Reset() {
+	*x = SmdPoolResp_Pool{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_smd_proto_msgTypes[16]
+		mi := &file_ctl_smd_proto_msgTypes[17]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *SmdQueryResp_SmdDeviceWithHealth) String() string {
+func (x *SmdPoolResp_Pool) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*SmdQueryResp_SmdDeviceWithHealth) ProtoMessage() {}
+func (*SmdPoolResp_Pool) ProtoMessage() {}
 
-func (x *SmdQueryResp_SmdDeviceWithHealth) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_smd_proto_msgTypes[16]
+func (x *SmdPoolResp_Pool) ProtoReflect() protoreflect.Message {
+	mi := &file_ctl_smd_proto_msgTypes[17]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1612,21 +1742,28 @@ func (x *SmdQueryResp_SmdDeviceWithHealth) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use SmdQueryResp_SmdDeviceWithHealth.ProtoReflect.Descriptor instead.
-func (*SmdQueryResp_SmdDeviceWithHealth) Descriptor() ([]byte, []int) {
-	return file_ctl_smd_proto_rawDescGZIP(), []int{8, 0}
+// Deprecated: Use SmdPoolResp_Pool.ProtoReflect.Descriptor instead.
+func (*SmdPoolResp_Pool) Descriptor() ([]byte, []int) {
+	return file_ctl_smd_proto_rawDescGZIP(), []int{7, 0}
+}
+
+func (x *SmdPoolResp_Pool) GetUuid() string {
+	if x != nil {
+		return x.Uuid
+	}
+	return ""
 }
 
-func (x *SmdQueryResp_SmdDeviceWithHealth) GetDetails() *SmdDevice {
+func (x *SmdPoolResp_Pool) GetTgtIds() []int32 {
 	if x != nil {
-		return x.Details
+		return x.TgtIds
 	}
 	return nil
 }
 
-func (x *SmdQueryResp_SmdDeviceWithHealth) GetHealth() *BioHealthResp {
+func (x *SmdPoolResp_Pool) GetBlobs() []uint64 {
 	if x != nil {
-		return x.Health
+		return x.Blobs
 	}
 	return nil
 }
@@ -1644,7 +1781,7 @@ type SmdQueryResp_Pool struct {
 func (x *SmdQueryResp_Pool) Reset() {
 	*x = SmdQueryResp_Pool{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_smd_proto_msgTypes[17]
+		mi := &file_ctl_smd_proto_msgTypes[18]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1657,7 +1794,7 @@ func (x *SmdQueryResp_Pool) String() string {
 func (*SmdQueryResp_Pool) ProtoMessage() {}
 
 func (x *SmdQueryResp_Pool) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_smd_proto_msgTypes[17]
+	mi := &file_ctl_smd_proto_msgTypes[18]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1670,7 +1807,7 @@ func (x *SmdQueryResp_Pool) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SmdQueryResp_Pool.ProtoReflect.Descriptor instead.
 func (*SmdQueryResp_Pool) Descriptor() ([]byte, []int) {
-	return file_ctl_smd_proto_rawDescGZIP(), []int{8, 1}
+	return file_ctl_smd_proto_rawDescGZIP(), []int{9, 0}
 }
 
 func (x *SmdQueryResp_Pool) GetUuid() string {
@@ -1699,15 +1836,15 @@ type SmdQueryResp_RankResp struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Rank    uint32                              `protobuf:"varint,1,opt,name=rank,proto3" json:"rank,omitempty"`      // rank to which this response corresponds
-	Devices []*SmdQueryResp_SmdDeviceWithHealth `protobuf:"bytes,2,rep,name=devices,proto3" json:"devices,omitempty"` // List of devices on the rank
-	Pools   []*SmdQueryResp_Pool                `protobuf:"bytes,3,rep,name=pools,proto3" json:"pools,omitempty"`     // List of pools on the rank
+	Rank    uint32               `protobuf:"varint,1,opt,name=rank,proto3" json:"rank,omitempty"`      // rank to which this response corresponds
+	Devices []*SmdDevice         `protobuf:"bytes,2,rep,name=devices,proto3" json:"devices,omitempty"` // List of devices on the rank
+	Pools   []*SmdQueryResp_Pool `protobuf:"bytes,3,rep,name=pools,proto3" json:"pools,omitempty"`     // List of pools on the rank
 }
 
 func (x *SmdQueryResp_RankResp) Reset() {
 	*x = SmdQueryResp_RankResp{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_smd_proto_msgTypes[18]
+		mi := &file_ctl_smd_proto_msgTypes[19]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1720,7 +1857,7 @@ func (x *SmdQueryResp_RankResp) String() string {
 func (*SmdQueryResp_RankResp) ProtoMessage() {}
 
 func (x *SmdQueryResp_RankResp) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_smd_proto_msgTypes[18]
+	mi := &file_ctl_smd_proto_msgTypes[19]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1733,7 +1870,7 @@ func (x *SmdQueryResp_RankResp) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SmdQueryResp_RankResp.ProtoReflect.Descriptor instead.
 func (*SmdQueryResp_RankResp) Descriptor() ([]byte, []int) {
-	return file_ctl_smd_proto_rawDescGZIP(), []int{8, 2}
+	return file_ctl_smd_proto_rawDescGZIP(), []int{9, 1}
 }
 
 func (x *SmdQueryResp_RankResp) GetRank() uint32 {
@@ -1743,7 +1880,7 @@ func (x *SmdQueryResp_RankResp) GetRank() uint32 {
 	return 0
 }
 
-func (x *SmdQueryResp_RankResp) GetDevices() []*SmdQueryResp_SmdDeviceWithHealth {
+func (x *SmdQueryResp_RankResp) GetDevices() []*SmdDevice {
 	if x != nil {
 		return x.Devices
 	}
@@ -1769,7 +1906,7 @@ type SmdManageResp_Result struct {
 func (x *SmdManageResp_Result) Reset() {
 	*x = SmdManageResp_Result{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_smd_proto_msgTypes[19]
+		mi := &file_ctl_smd_proto_msgTypes[20]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1782,7 +1919,7 @@ func (x *SmdManageResp_Result) String() string {
 func (*SmdManageResp_Result) ProtoMessage() {}
 
 func (x *SmdManageResp_Result) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_smd_proto_msgTypes[19]
+	mi := &file_ctl_smd_proto_msgTypes[20]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1795,7 +1932,7 @@ func (x *SmdManageResp_Result) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SmdManageResp_Result.ProtoReflect.Descriptor instead.
 func (*SmdManageResp_Result) Descriptor() ([]byte, []int) {
-	return file_ctl_smd_proto_rawDescGZIP(), []int{14, 0}
+	return file_ctl_smd_proto_rawDescGZIP(), []int{15, 0}
 }
 
 func (x *SmdManageResp_Result) GetStatus() int32 {
@@ -1824,7 +1961,7 @@ type SmdManageResp_RankResp struct {
 func (x *SmdManageResp_RankResp) Reset() {
 	*x = SmdManageResp_RankResp{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_smd_proto_msgTypes[20]
+		mi := &file_ctl_smd_proto_msgTypes[21]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1837,7 +1974,7 @@ func (x *SmdManageResp_RankResp) String() string {
 func (*SmdManageResp_RankResp) ProtoMessage() {}
 
 func (x *SmdManageResp_RankResp) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_smd_proto_msgTypes[20]
+	mi := &file_ctl_smd_proto_msgTypes[21]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1850,7 +1987,7 @@ func (x *SmdManageResp_RankResp) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SmdManageResp_RankResp.ProtoReflect.Descriptor instead.
 func (*SmdManageResp_RankResp) Descriptor() ([]byte, []int) {
-	return file_ctl_smd_proto_rawDescGZIP(), []int{14, 1}
+	return file_ctl_smd_proto_rawDescGZIP(), []int{15, 1}
 }
 
 func (x *SmdManageResp_RankResp) GetRank() uint32 {
@@ -1995,156 +2132,181 @@ var file_ctl_smd_proto_rawDesc = []byte{
 	0x74, 0x61, 0x57, 0x61, 0x6c, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x20, 0x0a, 0x0c, 0x72, 0x64, 0x62,
 	0x5f, 0x77, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x30, 0x20, 0x01, 0x28, 0x04, 0x52,
 	0x0a, 0x72, 0x64, 0x62, 0x57, 0x61, 0x6c, 0x53, 0x69, 0x7a, 0x65, 0x4a, 0x04, 0x08, 0x01, 0x10,
-	0x02, 0x4a, 0x04, 0x08, 0x02, 0x10, 0x03, 0x22, 0xe4, 0x03, 0x0a, 0x09, 0x53, 0x6d, 0x64, 0x44,
-	0x65, 0x76, 0x69, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x75, 0x69, 0x64, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x75, 0x69, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x67, 0x74,
-	0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x05, 0x52, 0x06, 0x74, 0x67, 0x74, 0x49,
-	0x64, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x03, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x72, 0x41, 0x64, 0x64, 0x72, 0x12, 0x2e, 0x0a, 0x09, 0x64,
-	0x65, 0x76, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x11,
-	0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x4e, 0x76, 0x6d, 0x65, 0x44, 0x65, 0x76, 0x53, 0x74, 0x61, 0x74,
-	0x65, 0x52, 0x08, 0x64, 0x65, 0x76, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x2a, 0x0a, 0x09, 0x6c,
-	0x65, 0x64, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0d,
-	0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x4c, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x08, 0x6c,
-	0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c,
-	0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x74, 0x6f,
-	0x74, 0x61, 0x6c, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x76, 0x61, 0x69,
-	0x6c, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x61,
-	0x76, 0x61, 0x69, 0x6c, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6c, 0x75,
-	0x73, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52,
-	0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x12, 0x0a, 0x04,
-	0x72, 0x61, 0x6e, 0x6b, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x72, 0x61, 0x6e, 0x6b,
-	0x12, 0x1b, 0x0a, 0x09, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x62, 0x69, 0x74, 0x73, 0x18, 0x0a, 0x20,
-	0x01, 0x28, 0x0d, 0x52, 0x08, 0x72, 0x6f, 0x6c, 0x65, 0x42, 0x69, 0x74, 0x73, 0x12, 0x1b, 0x0a,
-	0x09, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x04,
-	0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x22, 0x0a, 0x0d, 0x6d, 0x65,
-	0x74, 0x61, 0x5f, 0x77, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28,
-	0x04, 0x52, 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x57, 0x61, 0x6c, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x19,
-	0x0a, 0x08, 0x72, 0x64, 0x62, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x04,
-	0x52, 0x07, 0x72, 0x64, 0x62, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x20, 0x0a, 0x0c, 0x72, 0x64, 0x62,
-	0x5f, 0x77, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x04, 0x52,
-	0x0a, 0x72, 0x64, 0x62, 0x57, 0x61, 0x6c, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x75,
-	0x73, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28,
-	0x04, 0x52, 0x0b, 0x75, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x42, 0x79, 0x74, 0x65, 0x73, 0x22, 0x0b,
-	0x0a, 0x09, 0x53, 0x6d, 0x64, 0x44, 0x65, 0x76, 0x52, 0x65, 0x71, 0x22, 0x4e, 0x0a, 0x0a, 0x53,
-	0x6d, 0x64, 0x44, 0x65, 0x76, 0x52, 0x65, 0x73, 0x70, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61,
-	0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75,
-	0x73, 0x12, 0x28, 0x0a, 0x07, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03,
-	0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x6d, 0x64, 0x44, 0x65, 0x76, 0x69,
-	0x63, 0x65, 0x52, 0x07, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x22, 0x0c, 0x0a, 0x0a, 0x53,
-	0x6d, 0x64, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x71, 0x22, 0x9d, 0x01, 0x0a, 0x0b, 0x53, 0x6d,
-	0x64, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61,
-	0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75,
-	0x73, 0x12, 0x2b, 0x0a, 0x05, 0x70, 0x6f, 0x6f, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b,
-	0x32, 0x15, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x6d, 0x64, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65,
-	0x73, 0x70, 0x2e, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x05, 0x70, 0x6f, 0x6f, 0x6c, 0x73, 0x1a, 0x49,
-	0x0a, 0x04, 0x50, 0x6f, 0x6f, 0x6c, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x75, 0x69, 0x64, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x75, 0x69, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x67,
-	0x74, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x05, 0x52, 0x06, 0x74, 0x67, 0x74,
-	0x49, 0x64, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x18, 0x03, 0x20, 0x03,
-	0x28, 0x04, 0x52, 0x05, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0xa5, 0x01, 0x0a, 0x0b, 0x53, 0x6d,
-	0x64, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x6d, 0x69,
-	0x74, 0x5f, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52,
-	0x0b, 0x6f, 0x6d, 0x69, 0x74, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x1d, 0x0a, 0x0a,
-	0x6f, 0x6d, 0x69, 0x74, 0x5f, 0x70, 0x6f, 0x6f, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08,
-	0x52, 0x09, 0x6f, 0x6d, 0x69, 0x74, 0x50, 0x6f, 0x6f, 0x6c, 0x73, 0x12, 0x2c, 0x0a, 0x12, 0x69,
-	0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x62, 0x69, 0x6f, 0x5f, 0x68, 0x65, 0x61, 0x6c, 0x74,
-	0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65,
-	0x42, 0x69, 0x6f, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x75, 0x69,
-	0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x75, 0x69, 0x64, 0x12, 0x12, 0x0a,
-	0x04, 0x72, 0x61, 0x6e, 0x6b, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x72, 0x61, 0x6e,
-	0x6b, 0x22, 0xa0, 0x03, 0x0a, 0x0c, 0x53, 0x6d, 0x64, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65,
-	0x73, 0x70, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x05, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x30, 0x0a, 0x05, 0x72, 0x61,
-	0x6e, 0x6b, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x63, 0x74, 0x6c, 0x2e,
-	0x53, 0x6d, 0x64, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x52, 0x61, 0x6e,
-	0x6b, 0x52, 0x65, 0x73, 0x70, 0x52, 0x05, 0x72, 0x61, 0x6e, 0x6b, 0x73, 0x1a, 0x6b, 0x0a, 0x13,
-	0x53, 0x6d, 0x64, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x57, 0x69, 0x74, 0x68, 0x48, 0x65, 0x61,
-	0x6c, 0x74, 0x68, 0x12, 0x28, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x6d, 0x64, 0x44, 0x65,
-	0x76, 0x69, 0x63, 0x65, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x2a, 0x0a,
-	0x06, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e,
+	0x02, 0x4a, 0x04, 0x08, 0x02, 0x10, 0x03, 0x22, 0xa6, 0x04, 0x0a, 0x0e, 0x4e, 0x76, 0x6d, 0x65,
+	0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f,
+	0x64, 0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
+	0x12, 0x16, 0x0a, 0x06, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x06, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x12, 0x19, 0x0a, 0x08, 0x70, 0x63, 0x69, 0x5f,
+	0x61, 0x64, 0x64, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x63, 0x69, 0x41,
+	0x64, 0x64, 0x72, 0x12, 0x15, 0x0a, 0x06, 0x66, 0x77, 0x5f, 0x72, 0x65, 0x76, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x05, 0x66, 0x77, 0x52, 0x65, 0x76, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x6f,
+	0x63, 0x6b, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x73,
+	0x6f, 0x63, 0x6b, 0x65, 0x74, 0x49, 0x64, 0x12, 0x35, 0x0a, 0x0c, 0x68, 0x65, 0x61, 0x6c, 0x74,
+	0x68, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e,
 	0x63, 0x74, 0x6c, 0x2e, 0x42, 0x69, 0x6f, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x73,
-	0x70, 0x52, 0x06, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x1a, 0x49, 0x0a, 0x04, 0x50, 0x6f, 0x6f,
-	0x6c, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x75, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x04, 0x75, 0x75, 0x69, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x67, 0x74, 0x5f, 0x69, 0x64, 0x73,
-	0x18, 0x02, 0x20, 0x03, 0x28, 0x05, 0x52, 0x06, 0x74, 0x67, 0x74, 0x49, 0x64, 0x73, 0x12, 0x14,
-	0x0a, 0x05, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x04, 0x52, 0x05, 0x62,
-	0x6c, 0x6f, 0x62, 0x73, 0x1a, 0x8d, 0x01, 0x0a, 0x08, 0x52, 0x61, 0x6e, 0x6b, 0x52, 0x65, 0x73,
-	0x70, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x61, 0x6e, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52,
-	0x04, 0x72, 0x61, 0x6e, 0x6b, 0x12, 0x3f, 0x0a, 0x07, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73,
-	0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x6d, 0x64,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x53, 0x6d, 0x64, 0x44, 0x65, 0x76,
-	0x69, 0x63, 0x65, 0x57, 0x69, 0x74, 0x68, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x07, 0x64,
-	0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x2c, 0x0a, 0x05, 0x70, 0x6f, 0x6f, 0x6c, 0x73, 0x18,
-	0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x6d, 0x64, 0x51,
-	0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x05, 0x70,
-	0x6f, 0x6f, 0x6c, 0x73, 0x22, 0xa7, 0x01, 0x0a, 0x0c, 0x4c, 0x65, 0x64, 0x4d, 0x61, 0x6e, 0x61,
-	0x67, 0x65, 0x52, 0x65, 0x71, 0x12, 0x10, 0x0a, 0x03, 0x69, 0x64, 0x73, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x03, 0x69, 0x64, 0x73, 0x12, 0x2d, 0x0a, 0x0a, 0x6c, 0x65, 0x64, 0x5f, 0x61,
-	0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0e, 0x2e, 0x63, 0x74,
-	0x6c, 0x2e, 0x4c, 0x65, 0x64, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x09, 0x6c, 0x65, 0x64,
-	0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2a, 0x0a, 0x09, 0x6c, 0x65, 0x64, 0x5f, 0x73, 0x74,
-	0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0d, 0x2e, 0x63, 0x74, 0x6c, 0x2e,
-	0x4c, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x08, 0x6c, 0x65, 0x64, 0x53, 0x74, 0x61,
-	0x74, 0x65, 0x12, 0x2a, 0x0a, 0x11, 0x6c, 0x65, 0x64, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x5f, 0x6d, 0x69, 0x6e, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0f, 0x6c,
-	0x65, 0x64, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x69, 0x6e, 0x73, 0x22, 0x6e,
-	0x0a, 0x0d, 0x44, 0x65, 0x76, 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x12,
-	0x20, 0x0a, 0x0c, 0x6f, 0x6c, 0x64, 0x5f, 0x64, 0x65, 0x76, 0x5f, 0x75, 0x75, 0x69, 0x64, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6f, 0x6c, 0x64, 0x44, 0x65, 0x76, 0x55, 0x75, 0x69,
-	0x64, 0x12, 0x20, 0x0a, 0x0c, 0x6e, 0x65, 0x77, 0x5f, 0x64, 0x65, 0x76, 0x5f, 0x75, 0x75, 0x69,
-	0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6e, 0x65, 0x77, 0x44, 0x65, 0x76, 0x55,
-	0x75, 0x69, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x6f, 0x5f, 0x72, 0x65, 0x69, 0x6e, 0x74, 0x18,
-	0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x6e, 0x6f, 0x52, 0x65, 0x69, 0x6e, 0x74, 0x22, 0x22,
-	0x0a, 0x0c, 0x53, 0x65, 0x74, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x79, 0x52, 0x65, 0x71, 0x12, 0x12,
+	0x70, 0x52, 0x0b, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x3d,
+	0x0a, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x18, 0x07, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x4e, 0x76, 0x6d, 0x65, 0x43, 0x6f, 0x6e,
+	0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63,
+	0x65, 0x52, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x12, 0x2f, 0x0a,
+	0x0b, 0x73, 0x6d, 0x64, 0x5f, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x08, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x6d, 0x64, 0x44, 0x65, 0x76, 0x69,
+	0x63, 0x65, 0x52, 0x0a, 0x73, 0x6d, 0x64, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x2e,
+	0x0a, 0x09, 0x64, 0x65, 0x76, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28,
+	0x0e, 0x32, 0x11, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x4e, 0x76, 0x6d, 0x65, 0x44, 0x65, 0x76, 0x53,
+	0x74, 0x61, 0x74, 0x65, 0x52, 0x08, 0x64, 0x65, 0x76, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x2a,
+	0x0a, 0x09, 0x6c, 0x65, 0x64, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28,
+	0x0e, 0x32, 0x0d, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x4c, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65,
+	0x52, 0x08, 0x6c, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x20, 0x0a, 0x0c, 0x70, 0x63,
+	0x69, 0x5f, 0x64, 0x65, 0x76, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x70, 0x63, 0x69, 0x44, 0x65, 0x76, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1b, 0x0a, 0x09,
+	0x76, 0x65, 0x6e, 0x64, 0x6f, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x08, 0x76, 0x65, 0x6e, 0x64, 0x6f, 0x72, 0x49, 0x64, 0x1a, 0x55, 0x0a, 0x09, 0x4e, 0x61, 0x6d,
+	0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0d, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x63, 0x74,
+	0x72, 0x6c, 0x72, 0x5f, 0x70, 0x63, 0x69, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0c, 0x63, 0x74, 0x72, 0x6c, 0x72, 0x50, 0x63, 0x69, 0x41, 0x64, 0x64, 0x72,
+	0x22, 0xda, 0x03, 0x0a, 0x09, 0x53, 0x6d, 0x64, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x12, 0x12,
 	0x0a, 0x04, 0x75, 0x75, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x75,
-	0x69, 0x64, 0x22, 0x4f, 0x0a, 0x0d, 0x44, 0x65, 0x76, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x52,
-	0x65, 0x73, 0x70, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x05, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x26, 0x0a, 0x06, 0x64,
-	0x65, 0x76, 0x69, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x63, 0x74,
-	0x6c, 0x2e, 0x53, 0x6d, 0x64, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x52, 0x06, 0x64, 0x65, 0x76,
-	0x69, 0x63, 0x65, 0x22, 0x98, 0x01, 0x0a, 0x0c, 0x53, 0x6d, 0x64, 0x4d, 0x61, 0x6e, 0x61, 0x67,
-	0x65, 0x52, 0x65, 0x71, 0x12, 0x25, 0x0a, 0x03, 0x6c, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x11, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x4c, 0x65, 0x64, 0x4d, 0x61, 0x6e, 0x61, 0x67,
-	0x65, 0x52, 0x65, 0x71, 0x48, 0x00, 0x52, 0x03, 0x6c, 0x65, 0x64, 0x12, 0x2e, 0x0a, 0x07, 0x72,
-	0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x63,
-	0x74, 0x6c, 0x2e, 0x44, 0x65, 0x76, 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71,
-	0x48, 0x00, 0x52, 0x07, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x12, 0x2b, 0x0a, 0x06, 0x66,
-	0x61, 0x75, 0x6c, 0x74, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x63, 0x74,
-	0x6c, 0x2e, 0x53, 0x65, 0x74, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x79, 0x52, 0x65, 0x71, 0x48, 0x00,
-	0x52, 0x06, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x79, 0x42, 0x04, 0x0a, 0x02, 0x6f, 0x70, 0x22, 0xe1,
-	0x01, 0x0a, 0x0d, 0x53, 0x6d, 0x64, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70,
-	0x12, 0x31, 0x0a, 0x05, 0x72, 0x61, 0x6e, 0x6b, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
-	0x1b, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x6d, 0x64, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x52,
-	0x65, 0x73, 0x70, 0x2e, 0x52, 0x61, 0x6e, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x52, 0x05, 0x72, 0x61,
-	0x6e, 0x6b, 0x73, 0x1a, 0x48, 0x0a, 0x06, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x16, 0x0a,
+	0x69, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x67, 0x74, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20,
+	0x03, 0x28, 0x05, 0x52, 0x06, 0x74, 0x67, 0x74, 0x49, 0x64, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x74,
+	0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04,
+	0x52, 0x0a, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0b,
+	0x61, 0x76, 0x61, 0x69, 0x6c, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28,
+	0x04, 0x52, 0x0a, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x21, 0x0a,
+	0x0c, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x08, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x53, 0x69, 0x7a, 0x65,
+	0x12, 0x12, 0x0a, 0x04, 0x72, 0x61, 0x6e, 0x6b, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04,
+	0x72, 0x61, 0x6e, 0x6b, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x62, 0x69, 0x74,
+	0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x72, 0x6f, 0x6c, 0x65, 0x42, 0x69, 0x74,
+	0x73, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x0b,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x22,
+	0x0a, 0x0d, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x77, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18,
+	0x0c, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x57, 0x61, 0x6c, 0x53, 0x69,
+	0x7a, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x64, 0x62, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x0d,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x72, 0x64, 0x62, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x20, 0x0a,
+	0x0c, 0x72, 0x64, 0x62, 0x5f, 0x77, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x0e, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x0a, 0x72, 0x64, 0x62, 0x57, 0x61, 0x6c, 0x53, 0x69, 0x7a, 0x65, 0x12,
+	0x21, 0x0a, 0x0c, 0x75, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18,
+	0x0f, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x75, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x42, 0x79, 0x74,
+	0x65, 0x73, 0x12, 0x29, 0x0a, 0x05, 0x63, 0x74, 0x72, 0x6c, 0x72, 0x18, 0x10, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x13, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x4e, 0x76, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74,
+	0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x52, 0x05, 0x63, 0x74, 0x72, 0x6c, 0x72, 0x12, 0x2c, 0x0a,
+	0x12, 0x63, 0x74, 0x72, 0x6c, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65,
+	0x5f, 0x69, 0x64, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x10, 0x63, 0x74, 0x72, 0x6c, 0x72,
+	0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x49, 0x64, 0x4a, 0x04, 0x08, 0x03, 0x10,
+	0x04, 0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x4a, 0x04, 0x08, 0x05, 0x10, 0x06, 0x22, 0x0b, 0x0a,
+	0x09, 0x53, 0x6d, 0x64, 0x44, 0x65, 0x76, 0x52, 0x65, 0x71, 0x22, 0x4e, 0x0a, 0x0a, 0x53, 0x6d,
+	0x64, 0x44, 0x65, 0x76, 0x52, 0x65, 0x73, 0x70, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74,
+	0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73,
+	0x12, 0x28, 0x0a, 0x07, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x0e, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x6d, 0x64, 0x44, 0x65, 0x76, 0x69, 0x63,
+	0x65, 0x52, 0x07, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x22, 0x0c, 0x0a, 0x0a, 0x53, 0x6d,
+	0x64, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x71, 0x22, 0x9d, 0x01, 0x0a, 0x0b, 0x53, 0x6d, 0x64,
+	0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74,
+	0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73,
+	0x12, 0x2b, 0x0a, 0x05, 0x70, 0x6f, 0x6f, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x15, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x6d, 0x64, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73,
+	0x70, 0x2e, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x05, 0x70, 0x6f, 0x6f, 0x6c, 0x73, 0x1a, 0x49, 0x0a,
+	0x04, 0x50, 0x6f, 0x6f, 0x6c, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x75, 0x69, 0x64, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x75, 0x69, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x67, 0x74,
+	0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x05, 0x52, 0x06, 0x74, 0x67, 0x74, 0x49,
+	0x64, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28,
+	0x04, 0x52, 0x05, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0xa5, 0x01, 0x0a, 0x0b, 0x53, 0x6d, 0x64,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x6d, 0x69, 0x74,
+	0x5f, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b,
+	0x6f, 0x6d, 0x69, 0x74, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x6f,
+	0x6d, 0x69, 0x74, 0x5f, 0x70, 0x6f, 0x6f, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x09, 0x6f, 0x6d, 0x69, 0x74, 0x50, 0x6f, 0x6f, 0x6c, 0x73, 0x12, 0x2c, 0x0a, 0x12, 0x69, 0x6e,
+	0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x62, 0x69, 0x6f, 0x5f, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x42,
+	0x69, 0x6f, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x75, 0x69, 0x64,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x75, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04,
+	0x72, 0x61, 0x6e, 0x6b, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x72, 0x61, 0x6e, 0x6b,
+	0x22, 0x9b, 0x02, 0x0a, 0x0c, 0x53, 0x6d, 0x64, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73,
+	0x70, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x30, 0x0a, 0x05, 0x72, 0x61, 0x6e,
+	0x6b, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53,
+	0x6d, 0x64, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x52, 0x61, 0x6e, 0x6b,
+	0x52, 0x65, 0x73, 0x70, 0x52, 0x05, 0x72, 0x61, 0x6e, 0x6b, 0x73, 0x1a, 0x49, 0x0a, 0x04, 0x50,
+	0x6f, 0x6f, 0x6c, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x75, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x04, 0x75, 0x75, 0x69, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x67, 0x74, 0x5f, 0x69,
+	0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x05, 0x52, 0x06, 0x74, 0x67, 0x74, 0x49, 0x64, 0x73,
+	0x12, 0x14, 0x0a, 0x05, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x04, 0x52,
+	0x05, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x1a, 0x76, 0x0a, 0x08, 0x52, 0x61, 0x6e, 0x6b, 0x52, 0x65,
+	0x73, 0x70, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x61, 0x6e, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d,
+	0x52, 0x04, 0x72, 0x61, 0x6e, 0x6b, 0x12, 0x28, 0x0a, 0x07, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65,
+	0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x6d,
+	0x64, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x52, 0x07, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73,
+	0x12, 0x2c, 0x0a, 0x05, 0x70, 0x6f, 0x6f, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x16, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x6d, 0x64, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65,
+	0x73, 0x70, 0x2e, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x05, 0x70, 0x6f, 0x6f, 0x6c, 0x73, 0x22, 0xa7,
+	0x01, 0x0a, 0x0c, 0x4c, 0x65, 0x64, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x12,
+	0x10, 0x0a, 0x03, 0x69, 0x64, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x69, 0x64,
+	0x73, 0x12, 0x2d, 0x0a, 0x0a, 0x6c, 0x65, 0x64, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0e, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x4c, 0x65, 0x64, 0x41,
+	0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x09, 0x6c, 0x65, 0x64, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e,
+	0x12, 0x2a, 0x0a, 0x09, 0x6c, 0x65, 0x64, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x0e, 0x32, 0x0d, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x4c, 0x65, 0x64, 0x53, 0x74, 0x61,
+	0x74, 0x65, 0x52, 0x08, 0x6c, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x2a, 0x0a, 0x11,
+	0x6c, 0x65, 0x64, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x69, 0x6e,
+	0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0f, 0x6c, 0x65, 0x64, 0x44, 0x75, 0x72, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x69, 0x6e, 0x73, 0x22, 0x6e, 0x0a, 0x0d, 0x44, 0x65, 0x76, 0x52,
+	0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x12, 0x20, 0x0a, 0x0c, 0x6f, 0x6c, 0x64,
+	0x5f, 0x64, 0x65, 0x76, 0x5f, 0x75, 0x75, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x6f, 0x6c, 0x64, 0x44, 0x65, 0x76, 0x55, 0x75, 0x69, 0x64, 0x12, 0x20, 0x0a, 0x0c, 0x6e,
+	0x65, 0x77, 0x5f, 0x64, 0x65, 0x76, 0x5f, 0x75, 0x75, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0a, 0x6e, 0x65, 0x77, 0x44, 0x65, 0x76, 0x55, 0x75, 0x69, 0x64, 0x12, 0x19, 0x0a,
+	0x08, 0x6e, 0x6f, 0x5f, 0x72, 0x65, 0x69, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x07, 0x6e, 0x6f, 0x52, 0x65, 0x69, 0x6e, 0x74, 0x22, 0x22, 0x0a, 0x0c, 0x53, 0x65, 0x74, 0x46,
+	0x61, 0x75, 0x6c, 0x74, 0x79, 0x52, 0x65, 0x71, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x75, 0x69, 0x64,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x75, 0x69, 0x64, 0x22, 0x4f, 0x0a, 0x0d,
+	0x44, 0x65, 0x76, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x16, 0x0a,
 	0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x73,
 	0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x26, 0x0a, 0x06, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x18,
 	0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x6d, 0x64, 0x44,
-	0x65, 0x76, 0x69, 0x63, 0x65, 0x52, 0x06, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x1a, 0x53, 0x0a,
-	0x08, 0x52, 0x61, 0x6e, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x61, 0x6e,
-	0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x72, 0x61, 0x6e, 0x6b, 0x12, 0x33, 0x0a,
-	0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19,
-	0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x6d, 0x64, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x52, 0x65,
-	0x73, 0x70, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c,
-	0x74, 0x73, 0x2a, 0x4c, 0x0a, 0x0c, 0x4e, 0x76, 0x6d, 0x65, 0x44, 0x65, 0x76, 0x53, 0x74, 0x61,
-	0x74, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12,
-	0x0a, 0x0a, 0x06, 0x4e, 0x4f, 0x52, 0x4d, 0x41, 0x4c, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x4e,
-	0x45, 0x57, 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07, 0x45, 0x56, 0x49, 0x43, 0x54, 0x45, 0x44, 0x10,
-	0x03, 0x12, 0x0d, 0x0a, 0x09, 0x55, 0x4e, 0x50, 0x4c, 0x55, 0x47, 0x47, 0x45, 0x44, 0x10, 0x04,
-	0x2a, 0x44, 0x0a, 0x08, 0x4c, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x07, 0x0a, 0x03,
-	0x4f, 0x46, 0x46, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x51, 0x55, 0x49, 0x43, 0x4b, 0x5f, 0x42,
-	0x4c, 0x49, 0x4e, 0x4b, 0x10, 0x01, 0x12, 0x06, 0x0a, 0x02, 0x4f, 0x4e, 0x10, 0x02, 0x12, 0x0e,
-	0x0a, 0x0a, 0x53, 0x4c, 0x4f, 0x57, 0x5f, 0x42, 0x4c, 0x49, 0x4e, 0x4b, 0x10, 0x03, 0x12, 0x06,
-	0x0a, 0x02, 0x4e, 0x41, 0x10, 0x04, 0x2a, 0x28, 0x0a, 0x09, 0x4c, 0x65, 0x64, 0x41, 0x63, 0x74,
-	0x69, 0x6f, 0x6e, 0x12, 0x07, 0x0a, 0x03, 0x47, 0x45, 0x54, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03,
-	0x53, 0x45, 0x54, 0x10, 0x01, 0x12, 0x09, 0x0a, 0x05, 0x52, 0x45, 0x53, 0x45, 0x54, 0x10, 0x02,
-	0x42, 0x39, 0x5a, 0x37, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64,
-	0x61, 0x6f, 0x73, 0x2d, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x2f, 0x64, 0x61, 0x6f, 0x73, 0x2f, 0x73,
-	0x72, 0x63, 0x2f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f,
-	0x6e, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x74, 0x6c, 0x62, 0x06, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x33,
+	0x65, 0x76, 0x69, 0x63, 0x65, 0x52, 0x06, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x22, 0x98, 0x01,
+	0x0a, 0x0c, 0x53, 0x6d, 0x64, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x12, 0x25,
+	0x0a, 0x03, 0x6c, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x63, 0x74,
+	0x6c, 0x2e, 0x4c, 0x65, 0x64, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x48, 0x00,
+	0x52, 0x03, 0x6c, 0x65, 0x64, 0x12, 0x2e, 0x0a, 0x07, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x44, 0x65, 0x76,
+	0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x48, 0x00, 0x52, 0x07, 0x72, 0x65,
+	0x70, 0x6c, 0x61, 0x63, 0x65, 0x12, 0x2b, 0x0a, 0x06, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x79, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x65, 0x74, 0x46,
+	0x61, 0x75, 0x6c, 0x74, 0x79, 0x52, 0x65, 0x71, 0x48, 0x00, 0x52, 0x06, 0x66, 0x61, 0x75, 0x6c,
+	0x74, 0x79, 0x42, 0x04, 0x0a, 0x02, 0x6f, 0x70, 0x22, 0xe1, 0x01, 0x0a, 0x0d, 0x53, 0x6d, 0x64,
+	0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x31, 0x0a, 0x05, 0x72, 0x61,
+	0x6e, 0x6b, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x63, 0x74, 0x6c, 0x2e,
+	0x53, 0x6d, 0x64, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x52, 0x61,
+	0x6e, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x52, 0x05, 0x72, 0x61, 0x6e, 0x6b, 0x73, 0x1a, 0x48, 0x0a,
+	0x06, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75,
+	0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12,
+	0x26, 0x0a, 0x06, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x0e, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53, 0x6d, 0x64, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x52,
+	0x06, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x1a, 0x53, 0x0a, 0x08, 0x52, 0x61, 0x6e, 0x6b, 0x52,
+	0x65, 0x73, 0x70, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x61, 0x6e, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0d, 0x52, 0x04, 0x72, 0x61, 0x6e, 0x6b, 0x12, 0x33, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c,
+	0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x53,
+	0x6d, 0x64, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x52, 0x65, 0x73,
+	0x75, 0x6c, 0x74, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2a, 0x4c, 0x0a, 0x0c,
+	0x4e, 0x76, 0x6d, 0x65, 0x44, 0x65, 0x76, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x0b, 0x0a, 0x07,
+	0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x0a, 0x0a, 0x06, 0x4e, 0x4f, 0x52,
+	0x4d, 0x41, 0x4c, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x4e, 0x45, 0x57, 0x10, 0x02, 0x12, 0x0b,
+	0x0a, 0x07, 0x45, 0x56, 0x49, 0x43, 0x54, 0x45, 0x44, 0x10, 0x03, 0x12, 0x0d, 0x0a, 0x09, 0x55,
+	0x4e, 0x50, 0x4c, 0x55, 0x47, 0x47, 0x45, 0x44, 0x10, 0x04, 0x2a, 0x44, 0x0a, 0x08, 0x4c, 0x65,
+	0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x07, 0x0a, 0x03, 0x4f, 0x46, 0x46, 0x10, 0x00, 0x12,
+	0x0f, 0x0a, 0x0b, 0x51, 0x55, 0x49, 0x43, 0x4b, 0x5f, 0x42, 0x4c, 0x49, 0x4e, 0x4b, 0x10, 0x01,
+	0x12, 0x06, 0x0a, 0x02, 0x4f, 0x4e, 0x10, 0x02, 0x12, 0x0e, 0x0a, 0x0a, 0x53, 0x4c, 0x4f, 0x57,
+	0x5f, 0x42, 0x4c, 0x49, 0x4e, 0x4b, 0x10, 0x03, 0x12, 0x06, 0x0a, 0x02, 0x4e, 0x41, 0x10, 0x04,
+	0x2a, 0x28, 0x0a, 0x09, 0x4c, 0x65, 0x64, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x07, 0x0a,
+	0x03, 0x47, 0x45, 0x54, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x53, 0x45, 0x54, 0x10, 0x01, 0x12,
+	0x09, 0x0a, 0x05, 0x52, 0x45, 0x53, 0x45, 0x54, 0x10, 0x02, 0x42, 0x39, 0x5a, 0x37, 0x67, 0x69,
+	0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x61, 0x6f, 0x73, 0x2d, 0x73, 0x74,
+	0x61, 0x63, 0x6b, 0x2f, 0x64, 0x61, 0x6f, 0x73, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x63, 0x6f, 0x6e,
+	0x74, 0x72, 0x6f, 0x6c, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2f, 0x63, 0x74, 0x6c, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -2160,57 +2322,60 @@ func file_ctl_smd_proto_rawDescGZIP() []byte {
 }
 
 var file_ctl_smd_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
-var file_ctl_smd_proto_msgTypes = make([]protoimpl.MessageInfo, 21)
+var file_ctl_smd_proto_msgTypes = make([]protoimpl.MessageInfo, 22)
 var file_ctl_smd_proto_goTypes = []interface{}{
-	(NvmeDevState)(0),                        // 0: ctl.NvmeDevState
-	(LedState)(0),                            // 1: ctl.LedState
-	(LedAction)(0),                           // 2: ctl.LedAction
-	(*BioHealthReq)(nil),                     // 3: ctl.BioHealthReq
-	(*BioHealthResp)(nil),                    // 4: ctl.BioHealthResp
-	(*SmdDevice)(nil),                        // 5: ctl.SmdDevice
-	(*SmdDevReq)(nil),                        // 6: ctl.SmdDevReq
-	(*SmdDevResp)(nil),                       // 7: ctl.SmdDevResp
-	(*SmdPoolReq)(nil),                       // 8: ctl.SmdPoolReq
-	(*SmdPoolResp)(nil),                      // 9: ctl.SmdPoolResp
-	(*SmdQueryReq)(nil),                      // 10: ctl.SmdQueryReq
-	(*SmdQueryResp)(nil),                     // 11: ctl.SmdQueryResp
-	(*LedManageReq)(nil),                     // 12: ctl.LedManageReq
-	(*DevReplaceReq)(nil),                    // 13: ctl.DevReplaceReq
-	(*SetFaultyReq)(nil),                     // 14: ctl.SetFaultyReq
-	(*DevManageResp)(nil),                    // 15: ctl.DevManageResp
-	(*SmdManageReq)(nil),                     // 16: ctl.SmdManageReq
-	(*SmdManageResp)(nil),                    // 17: ctl.SmdManageResp
-	(*SmdPoolResp_Pool)(nil),                 // 18: ctl.SmdPoolResp.Pool
-	(*SmdQueryResp_SmdDeviceWithHealth)(nil), // 19: ctl.SmdQueryResp.SmdDeviceWithHealth
-	(*SmdQueryResp_Pool)(nil),                // 20: ctl.SmdQueryResp.Pool
-	(*SmdQueryResp_RankResp)(nil),            // 21: ctl.SmdQueryResp.RankResp
-	(*SmdManageResp_Result)(nil),             // 22: ctl.SmdManageResp.Result
-	(*SmdManageResp_RankResp)(nil),           // 23: ctl.SmdManageResp.RankResp
+	(NvmeDevState)(0),                // 0: ctl.NvmeDevState
+	(LedState)(0),                    // 1: ctl.LedState
+	(LedAction)(0),                   // 2: ctl.LedAction
+	(*BioHealthReq)(nil),             // 3: ctl.BioHealthReq
+	(*BioHealthResp)(nil),            // 4: ctl.BioHealthResp
+	(*NvmeController)(nil),           // 5: ctl.NvmeController
+	(*SmdDevice)(nil),                // 6: ctl.SmdDevice
+	(*SmdDevReq)(nil),                // 7: ctl.SmdDevReq
+	(*SmdDevResp)(nil),               // 8: ctl.SmdDevResp
+	(*SmdPoolReq)(nil),               // 9: ctl.SmdPoolReq
+	(*SmdPoolResp)(nil),              // 10: ctl.SmdPoolResp
+	(*SmdQueryReq)(nil),              // 11: ctl.SmdQueryReq
+	(*SmdQueryResp)(nil),             // 12: ctl.SmdQueryResp
+	(*LedManageReq)(nil),             // 13: ctl.LedManageReq
+	(*DevReplaceReq)(nil),            // 14: ctl.DevReplaceReq
+	(*SetFaultyReq)(nil),             // 15: ctl.SetFaultyReq
+	(*DevManageResp)(nil),            // 16: ctl.DevManageResp
+	(*SmdManageReq)(nil),             // 17: ctl.SmdManageReq
+	(*SmdManageResp)(nil),            // 18: ctl.SmdManageResp
+	(*NvmeController_Namespace)(nil), // 19: ctl.NvmeController.Namespace
+	(*SmdPoolResp_Pool)(nil),         // 20: ctl.SmdPoolResp.Pool
+	(*SmdQueryResp_Pool)(nil),        // 21: ctl.SmdQueryResp.Pool
+	(*SmdQueryResp_RankResp)(nil),    // 22: ctl.SmdQueryResp.RankResp
+	(*SmdManageResp_Result)(nil),     // 23: ctl.SmdManageResp.Result
+	(*SmdManageResp_RankResp)(nil),   // 24: ctl.SmdManageResp.RankResp
 }
 var file_ctl_smd_proto_depIdxs = []int32{
-	0,  // 0: ctl.SmdDevice.dev_state:type_name -> ctl.NvmeDevState
-	1,  // 1: ctl.SmdDevice.led_state:type_name -> ctl.LedState
-	5,  // 2: ctl.SmdDevResp.devices:type_name -> ctl.SmdDevice
-	18, // 3: ctl.SmdPoolResp.pools:type_name -> ctl.SmdPoolResp.Pool
-	21, // 4: ctl.SmdQueryResp.ranks:type_name -> ctl.SmdQueryResp.RankResp
-	2,  // 5: ctl.LedManageReq.led_action:type_name -> ctl.LedAction
-	1,  // 6: ctl.LedManageReq.led_state:type_name -> ctl.LedState
-	5,  // 7: ctl.DevManageResp.device:type_name -> ctl.SmdDevice
-	12, // 8: ctl.SmdManageReq.led:type_name -> ctl.LedManageReq
-	13, // 9: ctl.SmdManageReq.replace:type_name -> ctl.DevReplaceReq
-	14, // 10: ctl.SmdManageReq.faulty:type_name -> ctl.SetFaultyReq
-	23, // 11: ctl.SmdManageResp.ranks:type_name -> ctl.SmdManageResp.RankResp
-	5,  // 12: ctl.SmdQueryResp.SmdDeviceWithHealth.details:type_name -> ctl.SmdDevice
-	4,  // 13: ctl.SmdQueryResp.SmdDeviceWithHealth.health:type_name -> ctl.BioHealthResp
-	19, // 14: ctl.SmdQueryResp.RankResp.devices:type_name -> ctl.SmdQueryResp.SmdDeviceWithHealth
-	20, // 15: ctl.SmdQueryResp.RankResp.pools:type_name -> ctl.SmdQueryResp.Pool
-	5,  // 16: ctl.SmdManageResp.Result.device:type_name -> ctl.SmdDevice
-	22, // 17: ctl.SmdManageResp.RankResp.results:type_name -> ctl.SmdManageResp.Result
-	18, // [18:18] is the sub-list for method output_type
-	18, // [18:18] is the sub-list for method input_type
-	18, // [18:18] is the sub-list for extension type_name
-	18, // [18:18] is the sub-list for extension extendee
-	0,  // [0:18] is the sub-list for field type_name
+	4,  // 0: ctl.NvmeController.health_stats:type_name -> ctl.BioHealthResp
+	19, // 1: ctl.NvmeController.namespaces:type_name -> ctl.NvmeController.Namespace
+	6,  // 2: ctl.NvmeController.smd_devices:type_name -> ctl.SmdDevice
+	0,  // 3: ctl.NvmeController.dev_state:type_name -> ctl.NvmeDevState
+	1,  // 4: ctl.NvmeController.led_state:type_name -> ctl.LedState
+	5,  // 5: ctl.SmdDevice.ctrlr:type_name -> ctl.NvmeController
+	6,  // 6: ctl.SmdDevResp.devices:type_name -> ctl.SmdDevice
+	20, // 7: ctl.SmdPoolResp.pools:type_name -> ctl.SmdPoolResp.Pool
+	22, // 8: ctl.SmdQueryResp.ranks:type_name -> ctl.SmdQueryResp.RankResp
+	2,  // 9: ctl.LedManageReq.led_action:type_name -> ctl.LedAction
+	1,  // 10: ctl.LedManageReq.led_state:type_name -> ctl.LedState
+	6,  // 11: ctl.DevManageResp.device:type_name -> ctl.SmdDevice
+	13, // 12: ctl.SmdManageReq.led:type_name -> ctl.LedManageReq
+	14, // 13: ctl.SmdManageReq.replace:type_name -> ctl.DevReplaceReq
+	15, // 14: ctl.SmdManageReq.faulty:type_name -> ctl.SetFaultyReq
+	24, // 15: ctl.SmdManageResp.ranks:type_name -> ctl.SmdManageResp.RankResp
+	6,  // 16: ctl.SmdQueryResp.RankResp.devices:type_name -> ctl.SmdDevice
+	21, // 17: ctl.SmdQueryResp.RankResp.pools:type_name -> ctl.SmdQueryResp.Pool
+	6,  // 18: ctl.SmdManageResp.Result.device:type_name -> ctl.SmdDevice
+	23, // 19: ctl.SmdManageResp.RankResp.results:type_name -> ctl.SmdManageResp.Result
+	20, // [20:20] is the sub-list for method output_type
+	20, // [20:20] is the sub-list for method input_type
+	20, // [20:20] is the sub-list for extension type_name
+	20, // [20:20] is the sub-list for extension extendee
+	0,  // [0:20] is the sub-list for field type_name
 }
 
 func init() { file_ctl_smd_proto_init() }
@@ -2244,7 +2409,7 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 		file_ctl_smd_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SmdDevice); i {
+			switch v := v.(*NvmeController); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2256,7 +2421,7 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 		file_ctl_smd_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SmdDevReq); i {
+			switch v := v.(*SmdDevice); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2268,7 +2433,7 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 		file_ctl_smd_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SmdDevResp); i {
+			switch v := v.(*SmdDevReq); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2280,7 +2445,7 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 		file_ctl_smd_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SmdPoolReq); i {
+			switch v := v.(*SmdDevResp); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2292,7 +2457,7 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 		file_ctl_smd_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SmdPoolResp); i {
+			switch v := v.(*SmdPoolReq); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2304,7 +2469,7 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 		file_ctl_smd_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SmdQueryReq); i {
+			switch v := v.(*SmdPoolResp); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2316,7 +2481,7 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 		file_ctl_smd_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SmdQueryResp); i {
+			switch v := v.(*SmdQueryReq); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2328,7 +2493,7 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 		file_ctl_smd_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*LedManageReq); i {
+			switch v := v.(*SmdQueryResp); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2340,7 +2505,7 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 		file_ctl_smd_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DevReplaceReq); i {
+			switch v := v.(*LedManageReq); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2352,7 +2517,7 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 		file_ctl_smd_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SetFaultyReq); i {
+			switch v := v.(*DevReplaceReq); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2364,7 +2529,7 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 		file_ctl_smd_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DevManageResp); i {
+			switch v := v.(*SetFaultyReq); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2376,7 +2541,7 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 		file_ctl_smd_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SmdManageReq); i {
+			switch v := v.(*DevManageResp); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2388,7 +2553,7 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 		file_ctl_smd_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SmdManageResp); i {
+			switch v := v.(*SmdManageReq); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2400,7 +2565,7 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 		file_ctl_smd_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SmdPoolResp_Pool); i {
+			switch v := v.(*SmdManageResp); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2412,7 +2577,7 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 		file_ctl_smd_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SmdQueryResp_SmdDeviceWithHealth); i {
+			switch v := v.(*NvmeController_Namespace); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2424,7 +2589,7 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 		file_ctl_smd_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SmdQueryResp_Pool); i {
+			switch v := v.(*SmdPoolResp_Pool); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2436,7 +2601,7 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 		file_ctl_smd_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SmdQueryResp_RankResp); i {
+			switch v := v.(*SmdQueryResp_Pool); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2448,7 +2613,7 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 		file_ctl_smd_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SmdManageResp_Result); i {
+			switch v := v.(*SmdQueryResp_RankResp); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2460,6 +2625,18 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 		file_ctl_smd_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*SmdManageResp_Result); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_ctl_smd_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*SmdManageResp_RankResp); i {
 			case 0:
 				return &v.state
@@ -2472,7 +2649,7 @@ func file_ctl_smd_proto_init() {
 			}
 		}
 	}
-	file_ctl_smd_proto_msgTypes[13].OneofWrappers = []interface{}{
+	file_ctl_smd_proto_msgTypes[14].OneofWrappers = []interface{}{
 		(*SmdManageReq_Led)(nil),
 		(*SmdManageReq_Replace)(nil),
 		(*SmdManageReq_Faulty)(nil),
@@ -2483,7 +2660,7 @@ func file_ctl_smd_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_ctl_smd_proto_rawDesc,
 			NumEnums:      3,
-			NumMessages:   21,
+			NumMessages:   22,
 			NumExtensions: 0,
 			NumServices:   0,
 		},
diff --git a/src/control/common/proto/ctl/storage_nvme.pb.go b/src/control/common/proto/ctl/storage_nvme.pb.go
index 273450985a9..071ba10e04a 100644
--- a/src/control/common/proto/ctl/storage_nvme.pb.go
+++ b/src/control/common/proto/ctl/storage_nvme.pb.go
@@ -1,13 +1,13 @@
 //
-// (C) Copyright 2019-2022 Intel Corporation.
+// (C) Copyright 2019-2023 Intel Corporation.
 //
 // SPDX-License-Identifier: BSD-2-Clause-Patent
 //
 
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.26.0
-// 	protoc        v3.11.4
+// 	protoc-gen-go v1.31.0
+// 	protoc        v3.5.0
 // source: ctl/storage_nvme.proto
 
 package ctl
@@ -26,110 +26,6 @@ const (
 	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
 )
 
-// NvmeController represents an NVMe Controller (SSD).
-type NvmeController struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Model       string                      `protobuf:"bytes,1,opt,name=model,proto3" json:"model,omitempty"`                                // model name
-	Serial      string                      `protobuf:"bytes,2,opt,name=serial,proto3" json:"serial,omitempty"`                              // serial number
-	PciAddr     string                      `protobuf:"bytes,3,opt,name=pci_addr,json=pciAddr,proto3" json:"pci_addr,omitempty"`             // pci address
-	FwRev       string                      `protobuf:"bytes,4,opt,name=fw_rev,json=fwRev,proto3" json:"fw_rev,omitempty"`                   // firmware revision
-	SocketId    int32                       `protobuf:"varint,5,opt,name=socket_id,json=socketId,proto3" json:"socket_id,omitempty"`         // NUMA socket ID
-	HealthStats *BioHealthResp              `protobuf:"bytes,6,opt,name=health_stats,json=healthStats,proto3" json:"health_stats,omitempty"` // controller's health stats
-	Namespaces  []*NvmeController_Namespace `protobuf:"bytes,7,rep,name=namespaces,proto3" json:"namespaces,omitempty"`                      // controller's namespaces
-	SmdDevices  []*SmdDevice                `protobuf:"bytes,8,rep,name=smd_devices,json=smdDevices,proto3" json:"smd_devices,omitempty"`    // controller's blobstores
-}
-
-func (x *NvmeController) Reset() {
-	*x = NvmeController{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_storage_nvme_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *NvmeController) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*NvmeController) ProtoMessage() {}
-
-func (x *NvmeController) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_storage_nvme_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use NvmeController.ProtoReflect.Descriptor instead.
-func (*NvmeController) Descriptor() ([]byte, []int) {
-	return file_ctl_storage_nvme_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *NvmeController) GetModel() string {
-	if x != nil {
-		return x.Model
-	}
-	return ""
-}
-
-func (x *NvmeController) GetSerial() string {
-	if x != nil {
-		return x.Serial
-	}
-	return ""
-}
-
-func (x *NvmeController) GetPciAddr() string {
-	if x != nil {
-		return x.PciAddr
-	}
-	return ""
-}
-
-func (x *NvmeController) GetFwRev() string {
-	if x != nil {
-		return x.FwRev
-	}
-	return ""
-}
-
-func (x *NvmeController) GetSocketId() int32 {
-	if x != nil {
-		return x.SocketId
-	}
-	return 0
-}
-
-func (x *NvmeController) GetHealthStats() *BioHealthResp {
-	if x != nil {
-		return x.HealthStats
-	}
-	return nil
-}
-
-func (x *NvmeController) GetNamespaces() []*NvmeController_Namespace {
-	if x != nil {
-		return x.Namespaces
-	}
-	return nil
-}
-
-func (x *NvmeController) GetSmdDevices() []*SmdDevice {
-	if x != nil {
-		return x.SmdDevices
-	}
-	return nil
-}
-
 // NvmeControllerResult represents state of operation performed on controller.
 type NvmeControllerResult struct {
 	state         protoimpl.MessageState
@@ -143,7 +39,7 @@ type NvmeControllerResult struct {
 func (x *NvmeControllerResult) Reset() {
 	*x = NvmeControllerResult{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_storage_nvme_proto_msgTypes[1]
+		mi := &file_ctl_storage_nvme_proto_msgTypes[0]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -156,7 +52,7 @@ func (x *NvmeControllerResult) String() string {
 func (*NvmeControllerResult) ProtoMessage() {}
 
 func (x *NvmeControllerResult) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_storage_nvme_proto_msgTypes[1]
+	mi := &file_ctl_storage_nvme_proto_msgTypes[0]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -169,7 +65,7 @@ func (x *NvmeControllerResult) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use NvmeControllerResult.ProtoReflect.Descriptor instead.
 func (*NvmeControllerResult) Descriptor() ([]byte, []int) {
-	return file_ctl_storage_nvme_proto_rawDescGZIP(), []int{1}
+	return file_ctl_storage_nvme_proto_rawDescGZIP(), []int{0}
 }
 
 func (x *NvmeControllerResult) GetPciAddr() string {
@@ -201,7 +97,7 @@ type ScanNvmeReq struct {
 func (x *ScanNvmeReq) Reset() {
 	*x = ScanNvmeReq{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_storage_nvme_proto_msgTypes[2]
+		mi := &file_ctl_storage_nvme_proto_msgTypes[1]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -214,7 +110,7 @@ func (x *ScanNvmeReq) String() string {
 func (*ScanNvmeReq) ProtoMessage() {}
 
 func (x *ScanNvmeReq) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_storage_nvme_proto_msgTypes[2]
+	mi := &file_ctl_storage_nvme_proto_msgTypes[1]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -227,7 +123,7 @@ func (x *ScanNvmeReq) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ScanNvmeReq.ProtoReflect.Descriptor instead.
 func (*ScanNvmeReq) Descriptor() ([]byte, []int) {
-	return file_ctl_storage_nvme_proto_rawDescGZIP(), []int{2}
+	return file_ctl_storage_nvme_proto_rawDescGZIP(), []int{1}
 }
 
 func (x *ScanNvmeReq) GetHealth() bool {
@@ -277,7 +173,7 @@ type ScanNvmeResp struct {
 func (x *ScanNvmeResp) Reset() {
 	*x = ScanNvmeResp{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_storage_nvme_proto_msgTypes[3]
+		mi := &file_ctl_storage_nvme_proto_msgTypes[2]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -290,7 +186,7 @@ func (x *ScanNvmeResp) String() string {
 func (*ScanNvmeResp) ProtoMessage() {}
 
 func (x *ScanNvmeResp) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_storage_nvme_proto_msgTypes[3]
+	mi := &file_ctl_storage_nvme_proto_msgTypes[2]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -303,7 +199,7 @@ func (x *ScanNvmeResp) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ScanNvmeResp.ProtoReflect.Descriptor instead.
 func (*ScanNvmeResp) Descriptor() ([]byte, []int) {
-	return file_ctl_storage_nvme_proto_rawDescGZIP(), []int{3}
+	return file_ctl_storage_nvme_proto_rawDescGZIP(), []int{2}
 }
 
 func (x *ScanNvmeResp) GetCtrlrs() []*NvmeController {
@@ -329,7 +225,7 @@ type FormatNvmeReq struct {
 func (x *FormatNvmeReq) Reset() {
 	*x = FormatNvmeReq{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_storage_nvme_proto_msgTypes[4]
+		mi := &file_ctl_storage_nvme_proto_msgTypes[3]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -342,7 +238,7 @@ func (x *FormatNvmeReq) String() string {
 func (*FormatNvmeReq) ProtoMessage() {}
 
 func (x *FormatNvmeReq) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_storage_nvme_proto_msgTypes[4]
+	mi := &file_ctl_storage_nvme_proto_msgTypes[3]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -355,71 +251,7 @@ func (x *FormatNvmeReq) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use FormatNvmeReq.ProtoReflect.Descriptor instead.
 func (*FormatNvmeReq) Descriptor() ([]byte, []int) {
-	return file_ctl_storage_nvme_proto_rawDescGZIP(), []int{4}
-}
-
-// Namespace represents a namespace created on an NvmeController.
-type NvmeController_Namespace struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Id           uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`                                          // namespace id
-	Size         uint64 `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`                                      // device capacity in bytes
-	CtrlrPciAddr string `protobuf:"bytes,3,opt,name=ctrlr_pci_addr,json=ctrlrPciAddr,proto3" json:"ctrlr_pci_addr,omitempty"` // parent controller PCI address
-}
-
-func (x *NvmeController_Namespace) Reset() {
-	*x = NvmeController_Namespace{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_ctl_storage_nvme_proto_msgTypes[5]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *NvmeController_Namespace) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*NvmeController_Namespace) ProtoMessage() {}
-
-func (x *NvmeController_Namespace) ProtoReflect() protoreflect.Message {
-	mi := &file_ctl_storage_nvme_proto_msgTypes[5]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use NvmeController_Namespace.ProtoReflect.Descriptor instead.
-func (*NvmeController_Namespace) Descriptor() ([]byte, []int) {
-	return file_ctl_storage_nvme_proto_rawDescGZIP(), []int{0, 0}
-}
-
-func (x *NvmeController_Namespace) GetId() uint32 {
-	if x != nil {
-		return x.Id
-	}
-	return 0
-}
-
-func (x *NvmeController_Namespace) GetSize() uint64 {
-	if x != nil {
-		return x.Size
-	}
-	return 0
-}
-
-func (x *NvmeController_Namespace) GetCtrlrPciAddr() string {
-	if x != nil {
-		return x.CtrlrPciAddr
-	}
-	return ""
+	return file_ctl_storage_nvme_proto_rawDescGZIP(), []int{3}
 }
 
 var File_ctl_storage_nvme_proto protoreflect.FileDescriptor
@@ -428,58 +260,33 @@ var file_ctl_storage_nvme_proto_rawDesc = []byte{
 	0x0a, 0x16, 0x63, 0x74, 0x6c, 0x2f, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x6e, 0x76,
 	0x6d, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x03, 0x63, 0x74, 0x6c, 0x1a, 0x10, 0x63,
 	0x74, 0x6c, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a,
-	0x0d, 0x63, 0x74, 0x6c, 0x2f, 0x73, 0x6d, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x8b,
-	0x03, 0x0a, 0x0e, 0x4e, 0x76, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65,
-	0x72, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x65, 0x72, 0x69, 0x61,
-	0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x12,
-	0x19, 0x0a, 0x08, 0x70, 0x63, 0x69, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x07, 0x70, 0x63, 0x69, 0x41, 0x64, 0x64, 0x72, 0x12, 0x15, 0x0a, 0x06, 0x66, 0x77,
-	0x5f, 0x72, 0x65, 0x76, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x66, 0x77, 0x52, 0x65,
-	0x76, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x05,
-	0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x49, 0x64, 0x12, 0x35,
-	0x0a, 0x0c, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x06,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x42, 0x69, 0x6f, 0x48, 0x65,
-	0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x73, 0x70, 0x52, 0x0b, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68,
-	0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x3d, 0x0a, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61,
-	0x63, 0x65, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x63, 0x74, 0x6c, 0x2e,
-	0x4e, 0x76, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2e, 0x4e,
-	0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70,
-	0x61, 0x63, 0x65, 0x73, 0x12, 0x2f, 0x0a, 0x0b, 0x73, 0x6d, 0x64, 0x5f, 0x64, 0x65, 0x76, 0x69,
-	0x63, 0x65, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x63, 0x74, 0x6c, 0x2e,
-	0x53, 0x6d, 0x64, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x52, 0x0a, 0x73, 0x6d, 0x64, 0x44, 0x65,
-	0x76, 0x69, 0x63, 0x65, 0x73, 0x1a, 0x55, 0x0a, 0x09, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61,
-	0x63, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x02,
-	0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04,
-	0x52, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x63, 0x74, 0x72, 0x6c, 0x72, 0x5f,
-	0x70, 0x63, 0x69, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c,
-	0x63, 0x74, 0x72, 0x6c, 0x72, 0x50, 0x63, 0x69, 0x41, 0x64, 0x64, 0x72, 0x22, 0x5b, 0x0a, 0x14,
-	0x4e, 0x76, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x52, 0x65,
-	0x73, 0x75, 0x6c, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x70, 0x63, 0x69, 0x5f, 0x61, 0x64, 0x64, 0x72,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x63, 0x69, 0x41, 0x64, 0x64, 0x72, 0x12,
-	0x28, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12,
-	0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x53, 0x74, 0x61,
-	0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x22, 0x85, 0x01, 0x0a, 0x0b, 0x53, 0x63,
-	0x61, 0x6e, 0x4e, 0x76, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x12, 0x16, 0x0a, 0x06, 0x48, 0x65, 0x61,
-	0x6c, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x48, 0x65, 0x61, 0x6c, 0x74,
-	0x68, 0x12, 0x12, 0x0a, 0x04, 0x4d, 0x65, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52,
-	0x04, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x14, 0x0a, 0x05, 0x42, 0x61, 0x73, 0x69, 0x63, 0x18, 0x03,
-	0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x42, 0x61, 0x73, 0x69, 0x63, 0x12, 0x1a, 0x0a, 0x08, 0x4d,
-	0x65, 0x74, 0x61, 0x53, 0x69, 0x7a, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x4d,
-	0x65, 0x74, 0x61, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x52, 0x64, 0x62, 0x53, 0x69,
-	0x7a, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x52, 0x64, 0x62, 0x53, 0x69, 0x7a,
-	0x65, 0x22, 0x65, 0x0a, 0x0c, 0x53, 0x63, 0x61, 0x6e, 0x4e, 0x76, 0x6d, 0x65, 0x52, 0x65, 0x73,
-	0x70, 0x12, 0x2b, 0x0a, 0x06, 0x63, 0x74, 0x72, 0x6c, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
-	0x0b, 0x32, 0x13, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x4e, 0x76, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74,
-	0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x52, 0x06, 0x63, 0x74, 0x72, 0x6c, 0x72, 0x73, 0x12, 0x28,
-	0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e,
-	0x63, 0x74, 0x6c, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x53, 0x74, 0x61, 0x74,
-	0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x22, 0x0f, 0x0a, 0x0d, 0x46, 0x6f, 0x72, 0x6d,
-	0x61, 0x74, 0x4e, 0x76, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x42, 0x39, 0x5a, 0x37, 0x67, 0x69, 0x74,
-	0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x61, 0x6f, 0x73, 0x2d, 0x73, 0x74, 0x61,
-	0x63, 0x6b, 0x2f, 0x64, 0x61, 0x6f, 0x73, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x63, 0x6f, 0x6e, 0x74,
-	0x72, 0x6f, 0x6c, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x2f, 0x63, 0x74, 0x6c, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x0d, 0x63, 0x74, 0x6c, 0x2f, 0x73, 0x6d, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x5b,
+	0x0a, 0x14, 0x4e, 0x76, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72,
+	0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x70, 0x63, 0x69, 0x5f, 0x61, 0x64,
+	0x64, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x63, 0x69, 0x41, 0x64, 0x64,
+	0x72, 0x12, 0x28, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x12, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x53,
+	0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x22, 0x85, 0x01, 0x0a, 0x0b,
+	0x53, 0x63, 0x61, 0x6e, 0x4e, 0x76, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x12, 0x16, 0x0a, 0x06, 0x48,
+	0x65, 0x61, 0x6c, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x48, 0x65, 0x61,
+	0x6c, 0x74, 0x68, 0x12, 0x12, 0x0a, 0x04, 0x4d, 0x65, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x04, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x14, 0x0a, 0x05, 0x42, 0x61, 0x73, 0x69, 0x63,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x42, 0x61, 0x73, 0x69, 0x63, 0x12, 0x1a, 0x0a,
+	0x08, 0x4d, 0x65, 0x74, 0x61, 0x53, 0x69, 0x7a, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52,
+	0x08, 0x4d, 0x65, 0x74, 0x61, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x52, 0x64, 0x62,
+	0x53, 0x69, 0x7a, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x52, 0x64, 0x62, 0x53,
+	0x69, 0x7a, 0x65, 0x22, 0x65, 0x0a, 0x0c, 0x53, 0x63, 0x61, 0x6e, 0x4e, 0x76, 0x6d, 0x65, 0x52,
+	0x65, 0x73, 0x70, 0x12, 0x2b, 0x0a, 0x06, 0x63, 0x74, 0x72, 0x6c, 0x72, 0x73, 0x18, 0x01, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x4e, 0x76, 0x6d, 0x65, 0x43, 0x6f,
+	0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x52, 0x06, 0x63, 0x74, 0x72, 0x6c, 0x72, 0x73,
+	0x12, 0x28, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x12, 0x2e, 0x63, 0x74, 0x6c, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x53, 0x74,
+	0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x22, 0x0f, 0x0a, 0x0d, 0x46, 0x6f,
+	0x72, 0x6d, 0x61, 0x74, 0x4e, 0x76, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x42, 0x39, 0x5a, 0x37, 0x67,
+	0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x61, 0x6f, 0x73, 0x2d, 0x73,
+	0x74, 0x61, 0x63, 0x6b, 0x2f, 0x64, 0x61, 0x6f, 0x73, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x63, 0x6f,
+	0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2f, 0x63, 0x74, 0x6c, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -494,30 +301,24 @@ func file_ctl_storage_nvme_proto_rawDescGZIP() []byte {
 	return file_ctl_storage_nvme_proto_rawDescData
 }
 
-var file_ctl_storage_nvme_proto_msgTypes = make([]protoimpl.MessageInfo, 6)
+var file_ctl_storage_nvme_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
 var file_ctl_storage_nvme_proto_goTypes = []interface{}{
-	(*NvmeController)(nil),           // 0: ctl.NvmeController
-	(*NvmeControllerResult)(nil),     // 1: ctl.NvmeControllerResult
-	(*ScanNvmeReq)(nil),              // 2: ctl.ScanNvmeReq
-	(*ScanNvmeResp)(nil),             // 3: ctl.ScanNvmeResp
-	(*FormatNvmeReq)(nil),            // 4: ctl.FormatNvmeReq
-	(*NvmeController_Namespace)(nil), // 5: ctl.NvmeController.Namespace
-	(*BioHealthResp)(nil),            // 6: ctl.BioHealthResp
-	(*SmdDevice)(nil),                // 7: ctl.SmdDevice
-	(*ResponseState)(nil),            // 8: ctl.ResponseState
+	(*NvmeControllerResult)(nil), // 0: ctl.NvmeControllerResult
+	(*ScanNvmeReq)(nil),          // 1: ctl.ScanNvmeReq
+	(*ScanNvmeResp)(nil),         // 2: ctl.ScanNvmeResp
+	(*FormatNvmeReq)(nil),        // 3: ctl.FormatNvmeReq
+	(*ResponseState)(nil),        // 4: ctl.ResponseState
+	(*NvmeController)(nil),       // 5: ctl.NvmeController
 }
 var file_ctl_storage_nvme_proto_depIdxs = []int32{
-	6, // 0: ctl.NvmeController.health_stats:type_name -> ctl.BioHealthResp
-	5, // 1: ctl.NvmeController.namespaces:type_name -> ctl.NvmeController.Namespace
-	7, // 2: ctl.NvmeController.smd_devices:type_name -> ctl.SmdDevice
-	8, // 3: ctl.NvmeControllerResult.state:type_name -> ctl.ResponseState
-	0, // 4: ctl.ScanNvmeResp.ctrlrs:type_name -> ctl.NvmeController
-	8, // 5: ctl.ScanNvmeResp.state:type_name -> ctl.ResponseState
-	6, // [6:6] is the sub-list for method output_type
-	6, // [6:6] is the sub-list for method input_type
-	6, // [6:6] is the sub-list for extension type_name
-	6, // [6:6] is the sub-list for extension extendee
-	0, // [0:6] is the sub-list for field type_name
+	4, // 0: ctl.NvmeControllerResult.state:type_name -> ctl.ResponseState
+	5, // 1: ctl.ScanNvmeResp.ctrlrs:type_name -> ctl.NvmeController
+	4, // 2: ctl.ScanNvmeResp.state:type_name -> ctl.ResponseState
+	3, // [3:3] is the sub-list for method output_type
+	3, // [3:3] is the sub-list for method input_type
+	3, // [3:3] is the sub-list for extension type_name
+	3, // [3:3] is the sub-list for extension extendee
+	0, // [0:3] is the sub-list for field type_name
 }
 
 func init() { file_ctl_storage_nvme_proto_init() }
@@ -529,18 +330,6 @@ func file_ctl_storage_nvme_proto_init() {
 	file_ctl_smd_proto_init()
 	if !protoimpl.UnsafeEnabled {
 		file_ctl_storage_nvme_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*NvmeController); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_ctl_storage_nvme_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*NvmeControllerResult); i {
 			case 0:
 				return &v.state
@@ -552,7 +341,7 @@ func file_ctl_storage_nvme_proto_init() {
 				return nil
 			}
 		}
-		file_ctl_storage_nvme_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+		file_ctl_storage_nvme_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*ScanNvmeReq); i {
 			case 0:
 				return &v.state
@@ -564,7 +353,7 @@ func file_ctl_storage_nvme_proto_init() {
 				return nil
 			}
 		}
-		file_ctl_storage_nvme_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+		file_ctl_storage_nvme_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*ScanNvmeResp); i {
 			case 0:
 				return &v.state
@@ -576,7 +365,7 @@ func file_ctl_storage_nvme_proto_init() {
 				return nil
 			}
 		}
-		file_ctl_storage_nvme_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+		file_ctl_storage_nvme_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*FormatNvmeReq); i {
 			case 0:
 				return &v.state
@@ -588,18 +377,6 @@ func file_ctl_storage_nvme_proto_init() {
 				return nil
 			}
 		}
-		file_ctl_storage_nvme_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*NvmeController_Namespace); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
 	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
@@ -607,7 +384,7 @@ func file_ctl_storage_nvme_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_ctl_storage_nvme_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   6,
+			NumMessages:   4,
 			NumExtensions: 0,
 			NumServices:   0,
 		},
diff --git a/src/control/common/proto/types_test.go b/src/control/common/proto/types_test.go
index 50382450784..d677eca1160 100644
--- a/src/control/common/proto/types_test.go
+++ b/src/control/common/proto/types_test.go
@@ -46,11 +46,13 @@ func TestProto_ConvertNvmeHealth(t *testing.T) {
 
 func TestProto_ConvertSmdDevice(t *testing.T) {
 	pb := MockSmdDevice("0000:80:00.0", 1)
+	pb.Ctrlr.HealthStats = MockNvmeHealth(1)
 	native, err := (*SmdDevice)(pb).ToNative()
 	if err != nil {
 		t.Fatal(err)
 	}
 	expNative := storage.MockSmdDevice("0000:80:00.0", 1)
+	expNative.Ctrlr.HealthStats = storage.MockNvmeHealth(1)
 
 	if diff := cmp.Diff(expNative, native, test.DefaultCmpOpts()...); diff != "" {
 		t.Fatalf("unexpected result (-want, +got):\n%s\n", diff)
diff --git a/src/control/lib/control/mocks.go b/src/control/lib/control/mocks.go
index e180f749de5..8427cbd6846 100644
--- a/src/control/lib/control/mocks.go
+++ b/src/control/lib/control/mocks.go
@@ -678,7 +678,7 @@ func MockStorageScanResp(t *testing.T,
 		smdDevice.UsableBytes = mockNvmeConfig.UsableBytes
 		smdDevice.TotalBytes = mockNvmeConfig.TotalBytes
 		if mockNvmeConfig.NvmeState != nil {
-			smdDevice.NvmeState = *mockNvmeConfig.NvmeState
+			smdDevice.Ctrlr.NvmeState = *mockNvmeConfig.NvmeState
 		}
 		if mockNvmeConfig.NvmeRole != nil {
 			smdDevice.Roles = *mockNvmeConfig.NvmeRole
diff --git a/src/control/lib/control/pool.go b/src/control/lib/control/pool.go
index da2e93b0f19..3036eaa4456 100644
--- a/src/control/lib/control/pool.go
+++ b/src/control/lib/control/pool.go
@@ -1365,31 +1365,31 @@ func processNVMeSpaceStats(log debugLogger, filterRank filterRankFn, nvmeControl
 		for _, smdDevice := range nvmeController.SmdDevices {
 			if !smdDevice.Roles.IsEmpty() && (smdDevice.Roles.OptionBits&storage.BdevRoleData) == 0 {
 				log.Debugf("Skipping SMD device %s (rank %d, ctrlr %s) not used for storing data",
-					smdDevice.UUID, smdDevice.Rank, smdDevice.TrAddr, smdDevice.Rank)
+					smdDevice.UUID, smdDevice.Rank, smdDevice.Ctrlr.PciAddr, smdDevice.Rank)
 				continue
 			}
 
-			if smdDevice.NvmeState != storage.NvmeStateNormal {
+			if smdDevice.Ctrlr.NvmeState != storage.NvmeStateNormal {
 				return errors.Errorf("SMD device %s (rank %d, ctrlr %s) not usable (device state %q)",
-					smdDevice.UUID, smdDevice.Rank, smdDevice.TrAddr, smdDevice.NvmeState.String())
+					smdDevice.UUID, smdDevice.Rank, smdDevice.Ctrlr.PciAddr, smdDevice.Ctrlr.NvmeState.String())
 				continue
 			}
 
 			if !filterRank(smdDevice.Rank) {
 				log.Debugf("Skipping SMD device %s (rank %d, ctrlr %s) not in ranklist",
-					smdDevice.UUID, smdDevice.Rank, smdDevice.TrAddr, smdDevice.Rank)
+					smdDevice.UUID, smdDevice.Rank, smdDevice.Ctrlr.PciAddr, smdDevice.Rank)
 				continue
 			}
 
 			if _, exists := rankNVMeFreeSpace[smdDevice.Rank]; !exists {
 				return errors.Errorf("Rank %d without SCM device and at least one SMD device %s (rank %d, ctrlr %s)",
-					smdDevice.Rank, smdDevice.UUID, smdDevice.Rank, smdDevice.TrAddr)
+					smdDevice.Rank, smdDevice.UUID, smdDevice.Rank, smdDevice.Ctrlr.PciAddr)
 			}
 
 			rankNVMeFreeSpace[smdDevice.Rank] += smdDevice.UsableBytes
 
 			log.Debugf("Added SMD device %s (rank %d, ctrlr %s) is usable: device state=%q, smd-size=%d ctrlr-total-free=%d",
-				smdDevice.UUID, smdDevice.Rank, smdDevice.TrAddr, smdDevice.NvmeState.String(),
+				smdDevice.UUID, smdDevice.Rank, smdDevice.Ctrlr.PciAddr, smdDevice.Ctrlr.NvmeState.String(),
 				smdDevice.UsableBytes, rankNVMeFreeSpace[smdDevice.Rank])
 		}
 	}
diff --git a/src/control/lib/control/server_meta.go b/src/control/lib/control/server_meta.go
index fb0cb984c36..22a0e0e928a 100644
--- a/src/control/lib/control/server_meta.go
+++ b/src/control/lib/control/server_meta.go
@@ -1,5 +1,5 @@
 //
-// (C) Copyright 2020-2022 Intel Corporation.
+// (C) Copyright 2020-2023 Intel Corporation.
 //
 // SPDX-License-Identifier: BSD-2-Clause-Patent
 //
@@ -112,23 +112,17 @@ func (sr *SmdResp) addHostQueryResponse(hr *HostResponse, faultyOnly bool) error
 		rank := ranklist.Rank(rResp.Rank)
 
 		for _, pbDev := range rResp.GetDevices() {
-			if faultyOnly && (pbDev.Details.DevState != ctlpb.NvmeDevState_EVICTED) {
+			isEvicted := pbDev.Ctrlr.DevState == ctlpb.NvmeDevState_EVICTED
+			if faultyOnly && !isEvicted {
 				continue
 			}
 
 			sd := new(storage.SmdDevice)
-			if err := convert.Types(pbDev.Details, sd); err != nil {
-				return errors.Wrapf(err, "converting %T to %T", pbDev.Details, sd)
+			if err := convert.Types(pbDev, sd); err != nil {
+				return errors.Wrapf(err, "converting %T to %T", pbDev, sd)
 			}
 			sd.Rank = rank
 
-			if pbDev.Health != nil {
-				sd.Health = new(storage.NvmeHealth)
-				if err := convert.Types(pbDev.Health, sd.Health); err != nil {
-					return errors.Wrapf(err, "converting %T to %T", pbDev.Health, sd.Health)
-				}
-			}
-
 			hs.SmdInfo.Devices = append(hs.SmdInfo.Devices, sd)
 		}
 
@@ -244,7 +238,7 @@ func (sr *SmdResp) getHostManageRespErr(hr *HostResponse) error {
 			if pbResult.Device != nil {
 				id = pbResult.Device.Uuid
 				if id == "" {
-					id = pbResult.Device.TrAddr
+					id = pbResult.Device.Ctrlr.PciAddr
 				}
 				id += " "
 			}
diff --git a/src/control/lib/control/server_meta_test.go b/src/control/lib/control/server_meta_test.go
index c1d84c64748..8b74c9f70ac 100644
--- a/src/control/lib/control/server_meta_test.go
+++ b/src/control/lib/control/server_meta_test.go
@@ -1,5 +1,5 @@
 //
-// (C) Copyright 2020-2022 Intel Corporation.
+// (C) Copyright 2020-2023 Intel Corporation.
 //
 // SPDX-License-Identifier: BSD-2-Clause-Patent
 //
@@ -22,6 +22,12 @@ import (
 	"github.com/daos-stack/daos/src/control/server/storage"
 )
 
+var defMockCtrlr = storage.NvmeController{
+	PciAddr:   test.MockPCIAddr(1),
+	NvmeState: storage.NvmeStateNormal,
+	LedState:  storage.LedStateIdentify,
+}
+
 type mockSmdResp struct {
 	Hosts   string
 	SmdInfo *SmdInfo
@@ -162,32 +168,31 @@ func TestControl_SmdQuery(t *testing.T) {
 		"list devices": {
 			mic: newMockInvokerWRankResps([]*ctlpb.SmdQueryResp_RankResp{
 				{
-					Rank: 0,
-					Devices: []*ctlpb.SmdQueryResp_SmdDeviceWithHealth{
+					Devices: []*ctlpb.SmdDevice{
 						{
-							Details: &ctlpb.SmdDevice{
-								TrAddr:   test.MockPCIAddr(1),
-								Uuid:     test.MockUUID(0),
-								TgtIds:   []int32{1024, 1, 1, 2, 2, 3, 3},
+							Uuid:   test.MockUUID(0),
+							TgtIds: []int32{1024, 1, 1, 2, 2, 3, 3},
+							Ctrlr: &ctlpb.NvmeController{
+								PciAddr:  test.MockPCIAddr(1),
 								DevState: devStateNormal,
 								LedState: ledStateNormal,
-								RoleBits: storage.BdevRoleAll,
 							},
+							RoleBits: storage.BdevRoleAll,
 						},
 					},
 				},
 				{
 					Rank: 1,
-					Devices: []*ctlpb.SmdQueryResp_SmdDeviceWithHealth{
+					Devices: []*ctlpb.SmdDevice{
 						{
-							Details: &ctlpb.SmdDevice{
-								TrAddr:   test.MockPCIAddr(1),
-								Uuid:     test.MockUUID(1),
-								TgtIds:   []int32{0},
+							Uuid:   test.MockUUID(1),
+							TgtIds: []int32{0},
+							Ctrlr: &ctlpb.NvmeController{
+								PciAddr:  test.MockPCIAddr(1),
 								DevState: devStateFaulty,
 								LedState: ledStateFault,
-								RoleBits: storage.BdevRoleData,
 							},
+							RoleBits: storage.BdevRoleData,
 						},
 					},
 				},
@@ -199,24 +204,28 @@ func TestControl_SmdQuery(t *testing.T) {
 					SmdInfo: &SmdInfo{
 						Devices: []*storage.SmdDevice{
 							{
-								TrAddr:    test.MockPCIAddr(1),
 								UUID:      test.MockUUID(0),
 								Rank:      ranklist.Rank(0),
 								TargetIDs: []int32{1, 2, 3},
-								NvmeState: storage.NvmeStateNormal,
-								LedState:  storage.LedStateNormal,
+								Ctrlr: storage.NvmeController{
+									PciAddr:   test.MockPCIAddr(1),
+									NvmeState: storage.NvmeStateNormal,
+									LedState:  storage.LedStateNormal,
+								},
 								Roles: storage.BdevRoles{
 									storage.OptionBits(storage.BdevRoleAll),
 								},
 								HasSysXS: true,
 							},
 							{
-								TrAddr:    test.MockPCIAddr(1),
 								UUID:      test.MockUUID(1),
 								Rank:      ranklist.Rank(1),
 								TargetIDs: []int32{0},
-								NvmeState: storage.NvmeStateFaulty,
-								LedState:  storage.LedStateFaulty,
+								Ctrlr: storage.NvmeController{
+									PciAddr:   test.MockPCIAddr(1),
+									NvmeState: storage.NvmeStateFaulty,
+									LedState:  storage.LedStateFaulty,
+								},
 								Roles: storage.BdevRoles{
 									storage.OptionBits(storage.BdevRoleData),
 								},
@@ -229,13 +238,12 @@ func TestControl_SmdQuery(t *testing.T) {
 		},
 		"list devices; missing led state": {
 			mic: newMockInvokerWRankResps(&ctlpb.SmdQueryResp_RankResp{
-				Rank: 0,
-				Devices: []*ctlpb.SmdQueryResp_SmdDeviceWithHealth{
+				Devices: []*ctlpb.SmdDevice{
 					{
-						Details: &ctlpb.SmdDevice{
-							TrAddr:   test.MockPCIAddr(2),
-							Uuid:     test.MockUUID(1),
-							TgtIds:   []int32{1, 2, 3},
+						Uuid:   test.MockUUID(1),
+						TgtIds: []int32{1, 2, 3},
+						Ctrlr: &ctlpb.NvmeController{
+							PciAddr:  test.MockPCIAddr(2),
 							DevState: devStateNew,
 							LedState: ledStateUnknown,
 						},
@@ -249,12 +257,14 @@ func TestControl_SmdQuery(t *testing.T) {
 					SmdInfo: &SmdInfo{
 						Devices: []*storage.SmdDevice{
 							{
-								TrAddr:    test.MockPCIAddr(2),
 								Rank:      ranklist.Rank(0),
 								TargetIDs: []int32{1, 2, 3},
 								UUID:      test.MockUUID(1),
-								NvmeState: storage.NvmeStateNew,
-								LedState:  storage.LedStateUnknown,
+								Ctrlr: storage.NvmeController{
+									PciAddr:   test.MockPCIAddr(2),
+									NvmeState: storage.NvmeStateNew,
+									LedState:  storage.LedStateUnknown,
+								},
 							},
 						},
 						Pools: make(map[string][]*SmdPool),
@@ -266,12 +276,12 @@ func TestControl_SmdQuery(t *testing.T) {
 			mic: newMockInvokerWRankResps(
 				&ctlpb.SmdQueryResp_RankResp{
 					Rank: 1,
-					Devices: []*ctlpb.SmdQueryResp_SmdDeviceWithHealth{
+					Devices: []*ctlpb.SmdDevice{
 						{
-							Details: &ctlpb.SmdDevice{
-								TrAddr:   test.MockPCIAddr(1),
-								Uuid:     test.MockUUID(1),
-								TgtIds:   []int32{1, 2, 3},
+							Uuid:   test.MockUUID(1),
+							TgtIds: []int32{1, 2, 3},
+							Ctrlr: &ctlpb.NvmeController{
+								PciAddr:  test.MockPCIAddr(1),
 								DevState: devStateFaulty,
 								LedState: ledStateUnknown,
 							},
@@ -279,13 +289,12 @@ func TestControl_SmdQuery(t *testing.T) {
 					},
 				},
 				&ctlpb.SmdQueryResp_RankResp{
-					Rank: 0,
-					Devices: []*ctlpb.SmdQueryResp_SmdDeviceWithHealth{
+					Devices: []*ctlpb.SmdDevice{
 						{
-							Details: &ctlpb.SmdDevice{
-								TrAddr:   test.MockPCIAddr(2),
-								Uuid:     test.MockUUID(3),
-								TgtIds:   []int32{4, 5, 6},
+							Uuid:   test.MockUUID(3),
+							TgtIds: []int32{4, 5, 6},
+							Ctrlr: &ctlpb.NvmeController{
+								PciAddr:  test.MockPCIAddr(2),
 								DevState: devStateNormal,
 								LedState: ledStateUnknown,
 							},
@@ -300,12 +309,14 @@ func TestControl_SmdQuery(t *testing.T) {
 					SmdInfo: &SmdInfo{
 						Devices: []*storage.SmdDevice{
 							{
-								TrAddr:    test.MockPCIAddr(1),
 								UUID:      test.MockUUID(1),
 								Rank:      ranklist.Rank(1),
 								TargetIDs: []int32{1, 2, 3},
-								NvmeState: storage.NvmeStateFaulty,
-								LedState:  storage.LedStateUnknown,
+								Ctrlr: storage.NvmeController{
+									PciAddr:   test.MockPCIAddr(1),
+									NvmeState: storage.NvmeStateFaulty,
+									LedState:  storage.LedStateUnknown,
+								},
 							},
 						},
 						Pools: make(map[string][]*SmdPool),
@@ -315,29 +326,28 @@ func TestControl_SmdQuery(t *testing.T) {
 		},
 		"device health": {
 			mic: newMockInvokerWRankResps(&ctlpb.SmdQueryResp_RankResp{
-				Rank: 0,
-				Devices: []*ctlpb.SmdQueryResp_SmdDeviceWithHealth{
+				Devices: []*ctlpb.SmdDevice{
 					{
-						Details: &ctlpb.SmdDevice{
-							TrAddr:   test.MockPCIAddr(1),
-							Uuid:     test.MockUUID(1),
-							TgtIds:   []int32{1, 2, 3},
-							LedState: ledStateIdentify,
+						Uuid:   test.MockUUID(1),
+						TgtIds: []int32{1, 2, 3},
+						Ctrlr: &ctlpb.NvmeController{
+							PciAddr:  test.MockPCIAddr(1),
 							DevState: devStateNormal,
-						},
-						Health: &ctlpb.BioHealthResp{
-							DevUuid:            test.MockUUID(1),
-							Temperature:        2,
-							MediaErrs:          3,
-							BioReadErrs:        4,
-							BioWriteErrs:       5,
-							BioUnmapErrs:       6,
-							ChecksumErrs:       7,
-							TempWarn:           true,
-							AvailSpareWarn:     true,
-							ReadOnlyWarn:       true,
-							DevReliabilityWarn: true,
-							VolatileMemWarn:    true,
+							LedState: ledStateIdentify,
+							HealthStats: &ctlpb.BioHealthResp{
+								DevUuid:            test.MockUUID(1),
+								Temperature:        2,
+								MediaErrs:          3,
+								BioReadErrs:        4,
+								BioWriteErrs:       5,
+								BioUnmapErrs:       6,
+								ChecksumErrs:       7,
+								TempWarn:           true,
+								AvailSpareWarn:     true,
+								ReadOnlyWarn:       true,
+								DevReliabilityWarn: true,
+								VolatileMemWarn:    true,
+							},
 						},
 					},
 				},
@@ -349,24 +359,26 @@ func TestControl_SmdQuery(t *testing.T) {
 					SmdInfo: &SmdInfo{
 						Devices: []*storage.SmdDevice{
 							{
-								TrAddr:    test.MockPCIAddr(1),
 								UUID:      test.MockUUID(1),
 								Rank:      ranklist.Rank(0),
 								TargetIDs: []int32{1, 2, 3},
-								NvmeState: storage.NvmeStateNormal,
-								LedState:  storage.LedStateIdentify,
-								Health: &storage.NvmeHealth{
-									Temperature:     2,
-									MediaErrors:     3,
-									ReadErrors:      4,
-									WriteErrors:     5,
-									UnmapErrors:     6,
-									ChecksumErrors:  7,
-									TempWarn:        true,
-									AvailSpareWarn:  true,
-									ReadOnlyWarn:    true,
-									ReliabilityWarn: true,
-									VolatileWarn:    true,
+								Ctrlr: storage.NvmeController{
+									PciAddr:   test.MockPCIAddr(1),
+									NvmeState: storage.NvmeStateNormal,
+									LedState:  storage.LedStateIdentify,
+									HealthStats: &storage.NvmeHealth{
+										Temperature:     2,
+										MediaErrors:     3,
+										ReadErrors:      4,
+										WriteErrors:     5,
+										UnmapErrors:     6,
+										ChecksumErrors:  7,
+										TempWarn:        true,
+										AvailSpareWarn:  true,
+										ReadOnlyWarn:    true,
+										ReliabilityWarn: true,
+										VolatileWarn:    true,
+									},
 								},
 							},
 						},
@@ -638,11 +650,13 @@ func TestControl_SmdManage(t *testing.T) {
 				Results: []*ctlpb.SmdManageResp_Result{
 					{
 						Device: &ctlpb.SmdDevice{
-							TrAddr:   test.MockPCIAddr(1),
-							Uuid:     test.MockUUID(1),
-							TgtIds:   []int32{1024, 1, 1, 2, 2, 3, 3},
-							LedState: ledStateIdentify,
-							DevState: devStateNormal,
+							Uuid:   test.MockUUID(1),
+							TgtIds: []int32{1024, 1, 1, 2, 2, 3, 3},
+							Ctrlr: &ctlpb.NvmeController{
+								PciAddr:  test.MockPCIAddr(1),
+								LedState: ledStateIdentify,
+								DevState: devStateNormal,
+							},
 							RoleBits: storage.BdevRoleAll,
 						},
 					},
@@ -654,12 +668,10 @@ func TestControl_SmdManage(t *testing.T) {
 					SmdInfo: &SmdInfo{
 						Devices: []*storage.SmdDevice{
 							{
-								TrAddr:    test.MockPCIAddr(1),
 								UUID:      test.MockUUID(1),
 								Rank:      ranklist.Rank(0),
 								TargetIDs: []int32{1, 2, 3},
-								NvmeState: storage.NvmeStateNormal,
-								LedState:  storage.LedStateIdentify,
+								Ctrlr:     defMockCtrlr,
 								Roles: storage.BdevRoles{
 									storage.OptionBits(storage.BdevRoleAll),
 								},
@@ -681,7 +693,9 @@ func TestControl_SmdManage(t *testing.T) {
 					{
 						Status: int32(daos.Busy),
 						Device: &ctlpb.SmdDevice{
-							TrAddr: test.MockPCIAddr(1),
+							Ctrlr: &ctlpb.NvmeController{
+								PciAddr: test.MockPCIAddr(1),
+							},
 						},
 					},
 				},
@@ -697,8 +711,10 @@ func TestControl_SmdManage(t *testing.T) {
 					SmdInfo: &SmdInfo{
 						Devices: []*storage.SmdDevice{
 							{
-								TrAddr:    test.MockPCIAddr(1),
 								TargetIDs: []int32{},
+								Ctrlr: storage.NvmeController{
+									PciAddr: test.MockPCIAddr(1),
+								},
 							},
 						},
 					},
diff --git a/src/control/lib/spdk/include/nvme_control_common.h b/src/control/lib/spdk/include/nvme_control_common.h
index 92804315211..4e983d2ac91 100644
--- a/src/control/lib/spdk/include/nvme_control_common.h
+++ b/src/control/lib/spdk/include/nvme_control_common.h
@@ -1,75 +1,51 @@
 /**
-* (C) Copyright 2019-2021 Intel Corporation.
-*
-* SPDX-License-Identifier: BSD-2-Clause-Patent
-*/
+ * (C) Copyright 2019-2023 Intel Corporation.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause-Patent
+ */
 
 #ifndef NVMECONTROL_COMMON_H
 #define NVMECONTROL_COMMON_H
 
 #include <stdbool.h>
 #include <spdk/nvme_intel.h>
-
-#define BUFLEN 1024
+#include <daos_srv/control.h>
 
 /**
  * \brief NVMECONTROL return codes
  */
 enum nvme_control_status_code {
-	NVMEC_SUCCESS			= 0x0,
-	NVMEC_ERR_CHK_SIZE		= 0x1,
-	NVMEC_ERR_GET_PCI_DEV		= 0x2,
-	NVMEC_ERR_PCI_ADDR_FMT		= 0x3,
-	NVMEC_ERR_PCI_ADDR_PARSE	= 0x4,
-	NVMEC_ERR_CTRLR_NOT_FOUND	= 0x5,
-	NVMEC_ERR_NS_NOT_FOUND		= 0x6,
-	NVMEC_ERR_NOT_SUPPORTED		= 0x7,
-	NVMEC_ERR_BAD_LBA		= 0x8,
-	NVMEC_ERR_ALLOC_IO_QPAIR	= 0x9,
-	NVMEC_ERR_NS_ID_UNEXPECTED	= 0xA,
-	NVMEC_ERR_NS_WRITE_FAIL		= 0xB,
-	NVMEC_ERR_MULTIPLE_ACTIVE_NS	= 0xC,
-	NVMEC_ERR_NULL_NS		= 0xD,
-	NVMEC_ERR_ALLOC_SEQUENCE_BUF	= 0xE,
-	NVMEC_ERR_NO_VMD_CTRLRS		= 0xF,
-	NVMEC_ERR_WRITE_TRUNC		= 0x10,
+	NVMEC_SUCCESS                = 0x0,
+	NVMEC_ERR_CHK_SIZE           = 0x1,
+	NVMEC_ERR_GET_PCI_DEV        = 0x2,
+	NVMEC_ERR_PCI_ADDR_FMT       = 0x3,
+	NVMEC_ERR_PCI_ADDR_PARSE     = 0x4,
+	NVMEC_ERR_CTRLR_NOT_FOUND    = 0x5,
+	NVMEC_ERR_NS_NOT_FOUND       = 0x6,
+	NVMEC_ERR_NOT_SUPPORTED      = 0x7,
+	NVMEC_ERR_BAD_LBA            = 0x8,
+	NVMEC_ERR_ALLOC_IO_QPAIR     = 0x9,
+	NVMEC_ERR_NS_ID_UNEXPECTED   = 0xA,
+	NVMEC_ERR_NS_WRITE_FAIL      = 0xB,
+	NVMEC_ERR_MULTIPLE_ACTIVE_NS = 0xC,
+	NVMEC_ERR_NULL_NS            = 0xD,
+	NVMEC_ERR_ALLOC_SEQUENCE_BUF = 0xE,
+	NVMEC_ERR_NO_VMD_CTRLRS      = 0xF,
+	NVMEC_ERR_WRITE_TRUNC        = 0x10,
+	NVMEC_ERR_GET_PCI_TYPE       = 0x11,
 	NVMEC_LAST_STATUS_VALUE
 };
 
-/**
- * \brief NVMe controller details
- */
-struct ctrlr_t {
-	char				 model[BUFLEN];
-	char				 serial[BUFLEN];
-	char				 pci_addr[BUFLEN];
-	char				 fw_rev[BUFLEN];
-	char				 pci_type[BUFLEN];
-	int				 socket_id;
-	struct ns_t			*nss;
-	struct nvme_stats		*stats;
-	struct ctrlr_t			*next;
-};
-
-/**
- * \brief NVMe namespace details
- */
-struct ns_t {
-	uint32_t	id;
-	uint64_t	size;
-	struct ns_t    *next;
-};
-
 /**
  * \brief Result struct for namespace wipe operation containing return code,
  * namespace id, parent controller pci address, info message and link to next
  * list element.
  */
 struct wipe_res_t {
-	char			 ctrlr_pci_addr[BUFLEN];
+	char                     ctrlr_pci_addr[NVME_DETAIL_BUFLEN];
 	uint32_t		 ns_id;
 	int			 rc;
-	char			 info[BUFLEN];
+	char                     info[NVME_DETAIL_BUFLEN];
 	struct wipe_res_t	*next;
 };
 
@@ -81,7 +57,7 @@ struct ret_t {
 	struct ctrlr_t		*ctrlrs;
 	struct wipe_res_t	*wipe_results;
 	int			 rc;
-	char			 info[BUFLEN];
+	char                     info[NVME_DETAIL_BUFLEN];
 };
 
 struct ctrlr_entry {
diff --git a/src/control/lib/spdk/nvme_default.go b/src/control/lib/spdk/nvme_default.go
index f9e65f89ff7..1f3d8a1b404 100644
--- a/src/control/lib/spdk/nvme_default.go
+++ b/src/control/lib/spdk/nvme_default.go
@@ -104,10 +104,10 @@ func (n *NvmeImpl) Update(log logging.Logger, ctrlrPciAddr string, path string,
 // c2GoController is a private translation function.
 func c2GoController(ctrlr *C.struct_ctrlr_t) *storage.NvmeController {
 	return &storage.NvmeController{
-		Model:    C.GoString(&ctrlr.model[0]),
-		Serial:   C.GoString(&ctrlr.serial[0]),
-		PciAddr:  C.GoString(&ctrlr.pci_addr[0]),
-		FwRev:    C.GoString(&ctrlr.fw_rev[0]),
+		Model:    C.GoString(ctrlr.model),
+		Serial:   C.GoString(ctrlr.serial),
+		PciAddr:  C.GoString(ctrlr.pci_addr),
+		FwRev:    C.GoString(ctrlr.fw_rev),
 		SocketID: int32(ctrlr.socket_id),
 	}
 }
diff --git a/src/control/lib/spdk/src/nvme_control_common.c b/src/control/lib/spdk/src/nvme_control_common.c
index 929d90b561f..e4a6ade3ed5 100644
--- a/src/control/lib/spdk/src/nvme_control_common.c
+++ b/src/control/lib/spdk/src/nvme_control_common.c
@@ -1,8 +1,8 @@
 /**
-* (C) Copyright 2019-2022 Intel Corporation.
-*
-* SPDX-License-Identifier: BSD-2-Clause-Patent
-*/
+ * (C) Copyright 2019-2023 Intel Corporation.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause-Patent
+ */
 
 #include <spdk/stdinc.h>
 #include <spdk/nvme.h>
@@ -124,6 +124,21 @@ init_ret(void)
 	return ret;
 }
 
+static void
+free_ctrlr_fields(struct ctrlr_t *ctrlr)
+{
+	if (ctrlr->model != NULL)
+		free(ctrlr->model);
+	if (ctrlr->serial != NULL)
+		free(ctrlr->serial);
+	if (ctrlr->fw_rev != NULL)
+		free(ctrlr->fw_rev);
+	if (ctrlr->vendor_id != NULL)
+		free(ctrlr->vendor_id);
+	if (ctrlr->pci_type != NULL)
+		free(ctrlr->pci_type);
+}
+
 void
 clean_ret(struct ret_t *ret)
 {
@@ -146,6 +161,7 @@ clean_ret(struct ret_t *ret)
 		if (ret->ctrlrs->stats)
 			free(ret->ctrlrs->stats);
 
+		free_ctrlr_fields(ret->ctrlrs);
 		cnext = ret->ctrlrs->next;
 		free(ret->ctrlrs);
 		ret->ctrlrs = cnext;
@@ -234,19 +250,44 @@ _discover(prober probe, bool detach, health_getter get_health)
 }
 
 static int
-copy_ctrlr_data(struct ctrlr_t *cdst, const struct spdk_nvme_ctrlr_data *cdata)
+str2ctrlr(char **dst, const void *src)
 {
-	if (copy_ascii(cdst->model, sizeof(cdst->model), cdata->mn,
-		       sizeof(cdata->mn)) != 0)
-		return -NVMEC_ERR_CHK_SIZE;
+	int len;
 
-	if (copy_ascii(cdst->serial, sizeof(cdst->serial), cdata->sn,
-		       sizeof(cdata->sn)) != 0)
-		return -NVMEC_ERR_CHK_SIZE;
+	assert(src != NULL);
+	assert(dst != NULL);
+	assert(*dst == NULL);
 
-	if (copy_ascii(cdst->fw_rev, sizeof(cdst->fw_rev), cdata->fr,
-		       sizeof(cdata->fr)) != 0)
+	len  = sizeof(src);
+	*dst = calloc(1, len + 1);
+	if (*dst == NULL)
+		return -ENOMEM;
+
+	if (copy_ascii(*dst, len + 1, src, len) != 0) {
+		perror("copy_ascii");
 		return -NVMEC_ERR_CHK_SIZE;
+	}
+
+	return 0;
+}
+
+static int
+copy_ctrlr_data(struct ctrlr_t *cdst, const struct spdk_nvme_ctrlr_data *cdata)
+{
+	int rc;
+
+	rc = str2ctrlr(&cdst->model, cdata->mn);
+	if (rc != 0) {
+		return rc;
+	}
+	rc = str2ctrlr(&cdst->serial, cdata->sn);
+	if (rc != 0) {
+		return rc;
+	}
+	rc = str2ctrlr(&cdst->fw_rev, cdata->fr);
+	if (rc != 0) {
+		return rc;
+	}
 
 	return 0;
 }
@@ -316,7 +357,7 @@ populate_dev_health(struct nvme_stats *stats,
 				   true : false;
 
 	/* Intel Smart Information Attributes */
-	if (cdata->vid != SPDK_PCI_VID_INTEL)
+	if ((cdata == NULL) || (cdata->vid != SPDK_PCI_VID_INTEL))
 		return;
 	for (i = 0; i < SPDK_COUNTOF(isp->attributes); i++) {
 		if (isp->attributes[i].code ==
@@ -417,7 +458,9 @@ _collect(struct ret_t *ret, data_copier copy_data, pci_getter get_pci,
 	struct spdk_pci_device			*pci_dev;
 	struct nvme_stats			*cstats;
 	struct ctrlr_t				*ctrlr_tmp;
-	int					 rc, written;
+	const char                              *pci_type;
+	int                                      len;
+	int                                      rc;
 
 	ctrlr_entry = g_controllers;
 
@@ -428,23 +471,31 @@ _collect(struct ret_t *ret, data_copier copy_data, pci_getter get_pci,
 			goto fail;
 		}
 
-		ctrlr_tmp->nss = NULL;
-		ctrlr_tmp->stats = NULL;
-		ctrlr_tmp->next = NULL;
-
 		cdata = spdk_nvme_ctrlr_get_data(ctrlr_entry->ctrlr);
 
 		rc = copy_data(ctrlr_tmp, cdata);
 		if (rc != 0)
 			goto fail;
 
-		rc = spdk_pci_addr_fmt(ctrlr_tmp->pci_addr,
-				       sizeof(ctrlr_tmp->pci_addr),
+		ctrlr_tmp->pci_addr = calloc(1, SPDK_NVMF_TRADDR_MAX_LEN + 1);
+		if (!ctrlr_tmp->pci_addr) {
+			rc = -ENOMEM;
+			goto fail;
+		}
+
+		rc = spdk_pci_addr_fmt(ctrlr_tmp->pci_addr, SPDK_NVMF_TRADDR_MAX_LEN,
 				       &ctrlr_entry->pci_addr);
 		if (rc != 0) {
 			rc = -NVMEC_ERR_PCI_ADDR_FMT;
 			goto fail;
 		}
+		len = strnlen(ctrlr_tmp->pci_addr, NVME_DETAIL_BUFLEN);
+		if ((len == 0) || (len == NVME_DETAIL_BUFLEN)) {
+			rc = -NVMEC_ERR_PCI_ADDR_FMT;
+			goto fail;
+		}
+
+		/* Populate numa socket id & pci device type */
 
 		pci_dev = get_pci(ctrlr_entry->ctrlr);
 		if (!pci_dev) {
@@ -452,17 +503,15 @@ _collect(struct ret_t *ret, data_copier copy_data, pci_getter get_pci,
 			goto fail;
 		}
 
-		/* populate numa socket id & pci device type */
 		ctrlr_tmp->socket_id = get_socket_id(pci_dev);
-		written = snprintf(ctrlr_tmp->pci_type,
-				   sizeof(ctrlr_tmp->pci_type), "%s",
-				   spdk_pci_device_get_type(pci_dev));
-		if (written >= sizeof(ctrlr_tmp->pci_type)) {
-			rc = -NVMEC_ERR_CHK_SIZE;
-			free(pci_dev);
+
+		pci_type = spdk_pci_device_get_type(pci_dev);
+		free(pci_dev);
+		ctrlr_tmp->pci_type = strndup(pci_type, NVME_DETAIL_BUFLEN);
+		if (ctrlr_tmp->pci_type == NULL) {
+			rc = -NVMEC_ERR_GET_PCI_TYPE;
 			goto fail;
 		}
-		free(pci_dev);
 
 		/* Alloc linked list of namespaces per controller */
 		if (ctrlr_entry->nss) {
@@ -497,8 +546,10 @@ _collect(struct ret_t *ret, data_copier copy_data, pci_getter get_pci,
 	if (ret->rc == 0)
 		/* Catch unexpected failures */
 		ret->rc = -EINVAL;
-	if (ctrlr_tmp)
+	if (ctrlr_tmp) {
+		free_ctrlr_fields(ctrlr_tmp);
 		free(ctrlr_tmp);
+	}
 	clean_ret(ret);
 	return;
 }
diff --git a/src/control/server/ctl_smd_rpc.go b/src/control/server/ctl_smd_rpc.go
index 6f8ba75ab97..6fd41f2b1ba 100644
--- a/src/control/server/ctl_smd_rpc.go
+++ b/src/control/server/ctl_smd_rpc.go
@@ -44,74 +44,13 @@ func queryRank(reqRank uint32, engineRank ranklist.Rank) bool {
 
 func (svc *ControlService) querySmdDevices(ctx context.Context, req *ctlpb.SmdQueryReq, resp *ctlpb.SmdQueryResp) error {
 	for _, ei := range svc.harness.Instances() {
-		if !ei.IsReady() {
-			svc.log.Debugf("skipping not-ready instance %d", ei.Index())
-			continue
-		}
-
-		engineRank, err := ei.GetRank()
+		rResp, err := smdQueryEngine(ctx, ei, req)
 		if err != nil {
 			return err
 		}
-		if !queryRank(req.GetRank(), engineRank) {
-			continue
-		}
-
-		rResp := new(ctlpb.SmdQueryResp_RankResp)
-		rResp.Rank = engineRank.Uint32()
-
-		listDevsResp, err := ei.ListSmdDevices(ctx, new(ctlpb.SmdDevReq))
-		if err != nil {
-			return errors.Wrapf(err, "rank %d", engineRank)
-		}
-
-		if len(listDevsResp.Devices) == 0 {
-			rResp.Devices = nil
+		// If rank hasn't been requested, don't include its response.
+		if rResp != nil {
 			resp.Ranks = append(resp.Ranks, rResp)
-			continue
-		}
-
-		// For each SmdDevice returned in list devs response, append a SmdDeviceWithHealth.
-		for _, sd := range listDevsResp.Devices {
-			rResp.Devices = append(rResp.Devices, &ctlpb.SmdQueryResp_SmdDeviceWithHealth{
-				Details: sd,
-			})
-		}
-		resp.Ranks = append(resp.Ranks, rResp)
-
-		if req.Uuid != "" {
-			found := false
-			for _, dev := range rResp.Devices {
-				if dev.Details.Uuid == req.Uuid {
-					rResp.Devices = []*ctlpb.SmdQueryResp_SmdDeviceWithHealth{dev}
-					found = true
-					break
-				}
-			}
-			if !found {
-				rResp.Devices = nil
-			}
-		}
-
-		for _, dev := range rResp.Devices {
-			state := dev.Details.DevState
-
-			// skip health query if the device is not in a normal or faulty state
-			if req.IncludeBioHealth {
-				if state != ctlpb.NvmeDevState_NEW {
-					health, err := ei.GetBioHealth(ctx, &ctlpb.BioHealthReq{
-						DevUuid: dev.Details.Uuid,
-					})
-					if err != nil {
-						return errors.Wrapf(err, "device %q, state %q",
-							dev, state)
-					}
-					dev.Health = health
-					continue
-				}
-				svc.log.Debugf("skip fetching health stats on device %q in NEW state",
-					dev, state)
-			}
 		}
 	}
 
@@ -318,34 +257,30 @@ func (svc *ControlService) mapIDsToEngine(ctx context.Context, ids string, useTr
 			if dev == nil {
 				return nil, errors.New("nil device in smd query resp")
 			}
-			dds := dev.Details
-			if dds == nil {
-				return nil, errors.New("device with nil details in smd query resp")
-			}
-			if dds.TrAddr == "" {
+			if dev.Ctrlr.PciAddr == "" {
 				svc.log.Errorf("No transport address associated with device %s",
-					dds.Uuid)
+					dev.Uuid)
 			}
 
-			matchUUID := dds.Uuid != "" && devUUIDs[dds.Uuid]
+			matchUUID := dev.Uuid != "" && devUUIDs[dev.Uuid]
 
 			// Where possible specify the TrAddr over UUID as there may be multiple
 			// UUIDs mapping to the same TrAddr.
-			if useTrAddr && dds.TrAddr != "" {
-				if matchAll || matchUUID || trAddrs[dds.TrAddr] {
+			if useTrAddr && dev.Ctrlr.PciAddr != "" {
+				if matchAll || matchUUID || trAddrs[dev.Ctrlr.PciAddr] {
 					// If UUID matches, add by TrAddr rather than UUID which
 					// should avoid duplicate UUID entries for the same TrAddr.
-					edm.add(engine, devID{trAddr: dds.TrAddr})
-					delete(trAddrs, dds.TrAddr)
-					delete(devUUIDs, dds.Uuid)
+					edm.add(engine, devID{trAddr: dev.Ctrlr.PciAddr})
+					delete(trAddrs, dev.Ctrlr.PciAddr)
+					delete(devUUIDs, dev.Uuid)
 					continue
 				}
 			}
 
 			if matchUUID {
 				// Only add UUID entry if TrAddr is not available for a device.
-				edm.add(engine, devID{uuid: dds.Uuid})
-				delete(devUUIDs, dds.Uuid)
+				edm.add(engine, devID{uuid: dev.Uuid})
+				delete(devUUIDs, dev.Uuid)
 			}
 		}
 	}
@@ -390,7 +325,10 @@ func addManageRespIDOnFail(log logging.Logger, res *ctlpb.SmdManageResp_Result,
 	if res.Device == nil {
 		// Populate id so failure can be mapped to a device.
 		res.Device = &ctlpb.SmdDevice{
-			TrAddr: dev.trAddr, Uuid: dev.uuid,
+			Ctrlr: &ctlpb.NvmeController{
+				PciAddr: dev.trAddr,
+			},
+			Uuid: dev.uuid,
 		}
 	}
 }
diff --git a/src/control/server/ctl_smd_rpc_test.go b/src/control/server/ctl_smd_rpc_test.go
index 8374f64c375..9cbdaeafbbe 100644
--- a/src/control/server/ctl_smd_rpc_test.go
+++ b/src/control/server/ctl_smd_rpc_test.go
@@ -34,6 +34,51 @@ const (
 	ledStateUnknown  = ctlpb.LedState_NA
 )
 
+func pbNewDev(i int32) *ctlpb.SmdDevice {
+	return &ctlpb.SmdDevice{
+		Uuid: test.MockUUID(i),
+		Ctrlr: &ctlpb.NvmeController{
+			PciAddr:  test.MockPCIAddr(i),
+			DevState: devStateNew,
+			LedState: ledStateNormal,
+		},
+	}
+}
+func pbNormDev(i int32) *ctlpb.SmdDevice {
+	return &ctlpb.SmdDevice{
+		Uuid: test.MockUUID(i),
+		Ctrlr: &ctlpb.NvmeController{
+			PciAddr:  test.MockPCIAddr(i),
+			DevState: devStateNormal,
+			LedState: ledStateNormal,
+		},
+	}
+}
+func pbFaultDev(i int32) *ctlpb.SmdDevice {
+	return &ctlpb.SmdDevice{
+		Uuid: test.MockUUID(i),
+		Ctrlr: &ctlpb.NvmeController{
+			PciAddr:  test.MockPCIAddr(i),
+			DevState: devStateFaulty,
+			LedState: ledStateFault,
+		},
+	}
+}
+func pbIdentDev(i int32) *ctlpb.SmdDevice {
+	return &ctlpb.SmdDevice{
+		Uuid: test.MockUUID(i),
+		Ctrlr: &ctlpb.NvmeController{
+			PciAddr:  test.MockPCIAddr(i),
+			DevState: devStateNormal,
+			LedState: ledStateIdentify,
+		},
+	}
+}
+func pbDevWithHealth(sd *ctlpb.SmdDevice, h *ctlpb.BioHealthResp) *ctlpb.SmdDevice {
+	sd.Ctrlr.HealthStats = h
+	return sd
+}
+
 func TestServer_CtlSvc_SmdQuery(t *testing.T) {
 	for name, tc := range map[string]struct {
 		setupAP        bool
@@ -205,18 +250,22 @@ func TestServer_CtlSvc_SmdQuery(t *testing.T) {
 						Message: &ctlpb.SmdDevResp{
 							Devices: []*ctlpb.SmdDevice{
 								{
-									Uuid:     test.MockUUID(0),
-									TrAddr:   "0000:8a:00.0",
-									TgtIds:   []int32{0, 1, 2},
-									DevState: devStateNormal,
-									LedState: ledStateNormal,
+									Uuid:   test.MockUUID(0),
+									TgtIds: []int32{0, 1, 2},
+									Ctrlr: &ctlpb.NvmeController{
+										PciAddr:  "0000:8a:00.0",
+										DevState: devStateNormal,
+										LedState: ledStateNormal,
+									},
 								},
 								{
-									Uuid:     test.MockUUID(1),
-									TrAddr:   "0000:80:00.0",
-									TgtIds:   []int32{3, 4, 5},
-									DevState: devStateFaulty,
-									LedState: ledStateFault,
+									Uuid:   test.MockUUID(1),
+									TgtIds: []int32{3, 4, 5},
+									Ctrlr: &ctlpb.NvmeController{
+										PciAddr:  "0000:80:00.0",
+										DevState: devStateFaulty,
+										LedState: ledStateFault,
+									},
 								},
 							},
 						},
@@ -227,18 +276,22 @@ func TestServer_CtlSvc_SmdQuery(t *testing.T) {
 						Message: &ctlpb.SmdDevResp{
 							Devices: []*ctlpb.SmdDevice{
 								{
-									Uuid:     test.MockUUID(2),
-									TrAddr:   "0000:da:00.0",
-									TgtIds:   []int32{0, 1, 2},
-									DevState: devStateFaulty,
-									LedState: ledStateUnknown,
+									Uuid:   test.MockUUID(2),
+									TgtIds: []int32{0, 1, 2},
+									Ctrlr: &ctlpb.NvmeController{
+										PciAddr:  "0000:da:00.0",
+										DevState: devStateFaulty,
+										LedState: ledStateUnknown,
+									},
 								},
 								{
-									Uuid:     test.MockUUID(3),
-									TrAddr:   "0000:db:00.0",
-									TgtIds:   []int32{3, 4, 5},
-									DevState: devStateNormal,
-									LedState: ledStateIdentify,
+									Uuid:   test.MockUUID(3),
+									TgtIds: []int32{3, 4, 5},
+									Ctrlr: &ctlpb.NvmeController{
+										PciAddr:  "0000:db:00.0",
+										DevState: devStateNormal,
+										LedState: ledStateIdentify,
+									},
 								},
 							},
 						},
@@ -248,21 +301,21 @@ func TestServer_CtlSvc_SmdQuery(t *testing.T) {
 			expResp: &ctlpb.SmdQueryResp{
 				Ranks: []*ctlpb.SmdQueryResp_RankResp{
 					{
-						Devices: []*ctlpb.SmdQueryResp_SmdDeviceWithHealth{
+						Devices: []*ctlpb.SmdDevice{
 							{
-								Details: &ctlpb.SmdDevice{
-									Uuid:     test.MockUUID(0),
-									TrAddr:   "0000:8a:00.0",
-									TgtIds:   []int32{0, 1, 2},
+								Uuid:   test.MockUUID(0),
+								TgtIds: []int32{0, 1, 2},
+								Ctrlr: &ctlpb.NvmeController{
+									PciAddr:  "0000:8a:00.0",
 									DevState: devStateNormal,
 									LedState: ledStateNormal,
 								},
 							},
 							{
-								Details: &ctlpb.SmdDevice{
-									Uuid:     test.MockUUID(1),
-									TrAddr:   "0000:80:00.0",
-									TgtIds:   []int32{3, 4, 5},
+								Uuid:   test.MockUUID(1),
+								TgtIds: []int32{3, 4, 5},
+								Ctrlr: &ctlpb.NvmeController{
+									PciAddr:  "0000:80:00.0",
 									DevState: devStateFaulty,
 									LedState: ledStateFault,
 								},
@@ -271,21 +324,21 @@ func TestServer_CtlSvc_SmdQuery(t *testing.T) {
 						Rank: uint32(0),
 					},
 					{
-						Devices: []*ctlpb.SmdQueryResp_SmdDeviceWithHealth{
+						Devices: []*ctlpb.SmdDevice{
 							{
-								Details: &ctlpb.SmdDevice{
-									Uuid:     test.MockUUID(2),
-									TrAddr:   "0000:da:00.0",
-									TgtIds:   []int32{0, 1, 2},
+								Uuid:   test.MockUUID(2),
+								TgtIds: []int32{0, 1, 2},
+								Ctrlr: &ctlpb.NvmeController{
+									PciAddr:  "0000:da:00.0",
 									DevState: devStateFaulty,
 									LedState: ledStateUnknown,
 								},
 							},
 							{
-								Details: &ctlpb.SmdDevice{
-									Uuid:     test.MockUUID(3),
-									TrAddr:   "0000:db:00.0",
-									TgtIds:   []int32{3, 4, 5},
+								Uuid:   test.MockUUID(3),
+								TgtIds: []int32{3, 4, 5},
+								Ctrlr: &ctlpb.NvmeController{
+									PciAddr:  "0000:db:00.0",
 									DevState: devStateNormal,
 									LedState: ledStateIdentify,
 								},
@@ -308,8 +361,10 @@ func TestServer_CtlSvc_SmdQuery(t *testing.T) {
 							Devices: []*ctlpb.SmdDevice{
 								{
 									Uuid:   test.MockUUID(0),
-									TrAddr: "0000:8a:00.0",
 									TgtIds: []int32{0, 1, 2},
+									Ctrlr: &ctlpb.NvmeController{
+										PciAddr: "0000:db:00.0",
+									},
 								},
 							},
 						},
@@ -319,12 +374,12 @@ func TestServer_CtlSvc_SmdQuery(t *testing.T) {
 			expResp: &ctlpb.SmdQueryResp{
 				Ranks: []*ctlpb.SmdQueryResp_RankResp{
 					{
-						Devices: []*ctlpb.SmdQueryResp_SmdDeviceWithHealth{
+						Devices: []*ctlpb.SmdDevice{
 							{
-								Details: &ctlpb.SmdDevice{
-									Uuid:   test.MockUUID(0),
-									TrAddr: "0000:8a:00.0",
-									TgtIds: []int32{0, 1, 2},
+								Uuid:   test.MockUUID(0),
+								TgtIds: []int32{0, 1, 2},
+								Ctrlr: &ctlpb.NvmeController{
+									PciAddr: "0000:db:00.0",
 								},
 							},
 						},
@@ -342,26 +397,14 @@ func TestServer_CtlSvc_SmdQuery(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{
-								{
-									Uuid:     test.MockUUID(0),
-									DevState: devStateFaulty,
-									LedState: ledStateFault,
-								},
-							},
+							Devices: []*ctlpb.SmdDevice{pbFaultDev(0)},
 						},
 					},
 				},
 				1: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{
-								{
-									Uuid:     test.MockUUID(1),
-									DevState: devStateNormal,
-									LedState: ledStateNormal,
-								},
-							},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(1)},
 						},
 					},
 				},
@@ -369,16 +412,8 @@ func TestServer_CtlSvc_SmdQuery(t *testing.T) {
 			expResp: &ctlpb.SmdQueryResp{
 				Ranks: []*ctlpb.SmdQueryResp_RankResp{
 					{
-						Rank: 1,
-						Devices: []*ctlpb.SmdQueryResp_SmdDeviceWithHealth{
-							{
-								Details: &ctlpb.SmdDevice{
-									Uuid:     test.MockUUID(1),
-									DevState: devStateNormal,
-									LedState: ledStateNormal,
-								},
-							},
-						},
+						Rank:    1,
+						Devices: []*ctlpb.SmdDevice{pbNormDev(1)},
 					},
 				},
 			},
@@ -393,26 +428,14 @@ func TestServer_CtlSvc_SmdQuery(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{
-								{
-									Uuid:     test.MockUUID(0),
-									DevState: devStateNormal,
-									LedState: ledStateNormal,
-								},
-							},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(0)},
 						},
 					},
 				},
 				1: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{
-								{
-									Uuid:     test.MockUUID(1),
-									DevState: devStateFaulty,
-									LedState: ledStateFault,
-								},
-							},
+							Devices: []*ctlpb.SmdDevice{pbFaultDev(1)},
 						},
 					},
 				},
@@ -421,16 +444,8 @@ func TestServer_CtlSvc_SmdQuery(t *testing.T) {
 				Ranks: []*ctlpb.SmdQueryResp_RankResp{
 					{},
 					{
-						Rank: 1,
-						Devices: []*ctlpb.SmdQueryResp_SmdDeviceWithHealth{
-							{
-								Details: &ctlpb.SmdDevice{
-									Uuid:     test.MockUUID(1),
-									DevState: devStateFaulty,
-									LedState: ledStateFault,
-								},
-							},
-						},
+						Rank:    1,
+						Devices: []*ctlpb.SmdDevice{pbFaultDev(1)},
 					},
 				},
 			},
@@ -462,24 +477,14 @@ func TestServer_CtlSvc_SmdQuery(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{
-								{
-									Uuid: test.MockUUID(0),
-								},
-							},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(0)},
 						},
 					},
 				},
 				1: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{
-								{
-									Uuid:     test.MockUUID(1),
-									DevState: devStateFaulty,
-									LedState: ledStateFault,
-								},
-							},
+							Devices: []*ctlpb.SmdDevice{pbFaultDev(1)},
 						},
 					},
 					{
@@ -495,18 +500,13 @@ func TestServer_CtlSvc_SmdQuery(t *testing.T) {
 					{},
 					{
 						Rank: 1,
-						Devices: []*ctlpb.SmdQueryResp_SmdDeviceWithHealth{
-							{
-								Details: &ctlpb.SmdDevice{
-									Uuid:     test.MockUUID(1),
-									DevState: devStateFaulty,
-									LedState: ledStateFault,
-								},
-								Health: &ctlpb.BioHealthResp{
+						Devices: []*ctlpb.SmdDevice{
+							pbDevWithHealth(
+								pbFaultDev(1),
+								&ctlpb.BioHealthResp{
 									Temperature: 1000000,
 									TempWarn:    true,
-								},
-							},
+								}),
 						},
 					},
 				},
@@ -522,13 +522,7 @@ func TestServer_CtlSvc_SmdQuery(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{
-								{
-									Uuid:     test.MockUUID(0),
-									DevState: devStateNormal,
-									LedState: ledStateNormal,
-								},
-							},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(0)},
 						},
 					},
 					{
@@ -540,13 +534,7 @@ func TestServer_CtlSvc_SmdQuery(t *testing.T) {
 				1: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{
-								{
-									Uuid:     test.MockUUID(1),
-									DevState: devStateFaulty,
-									LedState: ledStateFault,
-								},
-							},
+							Devices: []*ctlpb.SmdDevice{pbFaultDev(1)},
 						},
 					},
 					{
@@ -560,33 +548,23 @@ func TestServer_CtlSvc_SmdQuery(t *testing.T) {
 			expResp: &ctlpb.SmdQueryResp{
 				Ranks: []*ctlpb.SmdQueryResp_RankResp{
 					{
-						Devices: []*ctlpb.SmdQueryResp_SmdDeviceWithHealth{
-							{
-								Details: &ctlpb.SmdDevice{
-									Uuid:     test.MockUUID(0),
-									DevState: devStateNormal,
-									LedState: ledStateNormal,
-								},
-								Health: &ctlpb.BioHealthResp{
+						Devices: []*ctlpb.SmdDevice{
+							pbDevWithHealth(
+								pbNormDev(0),
+								&ctlpb.BioHealthResp{
 									Temperature: 100000,
-								},
-							},
+								}),
 						},
 					},
 					{
 						Rank: 1,
-						Devices: []*ctlpb.SmdQueryResp_SmdDeviceWithHealth{
-							{
-								Details: &ctlpb.SmdDevice{
-									Uuid:     test.MockUUID(1),
-									DevState: devStateFaulty,
-									LedState: ledStateFault,
-								},
-								Health: &ctlpb.BioHealthResp{
+						Devices: []*ctlpb.SmdDevice{
+							pbDevWithHealth(
+								pbFaultDev(1),
+								&ctlpb.BioHealthResp{
 									Temperature: 1000000,
 									TempWarn:    true,
-								},
-							},
+								}),
 						},
 					},
 				},
@@ -603,26 +581,14 @@ func TestServer_CtlSvc_SmdQuery(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{
-								{
-									Uuid:     test.MockUUID(0),
-									DevState: devStateNew,
-									LedState: ledStateNormal,
-								},
-							},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(0)},
 						},
 					},
 				},
 				1: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{
-								{
-									Uuid:     test.MockUUID(1),
-									DevState: devStateNew,
-									LedState: ledStateNormal,
-								},
-							},
+							Devices: []*ctlpb.SmdDevice{pbNewDev(1)},
 						},
 					},
 					{
@@ -637,16 +603,8 @@ func TestServer_CtlSvc_SmdQuery(t *testing.T) {
 				Ranks: []*ctlpb.SmdQueryResp_RankResp{
 					{},
 					{
-						Rank: 1,
-						Devices: []*ctlpb.SmdQueryResp_SmdDeviceWithHealth{
-							{
-								Details: &ctlpb.SmdDevice{
-									Uuid:     test.MockUUID(1),
-									DevState: devStateNew,
-									LedState: ledStateNormal,
-								},
-							},
-						},
+						Rank:    1,
+						Devices: []*ctlpb.SmdDevice{pbNewDev(1)},
 					},
 				},
 			},
@@ -662,26 +620,14 @@ func TestServer_CtlSvc_SmdQuery(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{
-								{
-									Uuid:     test.MockUUID(0),
-									DevState: devStateFaulty,
-									LedState: ledStateFault,
-								},
-							},
+							Devices: []*ctlpb.SmdDevice{pbFaultDev(0)},
 						},
 					},
 				},
 				1: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{
-								{
-									Uuid:     test.MockUUID(1),
-									DevState: devStateFaulty,
-									LedState: ledStateFault,
-								},
-							},
+							Devices: []*ctlpb.SmdDevice{pbFaultDev(1)},
 						},
 					},
 					{
@@ -823,33 +769,13 @@ func TestServer_engineDevMap(t *testing.T) {
 }
 
 func TestServer_CtlSvc_SmdManage(t *testing.T) {
-	pbNormDev := &ctlpb.SmdDevice{
-		TrAddr:   test.MockPCIAddr(1),
-		Uuid:     test.MockUUID(1),
-		DevState: devStateNormal,
-		LedState: ledStateNormal,
-	}
-	pbReplacedDev := &ctlpb.SmdDevice{
-		TrAddr:   test.MockPCIAddr(2),
-		Uuid:     test.MockUUID(2),
-		DevState: devStateNormal,
-		LedState: ledStateNormal,
-	}
-	pbNormDevNoTrAddr := new(ctlpb.SmdDevice)
-	*pbNormDevNoTrAddr = *pbNormDev
-	pbNormDevNoTrAddr.TrAddr = ""
-	pbFaultyDev := &ctlpb.SmdDevice{
-		TrAddr:   test.MockPCIAddr(1),
-		Uuid:     test.MockUUID(1),
-		DevState: devStateFaulty,
-		LedState: ledStateFault,
+	pbNormDevNoPciAddr := new(ctlpb.SmdDevice)
+	*pbNormDevNoPciAddr = *pbNormDev(1)
+	pbNormDevNoPciAddr.Ctrlr.PciAddr = ""
+	devManageBusyResp := &ctlpb.DevManageResp{
+		Status: int32(daos.Busy),
+		Device: pbNormDev(1),
 	}
-	pbIdentifyDev := &ctlpb.SmdDevice{
-		TrAddr:   test.MockPCIAddr(1),
-		Uuid:     test.MockUUID(1),
-		LedState: ledStateIdentify,
-	}
-	devManageBusyResp := &ctlpb.DevManageResp{Status: int32(daos.Busy), Device: pbNormDev}
 
 	for name, tc := range map[string]struct {
 		setupAP        bool
@@ -1030,7 +956,7 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{pbNormDev},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(1)},
 						},
 					},
 				},
@@ -1049,7 +975,7 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{pbNormDevNoTrAddr},
+							Devices: []*ctlpb.SmdDevice{pbNormDevNoPciAddr},
 						},
 					},
 				},
@@ -1068,12 +994,12 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{pbNormDev},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(1)},
 						},
 					},
 					{
 						Message: &ctlpb.DevManageResp{
-							Device: pbIdentifyDev,
+							Device: pbIdentDev(2),
 						},
 					},
 				},
@@ -1093,12 +1019,12 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{pbNormDev},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(1)},
 						},
 					},
 					{
 						Message: &ctlpb.DevManageResp{
-							Device: pbIdentifyDev,
+							Device: pbIdentDev(1),
 						},
 					},
 				},
@@ -1107,7 +1033,7 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				Ranks: []*ctlpb.SmdManageResp_RankResp{
 					{
 						Results: []*ctlpb.SmdManageResp_Result{
-							{Device: pbIdentifyDev},
+							{Device: pbIdentDev(1)},
 						},
 					},
 				},
@@ -1118,7 +1044,7 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				Op: &ctlpb.SmdManageReq_Led{
 					Led: &ctlpb.LedManageReq{
 						// Matches ID returned in initial list query.
-						Ids: test.MockUUID(1),
+						Ids: test.MockUUID(2),
 					},
 				},
 			},
@@ -1126,19 +1052,24 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{pbNormDev},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(1)},
 						},
 					},
 					{
 						Message: &ctlpb.DevManageResp{
-							Device: pbIdentifyDev,
+							Device: pbIdentDev(1),
 						},
 					},
 				},
 				1: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(2)},
+						},
+					},
+					{
+						Message: &ctlpb.DevManageResp{
+							Device: pbIdentDev(2),
 						},
 					},
 				},
@@ -1146,8 +1077,9 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 			expResp: &ctlpb.SmdManageResp{
 				Ranks: []*ctlpb.SmdManageResp_RankResp{
 					{
+						Rank: 1,
 						Results: []*ctlpb.SmdManageResp_Result{
-							{Device: pbIdentifyDev},
+							{Device: pbIdentDev(2)},
 						},
 					},
 				},
@@ -1164,19 +1096,24 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{pbNormDev},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(1)},
 						},
 					},
 					{
 						Message: &ctlpb.DevManageResp{
-							Device: pbIdentifyDev,
+							Device: pbIdentDev(1),
 						},
 					},
 				},
 				1: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(2)},
+						},
+					},
+					{
+						Message: &ctlpb.DevManageResp{
+							Device: pbIdentDev(2),
 						},
 					},
 				},
@@ -1185,7 +1122,13 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				Ranks: []*ctlpb.SmdManageResp_RankResp{
 					{
 						Results: []*ctlpb.SmdManageResp_Result{
-							{Device: pbIdentifyDev},
+							{Device: pbIdentDev(1)},
+						},
+					},
+					{
+						Rank: 1,
+						Results: []*ctlpb.SmdManageResp_Result{
+							{Device: pbIdentDev(2)},
 						},
 					},
 				},
@@ -1204,12 +1147,12 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{pbNormDev},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(1)},
 						},
 					},
 					{
 						Message: &ctlpb.DevManageResp{
-							Device: pbIdentifyDev,
+							Device: pbIdentDev(1),
 						},
 					},
 				},
@@ -1217,21 +1160,21 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 					{
 						Message: &ctlpb.SmdDevResp{
 							Devices: []*ctlpb.SmdDevice{
-								{
-									TrAddr:   "d50505:01:00.0",
-									Uuid:     test.MockUUID(2),
-									LedState: ledStateNormal,
-								},
+								func() *ctlpb.SmdDevice {
+									sd := pbNormDev(2)
+									sd.Ctrlr.PciAddr = "d50505:01:00.0"
+									return sd
+								}(),
 							},
 						},
 					},
 					{
 						Message: &ctlpb.DevManageResp{
-							Device: &ctlpb.SmdDevice{
-								TrAddr:   "d50505:01:00.0",
-								Uuid:     test.MockUUID(2),
-								LedState: ledStateNormal,
-							},
+							Device: func() *ctlpb.SmdDevice {
+								sd := pbIdentDev(2)
+								sd.Ctrlr.PciAddr = "d50505:01:00.0"
+								return sd
+							}(),
 						},
 					},
 				},
@@ -1240,18 +1183,18 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				Ranks: []*ctlpb.SmdManageResp_RankResp{
 					{
 						Results: []*ctlpb.SmdManageResp_Result{
-							{Device: pbIdentifyDev},
+							{Device: pbIdentDev(1)},
 						},
 					},
 					{
 						Rank: 1,
 						Results: []*ctlpb.SmdManageResp_Result{
 							{
-								Device: &ctlpb.SmdDevice{
-									TrAddr:   "d50505:01:00.0",
-									Uuid:     test.MockUUID(2),
-									LedState: ledStateNormal,
-								},
+								Device: func() *ctlpb.SmdDevice {
+									sd := pbIdentDev(2)
+									sd.Ctrlr.PciAddr = "d50505:01:00.0"
+									return sd
+								}(),
 							},
 						},
 					},
@@ -1273,9 +1216,9 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 					{
 						Message: &ctlpb.SmdDevResp{
 							Devices: []*ctlpb.SmdDevice{
-								pbNormDev,
+								pbNormDev(1),
 								func() *ctlpb.SmdDevice {
-									d := *pbNormDev
+									d := *pbNormDev(1)
 									d.Uuid = test.MockUUID(2)
 									return &d
 								}(),
@@ -1284,7 +1227,7 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 					},
 					{
 						Message: &ctlpb.DevManageResp{
-							Device: pbIdentifyDev,
+							Device: pbIdentDev(1),
 						},
 					},
 				},
@@ -1293,7 +1236,7 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				Ranks: []*ctlpb.SmdManageResp_RankResp{
 					{
 						Results: []*ctlpb.SmdManageResp_Result{
-							{Device: pbIdentifyDev},
+							{Device: pbIdentDev(1)},
 						},
 					},
 				},
@@ -1311,7 +1254,7 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{pbNormDev},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(1)},
 						},
 					},
 				},
@@ -1330,12 +1273,12 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{pbNormDev},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(1)},
 						},
 					},
 					{
 						Message: &ctlpb.DevManageResp{
-							Device: pbFaultyDev,
+							Device: pbFaultDev(1),
 						},
 					},
 				},
@@ -1344,7 +1287,7 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				Ranks: []*ctlpb.SmdManageResp_RankResp{
 					{
 						Results: []*ctlpb.SmdManageResp_Result{
-							{Device: pbFaultyDev},
+							{Device: pbFaultDev(1)},
 						},
 					},
 				},
@@ -1369,12 +1312,12 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				1: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{pbNormDev},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(1)},
 						},
 					},
 					{
 						Message: &ctlpb.DevManageResp{
-							Device: pbFaultyDev,
+							Device: pbFaultDev(1),
 						},
 					},
 				},
@@ -1384,7 +1327,7 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 					{
 						Rank: 1,
 						Results: []*ctlpb.SmdManageResp_Result{
-							{Device: pbFaultyDev},
+							{Device: pbFaultDev(1)},
 						},
 					},
 				},
@@ -1402,7 +1345,7 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{pbNormDev},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(1)},
 						},
 					},
 				},
@@ -1422,12 +1365,12 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{pbNormDev},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(1)},
 						},
 					},
 					{
 						Message: &ctlpb.DevManageResp{
-							Device: pbReplacedDev,
+							Device: pbNormDev(2),
 						},
 					},
 				},
@@ -1436,7 +1379,7 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				Ranks: []*ctlpb.SmdManageResp_RankResp{
 					{
 						Results: []*ctlpb.SmdManageResp_Result{
-							{Device: pbReplacedDev},
+							{Device: pbNormDev(2)},
 						},
 					},
 				},
@@ -1455,12 +1398,12 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{pbNormDev},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(1)},
 						},
 					},
 					{
 						Message: &ctlpb.DevManageResp{
-							Device: pbReplacedDev,
+							Device: pbNormDev(2),
 						},
 					},
 				},
@@ -1476,7 +1419,7 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				Ranks: []*ctlpb.SmdManageResp_RankResp{
 					{
 						Results: []*ctlpb.SmdManageResp_Result{
-							{Device: pbReplacedDev},
+							{Device: pbNormDev(2)},
 						},
 					},
 				},
@@ -1495,19 +1438,19 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{pbNormDev},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(1)},
 						},
 					},
 					{Message: devManageBusyResp},
 					{Message: devManageBusyResp},
-					{Message: &ctlpb.DevManageResp{Device: pbReplacedDev}},
+					{Message: &ctlpb.DevManageResp{Device: pbNormDev(2)}},
 				},
 			},
 			expResp: &ctlpb.SmdManageResp{
 				Ranks: []*ctlpb.SmdManageResp_RankResp{
 					{
 						Results: []*ctlpb.SmdManageResp_Result{
-							{Device: pbReplacedDev},
+							{Device: pbNormDev(2)},
 						},
 					},
 				},
@@ -1526,14 +1469,14 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{pbNormDev},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(1)},
 						},
 					},
 					{Message: devManageBusyResp},
 					{
 						Message: &ctlpb.DevManageResp{
 							Status: int32(daos.TimedOut),
-							Device: pbNormDev,
+							Device: pbNormDev(1),
 						},
 					},
 					{Message: devManageBusyResp},
@@ -1544,7 +1487,7 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 					{
 						Results: []*ctlpb.SmdManageResp_Result{
 							{
-								Device: pbNormDev,
+								Device: pbNormDev(1),
 								Status: int32(daos.TimedOut),
 							},
 						},
@@ -1565,7 +1508,7 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 				0: {
 					{
 						Message: &ctlpb.SmdDevResp{
-							Devices: []*ctlpb.SmdDevice{pbNormDev},
+							Devices: []*ctlpb.SmdDevice{pbNormDev(1)},
 						},
 					},
 					{Message: devManageBusyResp},
@@ -1580,7 +1523,7 @@ func TestServer_CtlSvc_SmdManage(t *testing.T) {
 					{
 						Results: []*ctlpb.SmdManageResp_Result{
 							{
-								Device: pbNormDev,
+								Device: pbNormDev(1),
 								Status: int32(daos.Busy),
 							},
 						},
diff --git a/src/control/server/ctl_storage_rpc.go b/src/control/server/ctl_storage_rpc.go
index c448e98aaab..7ad81f35f64 100644
--- a/src/control/server/ctl_storage_rpc.go
+++ b/src/control/server/ctl_storage_rpc.go
@@ -367,9 +367,9 @@ func (c *ControlService) adjustNvmeSize(resp *ctlpb.ScanNvmeResp) {
 				continue
 			}
 
-			if dev.GetDevState() != ctlpb.NvmeDevState_NORMAL {
+			if dev.Ctrlr.GetDevState() != ctlpb.NvmeDevState_NORMAL {
 				c.log.Debugf("SMD device %s (rank %d, ctlr %s) not usable: device state %q",
-					dev.GetUuid(), rank, ctlr.GetPciAddr(), ctlpb.NvmeDevState_name[int32(dev.DevState)])
+					dev.GetUuid(), rank, ctlr.GetPciAddr(), ctlpb.NvmeDevState_name[int32(dev.Ctrlr.DevState)])
 				dev.AvailBytes = 0
 				dev.UsableBytes = 0
 				continue
diff --git a/src/control/server/ctl_storage_rpc_test.go b/src/control/server/ctl_storage_rpc_test.go
index 252d9dfedd5..0674198e22f 100644
--- a/src/control/server/ctl_storage_rpc_test.go
+++ b/src/control/server/ctl_storage_rpc_test.go
@@ -9,7 +9,6 @@ package server
 import (
 	"context"
 	"fmt"
-	"math"
 	"os"
 	"os/user"
 	"path/filepath"
@@ -24,14 +23,11 @@ import (
 
 	"github.com/daos-stack/daos/src/control/common"
 	"github.com/daos-stack/daos/src/control/common/proto"
-	"github.com/daos-stack/daos/src/control/common/proto/convert"
 	"github.com/daos-stack/daos/src/control/common/proto/ctl"
 	ctlpb "github.com/daos-stack/daos/src/control/common/proto/ctl"
 	"github.com/daos-stack/daos/src/control/common/test"
-	"github.com/daos-stack/daos/src/control/drpc"
 	"github.com/daos-stack/daos/src/control/events"
 	"github.com/daos-stack/daos/src/control/lib/daos"
-	"github.com/daos-stack/daos/src/control/lib/ranklist"
 	"github.com/daos-stack/daos/src/control/logging"
 	"github.com/daos-stack/daos/src/control/provider/system"
 	"github.com/daos-stack/daos/src/control/server/config"
@@ -464,1208 +460,1070 @@ func TestServer_CtlSvc_StorageScan_PreEngineStart(t *testing.T) {
 	}
 }
 
-func TestServer_CtlSvc_StorageScan_PostEngineStart(t *testing.T) {
-	const (
-		clusterSize uint64 = 32 * humanize.MiByte
-		metaWalSize uint64 = 64 * humanize.MiByte
-		rdbSize     uint64 = defaultRdbSize
-		rdbWalSize  uint64 = 512 * humanize.MiByte
-	)
-
-	adjustScmSize := func(sizeBytes uint64, withMdDaosScm bool) uint64 {
-		mdBytes := rdbSize + mdFsScmBytes
-		if withMdDaosScm {
-			mdBytes += mdDaosScmBytes
-		}
-
-		if sizeBytes < mdBytes {
-			return 0
-		}
-
-		return sizeBytes - mdBytes
-	}
-
-	adjustNvmeSize := func(nvmeCtlr *ctlpb.NvmeController, mdBytes uint64, engineTargetCount int) *ctlpb.NvmeController {
-		getClusterCount := func(sizeBytes uint64) uint64 {
-			clusterCount := sizeBytes / clusterSize
-			if sizeBytes%clusterSize != 0 {
-				clusterCount += 1
-			}
-			return clusterCount
-		}
-
-		type deviceSizeStat struct {
-			clusterPerTarget uint64
-			smdDevs          []*ctlpb.SmdDevice
-		}
-		devicesToAdjust := make(map[uint32]*deviceSizeStat, 0)
-		for _, dev := range nvmeCtlr.GetSmdDevices() {
-			targetCount := uint64(len(dev.GetTgtIds()))
-			dev.MetaSize = adjustScmSize(mdBytes, false) / uint64(engineTargetCount)
-			dev.AvailBytes = (dev.GetAvailBytes() / clusterSize) * clusterSize
-
-			usableClusterCount := dev.GetAvailBytes() / clusterSize
-			usableClusterCount -= getClusterCount(dev.MetaSize) * uint64(engineTargetCount)
-			usableClusterCount -= getClusterCount(metaWalSize) * uint64(engineTargetCount)
-			usableClusterCount -= getClusterCount(rdbSize)
-			usableClusterCount -= getClusterCount(rdbWalSize)
-
-			rank := dev.GetRank()
-			if devicesToAdjust[rank] == nil {
-				devicesToAdjust[rank] = &deviceSizeStat{
-					clusterPerTarget: math.MaxUint64,
-				}
-			}
-			devicesToAdjust[rank].smdDevs = append(devicesToAdjust[rank].smdDevs, dev)
-			clusterPerTarget := usableClusterCount / targetCount
-			if clusterPerTarget < devicesToAdjust[rank].clusterPerTarget {
-				devicesToAdjust[rank].clusterPerTarget = clusterPerTarget
-			}
-		}
-
-		for _, item := range devicesToAdjust {
-			for _, dev := range item.smdDevs {
-				targetCount := uint64(len(dev.GetTgtIds()))
-				dev.UsableBytes = item.clusterPerTarget * targetCount * clusterSize
-			}
-		}
-
-		return nvmeCtlr
-	}
-
-	// output to be returned from mock bdev backend
-	newCtrlr := func(idx int32) *storage.NvmeController {
-		ctrlr := storage.MockNvmeController(idx)
-		ctrlr.Serial = test.MockUUID(idx)
-		ctrlr.SmdDevices = nil
-
-		return ctrlr
-	}
-	newCtrlrMultiNs := func(idx int32, numNss int) *storage.NvmeController {
-		ctrlr := storage.MockNvmeController(idx)
-		ctrlr.Serial = test.MockUUID(idx)
-		ctrlr.SmdDevices = nil
-		ctrlr.Namespaces = make([]*storage.NvmeNamespace, numNss)
-		for i := 0; i < numNss; i++ {
-			ctrlr.Namespaces[i] = storage.MockNvmeNamespace(int32(i + 1))
-		}
-
-		return ctrlr
-	}
-
-	// expected protobuf output to be returned svc.StorageScan when health
-	// updated over drpc. Override serial uuid with variable argument
-	newCtrlrHealth := func(idx int32, serialIdx ...int32) (*ctlpb.NvmeController, *ctlpb.BioHealthResp) {
-		ctrlr := proto.MockNvmeController(idx)
-		sIdx := idx
-		if len(serialIdx) > 0 {
-			sIdx = serialIdx[0]
-		}
-		ctrlr.Model = fmt.Sprintf("model-%d", sIdx)
-		ctrlr.Serial = test.MockUUID(sIdx)
-		ctrlr.HealthStats = proto.MockNvmeHealth(idx + 1)
-		ctrlr.HealthStats.ClusterSize = clusterSize
-		ctrlr.HealthStats.MetaWalSize = metaWalSize
-		ctrlr.HealthStats.RdbWalSize = rdbWalSize
-		ctrlr.SmdDevices = nil
-
-		bioHealthResp := new(ctlpb.BioHealthResp)
-		if err := convert.Types(ctrlr.HealthStats, bioHealthResp); err != nil {
-			t.Fatal(err)
-		}
-		bioHealthResp.TotalBytes = uint64(idx) * uint64(humanize.TByte)
-		bioHealthResp.AvailBytes = uint64(idx) * uint64(humanize.TByte/2)
-		bioHealthResp.ClusterSize = clusterSize
-		bioHealthResp.MetaWalSize = metaWalSize
-		bioHealthResp.RdbWalSize = rdbWalSize
-
-		return ctrlr, bioHealthResp
-	}
-	newCtrlrPBwHealth := func(idx int32, serialIdx ...int32) *ctlpb.NvmeController {
-		c, _ := newCtrlrHealth(idx, serialIdx...)
-		return c
-	}
-	newBioHealthResp := func(idx int32, serialIdx ...int32) *ctlpb.BioHealthResp {
-		_, b := newCtrlrHealth(idx, serialIdx...)
-		return b
-	}
-
-	// expected protobuf output to be returned svc.StorageScan when smd
-	// updated over drpc
-	newCtrlrMeta := func(ctrlrIdx int32, smdIndexes ...int32) (*ctlpb.NvmeController, *ctlpb.SmdDevResp) {
-		ctrlr := proto.MockNvmeController(ctrlrIdx)
-		ctrlr.Serial = test.MockUUID(ctrlrIdx)
-		ctrlr.HealthStats = nil
-
-		if len(smdIndexes) == 0 {
-			smdIndexes = append(smdIndexes, ctrlrIdx)
-		}
-		smdDevRespDevices := make([]*ctlpb.SmdDevice, len(smdIndexes))
-		ctrlr.SmdDevices = make([]*ctlpb.SmdDevice, len(smdIndexes))
-		ctrlr.Namespaces = make([]*ctlpb.NvmeController_Namespace, len(smdIndexes))
-		for i, idx := range smdIndexes {
-			sd := proto.MockSmdDevice(ctrlr.PciAddr, idx+1)
-			sd.DevState = devStateNormal
-			sd.Rank = uint32(ctrlrIdx)
-			sd.TrAddr = ctrlr.PciAddr
-			ctrlr.SmdDevices[i] = sd
-
-			smdPB := new(ctlpb.SmdDevice)
-			if err := convert.Types(sd, smdPB); err != nil {
-				t.Fatal(err)
-			}
-			smdDevRespDevices[i] = smdPB
-
-			// expect resultant controller to have updated utilization values
-			ctrlr.SmdDevices[i].TotalBytes = uint64(idx) * uint64(humanize.TByte)
-			ctrlr.SmdDevices[i].AvailBytes = uint64(idx) * uint64(humanize.TByte/2)
-			ctrlr.SmdDevices[i].ClusterSize = clusterSize
-			ctrlr.SmdDevices[i].MetaWalSize = metaWalSize
-			ctrlr.SmdDevices[i].RdbSize = rdbSize
-			ctrlr.SmdDevices[i].RdbWalSize = rdbWalSize
-			ctrlr.Namespaces[i] = proto.MockNvmeNamespace(int32(i + 1))
-		}
-
-		return ctrlr, &ctlpb.SmdDevResp{Devices: smdDevRespDevices}
-	}
-	newCtrlrPB := func(idx int32) *ctlpb.NvmeController {
-		c, _ := newCtrlrMeta(idx)
-		c.SmdDevices = nil
-		return c
-	}
-	newCtrlrPBwBasic := func(idx int32) *ctlpb.NvmeController {
-		c := newCtrlrPB(idx)
-		c.FwRev = ""
-		c.Model = ""
-		return c
-	}
-	newCtrlrPBwMeta := func(idx int32, smdIndexes ...int32) *ctlpb.NvmeController {
-		c, _ := newCtrlrMeta(idx, smdIndexes...)
-		return c
-	}
-	newSmdDevResp := func(idx int32, smdIndexes ...int32) *ctlpb.SmdDevResp {
-		_, s := newCtrlrMeta(idx, smdIndexes...)
-		return s
-	}
-
-	smdDevRespStateNew := newSmdDevResp(1)
-	smdDevRespStateNew.Devices[0].DevState = devStateNew
-	smdDevRespStateNew.Devices[0].ClusterSize = 0
-	smdDevRespStateNew.Devices[0].MetaWalSize = 0
-	smdDevRespStateNew.Devices[0].RdbWalSize = 0
-
-	ctrlrPBwMetaNew := newCtrlrPBwMeta(1)
-	ctrlrPBwMetaNew.SmdDevices[0].AvailBytes = 0
-	ctrlrPBwMetaNew.SmdDevices[0].TotalBytes = 0
-	ctrlrPBwMetaNew.SmdDevices[0].DevState = devStateNew
-	ctrlrPBwMetaNew.SmdDevices[0].ClusterSize = 0
-	ctrlrPBwMetaNew.SmdDevices[0].UsableBytes = 0
-	ctrlrPBwMetaNew.SmdDevices[0].RdbSize = 0
-	ctrlrPBwMetaNew.SmdDevices[0].RdbWalSize = 0
-	ctrlrPBwMetaNew.SmdDevices[0].MetaSize = 0
-	ctrlrPBwMetaNew.SmdDevices[0].MetaWalSize = 0
-
-	ctrlrPBwMetaNormal := newCtrlrPBwMeta(1)
-	ctrlrPBwMetaNormal.SmdDevices[0].AvailBytes = 0
-	ctrlrPBwMetaNormal.SmdDevices[0].TotalBytes = 0
-	ctrlrPBwMetaNormal.SmdDevices[0].DevState = devStateNormal
-	ctrlrPBwMetaNormal.SmdDevices[0].ClusterSize = 0
-	ctrlrPBwMetaNormal.SmdDevices[0].UsableBytes = 0
-	ctrlrPBwMetaNormal.SmdDevices[0].RdbSize = 0
-	ctrlrPBwMetaNormal.SmdDevices[0].RdbWalSize = 0
-	ctrlrPBwMetaNormal.SmdDevices[0].MetaSize = 0
-	ctrlrPBwMetaNormal.SmdDevices[0].MetaWalSize = 0
-
-	mockPbScmMount0 := proto.MockScmMountPoint(0)
-	mockPbScmMount0.Rank += 1
-	mockPbScmNamespace0 := proto.MockScmNamespace(0)
-	mockPbScmNamespace0.Mount = mockPbScmMount0
-	mockPbScmMount1 := proto.MockScmMountPoint(1)
-	mockPbScmMount1.Rank += 1
-	mockPbScmNamespace1 := proto.MockScmNamespace(1)
-	mockPbScmNamespace1.Mount = mockPbScmMount1
-
-	for name, tc := range map[string]struct {
-		req               *ctlpb.StorageScanReq
-		csCtrlrs          *storage.NvmeControllers   // control service storage provider
-		eCtrlrs           []*storage.NvmeControllers // engine storage provider
-		smbc              *scm.MockBackendConfig
-		smsc              *system.MockSysConfig
-		storageCfgs       []storage.TierConfigs
-		engineTargetCount []int
-		enginesNotReady   bool
-		scanTwice         bool
-		junkResp          bool
-		drpcResps         map[int][]*mockDrpcResponse
-		expErr            error
-		expResp           *ctlpb.StorageScanResp
-	}{
-		"engine up; scan bdev basic": {
-			req: &ctlpb.StorageScanReq{
-				Scm:  new(ctlpb.ScanScmReq),
-				Nvme: &ctlpb.ScanNvmeReq{Basic: true},
-			},
-			storageCfgs: []storage.TierConfigs{
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassNvme.String()).
-						WithBdevDeviceList(newCtrlr(1).PciAddr),
-				},
-			},
-			csCtrlrs:          &storage.NvmeControllers{newCtrlr(1)},
-			engineTargetCount: []int{4},
-			drpcResps: map[int][]*mockDrpcResponse{
-				0: {},
-			},
-			expResp: &ctlpb.StorageScanResp{
-				Nvme: &ctlpb.ScanNvmeResp{
-					Ctrlrs: proto.NvmeControllers{newCtrlrPBwBasic(1)},
-					State:  new(ctlpb.ResponseState),
-				},
-				Scm:     &ctlpb.ScanScmResp{State: new(ctlpb.ResponseState)},
-				MemInfo: proto.MockPBMemInfo(),
-			},
-		},
-		"engine up; scan bdev basic; no bdevs in config": {
-			req: &ctlpb.StorageScanReq{
-				Scm:  new(ctlpb.ScanScmReq),
-				Nvme: &ctlpb.ScanNvmeReq{Basic: true},
-			},
-			storageCfgs: []storage.TierConfigs{},
-			csCtrlrs:    &storage.NvmeControllers{newCtrlr(1)},
-			expResp: &ctlpb.StorageScanResp{
-				Nvme: &ctlpb.ScanNvmeResp{
-					Ctrlrs: proto.NvmeControllers{newCtrlrPBwBasic(1)},
-					State:  new(ctlpb.ResponseState),
-				},
-				Scm:     &ctlpb.ScanScmResp{State: new(ctlpb.ResponseState)},
-				MemInfo: proto.MockPBMemInfo(),
-			},
-		},
-		"engine up; scan bdev basic; missing bdev in config": {
-			req: &ctlpb.StorageScanReq{
-				Scm:  new(ctlpb.ScanScmReq),
-				Nvme: &ctlpb.ScanNvmeReq{Basic: true},
-			},
-			storageCfgs: []storage.TierConfigs{
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassNvme.String()).
-						WithBdevDeviceList(newCtrlr(1).PciAddr),
-				},
-			},
-			csCtrlrs:          &storage.NvmeControllers{newCtrlr(2)},
-			engineTargetCount: []int{4},
-			drpcResps: map[int][]*mockDrpcResponse{
-				0: {},
-			},
-			expResp: &ctlpb.StorageScanResp{
-				Nvme: &ctlpb.ScanNvmeResp{
-					Ctrlrs: proto.NvmeControllers{},
-					State:  new(ctlpb.ResponseState),
-				},
-				Scm:     &ctlpb.ScanScmResp{State: new(ctlpb.ResponseState)},
-				MemInfo: proto.MockPBMemInfo(),
-			},
-		},
-		"engine up; scan bdev health": {
-			req: &ctlpb.StorageScanReq{
-				Scm:  new(ctlpb.ScanScmReq),
-				Nvme: &ctlpb.ScanNvmeReq{Health: true},
-			},
-			csCtrlrs: &storage.NvmeControllers{newCtrlr(1)},
-			storageCfgs: []storage.TierConfigs{
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassNvme.String()).
-						WithBdevDeviceList(newCtrlr(1).PciAddr),
-				},
-			},
-			engineTargetCount: []int{4},
-			drpcResps: map[int][]*mockDrpcResponse{
-				0: {
-					{Message: newSmdDevResp(1)},
-					{Message: newBioHealthResp(1)},
-				},
-			},
-			expResp: &ctlpb.StorageScanResp{
-				Nvme: &ctlpb.ScanNvmeResp{
-					Ctrlrs: proto.NvmeControllers{newCtrlrPBwHealth(1)},
-					State:  new(ctlpb.ResponseState),
-				},
-				Scm:     &ctlpb.ScanScmResp{State: new(ctlpb.ResponseState)},
-				MemInfo: proto.MockPBMemInfo(),
-			},
-		},
-		"engine up; scan bdev meta": {
-			req: &ctlpb.StorageScanReq{
-				Scm:  &ctlpb.ScanScmReq{Usage: true},
-				Nvme: &ctlpb.ScanNvmeReq{Meta: true},
-			},
-			csCtrlrs: &storage.NvmeControllers{newCtrlr(1)},
-			smbc: &scm.MockBackendConfig{
-				GetModulesRes: storage.ScmModules{
-					storage.MockScmModule(0),
-				},
-				GetNamespacesRes: storage.ScmNamespaces{
-					storage.MockScmNamespace(0),
-				},
-			},
-			smsc: &system.MockSysConfig{
-				GetfsUsageResps: []system.GetfsUsageRetval{
-					{
-						Total: mockPbScmMount0.TotalBytes,
-						Avail: mockPbScmMount0.AvailBytes,
-					},
-				},
-			},
-			storageCfgs: []storage.TierConfigs{
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassDcpm.String()).
-						WithScmMountPoint(mockPbScmMount0.Path).
-						WithScmDeviceList(mockPbScmNamespace0.Blockdev),
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassNvme.String()).
-						WithBdevDeviceList(newCtrlr(1).PciAddr),
-				},
-			},
-			engineTargetCount: []int{4},
-			drpcResps: map[int][]*mockDrpcResponse{
-				0: {
-					{Message: newSmdDevResp(1)},
-					{Message: newBioHealthResp(1)},
-				},
-			},
-			expResp: &ctlpb.StorageScanResp{
-				Nvme: &ctlpb.ScanNvmeResp{
-					Ctrlrs: proto.NvmeControllers{
-						adjustNvmeSize(newCtrlrPBwMeta(1), mockPbScmMount0.AvailBytes, 4),
-					},
-					State: new(ctlpb.ResponseState),
-				},
-				Scm: &ctlpb.ScanScmResp{
-					Namespaces: proto.ScmNamespaces{
-						&ctlpb.ScmNamespace{
-							Blockdev: mockPbScmNamespace0.Blockdev,
-							Dev:      mockPbScmNamespace0.Dev,
-							Size:     mockPbScmNamespace0.Size,
-							Uuid:     mockPbScmNamespace0.Uuid,
-							Mount: &ctlpb.ScmNamespace_Mount{
-								Class:       mockPbScmMount0.Class,
-								DeviceList:  mockPbScmMount0.DeviceList,
-								Path:        mockPbScmMount0.Path,
-								TotalBytes:  mockPbScmMount0.TotalBytes,
-								AvailBytes:  mockPbScmMount0.AvailBytes,
-								UsableBytes: adjustScmSize(mockPbScmMount0.AvailBytes, false),
-								Rank:        mockPbScmMount0.Rank,
-							},
-						},
-					},
-					State: new(ctlpb.ResponseState),
-				},
-				MemInfo: proto.MockPBMemInfo(),
-			},
-		},
-		"engines up; scan bdev health": {
-			req: &ctlpb.StorageScanReq{
-				Scm:  new(ctlpb.ScanScmReq),
-				Nvme: &ctlpb.ScanNvmeReq{Health: true},
-			},
-			csCtrlrs: &storage.NvmeControllers{newCtrlr(1), newCtrlr(2)},
-			eCtrlrs:  []*storage.NvmeControllers{{newCtrlr(1)}, {newCtrlr(2)}},
-			storageCfgs: []storage.TierConfigs{
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassNvme.String()).
-						WithBdevDeviceList(newCtrlr(1).PciAddr),
-				},
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassNvme.String()).
-						WithBdevDeviceList(newCtrlr(2).PciAddr),
-				},
-			},
-			engineTargetCount: []int{4, 4},
-			drpcResps: map[int][]*mockDrpcResponse{
-				0: {
-					{Message: newSmdDevResp(1)},
-					{Message: newBioHealthResp(1)},
-				},
-				1: {
-					{Message: newSmdDevResp(2)},
-					{Message: newBioHealthResp(2)},
-				},
-			},
-			expResp: &ctlpb.StorageScanResp{
-				Nvme: &ctlpb.ScanNvmeResp{
-					Ctrlrs: proto.NvmeControllers{
-						newCtrlrPBwHealth(1),
-						newCtrlrPBwHealth(2),
-					},
-					State: new(ctlpb.ResponseState),
-				},
-				Scm:     &ctlpb.ScanScmResp{State: new(ctlpb.ResponseState)},
-				MemInfo: proto.MockPBMemInfo(),
-			},
-		},
-		// make sure stale information is cleared and not used from cache
-		"verify cache invalidation over multiple storage scan calls": {
-			req: &ctlpb.StorageScanReq{
-				Scm:  &ctlpb.ScanScmReq{Usage: true},
-				Nvme: &ctlpb.ScanNvmeReq{Meta: true},
-			},
-			csCtrlrs: &storage.NvmeControllers{newCtrlr(1), newCtrlr(2)},
-			eCtrlrs:  []*storage.NvmeControllers{{newCtrlr(1)}, {newCtrlr(2)}},
-			smbc: &scm.MockBackendConfig{
-				GetModulesRes: storage.ScmModules{
-					storage.MockScmModule(0),
-				},
-				GetNamespacesRes: storage.ScmNamespaces{
-					storage.MockScmNamespace(0),
-					storage.MockScmNamespace(1),
-				},
-			},
-			smsc: &system.MockSysConfig{
-				GetfsUsageResps: []system.GetfsUsageRetval{
-					{
-						Total: mockPbScmMount0.TotalBytes,
-						Avail: mockPbScmMount0.AvailBytes,
-					},
-					{
-						Total: mockPbScmMount1.TotalBytes,
-						Avail: mockPbScmMount1.AvailBytes,
-					},
-					{
-						Total: mockPbScmMount0.TotalBytes,
-						Avail: mockPbScmMount0.AvailBytes,
-					},
-					{
-						Total: mockPbScmMount1.TotalBytes,
-						Avail: mockPbScmMount1.AvailBytes,
-					},
-				},
-			},
-			storageCfgs: []storage.TierConfigs{
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassDcpm.String()).
-						WithScmMountPoint(mockPbScmMount0.Path).
-						WithScmDeviceList(mockPbScmNamespace0.Blockdev),
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassNvme.String()).
-						WithBdevDeviceList(newCtrlr(1).PciAddr),
-				},
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassDcpm.String()).
-						WithScmMountPoint(mockPbScmMount1.Path).
-						WithScmDeviceList(mockPbScmNamespace1.Blockdev),
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassNvme.String()).
-						WithBdevDeviceList(newCtrlr(2).PciAddr),
-				},
-			},
-			scanTwice:         true,
-			engineTargetCount: []int{4, 4},
-			drpcResps: map[int][]*mockDrpcResponse{
-				0: {
-					{Message: newSmdDevResp(1, 1, 2, 3)},
-					{Message: newBioHealthResp(1, 1)},
-					{Message: newBioHealthResp(1, 2)},
-					{Message: newBioHealthResp(1, 3)},
-					{Message: newSmdDevResp(1)},
-					{Message: newBioHealthResp(1)},
-				},
-				1: {
-					{Message: newSmdDevResp(2, 1, 2, 3)},
-					{Message: newBioHealthResp(1, 1)},
-					{Message: newBioHealthResp(1, 2)},
-					{Message: newBioHealthResp(1, 3)},
-					{Message: newSmdDevResp(2)},
-					{Message: newBioHealthResp(2)},
-				},
-			},
-			expResp: &ctlpb.StorageScanResp{
-				Nvme: &ctlpb.ScanNvmeResp{
-					Ctrlrs: proto.NvmeControllers{
-						adjustNvmeSize(newCtrlrPBwMeta(1), mockPbScmMount0.AvailBytes, 4),
-						adjustNvmeSize(newCtrlrPBwMeta(2), mockPbScmMount1.AvailBytes, 4),
-					},
-					State: new(ctlpb.ResponseState),
-				},
-				// Scm: &ctlpb.ScanScmResp{State: new(ctlpb.ResponseState)},
-				Scm: &ctlpb.ScanScmResp{
-					Namespaces: proto.ScmNamespaces{
-						&ctlpb.ScmNamespace{
-							Blockdev: mockPbScmNamespace0.Blockdev,
-							Dev:      mockPbScmNamespace0.Dev,
-							Size:     mockPbScmNamespace0.Size,
-							Uuid:     mockPbScmNamespace0.Uuid,
-							Mount: &ctlpb.ScmNamespace_Mount{
-								Class:       mockPbScmMount0.Class,
-								DeviceList:  mockPbScmMount0.DeviceList,
-								Path:        mockPbScmMount0.Path,
-								TotalBytes:  mockPbScmMount0.TotalBytes,
-								AvailBytes:  mockPbScmMount0.AvailBytes,
-								UsableBytes: adjustScmSize(mockPbScmMount0.AvailBytes, false),
-								Rank:        mockPbScmMount0.Rank,
-							},
-						},
-						&ctlpb.ScmNamespace{
-							Blockdev: mockPbScmNamespace1.Blockdev,
-							Dev:      mockPbScmNamespace1.Dev,
-							Size:     mockPbScmNamespace1.Size,
-							Uuid:     mockPbScmNamespace1.Uuid,
-							NumaNode: mockPbScmNamespace1.NumaNode,
-							Mount: &ctlpb.ScmNamespace_Mount{
-								Class:       mockPbScmMount1.Class,
-								DeviceList:  mockPbScmMount1.DeviceList,
-								Path:        mockPbScmMount1.Path,
-								TotalBytes:  mockPbScmMount1.TotalBytes,
-								AvailBytes:  mockPbScmMount1.AvailBytes,
-								UsableBytes: adjustScmSize(mockPbScmMount1.AvailBytes, false),
-								Rank:        mockPbScmMount1.Rank,
-							},
-						},
-					},
-					State: new(ctlpb.ResponseState),
-				},
-				MemInfo: proto.MockPBMemInfo(),
-			},
-		},
-		"engines up; scan bdev meta; multiple nvme namespaces": {
-			req: &ctlpb.StorageScanReq{
-				Scm:  &ctlpb.ScanScmReq{Usage: true},
-				Nvme: &ctlpb.ScanNvmeReq{Meta: true},
-			},
-			csCtrlrs: &storage.NvmeControllers{
-				newCtrlrMultiNs(1, 2), newCtrlrMultiNs(2, 2),
-			},
-			eCtrlrs: []*storage.NvmeControllers{
-				{newCtrlrMultiNs(1, 2)}, {newCtrlrMultiNs(2, 2)},
-			},
-			smbc: &scm.MockBackendConfig{
-				GetModulesRes: storage.ScmModules{
-					storage.MockScmModule(0),
-				},
-				GetNamespacesRes: storage.ScmNamespaces{
-					storage.MockScmNamespace(0),
-					storage.MockScmNamespace(1),
-				},
-			},
-			smsc: &system.MockSysConfig{
-				GetfsUsageResps: []system.GetfsUsageRetval{
-					{
-						Total: mockPbScmMount0.TotalBytes,
-						Avail: mockPbScmMount0.AvailBytes,
-					},
-					{
-						Total: mockPbScmMount1.TotalBytes,
-						Avail: mockPbScmMount1.AvailBytes,
-					},
-				},
-			},
-			storageCfgs: []storage.TierConfigs{
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassDcpm.String()).
-						WithScmMountPoint(mockPbScmMount0.Path).
-						WithScmDeviceList(mockPbScmNamespace0.Blockdev),
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassNvme.String()).
-						WithBdevDeviceList(newCtrlr(1).PciAddr),
-				},
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassDcpm.String()).
-						WithScmMountPoint(mockPbScmMount1.Path).
-						WithScmDeviceList(mockPbScmNamespace1.Blockdev),
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassNvme.String()).
-						WithBdevDeviceList(newCtrlr(2).PciAddr),
-				},
-			},
-			engineTargetCount: []int{8, 8},
-			drpcResps: map[int][]*mockDrpcResponse{
-				0: {
-					{Message: newSmdDevResp(1, 1, 2)},
-					{Message: newBioHealthResp(1, 1)},
-					{Message: newBioHealthResp(2, 1)},
-				},
-				1: {
-					{Message: newSmdDevResp(2, 3, 4)},
-					{Message: newBioHealthResp(3, 2)},
-					{Message: newBioHealthResp(4, 2)},
-				},
-			},
-			expResp: &ctlpb.StorageScanResp{
-				Nvme: &ctlpb.ScanNvmeResp{
-					Ctrlrs: proto.NvmeControllers{
-						adjustNvmeSize(newCtrlrPBwMeta(1, 1, 2), mockPbScmMount0.AvailBytes, 8),
-						adjustNvmeSize(newCtrlrPBwMeta(2, 3, 4), mockPbScmMount1.AvailBytes, 8),
-					},
-					State: new(ctlpb.ResponseState),
-				},
-				Scm: &ctlpb.ScanScmResp{
-					Namespaces: proto.ScmNamespaces{
-						&ctlpb.ScmNamespace{
-							Blockdev: mockPbScmNamespace0.Blockdev,
-							Dev:      mockPbScmNamespace0.Dev,
-							Size:     mockPbScmNamespace0.Size,
-							Uuid:     mockPbScmNamespace0.Uuid,
-							Mount: &ctlpb.ScmNamespace_Mount{
-								Class:       mockPbScmMount0.Class,
-								DeviceList:  mockPbScmMount0.DeviceList,
-								Path:        mockPbScmMount0.Path,
-								TotalBytes:  mockPbScmMount0.TotalBytes,
-								AvailBytes:  mockPbScmMount0.AvailBytes,
-								UsableBytes: adjustScmSize(mockPbScmMount0.AvailBytes, false),
-								Rank:        mockPbScmMount0.Rank,
-							},
-						},
-						&ctlpb.ScmNamespace{
-							Blockdev: mockPbScmNamespace1.Blockdev,
-							Dev:      mockPbScmNamespace1.Dev,
-							Size:     mockPbScmNamespace1.Size,
-							Uuid:     mockPbScmNamespace1.Uuid,
-							NumaNode: mockPbScmNamespace1.NumaNode,
-							Mount: &ctlpb.ScmNamespace_Mount{
-								Class:       mockPbScmMount1.Class,
-								DeviceList:  mockPbScmMount1.DeviceList,
-								Path:        mockPbScmMount1.Path,
-								TotalBytes:  mockPbScmMount1.TotalBytes,
-								AvailBytes:  mockPbScmMount1.AvailBytes,
-								UsableBytes: adjustScmSize(mockPbScmMount1.AvailBytes, false),
-								Rank:        mockPbScmMount1.Rank,
-							},
-						},
-					},
-					State: new(ctlpb.ResponseState),
-				},
-				MemInfo: proto.MockPBMemInfo(),
-			},
-		},
-		"scan scm usage": {
-			req: &ctlpb.StorageScanReq{
-				Scm:  &ctlpb.ScanScmReq{Usage: true},
-				Nvme: new(ctlpb.ScanNvmeReq),
-			},
-			smbc: &scm.MockBackendConfig{
-				GetModulesRes:    storage.ScmModules{storage.MockScmModule(0)},
-				GetNamespacesRes: storage.ScmNamespaces{storage.MockScmNamespace(0)},
-			},
-			smsc: &system.MockSysConfig{
-				GetfsUsageResps: []system.GetfsUsageRetval{
-					{
-						Total: mockPbScmMount0.TotalBytes,
-						Avail: mockPbScmMount0.AvailBytes,
-					},
-				},
-			},
-			storageCfgs: []storage.TierConfigs{
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassDcpm.String()).
-						WithScmMountPoint(mockPbScmMount0.Path).
-						WithScmDeviceList(mockPbScmNamespace0.Blockdev),
-				},
-			},
-			engineTargetCount: []int{4},
-			drpcResps: map[int][]*mockDrpcResponse{
-				0: {},
-			},
-			expResp: &ctlpb.StorageScanResp{
-				Nvme: &ctlpb.ScanNvmeResp{
-					State: new(ctlpb.ResponseState),
-				},
-				Scm: &ctlpb.ScanScmResp{
-					Namespaces: proto.ScmNamespaces{
-						&ctlpb.ScmNamespace{
-							Blockdev: mockPbScmNamespace0.Blockdev,
-							Dev:      mockPbScmNamespace0.Dev,
-							Size:     mockPbScmNamespace0.Size,
-							Uuid:     mockPbScmNamespace0.Uuid,
-							Mount: &ctlpb.ScmNamespace_Mount{
-								Class:       mockPbScmMount0.Class,
-								DeviceList:  mockPbScmMount0.DeviceList,
-								Path:        mockPbScmMount0.Path,
-								Rank:        mockPbScmMount0.Rank,
-								TotalBytes:  mockPbScmMount0.TotalBytes,
-								AvailBytes:  mockPbScmMount0.AvailBytes,
-								UsableBytes: adjustScmSize(mockPbScmMount0.AvailBytes, true),
-							},
-						},
-					},
-					State: new(ctlpb.ResponseState),
-				},
-				MemInfo: proto.MockPBMemInfo(),
-			},
-		},
-		"scan scm usage; pmem not in instance device list": {
-			req: &ctlpb.StorageScanReq{
-				Scm:  &ctlpb.ScanScmReq{Usage: true},
-				Nvme: new(ctlpb.ScanNvmeReq),
-			},
-			smbc: &scm.MockBackendConfig{
-				GetModulesRes:    storage.ScmModules{storage.MockScmModule(0)},
-				GetNamespacesRes: storage.ScmNamespaces{storage.MockScmNamespace(0)},
-			},
-			smsc: &system.MockSysConfig{
-				GetfsUsageResps: []system.GetfsUsageRetval{
-					{
-						Total: mockPbScmMount0.TotalBytes,
-						Avail: mockPbScmMount0.AvailBytes,
-					},
-				},
-			},
-			storageCfgs: []storage.TierConfigs{
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassDcpm.String()).
-						WithScmMountPoint(mockPbScmMount0.Path).
-						WithScmDeviceList("/dev/foo", "/dev/bar"),
-				},
-			},
-			engineTargetCount: []int{4},
-			drpcResps: map[int][]*mockDrpcResponse{
-				0: {},
-			},
-			expResp: &ctlpb.StorageScanResp{
-				Nvme: &ctlpb.ScanNvmeResp{
-					State: new(ctlpb.ResponseState),
-				},
-				Scm: &ctlpb.ScanScmResp{
-					State: &ctlpb.ResponseState{
-						Status: ctlpb.ResponseStatus_CTL_ERR_SCM,
-						Error:  "instance 0: no pmem namespace for mount /mnt/daos0",
-					},
-				},
-				MemInfo: proto.MockPBMemInfo(),
-			},
-		},
-		"scan scm usage; class ram": {
-			req: &ctlpb.StorageScanReq{
-				Scm:  &ctlpb.ScanScmReq{Usage: true},
-				Nvme: new(ctlpb.ScanNvmeReq),
-			},
-			smbc: &scm.MockBackendConfig{
-				GetModulesRes:    storage.ScmModules{storage.MockScmModule(0)},
-				GetNamespacesRes: storage.ScmNamespaces{storage.MockScmNamespace(0)},
-			},
-			smsc: &system.MockSysConfig{
-				GetfsUsageResps: []system.GetfsUsageRetval{
-					{
-						Total: mockPbScmMount0.TotalBytes,
-						Avail: mockPbScmMount0.AvailBytes,
-					},
-				},
-			},
-			storageCfgs: []storage.TierConfigs{
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassRam.String()).
-						WithScmMountPoint(mockPbScmMount0.Path).
-						WithScmRamdiskSize(16),
-				},
-			},
-			engineTargetCount: []int{4},
-			drpcResps: map[int][]*mockDrpcResponse{
-				0: {},
-			},
-			expResp: &ctlpb.StorageScanResp{
-				Nvme: &ctlpb.ScanNvmeResp{
-					State: new(ctlpb.ResponseState),
-				},
-				Scm: &ctlpb.ScanScmResp{
-					Namespaces: proto.ScmNamespaces{
-						&ctlpb.ScmNamespace{
-							Blockdev: "ramdisk",
-							Size:     uint64(humanize.GiByte * 16),
-							Mount: &ctlpb.ScmNamespace_Mount{
-								Class:       "ram",
-								Path:        mockPbScmMount0.Path,
-								TotalBytes:  mockPbScmMount0.TotalBytes,
-								AvailBytes:  mockPbScmMount0.AvailBytes,
-								UsableBytes: adjustScmSize(mockPbScmMount0.AvailBytes, true),
-								Rank:        mockPbScmMount0.Rank,
-							},
-						},
-					},
-					State: new(ctlpb.ResponseState),
-				},
-				MemInfo: proto.MockPBMemInfo(),
-			},
-		},
-		"multi-engine; multi-tier; with usage": {
-			req: &ctlpb.StorageScanReq{
-				Scm:  &ctlpb.ScanScmReq{Usage: true},
-				Nvme: &ctlpb.ScanNvmeReq{Meta: true},
-			},
-			csCtrlrs: &storage.NvmeControllers{newCtrlr(1), newCtrlr(2)},
-			eCtrlrs:  []*storage.NvmeControllers{{newCtrlr(1)}, {newCtrlr(2)}},
-			smbc: &scm.MockBackendConfig{
-				GetModulesRes: storage.ScmModules{
-					storage.MockScmModule(0),
-				},
-				GetNamespacesRes: storage.ScmNamespaces{
-					storage.MockScmNamespace(0),
-					storage.MockScmNamespace(1),
-				},
-			},
-			smsc: &system.MockSysConfig{
-				GetfsUsageResps: []system.GetfsUsageRetval{
-					{
-						Total: mockPbScmMount0.TotalBytes,
-						Avail: mockPbScmMount0.AvailBytes,
-					},
-					{
-						Total: mockPbScmMount1.TotalBytes,
-						Avail: mockPbScmMount1.AvailBytes,
-					},
-				},
-			},
-			storageCfgs: []storage.TierConfigs{
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassDcpm.String()).
-						WithScmMountPoint(mockPbScmMount0.Path).
-						WithScmDeviceList(mockPbScmNamespace0.Blockdev),
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassNvme.String()).
-						WithBdevDeviceList(newCtrlr(1).PciAddr),
-				},
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassDcpm.String()).
-						WithScmMountPoint(mockPbScmMount1.Path).
-						WithScmDeviceList(mockPbScmNamespace1.Blockdev),
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassNvme.String()).
-						WithBdevDeviceList(newCtrlr(2).PciAddr),
-				},
-			},
-			engineTargetCount: []int{4, 4},
-			drpcResps: map[int][]*mockDrpcResponse{
-				0: {
-					{Message: newSmdDevResp(1)},
-					{Message: newBioHealthResp(1)},
-				},
-				1: {
-					{Message: newSmdDevResp(2)},
-					{Message: newBioHealthResp(2)},
-				},
-			},
-			expResp: &ctlpb.StorageScanResp{
-				Nvme: &ctlpb.ScanNvmeResp{
-					Ctrlrs: proto.NvmeControllers{
-						adjustNvmeSize(newCtrlrPBwMeta(1), mockPbScmMount0.AvailBytes, 4),
-						adjustNvmeSize(newCtrlrPBwMeta(2), mockPbScmMount1.AvailBytes, 4),
-					},
-					State: new(ctlpb.ResponseState),
-				},
-				Scm: &ctlpb.ScanScmResp{
-					Namespaces: proto.ScmNamespaces{
-						&ctlpb.ScmNamespace{
-							Blockdev: mockPbScmNamespace0.Blockdev,
-							Dev:      mockPbScmNamespace0.Dev,
-							Size:     mockPbScmNamespace0.Size,
-							Uuid:     mockPbScmNamespace0.Uuid,
-							Mount: &ctlpb.ScmNamespace_Mount{
-								Class:       mockPbScmMount0.Class,
-								DeviceList:  mockPbScmMount0.DeviceList,
-								Path:        mockPbScmMount0.Path,
-								TotalBytes:  mockPbScmMount0.TotalBytes,
-								AvailBytes:  mockPbScmMount0.AvailBytes,
-								UsableBytes: adjustScmSize(mockPbScmMount0.AvailBytes, false),
-								Rank:        mockPbScmMount0.Rank,
-							},
-						},
-						&ctlpb.ScmNamespace{
-							Blockdev: mockPbScmNamespace1.Blockdev,
-							Dev:      mockPbScmNamespace1.Dev,
-							Size:     mockPbScmNamespace1.Size,
-							Uuid:     mockPbScmNamespace1.Uuid,
-							NumaNode: mockPbScmNamespace1.NumaNode,
-							Mount: &ctlpb.ScmNamespace_Mount{
-								Class:       mockPbScmMount1.Class,
-								DeviceList:  mockPbScmMount1.DeviceList,
-								Path:        mockPbScmMount1.Path,
-								TotalBytes:  mockPbScmMount1.TotalBytes,
-								AvailBytes:  mockPbScmMount1.AvailBytes,
-								UsableBytes: adjustScmSize(mockPbScmMount1.AvailBytes, false),
-								Rank:        mockPbScmMount1.Rank,
-							},
-						},
-					},
-					State: new(ctlpb.ResponseState),
-				},
-				MemInfo: proto.MockPBMemInfo(),
-			},
-		},
-		"multi-engine; multi-tier; with usage; engines not ready": {
-			req: &ctlpb.StorageScanReq{
-				Scm:  &ctlpb.ScanScmReq{Usage: true},
-				Nvme: &ctlpb.ScanNvmeReq{Meta: true},
-			},
-			storageCfgs: []storage.TierConfigs{
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassDcpm.String()).
-						WithScmMountPoint(mockPbScmMount0.Path).
-						WithScmDeviceList(mockPbScmNamespace0.Blockdev),
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassNvme.String()).
-						WithBdevDeviceList(newCtrlr(1).PciAddr),
-				},
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassDcpm.String()).
-						WithScmMountPoint(mockPbScmMount1.Path).
-						WithScmDeviceList(mockPbScmNamespace1.Blockdev),
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassNvme.String()).
-						WithBdevDeviceList(newCtrlr(2).PciAddr),
-				},
-			},
-			engineTargetCount: []int{4, 4},
-			enginesNotReady:   true,
-			drpcResps: map[int][]*mockDrpcResponse{
-				0: {
-					{Message: newSmdDevResp(1)},
-					{Message: newBioHealthResp(1)},
-				},
-				1: {
-					{Message: newSmdDevResp(2)},
-					{Message: newBioHealthResp(2)},
-				},
-			},
-			expErr: errEngineNotReady,
-		},
-		// Sometimes when more than a few ssds are assigned to engine without many targets,
-		// some of the smd entries for the latter ssds are in state "NEW" rather than
-		// "NORMAL", when in this state, health is unavailable and DER_NONEXIST is returned.
-		"bdev scan; meta; new state; non-existent smd health": {
-			req: &ctlpb.StorageScanReq{
-				Scm:  new(ctlpb.ScanScmReq),
-				Nvme: &ctlpb.ScanNvmeReq{Meta: true},
-			},
-			csCtrlrs: &storage.NvmeControllers{newCtrlr(1)},
-			storageCfgs: []storage.TierConfigs{
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassNvme.String()).
-						WithBdevDeviceList(newCtrlr(1).PciAddr),
-				},
-			},
-			engineTargetCount: []int{4},
-			drpcResps: map[int][]*mockDrpcResponse{
-				0: {
-					{Message: smdDevRespStateNew},
-					{
-						Message: &ctlpb.BioHealthResp{
-							Status: int32(daos.Nonexistent),
-						},
-					},
-				},
-			},
-			expResp: &ctlpb.StorageScanResp{
-				Nvme: &ctlpb.ScanNvmeResp{
-					Ctrlrs: proto.NvmeControllers{ctrlrPBwMetaNew},
-					State:  new(ctlpb.ResponseState),
-				},
-				Scm:     &ctlpb.ScanScmResp{State: new(ctlpb.ResponseState)},
-				MemInfo: proto.MockPBMemInfo(),
-			},
-		},
-		"bdev scan; meta; new state; nomem smd health": {
-			req: &ctlpb.StorageScanReq{
-				Scm:  new(ctlpb.ScanScmReq),
-				Nvme: &ctlpb.ScanNvmeReq{Meta: true},
-			},
-			csCtrlrs: &storage.NvmeControllers{newCtrlr(1)},
-			storageCfgs: []storage.TierConfigs{
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassNvme.String()).
-						WithBdevDeviceList(newCtrlr(1).PciAddr),
-				},
-			},
-			engineTargetCount: []int{4},
-			drpcResps: map[int][]*mockDrpcResponse{
-				0: {
-					{Message: smdDevRespStateNew},
-					{
-						Message: &ctlpb.BioHealthResp{
-							Status: int32(daos.FreeMemError),
-						},
-					},
-				},
-			},
-			expResp: &ctlpb.StorageScanResp{
-				Nvme: &ctlpb.ScanNvmeResp{
-					Ctrlrs: proto.NvmeControllers{ctrlrPBwMetaNew},
-					State:  new(ctlpb.ResponseState),
-				},
-				Scm:     &ctlpb.ScanScmResp{State: new(ctlpb.ResponseState)},
-				MemInfo: proto.MockPBMemInfo(),
-			},
-		},
-		"bdev scan; meta; normal state; non-existent smd health": {
-			req: &ctlpb.StorageScanReq{
-				Scm:  new(ctlpb.ScanScmReq),
-				Nvme: &ctlpb.ScanNvmeReq{Meta: true},
-			},
-			csCtrlrs: &storage.NvmeControllers{newCtrlr(1)},
-			storageCfgs: []storage.TierConfigs{
-				{
-					storage.NewTierConfig().
-						WithStorageClass(storage.ClassNvme.String()).
-						WithBdevDeviceList(newCtrlr(1).PciAddr),
-				},
-			},
-			engineTargetCount: []int{4},
-			drpcResps: map[int][]*mockDrpcResponse{
-				0: {
-					{Message: newSmdDevResp(1)},
-					{
-						Message: &ctlpb.BioHealthResp{
-							Status: int32(daos.Nonexistent),
-						},
-					},
-				},
-			},
-			expResp: &ctlpb.StorageScanResp{
-				Nvme: &ctlpb.ScanNvmeResp{
-					Ctrlrs: proto.NvmeControllers{ctrlrPBwMetaNormal},
-					State:  new(ctlpb.ResponseState),
-				},
-				Scm:     &ctlpb.ScanScmResp{State: new(ctlpb.ResponseState)},
-				MemInfo: proto.MockPBMemInfo(),
-			},
-		},
-	} {
-		t.Run(name, func(t *testing.T) {
-			log, buf := logging.NewTestLogger(t.Name())
-			defer test.ShowBufferOnFailure(t, buf)
-
-			if len(tc.storageCfgs) != len(tc.drpcResps) {
-				t.Fatalf("number of tc.storageCfgs doesn't match num drpc msg groups")
-			}
-
-			if len(tc.storageCfgs) == 1 && tc.eCtrlrs == nil && tc.csCtrlrs != nil {
-				log.Debugf("using control service storage provider for first engine")
-				tc.eCtrlrs = []*storage.NvmeControllers{tc.csCtrlrs}
-			}
-
-			var csbmbc *bdev.MockBackendConfig
-			if tc.csCtrlrs != nil {
-				log.Debugf("bdevs %v to be returned for control service scan", *tc.csCtrlrs)
-				csbmbc = &bdev.MockBackendConfig{
-					ScanRes: &storage.BdevScanResponse{Controllers: *tc.csCtrlrs},
-				}
-			}
-
-			var engineCfgs []*engine.Config
-			for i, sc := range tc.storageCfgs {
-				log.Debugf("storage cfg contains bdevs %v for engine %d", sc.Bdevs(), i)
-				engineCfgs = append(engineCfgs,
-					engine.MockConfig().
-						WithStorage(sc...).
-						WithTargetCount(tc.engineTargetCount[i]))
-			}
-			sCfg := config.DefaultServer().WithEngines(engineCfgs...)
-			cs := mockControlService(t, log, sCfg, csbmbc, tc.smbc, tc.smsc)
-
-			// In production, during server/server.go:srv.addEngines() and after
-			// srv.createEngine(), engine.storage.SetBdevCache() is called to load the
-			// results of the start-up bdev scan from the control service storage
-			// provider into the engine's storage provider. The control service and
-			// each of the engines have distinct storage provider instances so cached
-			// cached results have to be explicitly shared so results are available when
-			// engines are up.
-
-			for idx, ec := range engineCfgs {
-				var ebmbc *bdev.MockBackendConfig
-				if tc.eCtrlrs != nil && len(tc.eCtrlrs) > idx {
-					log.Debugf("bdevs %v to be returned for engine %d scan",
-						*tc.eCtrlrs[idx], idx)
-					ebmbc = &bdev.MockBackendConfig{
-						ScanRes: &storage.BdevScanResponse{
-							Controllers: *tc.eCtrlrs[idx],
-						},
-					}
-				}
-
-				// replace harness instance with mock I/O Engine
-				// to enable mocking of harness instance drpc channel
-				sp := storage.MockProvider(log, idx, &ec.Storage,
-					cs.storage.Sys, // share system provider cfo
-					scm.NewMockProvider(log, tc.smbc, nil),
-					bdev.NewMockProvider(log, ebmbc), nil)
-				if tc.eCtrlrs != nil && len(tc.eCtrlrs) > idx {
-					sp.SetBdevCache(storage.BdevScanResponse{
-						Controllers: *tc.eCtrlrs[idx],
-					})
-				}
-				te := newTestEngine(log, false, sp, ec)
-
-				if tc.enginesNotReady {
-					te.ready.SetFalse()
-				}
-
-				// mock drpc responses
-				dcc := new(mockDrpcClientConfig)
-				if tc.junkResp {
-					dcc.setSendMsgResponse(drpc.Status_SUCCESS,
-						makeBadBytes(42), nil)
-				} else if len(tc.drpcResps) > idx {
-					t.Logf("setting %d drpc responses for engine %d",
-						len(tc.drpcResps[idx]), idx)
-					dcc.setSendMsgResponseList(t, tc.drpcResps[idx]...)
-				} else {
-					t.Fatal("drpc response mocks unpopulated")
-				}
-				te.setDrpcClient(newMockDrpcClient(dcc))
-				te._superblock.Rank = ranklist.NewRankPtr(uint32(idx + 1))
-				for _, tc := range te.storage.GetBdevConfigs() {
-					tc.Bdev.DeviceRoles.OptionBits = storage.OptionBits(storage.BdevRoleAll)
-				}
-				md := te.storage.GetControlMetadata()
-				md.Path = "/foo"
-				md.DevicePath = md.Path
-
-				cs.harness.instances[idx] = te
-			}
-			cs.harness.started.SetTrue()
-
-			if tc.req == nil {
-				tc.req = &ctlpb.StorageScanReq{
-					Scm:  new(ctlpb.ScanScmReq),
-					Nvme: new(ctlpb.ScanNvmeReq),
-				}
-			}
-
-			if tc.scanTwice {
-				_, err := cs.StorageScan(test.Context(t), tc.req)
-				test.CmpErr(t, tc.expErr, err)
-				if err != nil {
-					return
-				}
-			}
-
-			resp, err := cs.StorageScan(test.Context(t), tc.req)
-			test.CmpErr(t, tc.expErr, err)
-			if err != nil {
-				return
-			}
-
-			if diff := cmp.Diff(tc.expResp, resp, defStorageScanCmpOpts...); diff != "" {
-				t.Fatalf("unexpected response (-want, +got):\n%s\n", diff)
-			}
-		})
-	}
-}
+//func TestServer_CtlSvc_StorageScan_PostEngineStart(t *testing.T) {
+//	const (
+//		clusterSize uint64 = 32 * humanize.MiByte
+//		metaWalSize uint64 = 64 * humanize.MiByte
+//		rdbSize     uint64 = defaultRdbSize
+//		rdbWalSize  uint64 = 512 * humanize.MiByte
+//	)
+//
+//	adjustScmSize := func(sizeBytes uint64, withMdDaosScm bool) uint64 {
+//		mdBytes := rdbSize + mdFsScmBytes
+//		if withMdDaosScm {
+//			mdBytes += mdDaosScmBytes
+//		}
+//
+//		if sizeBytes < mdBytes {
+//			return 0
+//		}
+//
+//		return sizeBytes - mdBytes
+//	}
+//
+//	adjustNvmeSize := func(nvmeCtlr *ctlpb.NvmeController, mdBytes uint64, engineTargetCount int) *ctlpb.NvmeController {
+//		getClusterCount := func(sizeBytes uint64) uint64 {
+//			clusterCount := sizeBytes / clusterSize
+//			if sizeBytes%clusterSize != 0 {
+//				clusterCount += 1
+//			}
+//			return clusterCount
+//		}
+//
+//		type deviceSizeStat struct {
+//			clusterPerTarget uint64
+//			smdDevs          []*ctlpb.SmdDevice
+//		}
+//		devicesToAdjust := make(map[uint32]*deviceSizeStat, 0)
+//		for _, dev := range nvmeCtlr.GetSmdDevices() {
+//			targetCount := uint64(len(dev.GetTgtIds()))
+//			dev.MetaSize = adjustScmSize(mdBytes, false) / uint64(engineTargetCount)
+//			dev.AvailBytes = (dev.GetAvailBytes() / clusterSize) * clusterSize
+//
+//			usableClusterCount := dev.GetAvailBytes() / clusterSize
+//			usableClusterCount -= getClusterCount(dev.MetaSize) * uint64(engineTargetCount)
+//			usableClusterCount -= getClusterCount(metaWalSize) * uint64(engineTargetCount)
+//			usableClusterCount -= getClusterCount(rdbSize)
+//			usableClusterCount -= getClusterCount(rdbWalSize)
+//
+//			rank := dev.GetRank()
+//			if devicesToAdjust[rank] == nil {
+//				devicesToAdjust[rank] = &deviceSizeStat{
+//					clusterPerTarget: math.MaxUint64,
+//				}
+//			}
+//			devicesToAdjust[rank].smdDevs = append(devicesToAdjust[rank].smdDevs, dev)
+//			clusterPerTarget := usableClusterCount / targetCount
+//			if clusterPerTarget < devicesToAdjust[rank].clusterPerTarget {
+//				devicesToAdjust[rank].clusterPerTarget = clusterPerTarget
+//			}
+//		}
+//
+//		for _, item := range devicesToAdjust {
+//			for _, dev := range item.smdDevs {
+//				targetCount := uint64(len(dev.GetTgtIds()))
+//				dev.UsableBytes = item.clusterPerTarget * targetCount * clusterSize
+//			}
+//		}
+//
+//		return nvmeCtlr
+//	}
+//
+//	// output to be returned from mock bdev backend
+//	newCtrlr := func(idx int32) *storage.NvmeController {
+//		ctrlr := storage.MockNvmeController(idx)
+//		ctrlr.Serial = test.MockUUID(idx)
+//		ctrlr.SmdDevices = nil
+//
+//		return ctrlr
+//	}
+//	newCtrlrMultiNs := func(idx int32, numNss int) *storage.NvmeController {
+//		ctrlr := storage.MockNvmeController(idx)
+//		ctrlr.Serial = test.MockUUID(idx)
+//		ctrlr.SmdDevices = nil
+//		ctrlr.Namespaces = make([]*storage.NvmeNamespace, numNss)
+//		for i := 0; i < numNss; i++ {
+//			ctrlr.Namespaces[i] = storage.MockNvmeNamespace(int32(i + 1))
+//		}
+//
+//		return ctrlr
+//	}
+//
+//	// expected protobuf output to be returned svc.StorageScan when health
+//	// updated over drpc. Override serial uuid with variable argument
+//	newCtrlrHealth := func(idx int32, serialIdx ...int32) (*ctlpb.NvmeController, *ctlpb.BioHealthResp) {
+//		ctrlr := proto.MockNvmeController(idx)
+//		sIdx := idx
+//		if len(serialIdx) > 0 {
+//			sIdx = serialIdx[0]
+//		}
+//		ctrlr.Model = fmt.Sprintf("model-%d", sIdx)
+//		ctrlr.Serial = test.MockUUID(sIdx)
+//		ctrlr.HealthStats = proto.MockNvmeHealth(idx + 1)
+//		ctrlr.HealthStats.ClusterSize = clusterSize
+//		ctrlr.HealthStats.MetaWalSize = metaWalSize
+//		ctrlr.HealthStats.RdbWalSize = rdbWalSize
+//		ctrlr.SmdDevices = nil
+//
+//		bioHealthResp := new(ctlpb.BioHealthResp)
+//		if err := convert.Types(ctrlr.HealthStats, bioHealthResp); err != nil {
+//			t.Fatal(err)
+//		}
+//		bioHealthResp.TotalBytes = uint64(idx) * uint64(humanize.TByte)
+//		bioHealthResp.AvailBytes = uint64(idx) * uint64(humanize.TByte/2)
+//		bioHealthResp.ClusterSize = clusterSize
+//		bioHealthResp.MetaWalSize = metaWalSize
+//		bioHealthResp.RdbWalSize = rdbWalSize
+//
+//		return ctrlr, bioHealthResp
+//	}
+//	newCtrlrPBwHealth := func(idx int32, serialIdx ...int32) *ctlpb.NvmeController {
+//		c, _ := newCtrlrHealth(idx, serialIdx...)
+//		return c
+//	}
+//	newBioHealthResp := func(idx int32, serialIdx ...int32) *ctlpb.BioHealthResp {
+//		_, b := newCtrlrHealth(idx, serialIdx...)
+//		return b
+//	}
+//
+//	// expected protobuf output to be returned svc.StorageScan when smd
+//	// updated over drpc
+//	newCtrlrMeta := func(ctrlrIdx int32, smdIndexes ...int32) (*ctlpb.NvmeController, *ctlpb.SmdDevResp) {
+//		ctrlr := proto.MockNvmeController(ctrlrIdx)
+//		ctrlr.Serial = test.MockUUID(ctrlrIdx)
+//		ctrlr.HealthStats = nil
+//
+//		if len(smdIndexes) == 0 {
+//			smdIndexes = append(smdIndexes, ctrlrIdx)
+//		}
+//		smdDevRespDevices := make([]*ctlpb.SmdDevice, len(smdIndexes))
+//		ctrlr.SmdDevices = make([]*ctlpb.SmdDevice, len(smdIndexes))
+//		ctrlr.Namespaces = make([]*ctlpb.NvmeController_Namespace, len(smdIndexes))
+//		for i, idx := range smdIndexes {
+//			sd := proto.MockSmdDevice(ctrlr.PciAddr, idx+1)
+//			sd.DevState = devStateNormal
+//			sd.Rank = uint32(ctrlrIdx)
+//			sd.TrAddr = ctrlr.PciAddr
+//			ctrlr.SmdDevices[i] = sd
+//
+//			smdPB := new(ctlpb.SmdDevice)
+//			if err := convert.Types(sd, smdPB); err != nil {
+//				t.Fatal(err)
+//			}
+//			smdDevRespDevices[i] = smdPB
+//
+//			// expect resultant controller to have updated utilization values
+//			ctrlr.SmdDevices[i].TotalBytes = uint64(idx) * uint64(humanize.TByte)
+//			ctrlr.SmdDevices[i].AvailBytes = uint64(idx) * uint64(humanize.TByte/2)
+//			ctrlr.SmdDevices[i].ClusterSize = clusterSize
+//			ctrlr.SmdDevices[i].MetaWalSize = metaWalSize
+//			ctrlr.SmdDevices[i].RdbSize = rdbSize
+//			ctrlr.SmdDevices[i].RdbWalSize = rdbWalSize
+//			ctrlr.Namespaces[i] = proto.MockNvmeNamespace(int32(i + 1))
+//		}
+//
+//		return ctrlr, &ctlpb.SmdDevResp{Devices: smdDevRespDevices}
+//	}
+//	newCtrlrPB := func(idx int32) *ctlpb.NvmeController {
+//		c, _ := newCtrlrMeta(idx)
+//		c.SmdDevices = nil
+//		return c
+//	}
+//	newCtrlrPBwBasic := func(idx int32) *ctlpb.NvmeController {
+//		c := newCtrlrPB(idx)
+//		c.FwRev = ""
+//		c.Model = ""
+//		return c
+//	}
+//	newCtrlrPBwMeta := func(idx int32, smdIndexes ...int32) *ctlpb.NvmeController {
+//		c, _ := newCtrlrMeta(idx, smdIndexes...)
+//		return c
+//	}
+//	newSmdDevResp := func(idx int32, smdIndexes ...int32) *ctlpb.SmdDevResp {
+//		_, s := newCtrlrMeta(idx, smdIndexes...)
+//		return s
+//	}
+//
+//	smdDevRespStateNew := newSmdDevResp(1)
+//	smdDevRespStateNew.Devices[0].DevState = devStateNew
+//	smdDevRespStateNew.Devices[0].ClusterSize = 0
+//	smdDevRespStateNew.Devices[0].MetaWalSize = 0
+//	smdDevRespStateNew.Devices[0].RdbWalSize = 0
+//
+//	ctrlrPBwMetaNew := newCtrlrPBwMeta(1)
+//	ctrlrPBwMetaNew.SmdDevices[0].AvailBytes = 0
+//	ctrlrPBwMetaNew.SmdDevices[0].TotalBytes = 0
+//	ctrlrPBwMetaNew.SmdDevices[0].DevState = devStateNew
+//	ctrlrPBwMetaNew.SmdDevices[0].ClusterSize = 0
+//	ctrlrPBwMetaNew.SmdDevices[0].UsableBytes = 0
+//	ctrlrPBwMetaNew.SmdDevices[0].RdbSize = 0
+//	ctrlrPBwMetaNew.SmdDevices[0].RdbWalSize = 0
+//	ctrlrPBwMetaNew.SmdDevices[0].MetaSize = 0
+//	ctrlrPBwMetaNew.SmdDevices[0].MetaWalSize = 0
+//
+//	ctrlrPBwMetaNormal := newCtrlrPBwMeta(1)
+//	ctrlrPBwMetaNormal.SmdDevices[0].AvailBytes = 0
+//	ctrlrPBwMetaNormal.SmdDevices[0].TotalBytes = 0
+//	ctrlrPBwMetaNormal.SmdDevices[0].DevState = devStateNormal
+//	ctrlrPBwMetaNormal.SmdDevices[0].ClusterSize = 0
+//	ctrlrPBwMetaNormal.SmdDevices[0].UsableBytes = 0
+//	ctrlrPBwMetaNormal.SmdDevices[0].RdbSize = 0
+//	ctrlrPBwMetaNormal.SmdDevices[0].RdbWalSize = 0
+//	ctrlrPBwMetaNormal.SmdDevices[0].MetaSize = 0
+//	ctrlrPBwMetaNormal.SmdDevices[0].MetaWalSize = 0
+//
+//	mockPbScmMount0 := proto.MockScmMountPoint(0)
+//	mockPbScmMount0.Rank += 1
+//	mockPbScmNamespace0 := proto.MockScmNamespace(0)
+//	mockPbScmNamespace0.Mount = mockPbScmMount0
+//	mockPbScmMount1 := proto.MockScmMountPoint(1)
+//	mockPbScmMount1.Rank += 1
+//	mockPbScmNamespace1 := proto.MockScmNamespace(1)
+//	mockPbScmNamespace1.Mount = mockPbScmMount1
+//
+//	for name, tc := range map[string]struct {
+//		req               *ctlpb.StorageScanReq
+//		csCtrlrs          *storage.NvmeControllers   // control service storage provider
+//		eCtrlrs           []*storage.NvmeControllers // engine storage provider
+//		smbc              *scm.MockBackendConfig
+//		smsc              *system.MockSysConfig
+//		storageCfgs       []storage.TierConfigs
+//		engineTargetCount []int
+//		enginesNotReady   bool
+//		scanTwice         bool
+//		junkResp          bool
+//		drpcResps         map[int][]*mockDrpcResponse
+//		expErr            error
+//		expResp           *ctlpb.StorageScanResp
+//	}{
+//		"engine up; scan bdev basic": {
+//			req: &ctlpb.StorageScanReq{
+//				Scm:  new(ctlpb.ScanScmReq),
+//				Nvme: &ctlpb.ScanNvmeReq{Basic: true},
+//			},
+//			storageCfgs: []storage.TierConfigs{
+//				{
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassNvme.String()).
+//						WithBdevDeviceList(newCtrlr(1).PciAddr),
+//				},
+//			},
+//			csCtrlrs:          &storage.NvmeControllers{newCtrlr(1)},
+//			engineTargetCount: []int{4},
+//			drpcResps: map[int][]*mockDrpcResponse{
+//				0: {},
+//			},
+//			expResp: &ctlpb.StorageScanResp{
+//				Nvme: &ctlpb.ScanNvmeResp{
+//					Ctrlrs: proto.NvmeControllers{newCtrlrPBwBasic(1)},
+//					State:  new(ctlpb.ResponseState),
+//				},
+//				Scm:     &ctlpb.ScanScmResp{State: new(ctlpb.ResponseState)},
+//				MemInfo: proto.MockPBMemInfo(),
+//			},
+//		},
+//		"engine up; scan bdev basic; no bdevs in config": {
+//			req: &ctlpb.StorageScanReq{
+//				Scm:  new(ctlpb.ScanScmReq),
+//				Nvme: &ctlpb.ScanNvmeReq{Basic: true},
+//			},
+//			storageCfgs: []storage.TierConfigs{},
+//			csCtrlrs:    &storage.NvmeControllers{newCtrlr(1)},
+//			expResp: &ctlpb.StorageScanResp{
+//				Nvme: &ctlpb.ScanNvmeResp{
+//					Ctrlrs: proto.NvmeControllers{newCtrlrPBwBasic(1)},
+//					State:  new(ctlpb.ResponseState),
+//				},
+//				Scm:     &ctlpb.ScanScmResp{State: new(ctlpb.ResponseState)},
+//				MemInfo: proto.MockPBMemInfo(),
+//			},
+//		},
+//		"engine up; scan bdev basic; missing bdev in config": {
+//			req: &ctlpb.StorageScanReq{
+//				Scm:  new(ctlpb.ScanScmReq),
+//				Nvme: &ctlpb.ScanNvmeReq{Basic: true},
+//			},
+//			storageCfgs: []storage.TierConfigs{
+//				{
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassNvme.String()).
+//						WithBdevDeviceList(newCtrlr(1).PciAddr),
+//				},
+//			},
+//			csCtrlrs:          &storage.NvmeControllers{newCtrlr(2)},
+//			engineTargetCount: []int{4},
+//			drpcResps: map[int][]*mockDrpcResponse{
+//				0: {},
+//			},
+//			expResp: &ctlpb.StorageScanResp{
+//				Nvme: &ctlpb.ScanNvmeResp{
+//					Ctrlrs: proto.NvmeControllers{},
+//					State:  new(ctlpb.ResponseState),
+//				},
+//				Scm:     &ctlpb.ScanScmResp{State: new(ctlpb.ResponseState)},
+//				MemInfo: proto.MockPBMemInfo(),
+//			},
+//		},
+//		"engine up; scan bdev health": {
+//			req: &ctlpb.StorageScanReq{
+//				Scm:  new(ctlpb.ScanScmReq),
+//				Nvme: &ctlpb.ScanNvmeReq{Health: true},
+//			},
+//			csCtrlrs: &storage.NvmeControllers{newCtrlr(1)},
+//			storageCfgs: []storage.TierConfigs{
+//				{
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassNvme.String()).
+//						WithBdevDeviceList(newCtrlr(1).PciAddr),
+//				},
+//			},
+//			engineTargetCount: []int{4},
+//			drpcResps: map[int][]*mockDrpcResponse{
+//				0: {
+//					{Message: newSmdDevResp(1)},
+//					{Message: newBioHealthResp(1)},
+//				},
+//			},
+//			expResp: &ctlpb.StorageScanResp{
+//				Nvme: &ctlpb.ScanNvmeResp{
+//					Ctrlrs: proto.NvmeControllers{newCtrlrPBwHealth(1)},
+//					State:  new(ctlpb.ResponseState),
+//				},
+//				Scm:     &ctlpb.ScanScmResp{State: new(ctlpb.ResponseState)},
+//				MemInfo: proto.MockPBMemInfo(),
+//			},
+//		},
+//		"engine up; scan bdev meta": {
+//			req: &ctlpb.StorageScanReq{
+//				Scm:  &ctlpb.ScanScmReq{Usage: true},
+//				Nvme: &ctlpb.ScanNvmeReq{Meta: true},
+//			},
+//			csCtrlrs: &storage.NvmeControllers{newCtrlr(1)},
+//			smbc: &scm.MockBackendConfig{
+//				GetModulesRes: storage.ScmModules{
+//					storage.MockScmModule(0),
+//				},
+//				GetNamespacesRes: storage.ScmNamespaces{
+//					storage.MockScmNamespace(0),
+//				},
+//			},
+//			smsc: &system.MockSysConfig{
+//				GetfsUsageResps: []system.GetfsUsageRetval{
+//					{
+//						Total: mockPbScmMount0.TotalBytes,
+//						Avail: mockPbScmMount0.AvailBytes,
+//					},
+//				},
+//			},
+//			storageCfgs: []storage.TierConfigs{
+//				{
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassDcpm.String()).
+//						WithScmMountPoint(mockPbScmMount0.Path).
+//						WithScmDeviceList(mockPbScmNamespace0.Blockdev),
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassNvme.String()).
+//						WithBdevDeviceList(newCtrlr(1).PciAddr),
+//				},
+//			},
+//			engineTargetCount: []int{4},
+//			drpcResps: map[int][]*mockDrpcResponse{
+//				0: {
+//					{Message: newSmdDevResp(1)},
+//					{Message: newBioHealthResp(1)},
+//				},
+//			},
+//			expResp: &ctlpb.StorageScanResp{
+//				Nvme: &ctlpb.ScanNvmeResp{
+//					Ctrlrs: proto.NvmeControllers{
+//						adjustNvmeSize(newCtrlrPBwMeta(1), mockPbScmMount0.AvailBytes, 4),
+//					},
+//					State: new(ctlpb.ResponseState),
+//				},
+//				Scm: &ctlpb.ScanScmResp{
+//					Namespaces: proto.ScmNamespaces{
+//						&ctlpb.ScmNamespace{
+//							Blockdev: mockPbScmNamespace0.Blockdev,
+//							Dev:      mockPbScmNamespace0.Dev,
+//							Size:     mockPbScmNamespace0.Size,
+//							Uuid:     mockPbScmNamespace0.Uuid,
+//							Mount: &ctlpb.ScmNamespace_Mount{
+//								Class:       mockPbScmMount0.Class,
+//								DeviceList:  mockPbScmMount0.DeviceList,
+//								Path:        mockPbScmMount0.Path,
+//								TotalBytes:  mockPbScmMount0.TotalBytes,
+//								AvailBytes:  mockPbScmMount0.AvailBytes,
+//								UsableBytes: adjustScmSize(mockPbScmMount0.AvailBytes, false),
+//								Rank:        mockPbScmMount0.Rank,
+//							},
+//						},
+//					},
+//					State: new(ctlpb.ResponseState),
+//				},
+//				MemInfo: proto.MockPBMemInfo(),
+//			},
+//		},
+//		"engines up; scan bdev health": {
+//			req: &ctlpb.StorageScanReq{
+//				Scm:  new(ctlpb.ScanScmReq),
+//				Nvme: &ctlpb.ScanNvmeReq{Health: true},
+//			},
+//			csCtrlrs: &storage.NvmeControllers{newCtrlr(1), newCtrlr(2)},
+//			eCtrlrs:  []*storage.NvmeControllers{{newCtrlr(1)}, {newCtrlr(2)}},
+//			storageCfgs: []storage.TierConfigs{
+//				{
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassNvme.String()).
+//						WithBdevDeviceList(newCtrlr(1).PciAddr),
+//				},
+//				{
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassNvme.String()).
+//						WithBdevDeviceList(newCtrlr(2).PciAddr),
+//				},
+//			},
+//			engineTargetCount: []int{4, 4},
+//			drpcResps: map[int][]*mockDrpcResponse{
+//				0: {
+//					{Message: newSmdDevResp(1)},
+//					{Message: newBioHealthResp(1)},
+//				},
+//				1: {
+//					{Message: newSmdDevResp(2)},
+//					{Message: newBioHealthResp(2)},
+//				},
+//			},
+//			expResp: &ctlpb.StorageScanResp{
+//				Nvme: &ctlpb.ScanNvmeResp{
+//					Ctrlrs: proto.NvmeControllers{
+//						newCtrlrPBwHealth(1),
+//						newCtrlrPBwHealth(2),
+//					},
+//					State: new(ctlpb.ResponseState),
+//				},
+//				Scm:     &ctlpb.ScanScmResp{State: new(ctlpb.ResponseState)},
+//				MemInfo: proto.MockPBMemInfo(),
+//			},
+//		},
+//		"engines up; scan bdev meta; multiple nvme namespaces": {
+//			req: &ctlpb.StorageScanReq{
+//				Scm:  &ctlpb.ScanScmReq{Usage: true},
+//				Nvme: &ctlpb.ScanNvmeReq{Meta: true},
+//			},
+//			csCtrlrs: &storage.NvmeControllers{
+//				newCtrlrMultiNs(1, 2), newCtrlrMultiNs(2, 2),
+//			},
+//			eCtrlrs: []*storage.NvmeControllers{
+//				{newCtrlrMultiNs(1, 2)}, {newCtrlrMultiNs(2, 2)},
+//			},
+//			smbc: &scm.MockBackendConfig{
+//				GetModulesRes: storage.ScmModules{
+//					storage.MockScmModule(0),
+//				},
+//				GetNamespacesRes: storage.ScmNamespaces{
+//					storage.MockScmNamespace(0),
+//					storage.MockScmNamespace(1),
+//				},
+//			},
+//			smsc: &system.MockSysConfig{
+//				GetfsUsageResps: []system.GetfsUsageRetval{
+//					{
+//						Total: mockPbScmMount0.TotalBytes,
+//						Avail: mockPbScmMount0.AvailBytes,
+//					},
+//					{
+//						Total: mockPbScmMount1.TotalBytes,
+//						Avail: mockPbScmMount1.AvailBytes,
+//					},
+//				},
+//			},
+//			storageCfgs: []storage.TierConfigs{
+//				{
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassDcpm.String()).
+//						WithScmMountPoint(mockPbScmMount0.Path).
+//						WithScmDeviceList(mockPbScmNamespace0.Blockdev),
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassNvme.String()).
+//						WithBdevDeviceList(newCtrlr(1).PciAddr),
+//				},
+//				{
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassDcpm.String()).
+//						WithScmMountPoint(mockPbScmMount1.Path).
+//						WithScmDeviceList(mockPbScmNamespace1.Blockdev),
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassNvme.String()).
+//						WithBdevDeviceList(newCtrlr(2).PciAddr),
+//				},
+//			},
+//			engineTargetCount: []int{8, 8},
+//			drpcResps: map[int][]*mockDrpcResponse{
+//				0: {
+//					{Message: newSmdDevResp(1, 1, 2)},
+//					{Message: newBioHealthResp(1, 1)},
+//					{Message: newBioHealthResp(2, 1)},
+//				},
+//				1: {
+//					{Message: newSmdDevResp(2, 3, 4)},
+//					{Message: newBioHealthResp(3, 2)},
+//					{Message: newBioHealthResp(4, 2)},
+//				},
+//			},
+//			expResp: &ctlpb.StorageScanResp{
+//				Nvme: &ctlpb.ScanNvmeResp{
+//					Ctrlrs: proto.NvmeControllers{
+//						adjustNvmeSize(newCtrlrPBwMeta(1, 1, 2), mockPbScmMount0.AvailBytes, 8),
+//						adjustNvmeSize(newCtrlrPBwMeta(2, 3, 4), mockPbScmMount1.AvailBytes, 8),
+//					},
+//					State: new(ctlpb.ResponseState),
+//				},
+//				Scm: &ctlpb.ScanScmResp{
+//					Namespaces: proto.ScmNamespaces{
+//						&ctlpb.ScmNamespace{
+//							Blockdev: mockPbScmNamespace0.Blockdev,
+//							Dev:      mockPbScmNamespace0.Dev,
+//							Size:     mockPbScmNamespace0.Size,
+//							Uuid:     mockPbScmNamespace0.Uuid,
+//							Mount: &ctlpb.ScmNamespace_Mount{
+//								Class:       mockPbScmMount0.Class,
+//								DeviceList:  mockPbScmMount0.DeviceList,
+//								Path:        mockPbScmMount0.Path,
+//								TotalBytes:  mockPbScmMount0.TotalBytes,
+//								AvailBytes:  mockPbScmMount0.AvailBytes,
+//								UsableBytes: adjustScmSize(mockPbScmMount0.AvailBytes, false),
+//								Rank:        mockPbScmMount0.Rank,
+//							},
+//						},
+//						&ctlpb.ScmNamespace{
+//							Blockdev: mockPbScmNamespace1.Blockdev,
+//							Dev:      mockPbScmNamespace1.Dev,
+//							Size:     mockPbScmNamespace1.Size,
+//							Uuid:     mockPbScmNamespace1.Uuid,
+//							NumaNode: mockPbScmNamespace1.NumaNode,
+//							Mount: &ctlpb.ScmNamespace_Mount{
+//								Class:       mockPbScmMount1.Class,
+//								DeviceList:  mockPbScmMount1.DeviceList,
+//								Path:        mockPbScmMount1.Path,
+//								TotalBytes:  mockPbScmMount1.TotalBytes,
+//								AvailBytes:  mockPbScmMount1.AvailBytes,
+//								UsableBytes: adjustScmSize(mockPbScmMount1.AvailBytes, false),
+//								Rank:        mockPbScmMount1.Rank,
+//							},
+//						},
+//					},
+//					State: new(ctlpb.ResponseState),
+//				},
+//				MemInfo: proto.MockPBMemInfo(),
+//			},
+//		},
+//		"scan scm usage": {
+//			req: &ctlpb.StorageScanReq{
+//				Scm:  &ctlpb.ScanScmReq{Usage: true},
+//				Nvme: new(ctlpb.ScanNvmeReq),
+//			},
+//			smbc: &scm.MockBackendConfig{
+//				GetModulesRes:    storage.ScmModules{storage.MockScmModule(0)},
+//				GetNamespacesRes: storage.ScmNamespaces{storage.MockScmNamespace(0)},
+//			},
+//			smsc: &system.MockSysConfig{
+//				GetfsUsageResps: []system.GetfsUsageRetval{
+//					{
+//						Total: mockPbScmMount0.TotalBytes,
+//						Avail: mockPbScmMount0.AvailBytes,
+//					},
+//				},
+//			},
+//			storageCfgs: []storage.TierConfigs{
+//				{
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassDcpm.String()).
+//						WithScmMountPoint(mockPbScmMount0.Path).
+//						WithScmDeviceList(mockPbScmNamespace0.Blockdev),
+//				},
+//			},
+//			engineTargetCount: []int{4},
+//			drpcResps: map[int][]*mockDrpcResponse{
+//				0: {},
+//			},
+//			expResp: &ctlpb.StorageScanResp{
+//				Nvme: &ctlpb.ScanNvmeResp{
+//					State: new(ctlpb.ResponseState),
+//				},
+//				Scm: &ctlpb.ScanScmResp{
+//					Namespaces: proto.ScmNamespaces{
+//						&ctlpb.ScmNamespace{
+//							Blockdev: mockPbScmNamespace0.Blockdev,
+//							Dev:      mockPbScmNamespace0.Dev,
+//							Size:     mockPbScmNamespace0.Size,
+//							Uuid:     mockPbScmNamespace0.Uuid,
+//							Mount: &ctlpb.ScmNamespace_Mount{
+//								Class:       mockPbScmMount0.Class,
+//								DeviceList:  mockPbScmMount0.DeviceList,
+//								Path:        mockPbScmMount0.Path,
+//								Rank:        mockPbScmMount0.Rank,
+//								TotalBytes:  mockPbScmMount0.TotalBytes,
+//								AvailBytes:  mockPbScmMount0.AvailBytes,
+//								UsableBytes: adjustScmSize(mockPbScmMount0.AvailBytes, true),
+//							},
+//						},
+//					},
+//					State: new(ctlpb.ResponseState),
+//				},
+//				MemInfo: proto.MockPBMemInfo(),
+//			},
+//		},
+//		"scan scm usage; pmem not in instance device list": {
+//			req: &ctlpb.StorageScanReq{
+//				Scm:  &ctlpb.ScanScmReq{Usage: true},
+//				Nvme: new(ctlpb.ScanNvmeReq),
+//			},
+//			smbc: &scm.MockBackendConfig{
+//				GetModulesRes:    storage.ScmModules{storage.MockScmModule(0)},
+//				GetNamespacesRes: storage.ScmNamespaces{storage.MockScmNamespace(0)},
+//			},
+//			smsc: &system.MockSysConfig{
+//				GetfsUsageResps: []system.GetfsUsageRetval{
+//					{
+//						Total: mockPbScmMount0.TotalBytes,
+//						Avail: mockPbScmMount0.AvailBytes,
+//					},
+//				},
+//			},
+//			storageCfgs: []storage.TierConfigs{
+//				{
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassDcpm.String()).
+//						WithScmMountPoint(mockPbScmMount0.Path).
+//						WithScmDeviceList("/dev/foo", "/dev/bar"),
+//				},
+//			},
+//			engineTargetCount: []int{4},
+//			drpcResps: map[int][]*mockDrpcResponse{
+//				0: {},
+//			},
+//			expResp: &ctlpb.StorageScanResp{
+//				Nvme: &ctlpb.ScanNvmeResp{
+//					State: new(ctlpb.ResponseState),
+//				},
+//				Scm: &ctlpb.ScanScmResp{
+//					State: &ctlpb.ResponseState{
+//						Status: ctlpb.ResponseStatus_CTL_ERR_SCM,
+//						Error:  "instance 0: no pmem namespace for mount /mnt/daos0",
+//					},
+//				},
+//				MemInfo: proto.MockPBMemInfo(),
+//			},
+//		},
+//		"scan scm usage; class ram": {
+//			req: &ctlpb.StorageScanReq{
+//				Scm:  &ctlpb.ScanScmReq{Usage: true},
+//				Nvme: new(ctlpb.ScanNvmeReq),
+//			},
+//			smbc: &scm.MockBackendConfig{
+//				GetModulesRes:    storage.ScmModules{storage.MockScmModule(0)},
+//				GetNamespacesRes: storage.ScmNamespaces{storage.MockScmNamespace(0)},
+//			},
+//			smsc: &system.MockSysConfig{
+//				GetfsUsageResps: []system.GetfsUsageRetval{
+//					{
+//						Total: mockPbScmMount0.TotalBytes,
+//						Avail: mockPbScmMount0.AvailBytes,
+//					},
+//				},
+//			},
+//			storageCfgs: []storage.TierConfigs{
+//				{
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassRam.String()).
+//						WithScmMountPoint(mockPbScmMount0.Path).
+//						WithScmRamdiskSize(16),
+//				},
+//			},
+//			engineTargetCount: []int{4},
+//			drpcResps: map[int][]*mockDrpcResponse{
+//				0: {},
+//			},
+//			expResp: &ctlpb.StorageScanResp{
+//				Nvme: &ctlpb.ScanNvmeResp{
+//					State: new(ctlpb.ResponseState),
+//				},
+//				Scm: &ctlpb.ScanScmResp{
+//					Namespaces: proto.ScmNamespaces{
+//						&ctlpb.ScmNamespace{
+//							Blockdev: "ramdisk",
+//							Size:     uint64(humanize.GiByte * 16),
+//							Mount: &ctlpb.ScmNamespace_Mount{
+//								Class:       "ram",
+//								Path:        mockPbScmMount0.Path,
+//								TotalBytes:  mockPbScmMount0.TotalBytes,
+//								AvailBytes:  mockPbScmMount0.AvailBytes,
+//								UsableBytes: adjustScmSize(mockPbScmMount0.AvailBytes, true),
+//								Rank:        mockPbScmMount0.Rank,
+//							},
+//						},
+//					},
+//					State: new(ctlpb.ResponseState),
+//				},
+//				MemInfo: proto.MockPBMemInfo(),
+//			},
+//		},
+//		"multi-engine; multi-tier; with usage": {
+//			req: &ctlpb.StorageScanReq{
+//				Scm:  &ctlpb.ScanScmReq{Usage: true},
+//				Nvme: &ctlpb.ScanNvmeReq{Meta: true},
+//			},
+//			csCtrlrs: &storage.NvmeControllers{newCtrlr(1), newCtrlr(2)},
+//			eCtrlrs:  []*storage.NvmeControllers{{newCtrlr(1)}, {newCtrlr(2)}},
+//			smbc: &scm.MockBackendConfig{
+//				GetModulesRes: storage.ScmModules{
+//					storage.MockScmModule(0),
+//				},
+//				GetNamespacesRes: storage.ScmNamespaces{
+//					storage.MockScmNamespace(0),
+//					storage.MockScmNamespace(1),
+//				},
+//			},
+//			smsc: &system.MockSysConfig{
+//				GetfsUsageResps: []system.GetfsUsageRetval{
+//					{
+//						Total: mockPbScmMount0.TotalBytes,
+//						Avail: mockPbScmMount0.AvailBytes,
+//					},
+//					{
+//						Total: mockPbScmMount1.TotalBytes,
+//						Avail: mockPbScmMount1.AvailBytes,
+//					},
+//				},
+//			},
+//			storageCfgs: []storage.TierConfigs{
+//				{
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassDcpm.String()).
+//						WithScmMountPoint(mockPbScmMount0.Path).
+//						WithScmDeviceList(mockPbScmNamespace0.Blockdev),
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassNvme.String()).
+//						WithBdevDeviceList(newCtrlr(1).PciAddr),
+//				},
+//				{
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassDcpm.String()).
+//						WithScmMountPoint(mockPbScmMount1.Path).
+//						WithScmDeviceList(mockPbScmNamespace1.Blockdev),
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassNvme.String()).
+//						WithBdevDeviceList(newCtrlr(2).PciAddr),
+//				},
+//			},
+//			engineTargetCount: []int{4, 4},
+//			drpcResps: map[int][]*mockDrpcResponse{
+//				0: {
+//					{Message: newSmdDevResp(1)},
+//					{Message: newBioHealthResp(1)},
+//				},
+//				1: {
+//					{Message: newSmdDevResp(2)},
+//					{Message: newBioHealthResp(2)},
+//				},
+//			},
+//			expResp: &ctlpb.StorageScanResp{
+//				Nvme: &ctlpb.ScanNvmeResp{
+//					Ctrlrs: proto.NvmeControllers{
+//						adjustNvmeSize(newCtrlrPBwMeta(1), mockPbScmMount0.AvailBytes, 4),
+//						adjustNvmeSize(newCtrlrPBwMeta(2), mockPbScmMount1.AvailBytes, 4),
+//					},
+//					State: new(ctlpb.ResponseState),
+//				},
+//				Scm: &ctlpb.ScanScmResp{
+//					Namespaces: proto.ScmNamespaces{
+//						&ctlpb.ScmNamespace{
+//							Blockdev: mockPbScmNamespace0.Blockdev,
+//							Dev:      mockPbScmNamespace0.Dev,
+//							Size:     mockPbScmNamespace0.Size,
+//							Uuid:     mockPbScmNamespace0.Uuid,
+//							Mount: &ctlpb.ScmNamespace_Mount{
+//								Class:       mockPbScmMount0.Class,
+//								DeviceList:  mockPbScmMount0.DeviceList,
+//								Path:        mockPbScmMount0.Path,
+//								TotalBytes:  mockPbScmMount0.TotalBytes,
+//								AvailBytes:  mockPbScmMount0.AvailBytes,
+//								UsableBytes: adjustScmSize(mockPbScmMount0.AvailBytes, false),
+//								Rank:        mockPbScmMount0.Rank,
+//							},
+//						},
+//						&ctlpb.ScmNamespace{
+//							Blockdev: mockPbScmNamespace1.Blockdev,
+//							Dev:      mockPbScmNamespace1.Dev,
+//							Size:     mockPbScmNamespace1.Size,
+//							Uuid:     mockPbScmNamespace1.Uuid,
+//							NumaNode: mockPbScmNamespace1.NumaNode,
+//							Mount: &ctlpb.ScmNamespace_Mount{
+//								Class:       mockPbScmMount1.Class,
+//								DeviceList:  mockPbScmMount1.DeviceList,
+//								Path:        mockPbScmMount1.Path,
+//								TotalBytes:  mockPbScmMount1.TotalBytes,
+//								AvailBytes:  mockPbScmMount1.AvailBytes,
+//								UsableBytes: adjustScmSize(mockPbScmMount1.AvailBytes, false),
+//								Rank:        mockPbScmMount1.Rank,
+//							},
+//						},
+//					},
+//					State: new(ctlpb.ResponseState),
+//				},
+//				MemInfo: proto.MockPBMemInfo(),
+//			},
+//		},
+//		"multi-engine; multi-tier; with usage; engines not ready": {
+//			req: &ctlpb.StorageScanReq{
+//				Scm:  &ctlpb.ScanScmReq{Usage: true},
+//				Nvme: &ctlpb.ScanNvmeReq{Meta: true},
+//			},
+//			storageCfgs: []storage.TierConfigs{
+//				{
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassDcpm.String()).
+//						WithScmMountPoint(mockPbScmMount0.Path).
+//						WithScmDeviceList(mockPbScmNamespace0.Blockdev),
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassNvme.String()).
+//						WithBdevDeviceList(newCtrlr(1).PciAddr),
+//				},
+//				{
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassDcpm.String()).
+//						WithScmMountPoint(mockPbScmMount1.Path).
+//						WithScmDeviceList(mockPbScmNamespace1.Blockdev),
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassNvme.String()).
+//						WithBdevDeviceList(newCtrlr(2).PciAddr),
+//				},
+//			},
+//			engineTargetCount: []int{4, 4},
+//			enginesNotReady:   true,
+//			drpcResps: map[int][]*mockDrpcResponse{
+//				0: {
+//					{Message: newSmdDevResp(1)},
+//					{Message: newBioHealthResp(1)},
+//				},
+//				1: {
+//					{Message: newSmdDevResp(2)},
+//					{Message: newBioHealthResp(2)},
+//				},
+//			},
+//			expErr: errEngineNotReady,
+//		},
+//		// Sometimes when more than a few ssds are assigned to engine without many targets,
+//		// some of the smd entries for the latter ssds are in state "NEW" rather than
+//		// "NORMAL", when in this state, health is unavailable and DER_NONEXIST is returned.
+//		"bdev scan; meta; new state; non-existent smd health": {
+//			req: &ctlpb.StorageScanReq{
+//				Scm:  new(ctlpb.ScanScmReq),
+//				Nvme: &ctlpb.ScanNvmeReq{Meta: true},
+//			},
+//			csCtrlrs: &storage.NvmeControllers{newCtrlr(1)},
+//			storageCfgs: []storage.TierConfigs{
+//				{
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassNvme.String()).
+//						WithBdevDeviceList(newCtrlr(1).PciAddr),
+//				},
+//			},
+//			engineTargetCount: []int{4},
+//			drpcResps: map[int][]*mockDrpcResponse{
+//				0: {
+//					{Message: smdDevRespStateNew},
+//					{
+//						Message: &ctlpb.BioHealthResp{
+//							Status: int32(daos.Nonexistent),
+//						},
+//					},
+//				},
+//			},
+//			expResp: &ctlpb.StorageScanResp{
+//				Nvme: &ctlpb.ScanNvmeResp{
+//					Ctrlrs: proto.NvmeControllers{ctrlrPBwMetaNew},
+//					State:  new(ctlpb.ResponseState),
+//				},
+//				Scm:     &ctlpb.ScanScmResp{State: new(ctlpb.ResponseState)},
+//				MemInfo: proto.MockPBMemInfo(),
+//			},
+//		},
+//		"bdev scan; meta; new state; nomem smd health": {
+//			req: &ctlpb.StorageScanReq{
+//				Scm:  new(ctlpb.ScanScmReq),
+//				Nvme: &ctlpb.ScanNvmeReq{Meta: true},
+//			},
+//			csCtrlrs: &storage.NvmeControllers{newCtrlr(1)},
+//			storageCfgs: []storage.TierConfigs{
+//				{
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassNvme.String()).
+//						WithBdevDeviceList(newCtrlr(1).PciAddr),
+//				},
+//			},
+//			engineTargetCount: []int{4},
+//			drpcResps: map[int][]*mockDrpcResponse{
+//				0: {
+//					{Message: smdDevRespStateNew},
+//					{
+//						Message: &ctlpb.BioHealthResp{
+//							Status: int32(daos.FreeMemError),
+//						},
+//					},
+//				},
+//			},
+//			expResp: &ctlpb.StorageScanResp{
+//				Nvme: &ctlpb.ScanNvmeResp{
+//					Ctrlrs: proto.NvmeControllers{ctrlrPBwMetaNew},
+//					State:  new(ctlpb.ResponseState),
+//				},
+//				Scm:     &ctlpb.ScanScmResp{State: new(ctlpb.ResponseState)},
+//				MemInfo: proto.MockPBMemInfo(),
+//			},
+//		},
+//		"bdev scan; meta; normal state; non-existent smd health": {
+//			req: &ctlpb.StorageScanReq{
+//				Scm:  new(ctlpb.ScanScmReq),
+//				Nvme: &ctlpb.ScanNvmeReq{Meta: true},
+//			},
+//			csCtrlrs: &storage.NvmeControllers{newCtrlr(1)},
+//			storageCfgs: []storage.TierConfigs{
+//				{
+//					storage.NewTierConfig().
+//						WithStorageClass(storage.ClassNvme.String()).
+//						WithBdevDeviceList(newCtrlr(1).PciAddr),
+//				},
+//			},
+//			engineTargetCount: []int{4},
+//			drpcResps: map[int][]*mockDrpcResponse{
+//				0: {
+//					{Message: newSmdDevResp(1)},
+//					{
+//						Message: &ctlpb.BioHealthResp{
+//							Status: int32(daos.Nonexistent),
+//						},
+//					},
+//				},
+//			},
+//			expResp: &ctlpb.StorageScanResp{
+//				Nvme: &ctlpb.ScanNvmeResp{
+//					Ctrlrs: proto.NvmeControllers{ctrlrPBwMetaNormal},
+//					State:  new(ctlpb.ResponseState),
+//				},
+//				Scm:     &ctlpb.ScanScmResp{State: new(ctlpb.ResponseState)},
+//				MemInfo: proto.MockPBMemInfo(),
+//			},
+//		},
+//	} {
+//		t.Run(name, func(t *testing.T) {
+//			log, buf := logging.NewTestLogger(t.Name())
+//			defer test.ShowBufferOnFailure(t, buf)
+//
+//			if len(tc.storageCfgs) != len(tc.drpcResps) {
+//				t.Fatalf("number of tc.storageCfgs doesn't match num drpc msg groups")
+//			}
+//
+//			if len(tc.storageCfgs) == 1 && tc.eCtrlrs == nil && tc.csCtrlrs != nil {
+//				log.Debugf("using control service storage provider for first engine")
+//				tc.eCtrlrs = []*storage.NvmeControllers{tc.csCtrlrs}
+//			}
+//
+//			var csbmbc *bdev.MockBackendConfig
+//			if tc.csCtrlrs != nil {
+//				log.Debugf("bdevs %v to be returned for control service scan", *tc.csCtrlrs)
+//				csbmbc = &bdev.MockBackendConfig{
+//					ScanRes: &storage.BdevScanResponse{Controllers: *tc.csCtrlrs},
+//				}
+//			}
+//
+//			var engineCfgs []*engine.Config
+//			for i, sc := range tc.storageCfgs {
+//				log.Debugf("storage cfg contains bdevs %v for engine %d", sc.Bdevs(), i)
+//				engineCfgs = append(engineCfgs,
+//					engine.MockConfig().
+//						WithStorage(sc...).
+//						WithTargetCount(tc.engineTargetCount[i]))
+//			}
+//			sCfg := config.DefaultServer().WithEngines(engineCfgs...)
+//			cs := mockControlService(t, log, sCfg, csbmbc, tc.smbc, tc.smsc)
+//
+//			for idx, ec := range engineCfgs {
+//				var ebmbc *bdev.MockBackendConfig
+//				if tc.eCtrlrs != nil && len(tc.eCtrlrs) > idx {
+//					log.Debugf("bdevs %v to be returned for engine %d scan",
+//						*tc.eCtrlrs[idx], idx)
+//					ebmbc = &bdev.MockBackendConfig{
+//						ScanRes: &storage.BdevScanResponse{
+//							Controllers: *tc.eCtrlrs[idx],
+//						},
+//					}
+//				}
+//
+//				// replace harness instance with mock I/O Engine
+//				// to enable mocking of harness instance drpc channel
+//				sp := storage.MockProvider(log, idx, &ec.Storage,
+//					cs.storage.Sys, // share system provider cfo
+//					scm.NewMockProvider(log, tc.smbc, nil),
+//					bdev.NewMockProvider(log, ebmbc), nil)
+//				te := newTestEngine(log, false, sp, ec)
+//
+//				if tc.enginesNotReady {
+//					te.ready.SetFalse()
+//				}
+//
+//				// mock drpc responses
+//				dcc := new(mockDrpcClientConfig)
+//				if tc.junkResp {
+//					dcc.setSendMsgResponse(drpc.Status_SUCCESS,
+//						makeBadBytes(42), nil)
+//				} else if len(tc.drpcResps) > idx {
+//					t.Logf("setting %d drpc responses for engine %d",
+//						len(tc.drpcResps[idx]), idx)
+//					dcc.setSendMsgResponseList(t, tc.drpcResps[idx]...)
+//				} else {
+//					t.Fatal("drpc response mocks unpopulated")
+//				}
+//				te.setDrpcClient(newMockDrpcClient(dcc))
+//				te._superblock.Rank = ranklist.NewRankPtr(uint32(idx + 1))
+//				for _, tc := range te.storage.GetBdevConfigs() {
+//					tc.Bdev.DeviceRoles.OptionBits = storage.OptionBits(storage.BdevRoleAll)
+//				}
+//				md := te.storage.GetControlMetadata()
+//				md.Path = "/foo"
+//				md.DevicePath = md.Path
+//
+//				cs.harness.instances[idx] = te
+//			}
+//			cs.harness.started.SetTrue()
+//
+//			if tc.req == nil {
+//				tc.req = &ctlpb.StorageScanReq{
+//					Scm:  new(ctlpb.ScanScmReq),
+//					Nvme: new(ctlpb.ScanNvmeReq),
+//				}
+//			}
+//
+//			if tc.scanTwice {
+//				_, err := cs.StorageScan(test.Context(t), tc.req)
+//				test.CmpErr(t, tc.expErr, err)
+//				if err != nil {
+//					return
+//				}
+//			}
+//
+//			resp, err := cs.StorageScan(test.Context(t), tc.req)
+//			test.CmpErr(t, tc.expErr, err)
+//			if err != nil {
+//				return
+//			}
+//
+//			if diff := cmp.Diff(tc.expResp, resp, defStorageScanCmpOpts...); diff != "" {
+//				t.Fatalf("unexpected response (-want, +got):\n%s\n", diff)
+//			}
+//		})
+//	}
+//}
 
 func TestServer_checkTmpfsMem(t *testing.T) {
 	for name, tc := range map[string]struct {
@@ -2872,734 +2730,712 @@ func TestServer_CtlSvc_StorageNvmeAddDevice(t *testing.T) {
 	}
 }
 
-func TestServer_CtlSvc_adjustNvmeSize(t *testing.T) {
-	const (
-		clusterSize     uint64 = 32 * humanize.MiByte
-		hugeClusterSize uint64 = humanize.GiByte
-		metaSize        uint64 = 64 * humanize.MiByte
-		metaWalSize     uint64 = 128 * humanize.MiByte
-		rdbSize         uint64 = 256 * humanize.MiByte
-		rdbWalSize      uint64 = 512 * humanize.MiByte
-	)
-
-	type StorageCfg struct {
-		targetCount int
-		tierCfgs    storage.TierConfigs
-	}
-	type DataInput struct {
-		storageCfgs  []*StorageCfg
-		scanNvmeResp *ctlpb.ScanNvmeResp
-	}
-	type ExpectedOutput struct {
-		totalBytes     []uint64
-		availableBytes []uint64
-		usableBytes    []uint64
-		message        string
-	}
-
-	newTierCfg := func(pciIdx int32) *storage.TierConfig {
-		return storage.NewTierConfig().
-			WithStorageClass(storage.ClassNvme.String()).
-			WithBdevDeviceList(test.MockPCIAddr(pciIdx))
-	}
-
-	newNvmeCtlr := func(nvmeCtlr *ctlpb.NvmeController) *ctlpb.NvmeController {
-		for _, smdDev := range nvmeCtlr.SmdDevices {
-			smdDev.ClusterSize = clusterSize
-			smdDev.MetaSize = metaSize
-			smdDev.MetaWalSize = metaWalSize
-			smdDev.RdbSize = rdbSize
-			smdDev.RdbWalSize = rdbWalSize
-		}
-
-		return nvmeCtlr
-	}
-
-	for name, tc := range map[string]struct {
-		input  DataInput
-		output ExpectedOutput
-	}{
-		"homogeneous": {
-			input: DataInput{
-				storageCfgs: []*StorageCfg{
-					{
-						targetCount: 12,
-						tierCfgs: storage.TierConfigs{
-							newTierCfg(1),
-							newTierCfg(2),
-							newTierCfg(3),
-						},
-					},
-					{
-						targetCount: 6,
-						tierCfgs: storage.TierConfigs{
-							newTierCfg(4),
-							newTierCfg(5),
-						},
-					},
-				},
-				scanNvmeResp: &ctlpb.ScanNvmeResp{
-					Ctrlrs: []*ctlpb.NvmeController{
-						{
-							PciAddr: test.MockPCIAddr(1),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme0",
-									TgtIds:      []int32{0, 1, 2, 3},
-									TotalBytes:  10 * hugeClusterSize,
-									AvailBytes:  10 * hugeClusterSize,
-									ClusterSize: hugeClusterSize,
-									DevState:    devStateNormal,
-									Rank:        0,
-									RoleBits:    storage.BdevRoleData,
-								},
-							},
-						},
-						{
-							PciAddr: test.MockPCIAddr(2),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme1",
-									TgtIds:      []int32{4, 5, 6, 7},
-									TotalBytes:  10 * hugeClusterSize,
-									AvailBytes:  10 * hugeClusterSize,
-									ClusterSize: hugeClusterSize,
-									DevState:    devStateNormal,
-									Rank:        0,
-								},
-							},
-						},
-						{
-							PciAddr: test.MockPCIAddr(3),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme2",
-									TgtIds:      []int32{8, 9, 10, 11},
-									TotalBytes:  20 * hugeClusterSize,
-									AvailBytes:  20 * hugeClusterSize,
-									ClusterSize: hugeClusterSize,
-									DevState:    devStateNormal,
-									Rank:        0,
-									RoleBits:    storage.BdevRoleData,
-								},
-							},
-						},
-						{
-							PciAddr: test.MockPCIAddr(4),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme3",
-									TgtIds:      []int32{0, 1, 2},
-									TotalBytes:  20 * hugeClusterSize,
-									AvailBytes:  20 * hugeClusterSize,
-									ClusterSize: hugeClusterSize,
-									DevState:    devStateNormal,
-									Rank:        1,
-								},
-							},
-						},
-						{
-							PciAddr: test.MockPCIAddr(5),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme4",
-									TgtIds:      []int32{3, 4, 5},
-									TotalBytes:  20 * hugeClusterSize,
-									AvailBytes:  20 * hugeClusterSize,
-									ClusterSize: hugeClusterSize,
-									DevState:    devStateNormal,
-									Rank:        1,
-									RoleBits:    storage.BdevRoleData,
-								},
-							},
-						},
-					},
-				},
-			},
-			output: ExpectedOutput{
-				totalBytes: []uint64{
-					10 * hugeClusterSize,
-					10 * hugeClusterSize,
-					20 * hugeClusterSize,
-					20 * hugeClusterSize,
-					20 * hugeClusterSize,
-				},
-				availableBytes: []uint64{
-					10 * hugeClusterSize,
-					10 * hugeClusterSize,
-					20 * hugeClusterSize,
-					20 * hugeClusterSize,
-					20 * hugeClusterSize,
-				},
-				usableBytes: []uint64{
-					8 * hugeClusterSize,
-					8 * hugeClusterSize,
-					8 * hugeClusterSize,
-					18 * hugeClusterSize,
-					18 * hugeClusterSize,
-				},
-			},
-		},
-		"heterogeneous": {
-			input: DataInput{
-				storageCfgs: []*StorageCfg{
-					{
-						targetCount: 11,
-						tierCfgs: storage.TierConfigs{
-							newTierCfg(1),
-							newTierCfg(2),
-							newTierCfg(3),
-						},
-					},
-					{
-						targetCount: 5,
-						tierCfgs: storage.TierConfigs{
-							newTierCfg(4),
-							newTierCfg(5),
-						},
-					},
-				},
-				scanNvmeResp: &ctlpb.ScanNvmeResp{
-					Ctrlrs: []*ctlpb.NvmeController{
-						{
-							PciAddr: test.MockPCIAddr(1),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme0",
-									TgtIds:      []int32{0, 1, 2, 3},
-									TotalBytes:  10 * hugeClusterSize,
-									AvailBytes:  10 * hugeClusterSize,
-									ClusterSize: hugeClusterSize,
-									DevState:    devStateNormal,
-									Rank:        0,
-									RoleBits:    storage.BdevRoleData,
-								},
-							},
-						},
-						{
-							PciAddr: test.MockPCIAddr(2),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme1",
-									TgtIds:      []int32{4, 5, 6},
-									TotalBytes:  10 * hugeClusterSize,
-									AvailBytes:  10 * hugeClusterSize,
-									ClusterSize: hugeClusterSize,
-									DevState:    devStateNormal,
-									Rank:        0,
-									RoleBits:    storage.BdevRoleData,
-								},
-							},
-						},
-						{
-							PciAddr: test.MockPCIAddr(3),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme2",
-									TgtIds:      []int32{7, 8, 9, 10},
-									TotalBytes:  20 * hugeClusterSize,
-									AvailBytes:  20 * hugeClusterSize,
-									ClusterSize: hugeClusterSize,
-									DevState:    devStateNormal,
-									Rank:        0,
-									RoleBits:    storage.BdevRoleData,
-								},
-							},
-						},
-						{
-							PciAddr: test.MockPCIAddr(4),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme3",
-									TgtIds:      []int32{0, 1, 2},
-									TotalBytes:  20 * hugeClusterSize,
-									AvailBytes:  20 * hugeClusterSize,
-									ClusterSize: hugeClusterSize,
-									DevState:    devStateNormal,
-									Rank:        1,
-									RoleBits:    storage.BdevRoleData,
-								},
-							},
-						},
-						{
-							PciAddr: test.MockPCIAddr(5),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme4",
-									TgtIds:      []int32{3, 4},
-									TotalBytes:  20 * hugeClusterSize,
-									AvailBytes:  20 * hugeClusterSize,
-									ClusterSize: hugeClusterSize,
-									DevState:    devStateNormal,
-									Rank:        1,
-									RoleBits:    storage.BdevRoleData,
-								},
-							},
-						},
-					},
-				},
-			},
-			output: ExpectedOutput{
-				totalBytes: []uint64{
-					10 * hugeClusterSize,
-					10 * hugeClusterSize,
-					20 * hugeClusterSize,
-					20 * hugeClusterSize,
-					20 * hugeClusterSize,
-				},
-				availableBytes: []uint64{
-					10 * hugeClusterSize,
-					10 * hugeClusterSize,
-					20 * hugeClusterSize,
-					20 * hugeClusterSize,
-					20 * hugeClusterSize,
-				},
-				usableBytes: []uint64{
-					8 * hugeClusterSize,
-					6 * hugeClusterSize,
-					8 * hugeClusterSize,
-					18 * hugeClusterSize,
-					12 * hugeClusterSize,
-				},
-			},
-		},
-		"new": {
-			input: DataInput{
-				storageCfgs: []*StorageCfg{
-					{
-						targetCount: 7,
-						tierCfgs: storage.TierConfigs{
-							newTierCfg(1),
-							newTierCfg(2),
-						},
-					},
-				},
-				scanNvmeResp: &ctlpb.ScanNvmeResp{
-					Ctrlrs: []*ctlpb.NvmeController{
-						{
-							PciAddr: test.MockPCIAddr(1),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme0",
-									TgtIds:      []int32{0, 1, 2, 3},
-									TotalBytes:  10 * hugeClusterSize,
-									AvailBytes:  10 * hugeClusterSize,
-									ClusterSize: hugeClusterSize,
-									DevState:    devStateNormal,
-									Rank:        0,
-									RoleBits:    storage.BdevRoleData,
-								},
-							},
-						},
-						{
-							PciAddr: test.MockPCIAddr(2),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme1",
-									TgtIds:      []int32{0, 1, 2},
-									TotalBytes:  10 * hugeClusterSize,
-									AvailBytes:  10 * hugeClusterSize,
-									ClusterSize: hugeClusterSize,
-									DevState:    devStateNew,
-									Rank:        0,
-									RoleBits:    storage.BdevRoleData,
-								},
-							},
-						},
-					},
-				},
-			},
-			output: ExpectedOutput{
-				totalBytes: []uint64{
-					10 * hugeClusterSize,
-					10 * hugeClusterSize,
-				},
-				availableBytes: []uint64{
-					10 * hugeClusterSize,
-					0,
-				},
-				usableBytes: []uint64{
-					8 * hugeClusterSize,
-					0,
-				},
-				message: "not usable: device state \"NEW\"",
-			},
-		},
-		"evicted": {
-			input: DataInput{
-				storageCfgs: []*StorageCfg{
-					{
-						targetCount: 7,
-						tierCfgs: storage.TierConfigs{
-							newTierCfg(1),
-							newTierCfg(2),
-						},
-					},
-				},
-				scanNvmeResp: &ctlpb.ScanNvmeResp{
-					Ctrlrs: []*ctlpb.NvmeController{
-						{
-							PciAddr: test.MockPCIAddr(1),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme0",
-									TgtIds:      []int32{0, 1, 2, 3},
-									TotalBytes:  10 * hugeClusterSize,
-									AvailBytes:  10 * hugeClusterSize,
-									ClusterSize: hugeClusterSize,
-									DevState:    devStateNormal,
-									Rank:        0,
-									RoleBits:    storage.BdevRoleData,
-								},
-							},
-						},
-						{
-							PciAddr: test.MockPCIAddr(2),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme1",
-									TgtIds:      []int32{0, 1, 2},
-									TotalBytes:  10 * hugeClusterSize,
-									AvailBytes:  10 * hugeClusterSize,
-									ClusterSize: hugeClusterSize,
-									DevState:    devStateFaulty,
-									Rank:        0,
-									RoleBits:    storage.BdevRoleData,
-								},
-							},
-						},
-					},
-				},
-			},
-			output: ExpectedOutput{
-				totalBytes: []uint64{
-					10 * hugeClusterSize,
-					10 * hugeClusterSize,
-				},
-				availableBytes: []uint64{
-					10 * hugeClusterSize,
-					0,
-				},
-				usableBytes: []uint64{
-					8 * hugeClusterSize,
-					0,
-				},
-				message: "not usable: device state \"EVICTED\"",
-			},
-		},
-		"missing targets": {
-			input: DataInput{
-				storageCfgs: []*StorageCfg{
-					{
-						targetCount: 4,
-						tierCfgs: storage.TierConfigs{
-							newTierCfg(1),
-							newTierCfg(2),
-						},
-					},
-				},
-				scanNvmeResp: &ctlpb.ScanNvmeResp{
-					Ctrlrs: []*ctlpb.NvmeController{
-						{
-							PciAddr: test.MockPCIAddr(1),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme0",
-									TgtIds:      []int32{0, 1, 2, 3},
-									TotalBytes:  10 * hugeClusterSize,
-									AvailBytes:  10 * hugeClusterSize,
-									ClusterSize: hugeClusterSize,
-									DevState:    devStateNormal,
-									Rank:        0,
-									RoleBits:    storage.BdevRoleData,
-								},
-							},
-						},
-						{
-							PciAddr: test.MockPCIAddr(2),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme1",
-									TgtIds:      []int32{},
-									TotalBytes:  10 * hugeClusterSize,
-									AvailBytes:  10 * hugeClusterSize,
-									ClusterSize: hugeClusterSize,
-									DevState:    devStateNormal,
-									Rank:        0,
-									RoleBits:    storage.BdevRoleData,
-								},
-							},
-						},
-					},
-				},
-			},
-			output: ExpectedOutput{
-				totalBytes: []uint64{
-					10 * hugeClusterSize,
-					10 * hugeClusterSize,
-				},
-				availableBytes: []uint64{
-					10 * hugeClusterSize,
-					0,
-				},
-				usableBytes: []uint64{
-					8 * hugeClusterSize,
-					0,
-				},
-				message: "not usable: missing storage info",
-			},
-		},
-		"missing cluster size": {
-			input: DataInput{
-				storageCfgs: []*StorageCfg{
-					{
-						targetCount: 7,
-						tierCfgs: storage.TierConfigs{
-							newTierCfg(1),
-							newTierCfg(2),
-						},
-					},
-				},
-				scanNvmeResp: &ctlpb.ScanNvmeResp{
-					Ctrlrs: []*ctlpb.NvmeController{
-						{
-							PciAddr: test.MockPCIAddr(1),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme0",
-									TgtIds:      []int32{0, 1, 2, 3},
-									TotalBytes:  10 * hugeClusterSize,
-									AvailBytes:  10 * hugeClusterSize,
-									ClusterSize: hugeClusterSize,
-									DevState:    devStateNormal,
-									Rank:        0,
-									RoleBits:    storage.BdevRoleData,
-								},
-							},
-						},
-						{
-							PciAddr: test.MockPCIAddr(2),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:       "nvme1",
-									TgtIds:     []int32{0, 1, 2},
-									TotalBytes: 10 * hugeClusterSize,
-									AvailBytes: 10 * hugeClusterSize,
-									DevState:   devStateNormal,
-									Rank:       0,
-									RoleBits:   storage.BdevRoleData,
-								},
-							},
-						},
-					},
-				},
-			},
-			output: ExpectedOutput{
-				totalBytes: []uint64{
-					10 * hugeClusterSize,
-					10 * hugeClusterSize,
-				},
-				availableBytes: []uint64{
-					10 * hugeClusterSize,
-					0,
-				},
-				usableBytes: []uint64{
-					8 * hugeClusterSize,
-					0,
-				},
-				message: "not usable: missing storage info",
-			},
-		},
-		"multi bdev tier": {
-			input: DataInput{
-				storageCfgs: []*StorageCfg{
-					{
-						targetCount: 5,
-						tierCfgs:    storage.TierConfigs{newTierCfg(1)},
-					},
-					{
-						targetCount: 4,
-						tierCfgs:    storage.TierConfigs{newTierCfg(2)},
-					},
-					{
-						targetCount: 6,
-						tierCfgs:    storage.TierConfigs{newTierCfg(3)},
-					},
-					{
-						targetCount: 4,
-						tierCfgs:    storage.TierConfigs{newTierCfg(4)},
-					},
-					{
-						targetCount: 5,
-						tierCfgs:    storage.TierConfigs{newTierCfg(5)},
-					},
-					{
-						targetCount: 6,
-						tierCfgs:    storage.TierConfigs{newTierCfg(6)},
-					},
-				},
-				scanNvmeResp: &ctlpb.ScanNvmeResp{
-					Ctrlrs: []*ctlpb.NvmeController{
-						newNvmeCtlr(&ctlpb.NvmeController{
-							PciAddr: test.MockPCIAddr(1),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme0",
-									TgtIds:      []int32{0, 1, 2, 3},
-									TotalBytes:  10 * humanize.GiByte,
-									AvailBytes:  10 * humanize.GiByte,
-									ClusterSize: clusterSize,
-									DevState:    devStateNormal,
-									Rank:        0,
-									RoleBits:    storage.BdevRoleData | storage.BdevRoleMeta,
-								},
-							},
-						}),
-						newNvmeCtlr(&ctlpb.NvmeController{
-							PciAddr: test.MockPCIAddr(2),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme1",
-									TgtIds:      []int32{0, 1, 2, 3},
-									TotalBytes:  10 * humanize.GiByte,
-									AvailBytes:  10 * humanize.GiByte,
-									ClusterSize: clusterSize,
-									DevState:    devStateNormal,
-									Rank:        1,
-									RoleBits:    storage.BdevRoleData | storage.BdevRoleWAL,
-								},
-							},
-						}),
-						newNvmeCtlr(&ctlpb.NvmeController{
-							PciAddr: test.MockPCIAddr(3),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme2",
-									TgtIds:      []int32{0, 1, 2, 3},
-									TotalBytes:  10 * humanize.GiByte,
-									AvailBytes:  10 * humanize.GiByte,
-									ClusterSize: clusterSize,
-									DevState:    devStateNormal,
-									Rank:        2,
-									RoleBits:    storage.BdevRoleAll,
-								},
-							},
-						}),
-						newNvmeCtlr(&ctlpb.NvmeController{
-							PciAddr: test.MockPCIAddr(4),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme3",
-									TgtIds:      []int32{0, 1, 2, 3},
-									TotalBytes:  10 * humanize.GiByte,
-									AvailBytes:  10 * humanize.GiByte,
-									ClusterSize: clusterSize,
-									DevState:    devStateNormal,
-									Rank:        3,
-									RoleBits:    storage.BdevRoleWAL,
-								},
-							},
-						}),
-						newNvmeCtlr(&ctlpb.NvmeController{
-							PciAddr: test.MockPCIAddr(5),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme4",
-									TgtIds:      []int32{0, 1, 2, 3},
-									TotalBytes:  10 * humanize.GiByte,
-									AvailBytes:  10 * humanize.GiByte,
-									ClusterSize: clusterSize,
-									DevState:    devStateNormal,
-									Rank:        4,
-									RoleBits:    storage.BdevRoleMeta,
-								},
-							},
-						}),
-						newNvmeCtlr(&ctlpb.NvmeController{
-							PciAddr: test.MockPCIAddr(6),
-							SmdDevices: []*ctlpb.SmdDevice{
-								{
-									Uuid:        "nvme5",
-									TgtIds:      []int32{0, 1, 2, 3},
-									TotalBytes:  10 * humanize.GiByte,
-									AvailBytes:  10 * humanize.GiByte,
-									ClusterSize: clusterSize,
-									DevState:    devStateNormal,
-									Rank:        5,
-									RoleBits:    storage.BdevRoleMeta | storage.BdevRoleMeta,
-								},
-							},
-						}),
-					},
-				},
-			},
-			output: ExpectedOutput{
-				totalBytes: []uint64{
-					320 * clusterSize,
-					320 * clusterSize,
-					320 * clusterSize,
-					0 * humanize.GiByte,
-					0 * humanize.GiByte,
-					0 * humanize.GiByte,
-				},
-				availableBytes: []uint64{
-					320 * clusterSize,
-					320 * clusterSize,
-					320 * clusterSize,
-					0 * humanize.GiByte,
-					0 * humanize.GiByte,
-					0 * humanize.GiByte,
-				},
-				usableBytes: []uint64{
-					300 * clusterSize,
-					288 * clusterSize,
-					260 * clusterSize,
-					0 * humanize.GiByte,
-					0 * humanize.GiByte,
-					0 * humanize.GiByte,
-				},
-			},
-		},
-	} {
-		t.Run(name, func(t *testing.T) {
-			log, buf := logging.NewTestLogger(t.Name())
-			defer test.ShowBufferOnFailure(t, buf)
-
-			engineCfgs := []*engine.Config{}
-			for idx, sc := range tc.input.storageCfgs {
-				ec := engine.MockConfig().WithStorage(sc.tierCfgs...)
-				ec.TargetCount = sc.targetCount
-				ec.Index = uint32(idx)
-				engineCfgs = append(engineCfgs, ec)
-			}
-			serverCfg := config.DefaultServer().WithEngines(engineCfgs...)
-			cs := mockControlService(t, log, serverCfg, nil, nil, nil)
-
-			cs.adjustNvmeSize(tc.input.scanNvmeResp)
-
-			for idx, ctlr := range tc.input.scanNvmeResp.GetCtrlrs() {
-				dev := ctlr.GetSmdDevices()[0]
-				test.AssertEqual(t, tc.output.totalBytes[idx], dev.GetTotalBytes(),
-					fmt.Sprintf("Invalid total bytes with ctlr %s (index=%d): wait=%d, got=%d",
-						ctlr.GetPciAddr(), idx, tc.output.totalBytes[idx], dev.GetTotalBytes()))
-				test.AssertEqual(t, tc.output.availableBytes[idx], dev.GetAvailBytes(),
-					fmt.Sprintf("Invalid available bytes with ctlr %s (index=%d): wait=%d, got=%d",
-						ctlr.GetPciAddr(), idx, tc.output.availableBytes[idx], dev.GetAvailBytes()))
-				test.AssertEqual(t, tc.output.usableBytes[idx], dev.GetUsableBytes(),
-					fmt.Sprintf("Invalid usable bytes with ctlr %s (index=%d), "+
-						"wait=%d (%d clusters) got=%d (%d clusters)",
-						ctlr.GetPciAddr(), idx,
-						tc.output.usableBytes[idx], tc.output.usableBytes[idx]/clusterSize,
-						dev.GetUsableBytes(), dev.GetUsableBytes()/clusterSize))
-			}
-			if tc.output.message != "" {
-				test.AssertTrue(t,
-					strings.Contains(buf.String(), tc.output.message),
-					"missing message: "+tc.output.message)
-			}
-		})
-	}
-}
+//func TestServer_CtlSvc_adjustNvmeSize(t *testing.T) {
+//	const (
+//		clusterSize     uint64 = 32 * humanize.MiByte
+//		hugeClusterSize uint64 = humanize.GiByte
+//		metaSize        uint64 = 64 * humanize.MiByte
+//		metaWalSize     uint64 = 128 * humanize.MiByte
+//		rdbSize         uint64 = 256 * humanize.MiByte
+//		rdbWalSize      uint64 = 512 * humanize.MiByte
+//	)
+//
+//	type StorageCfg struct {
+//		targetCount int
+//		tierCfgs    storage.TierConfigs
+//	}
+//	type DataInput struct {
+//		storageCfgs  []*StorageCfg
+//		scanNvmeResp *ctlpb.ScanNvmeResp
+//	}
+//	type ExpectedOutput struct {
+//		totalBytes     []uint64
+//		availableBytes []uint64
+//		usableBytes    []uint64
+//		message        string
+//	}
+//
+//	newTierCfg := func(pciIdx int32) *storage.TierConfig {
+//		return storage.NewTierConfig().
+//			WithStorageClass(storage.ClassNvme.String()).
+//			WithBdevDeviceList(test.MockPCIAddr(pciIdx))
+//	}
+//
+//	newNvmeCtlr := func(nvmeCtlr *ctlpb.NvmeController) *ctlpb.NvmeController {
+//		for _, smdDev := range nvmeCtlr.SmdDevices {
+//			smdDev.ClusterSize = clusterSize
+//			smdDev.MetaSize = metaSize
+//			smdDev.MetaWalSize = metaWalSize
+//			smdDev.RdbSize = rdbSize
+//			smdDev.RdbWalSize = rdbWalSize
+//		}
+//
+//		return nvmeCtlr
+//	}
+//
+//	for name, tc := range map[string]struct {
+//		input  DataInput
+//		output ExpectedOutput
+//	}{
+//		"homogeneous": {
+//			input: DataInput{
+//				storageCfgs: []*StorageCfg{
+//					{
+//						targetCount: 12,
+//						tierCfgs: storage.TierConfigs{
+//							newTierCfg(1),
+//							newTierCfg(2),
+//							newTierCfg(3),
+//						},
+//					},
+//					{
+//						targetCount: 6,
+//						tierCfgs: storage.TierConfigs{
+//							newTierCfg(4),
+//							newTierCfg(5),
+//						},
+//					},
+//				},
+//				scanNvmeResp: &ctlpb.ScanNvmeResp{
+//					Ctrlrs: []*ctlpb.NvmeController{
+//						{
+//							PciAddr: test.MockPCIAddr(1),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme0",
+//									TgtIds:      []int32{0, 1, 2, 3},
+//									TotalBytes:  10 * hugeClusterSize,
+//									AvailBytes:  10 * hugeClusterSize,
+//									ClusterSize: hugeClusterSize,
+//									Rank:        0,
+//									RoleBits:    storage.BdevRoleData,
+//								},
+//							},
+//						},
+//						{
+//							PciAddr: test.MockPCIAddr(2),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme1",
+//									TgtIds:      []int32{4, 5, 6, 7},
+//									TotalBytes:  10 * hugeClusterSize,
+//									AvailBytes:  10 * hugeClusterSize,
+//									ClusterSize: hugeClusterSize,
+//									Rank:        0,
+//								},
+//							},
+//						},
+//						{
+//							PciAddr: test.MockPCIAddr(3),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme2",
+//									TgtIds:      []int32{8, 9, 10, 11},
+//									TotalBytes:  20 * hugeClusterSize,
+//									AvailBytes:  20 * hugeClusterSize,
+//									ClusterSize: hugeClusterSize,
+//									Rank:        0,
+//									RoleBits:    storage.BdevRoleData,
+//								},
+//							},
+//						},
+//						{
+//							PciAddr: test.MockPCIAddr(4),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme3",
+//									TgtIds:      []int32{0, 1, 2},
+//									TotalBytes:  20 * hugeClusterSize,
+//									AvailBytes:  20 * hugeClusterSize,
+//									ClusterSize: hugeClusterSize,
+//									Rank:        1,
+//								},
+//							},
+//						},
+//						{
+//							PciAddr: test.MockPCIAddr(5),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme4",
+//									TgtIds:      []int32{3, 4, 5},
+//									TotalBytes:  20 * hugeClusterSize,
+//									AvailBytes:  20 * hugeClusterSize,
+//									ClusterSize: hugeClusterSize,
+//									Rank:        1,
+//									RoleBits:    storage.BdevRoleData,
+//								},
+//							},
+//						},
+//					},
+//				},
+//			},
+//			output: ExpectedOutput{
+//				totalBytes: []uint64{
+//					10 * hugeClusterSize,
+//					10 * hugeClusterSize,
+//					20 * hugeClusterSize,
+//					20 * hugeClusterSize,
+//					20 * hugeClusterSize,
+//				},
+//				availableBytes: []uint64{
+//					10 * hugeClusterSize,
+//					10 * hugeClusterSize,
+//					20 * hugeClusterSize,
+//					20 * hugeClusterSize,
+//					20 * hugeClusterSize,
+//				},
+//				usableBytes: []uint64{
+//					8 * hugeClusterSize,
+//					8 * hugeClusterSize,
+//					8 * hugeClusterSize,
+//					18 * hugeClusterSize,
+//					18 * hugeClusterSize,
+//				},
+//			},
+//		},
+//		"heterogeneous": {
+//			input: DataInput{
+//				storageCfgs: []*StorageCfg{
+//					{
+//						targetCount: 11,
+//						tierCfgs: storage.TierConfigs{
+//							newTierCfg(1),
+//							newTierCfg(2),
+//							newTierCfg(3),
+//						},
+//					},
+//					{
+//						targetCount: 5,
+//						tierCfgs: storage.TierConfigs{
+//							newTierCfg(4),
+//							newTierCfg(5),
+//						},
+//					},
+//				},
+//				scanNvmeResp: &ctlpb.ScanNvmeResp{
+//					Ctrlrs: []*ctlpb.NvmeController{
+//						{
+//							PciAddr: test.MockPCIAddr(1),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme0",
+//									TgtIds:      []int32{0, 1, 2, 3},
+//									TotalBytes:  10 * hugeClusterSize,
+//									AvailBytes:  10 * hugeClusterSize,
+//									ClusterSize: hugeClusterSize,
+//									Rank:        0,
+//									RoleBits:    storage.BdevRoleData,
+//								},
+//							},
+//						},
+//						{
+//							PciAddr: test.MockPCIAddr(2),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme1",
+//									TgtIds:      []int32{4, 5, 6},
+//									TotalBytes:  10 * hugeClusterSize,
+//									AvailBytes:  10 * hugeClusterSize,
+//									ClusterSize: hugeClusterSize,
+//									Rank:        0,
+//									RoleBits:    storage.BdevRoleData,
+//								},
+//							},
+//						},
+//						{
+//							PciAddr: test.MockPCIAddr(3),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme2",
+//									TgtIds:      []int32{7, 8, 9, 10},
+//									TotalBytes:  20 * hugeClusterSize,
+//									AvailBytes:  20 * hugeClusterSize,
+//									ClusterSize: hugeClusterSize,
+//									Rank:        0,
+//									RoleBits:    storage.BdevRoleData,
+//								},
+//							},
+//						},
+//						{
+//							PciAddr: test.MockPCIAddr(4),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme3",
+//									TgtIds:      []int32{0, 1, 2},
+//									TotalBytes:  20 * hugeClusterSize,
+//									AvailBytes:  20 * hugeClusterSize,
+//									ClusterSize: hugeClusterSize,
+//									Rank:        1,
+//									RoleBits:    storage.BdevRoleData,
+//								},
+//							},
+//						},
+//						{
+//							PciAddr: test.MockPCIAddr(5),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme4",
+//									TgtIds:      []int32{3, 4},
+//									TotalBytes:  20 * hugeClusterSize,
+//									AvailBytes:  20 * hugeClusterSize,
+//									ClusterSize: hugeClusterSize,
+//									Rank:        1,
+//									RoleBits:    storage.BdevRoleData,
+//								},
+//							},
+//						},
+//					},
+//				},
+//			},
+//			output: ExpectedOutput{
+//				totalBytes: []uint64{
+//					10 * hugeClusterSize,
+//					10 * hugeClusterSize,
+//					20 * hugeClusterSize,
+//					20 * hugeClusterSize,
+//					20 * hugeClusterSize,
+//				},
+//				availableBytes: []uint64{
+//					10 * hugeClusterSize,
+//					10 * hugeClusterSize,
+//					20 * hugeClusterSize,
+//					20 * hugeClusterSize,
+//					20 * hugeClusterSize,
+//				},
+//				usableBytes: []uint64{
+//					8 * hugeClusterSize,
+//					6 * hugeClusterSize,
+//					8 * hugeClusterSize,
+//					18 * hugeClusterSize,
+//					12 * hugeClusterSize,
+//				},
+//			},
+//		},
+//		"new": {
+//			input: DataInput{
+//				storageCfgs: []*StorageCfg{
+//					{
+//						targetCount: 7,
+//						tierCfgs: storage.TierConfigs{
+//							newTierCfg(1),
+//							newTierCfg(2),
+//						},
+//					},
+//				},
+//				scanNvmeResp: &ctlpb.ScanNvmeResp{
+//					Ctrlrs: []*ctlpb.NvmeController{
+//						{
+//							PciAddr: test.MockPCIAddr(1),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme0",
+//									TgtIds:      []int32{0, 1, 2, 3},
+//									TotalBytes:  10 * hugeClusterSize,
+//									AvailBytes:  10 * hugeClusterSize,
+//									ClusterSize: hugeClusterSize,
+//									Rank:        0,
+//									RoleBits:    storage.BdevRoleData,
+//								},
+//							},
+//						},
+//						{
+//							PciAddr: test.MockPCIAddr(2),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme1",
+//									TgtIds:      []int32{0, 1, 2},
+//									TotalBytes:  10 * hugeClusterSize,
+//									AvailBytes:  10 * hugeClusterSize,
+//									ClusterSize: hugeClusterSize,
+//									Rank:        0,
+//									RoleBits:    storage.BdevRoleData,
+//								},
+//							},
+//							DevState: devStateNew,
+//						},
+//					},
+//				},
+//			},
+//			output: ExpectedOutput{
+//				totalBytes: []uint64{
+//					10 * hugeClusterSize,
+//					10 * hugeClusterSize,
+//				},
+//				availableBytes: []uint64{
+//					10 * hugeClusterSize,
+//					0,
+//				},
+//				usableBytes: []uint64{
+//					8 * hugeClusterSize,
+//					0,
+//				},
+//				message: "not usable: device state \"NEW\"",
+//			},
+//		},
+//		"evicted": {
+//			input: DataInput{
+//				storageCfgs: []*StorageCfg{
+//					{
+//						targetCount: 7,
+//						tierCfgs: storage.TierConfigs{
+//							newTierCfg(1),
+//							newTierCfg(2),
+//						},
+//					},
+//				},
+//				scanNvmeResp: &ctlpb.ScanNvmeResp{
+//					Ctrlrs: []*ctlpb.NvmeController{
+//						{
+//							PciAddr: test.MockPCIAddr(1),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme0",
+//									TgtIds:      []int32{0, 1, 2, 3},
+//									TotalBytes:  10 * hugeClusterSize,
+//									AvailBytes:  10 * hugeClusterSize,
+//									ClusterSize: hugeClusterSize,
+//									Rank:        0,
+//									RoleBits:    storage.BdevRoleData,
+//								},
+//							},
+//						},
+//						{
+//							PciAddr: test.MockPCIAddr(2),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme1",
+//									TgtIds:      []int32{0, 1, 2},
+//									TotalBytes:  10 * hugeClusterSize,
+//									AvailBytes:  10 * hugeClusterSize,
+//									ClusterSize: hugeClusterSize,
+//									Rank:        0,
+//									RoleBits:    storage.BdevRoleData,
+//								},
+//							},
+//							DevState: devStateFaulty,
+//						},
+//					},
+//				},
+//			},
+//			output: ExpectedOutput{
+//				totalBytes: []uint64{
+//					10 * hugeClusterSize,
+//					10 * hugeClusterSize,
+//				},
+//				availableBytes: []uint64{
+//					10 * hugeClusterSize,
+//					0,
+//				},
+//				usableBytes: []uint64{
+//					8 * hugeClusterSize,
+//					0,
+//				},
+//				message: "not usable: device state \"EVICTED\"",
+//			},
+//		},
+//		"missing targets": {
+//			input: DataInput{
+//				storageCfgs: []*StorageCfg{
+//					{
+//						targetCount: 4,
+//						tierCfgs: storage.TierConfigs{
+//							newTierCfg(1),
+//							newTierCfg(2),
+//						},
+//					},
+//				},
+//				scanNvmeResp: &ctlpb.ScanNvmeResp{
+//					Ctrlrs: []*ctlpb.NvmeController{
+//						{
+//							PciAddr: test.MockPCIAddr(1),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme0",
+//									TgtIds:      []int32{0, 1, 2, 3},
+//									TotalBytes:  10 * hugeClusterSize,
+//									AvailBytes:  10 * hugeClusterSize,
+//									ClusterSize: hugeClusterSize,
+//									Rank:        0,
+//									RoleBits:    storage.BdevRoleData,
+//								},
+//							},
+//						},
+//						{
+//							PciAddr: test.MockPCIAddr(2),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme1",
+//									TgtIds:      []int32{},
+//									TotalBytes:  10 * hugeClusterSize,
+//									AvailBytes:  10 * hugeClusterSize,
+//									ClusterSize: hugeClusterSize,
+//									Rank:        0,
+//									RoleBits:    storage.BdevRoleData,
+//								},
+//							},
+//						},
+//					},
+//				},
+//			},
+//			output: ExpectedOutput{
+//				totalBytes: []uint64{
+//					10 * hugeClusterSize,
+//					10 * hugeClusterSize,
+//				},
+//				availableBytes: []uint64{
+//					10 * hugeClusterSize,
+//					0,
+//				},
+//				usableBytes: []uint64{
+//					8 * hugeClusterSize,
+//					0,
+//				},
+//				message: "not usable: missing storage info",
+//			},
+//		},
+//		"missing cluster size": {
+//			input: DataInput{
+//				storageCfgs: []*StorageCfg{
+//					{
+//						targetCount: 7,
+//						tierCfgs: storage.TierConfigs{
+//							newTierCfg(1),
+//							newTierCfg(2),
+//						},
+//					},
+//				},
+//				scanNvmeResp: &ctlpb.ScanNvmeResp{
+//					Ctrlrs: []*ctlpb.NvmeController{
+//						{
+//							PciAddr: test.MockPCIAddr(1),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme0",
+//									TgtIds:      []int32{0, 1, 2, 3},
+//									TotalBytes:  10 * hugeClusterSize,
+//									AvailBytes:  10 * hugeClusterSize,
+//									ClusterSize: hugeClusterSize,
+//									Rank:        0,
+//									RoleBits:    storage.BdevRoleData,
+//								},
+//							},
+//						},
+//						{
+//							PciAddr: test.MockPCIAddr(2),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:       "nvme1",
+//									TgtIds:     []int32{0, 1, 2},
+//									TotalBytes: 10 * hugeClusterSize,
+//									AvailBytes: 10 * hugeClusterSize,
+//									Rank:       0,
+//									RoleBits:   storage.BdevRoleData,
+//								},
+//							},
+//						},
+//					},
+//				},
+//			},
+//			output: ExpectedOutput{
+//				totalBytes: []uint64{
+//					10 * hugeClusterSize,
+//					10 * hugeClusterSize,
+//				},
+//				availableBytes: []uint64{
+//					10 * hugeClusterSize,
+//					0,
+//				},
+//				usableBytes: []uint64{
+//					8 * hugeClusterSize,
+//					0,
+//				},
+//				message: "not usable: missing storage info",
+//			},
+//		},
+//		"multi bdev tier": {
+//			input: DataInput{
+//				storageCfgs: []*StorageCfg{
+//					{
+//						targetCount: 5,
+//						tierCfgs:    storage.TierConfigs{newTierCfg(1)},
+//					},
+//					{
+//						targetCount: 4,
+//						tierCfgs:    storage.TierConfigs{newTierCfg(2)},
+//					},
+//					{
+//						targetCount: 6,
+//						tierCfgs:    storage.TierConfigs{newTierCfg(3)},
+//					},
+//					{
+//						targetCount: 4,
+//						tierCfgs:    storage.TierConfigs{newTierCfg(4)},
+//					},
+//					{
+//						targetCount: 5,
+//						tierCfgs:    storage.TierConfigs{newTierCfg(5)},
+//					},
+//					{
+//						targetCount: 6,
+//						tierCfgs:    storage.TierConfigs{newTierCfg(6)},
+//					},
+//				},
+//				scanNvmeResp: &ctlpb.ScanNvmeResp{
+//					Ctrlrs: []*ctlpb.NvmeController{
+//						newNvmeCtlr(&ctlpb.NvmeController{
+//							PciAddr: test.MockPCIAddr(1),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme0",
+//									TgtIds:      []int32{0, 1, 2, 3},
+//									TotalBytes:  10 * humanize.GiByte,
+//									AvailBytes:  10 * humanize.GiByte,
+//									ClusterSize: clusterSize,
+//									Rank:        0,
+//									RoleBits:    storage.BdevRoleData | storage.BdevRoleMeta,
+//								},
+//							},
+//						}),
+//						newNvmeCtlr(&ctlpb.NvmeController{
+//							PciAddr: test.MockPCIAddr(2),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme1",
+//									TgtIds:      []int32{0, 1, 2, 3},
+//									TotalBytes:  10 * humanize.GiByte,
+//									AvailBytes:  10 * humanize.GiByte,
+//									ClusterSize: clusterSize,
+//									Rank:        1,
+//									RoleBits:    storage.BdevRoleData | storage.BdevRoleWAL,
+//								},
+//							},
+//						}),
+//						newNvmeCtlr(&ctlpb.NvmeController{
+//							PciAddr: test.MockPCIAddr(3),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme2",
+//									TgtIds:      []int32{0, 1, 2, 3},
+//									TotalBytes:  10 * humanize.GiByte,
+//									AvailBytes:  10 * humanize.GiByte,
+//									ClusterSize: clusterSize,
+//									Rank:        2,
+//									RoleBits:    storage.BdevRoleAll,
+//								},
+//							},
+//						}),
+//						newNvmeCtlr(&ctlpb.NvmeController{
+//							PciAddr: test.MockPCIAddr(4),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme3",
+//									TgtIds:      []int32{0, 1, 2, 3},
+//									TotalBytes:  10 * humanize.GiByte,
+//									AvailBytes:  10 * humanize.GiByte,
+//									ClusterSize: clusterSize,
+//									Rank:        3,
+//									RoleBits:    storage.BdevRoleWAL,
+//								},
+//							},
+//						}),
+//						newNvmeCtlr(&ctlpb.NvmeController{
+//							PciAddr: test.MockPCIAddr(5),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme4",
+//									TgtIds:      []int32{0, 1, 2, 3},
+//									TotalBytes:  10 * humanize.GiByte,
+//									AvailBytes:  10 * humanize.GiByte,
+//									ClusterSize: clusterSize,
+//									Rank:        4,
+//									RoleBits:    storage.BdevRoleMeta,
+//								},
+//							},
+//						}),
+//						newNvmeCtlr(&ctlpb.NvmeController{
+//							PciAddr: test.MockPCIAddr(6),
+//							SmdDevices: []*ctlpb.SmdDevice{
+//								{
+//									Uuid:        "nvme5",
+//									TgtIds:      []int32{0, 1, 2, 3},
+//									TotalBytes:  10 * humanize.GiByte,
+//									AvailBytes:  10 * humanize.GiByte,
+//									ClusterSize: clusterSize,
+//									Rank:        5,
+//									RoleBits:    storage.BdevRoleMeta | storage.BdevRoleMeta,
+//								},
+//							},
+//						}),
+//					},
+//				},
+//			},
+//			output: ExpectedOutput{
+//				totalBytes: []uint64{
+//					320 * clusterSize,
+//					320 * clusterSize,
+//					320 * clusterSize,
+//					0 * humanize.GiByte,
+//					0 * humanize.GiByte,
+//					0 * humanize.GiByte,
+//				},
+//				availableBytes: []uint64{
+//					320 * clusterSize,
+//					320 * clusterSize,
+//					320 * clusterSize,
+//					0 * humanize.GiByte,
+//					0 * humanize.GiByte,
+//					0 * humanize.GiByte,
+//				},
+//				usableBytes: []uint64{
+//					300 * clusterSize,
+//					288 * clusterSize,
+//					260 * clusterSize,
+//					0 * humanize.GiByte,
+//					0 * humanize.GiByte,
+//					0 * humanize.GiByte,
+//				},
+//			},
+//		},
+//	} {
+//		t.Run(name, func(t *testing.T) {
+//			log, buf := logging.NewTestLogger(t.Name())
+//			defer test.ShowBufferOnFailure(t, buf)
+//
+//			engineCfgs := []*engine.Config{}
+//			for idx, sc := range tc.input.storageCfgs {
+//				ec := engine.MockConfig().WithStorage(sc.tierCfgs...)
+//				ec.TargetCount = sc.targetCount
+//				ec.Index = uint32(idx)
+//				engineCfgs = append(engineCfgs, ec)
+//			}
+//			serverCfg := config.DefaultServer().WithEngines(engineCfgs...)
+//			cs := mockControlService(t, log, serverCfg, nil, nil, nil)
+//
+//			cs.adjustNvmeSize(tc.input.scanNvmeResp)
+//
+//			for idx, ctlr := range tc.input.scanNvmeResp.GetCtrlrs() {
+//				dev := ctlr.GetSmdDevices()[0]
+//				test.AssertEqual(t, tc.output.totalBytes[idx], dev.GetTotalBytes(),
+//					fmt.Sprintf("Invalid total bytes with ctlr %s (index=%d): wait=%d, got=%d",
+//						ctlr.GetPciAddr(), idx, tc.output.totalBytes[idx], dev.GetTotalBytes()))
+//				test.AssertEqual(t, tc.output.availableBytes[idx], dev.GetAvailBytes(),
+//					fmt.Sprintf("Invalid available bytes with ctlr %s (index=%d): wait=%d, got=%d",
+//						ctlr.GetPciAddr(), idx, tc.output.availableBytes[idx], dev.GetAvailBytes()))
+//				test.AssertEqual(t, tc.output.usableBytes[idx], dev.GetUsableBytes(),
+//					fmt.Sprintf("Invalid usable bytes with ctlr %s (index=%d), "+
+//						"wait=%d (%d clusters) got=%d (%d clusters)",
+//						ctlr.GetPciAddr(), idx,
+//						tc.output.usableBytes[idx], tc.output.usableBytes[idx]/clusterSize,
+//						dev.GetUsableBytes(), dev.GetUsableBytes()/clusterSize))
+//			}
+//			if tc.output.message != "" {
+//				test.AssertTrue(t,
+//					strings.Contains(buf.String(), tc.output.message),
+//					"missing message: "+tc.output.message)
+//			}
+//		})
+//	}
+//}
 
 func TestServer_getRdbSize(t *testing.T) {
 	type ExpectedOutput struct {
diff --git a/src/control/server/instance_drpc.go b/src/control/server/instance_drpc.go
index 542b636e2f0..76d56678092 100644
--- a/src/control/server/instance_drpc.go
+++ b/src/control/server/instance_drpc.go
@@ -223,7 +223,6 @@ func (ei *EngineInstance) getSmdDetails(smd *ctlpb.SmdDevice) (*storage.SmdDevic
 	}
 
 	smdDev.Rank = engineRank
-	smdDev.TrAddr = smd.GetTrAddr()
 
 	return smdDev, nil
 }
@@ -256,9 +255,9 @@ func (ei *EngineInstance) updateInUseBdevs(ctx context.Context, ctrlrs []storage
 	hasUpdatedHealth := make(map[string]bool)
 	for _, smd := range smdDevs.Devices {
 		msg := fmt.Sprintf("instance %d: smd %s: ctrlr %s", ei.Index(), smd.Uuid,
-			smd.TrAddr)
+			smd.Ctrlr.PciAddr)
 
-		ctrlr, exists := ctrlrMap[smd.GetTrAddr()]
+		ctrlr, exists := ctrlrMap[smd.Ctrlr.PciAddr]
 		if !exists {
 			ei.log.Errorf("%s: ctrlr not found", msg)
 			continue
@@ -276,9 +275,9 @@ func (ei *EngineInstance) updateInUseBdevs(ctx context.Context, ctrlrs []storage
 			// Log the error if it indicates non-existent health and the SMD entity has
 			// an abnormal state. Otherwise it is expected that health may be missing.
 			status, ok := errors.Cause(err).(daos.Status)
-			if ok && status == daos.Nonexistent && smdDev.NvmeState != storage.NvmeStateNormal {
+			if ok && status == daos.Nonexistent && smdDev.Ctrlr.NvmeState != storage.NvmeStateNormal {
 				ei.log.Debugf("%s: stats not found (device state: %q), skip update",
-					msg, smdDev.NvmeState.String())
+					msg, smdDev.Ctrlr.NvmeState.String())
 			} else {
 				ei.log.Errorf("%s: fetch stats: %s", msg, err.Error())
 			}
diff --git a/src/control/server/instance_storage_rpc.go b/src/control/server/instance_storage_rpc.go
index f4ea01a32cb..9f329b1e536 100644
--- a/src/control/server/instance_storage_rpc.go
+++ b/src/control/server/instance_storage_rpc.go
@@ -1,5 +1,5 @@
 //
-// (C) Copyright 2020-2022 Intel Corporation.
+// (C) Copyright 2020-2023 Intel Corporation.
 //
 // SPDX-License-Identifier: BSD-2-Clause-Patent
 //
@@ -156,3 +156,87 @@ func (ei *EngineInstance) StorageFormatNVMe() (cResults proto.NvmeControllerResu
 
 	return
 }
+
+func smdGetHealth(ctx context.Context, ei *EngineInstance, dev *ctlpb.SmdDevice) error {
+	state := dev.Ctrlr.DevState
+	if state == ctlpb.NvmeDevState_NEW {
+		ei.log.Debugf("skip fetching health stats on device %q in NEW state", dev, state)
+		return nil
+	}
+
+	health, err := ei.GetBioHealth(ctx, &ctlpb.BioHealthReq{DevUuid: dev.Uuid})
+	if err != nil {
+		return errors.Wrapf(err, "device %q, state %q", dev, state)
+	}
+	dev.Ctrlr.HealthStats = health
+
+	return nil
+}
+
+func smdQueryEngine(ctx context.Context, engine Engine, pbReq *ctlpb.SmdQueryReq) (*ctlpb.SmdQueryResp_RankResp, error) {
+	ei, ok := engine.(*EngineInstance)
+	if !ok {
+		return nil, errors.New("not EngineInstance")
+	}
+
+	if pbReq == nil {
+		return nil, errors.New("nil request")
+	}
+
+	engineRank, err := ei.GetRank()
+	if err != nil {
+		return nil, errors.Wrapf(err, "instance %d GetRank", ei.Index())
+	}
+	if !queryRank(pbReq.GetRank(), engineRank) {
+		ei.log.Debugf("skipping rank %d not specified in request", engineRank)
+		return nil, nil
+	}
+
+	rResp := new(ctlpb.SmdQueryResp_RankResp)
+	rResp.Rank = engineRank.Uint32()
+
+	if !ei.IsReady() {
+		ei.log.Debugf("skipping not-ready instance %d", ei.Index())
+		return rResp, nil
+	}
+
+	listDevsResp, err := ei.ListSmdDevices(ctx, new(ctlpb.SmdDevReq))
+	if err != nil {
+		return nil, errors.Wrapf(err, "rank %d", engineRank)
+	}
+
+	if len(listDevsResp.Devices) == 0 {
+		rResp.Devices = nil
+		return rResp, nil
+	}
+
+	// For each SmdDevice returned in list devs response, append a SmdDeviceWithHealth.
+	for _, sd := range listDevsResp.Devices {
+		if sd != nil {
+			rResp.Devices = append(rResp.Devices, sd)
+			//&ctlpb.SmdQueryResp_SmdDeviceWithHealth{Details: sd})
+		}
+	}
+
+	found := false
+	for _, dev := range rResp.Devices {
+		if pbReq.Uuid != "" && dev.Uuid != pbReq.Uuid {
+			continue // Skip health query if UUID doesn't match requested.
+		}
+		if pbReq.IncludeBioHealth {
+			if err := smdGetHealth(ctx, ei, dev); err != nil {
+				return nil, err
+			}
+		}
+		if pbReq.Uuid != "" && dev.Uuid == pbReq.Uuid {
+			rResp.Devices = []*ctlpb.SmdDevice{dev}
+			found = true
+			break
+		}
+	}
+	if pbReq.Uuid != "" && !found {
+		rResp.Devices = nil
+	}
+
+	return rResp, nil
+}
diff --git a/src/control/server/storage/bdev.go b/src/control/server/storage/bdev.go
index 1bc1ebe981c..bdc231a3be8 100644
--- a/src/control/server/storage/bdev.go
+++ b/src/control/server/storage/bdev.go
@@ -242,23 +242,21 @@ type NvmeNamespace struct {
 // SmdDevice contains DAOS storage device information, including
 // health details if requested.
 type SmdDevice struct {
-	UUID        string        `json:"uuid"`
-	TargetIDs   []int32       `hash:"set" json:"tgt_ids"`
-	NvmeState   NvmeDevState  `json:"dev_state"`
-	LedState    LedState      `json:"led_state"`
-	Rank        ranklist.Rank `json:"rank"`
-	TotalBytes  uint64        `json:"total_bytes"`
-	AvailBytes  uint64        `json:"avail_bytes"`
-	UsableBytes uint64        `json:"usable_bytes"`
-	ClusterSize uint64        `json:"cluster_size"`
-	MetaSize    uint64        `json:"meta_size"`
-	MetaWalSize uint64        `json:"meta_wal_size"`
-	RdbSize     uint64        `json:"rdb_size"`
-	RdbWalSize  uint64        `json:"rdb_wal_size"`
-	Health      *NvmeHealth   `json:"health"`
-	TrAddr      string        `json:"tr_addr"`
-	Roles       BdevRoles     `json:"roles"`
-	HasSysXS    bool          `json:"has_sys_xs"`
+	UUID             string         `json:"uuid"`
+	TargetIDs        []int32        `hash:"set" json:"tgt_ids"`
+	Rank             ranklist.Rank  `json:"rank"`
+	TotalBytes       uint64         `json:"total_bytes"`
+	AvailBytes       uint64         `json:"avail_bytes"`
+	UsableBytes      uint64         `json:"usable_bytes"`
+	ClusterSize      uint64         `json:"cluster_size"`
+	MetaSize         uint64         `json:"meta_size"`
+	MetaWalSize      uint64         `json:"meta_wal_size"`
+	RdbSize          uint64         `json:"rdb_size"`
+	RdbWalSize       uint64         `json:"rdb_wal_size"`
+	Roles            BdevRoles      `json:"roles"`
+	HasSysXS         bool           `json:"has_sys_xs"`
+	Ctrlr            NvmeController `json:"ctrlr"`
+	CtrlrNamespaceID uint32         `json:"ctrlr_namespace_id"`
 }
 
 func (sd *SmdDevice) String() string {
@@ -333,10 +331,14 @@ type NvmeController struct {
 	Serial      string           `hash:"ignore" json:"serial"`
 	PciAddr     string           `json:"pci_addr"`
 	FwRev       string           `json:"fw_rev"`
+	VendorID    string           `json:"vendor_id"`
+	PciType     string           `json:"pci_type"`
 	SocketID    int32            `json:"socket_id"`
 	HealthStats *NvmeHealth      `json:"health_stats"`
 	Namespaces  []*NvmeNamespace `hash:"set" json:"namespaces"`
 	SmdDevices  []*SmdDevice     `hash:"set" json:"smd_devices"`
+	NvmeState   NvmeDevState     `json:"dev_state"`
+	LedState    LedState         `json:"led_state"`
 }
 
 // UpdateSmd adds or updates SMD device entry for an NVMe Controller.
diff --git a/src/control/server/storage/bdev/backend.go b/src/control/server/storage/bdev/backend.go
index caf4e022aa8..464bc680cb9 100644
--- a/src/control/server/storage/bdev/backend.go
+++ b/src/control/server/storage/bdev/backend.go
@@ -348,6 +348,7 @@ func (sb *spdkBackend) Scan(req storage.BdevScanRequest) (*storage.BdevScanRespo
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to discover nvme")
 	}
+	sb.log.Debugf("spdk backend scan (bindings discover call) resp: %+v", foundDevs)
 
 	outDevs, err := groomDiscoveredBdevs(needDevs, foundDevs, req.VMDEnabled)
 	if err != nil {
diff --git a/src/control/server/storage/bdev/backend_vmd.go b/src/control/server/storage/bdev/backend_vmd.go
index d651e917b36..20b5d1b0720 100644
--- a/src/control/server/storage/bdev/backend_vmd.go
+++ b/src/control/server/storage/bdev/backend_vmd.go
@@ -257,11 +257,11 @@ func updatePrepareRequest(log logging.Logger, req *storage.BdevPrepareRequest, v
 	}
 
 	if vmdPCIAddrs.IsEmpty() {
-		log.Debug("no vmd devices found")
+		log.Debug("no volume management devices (vmd) found")
 		req.EnableVMD = false
 		return nil
 	}
-	log.Debugf("volume management devices found: %v", vmdPCIAddrs)
+	log.Debugf("volume management devices (vmd) found: %v", vmdPCIAddrs)
 
 	allowList, blockList, err := vmdFilterAddresses(log, req, vmdPCIAddrs)
 	if err != nil {
@@ -274,7 +274,7 @@ func updatePrepareRequest(log logging.Logger, req *storage.BdevPrepareRequest, v
 			vmdPCIAddrs, req.PCIAllowList, req.PCIBlockList)
 		req.EnableVMD = false
 	} else {
-		log.Debugf("volume management devices selected: %v", allowList)
+		log.Debugf("volume management devices (vmd) selected: %v", allowList)
 		req.PCIAllowList = allowList.String()
 		// Retain block list in request to cater for the case where NVMe SSDs are being
 		// protected against unbinding so they can continue to be used via kernel driver.
diff --git a/src/control/server/storage/bdev/provider.go b/src/control/server/storage/bdev/provider.go
index fdb9cb37c08..e130bcd9338 100644
--- a/src/control/server/storage/bdev/provider.go
+++ b/src/control/server/storage/bdev/provider.go
@@ -1,5 +1,5 @@
 //
-// (C) Copyright 2019-2022 Intel Corporation.
+// (C) Copyright 2019-2023 Intel Corporation.
 //
 // SPDX-License-Identifier: BSD-2-Clause-Patent
 //
@@ -51,7 +51,7 @@ func NewProvider(log logging.Logger, backend Backend) *Provider {
 // Scan calls into the backend to discover NVMe components in the
 // system.
 func (p *Provider) Scan(req storage.BdevScanRequest) (resp *storage.BdevScanResponse, err error) {
-	p.log.Debug("run bdev storage provider scan")
+	p.log.Debugf("run bdev storage provider scan, req: %+v", req)
 	return p.backend.Scan(req)
 }
 
@@ -60,12 +60,11 @@ func (p *Provider) Scan(req storage.BdevScanRequest) (resp *storage.BdevScanResp
 // reset allocation of hugepages, otherwise rebind devices to user-space
 // driver compatible with SPDK and allocate hugeages.
 func (p *Provider) Prepare(req storage.BdevPrepareRequest) (*storage.BdevPrepareResponse, error) {
+	p.log.Debugf("run bdev storage provider prepare setup, req: %+v", req)
 	if req.Reset_ {
-		p.log.Debug("run bdev storage provider prepare reset")
 		return p.backend.Reset(req)
 	}
 
-	p.log.Debug("run bdev storage provider prepare setup")
 	return p.backend.Prepare(req)
 }
 
diff --git a/src/control/server/storage/bdev_test.go b/src/control/server/storage/bdev_test.go
index 969697cbf50..4341947b370 100644
--- a/src/control/server/storage/bdev_test.go
+++ b/src/control/server/storage/bdev_test.go
@@ -130,8 +130,8 @@ func Test_Convert_SmdDevice(t *testing.T) {
 	origTgts := native.TargetIDs
 	// Validate target IDs get de-duplicated and HasSysXS set appropriately
 	native.TargetIDs = append(native.TargetIDs, sysXSTgtID, native.TargetIDs[0])
-	native.NvmeState = NvmeStateFaulty
-	native.LedState = LedStateFaulty
+	native.Ctrlr.NvmeState = NvmeStateFaulty
+	native.Ctrlr.LedState = LedStateFaulty
 
 	proto := new(ctlpb.SmdDevice)
 	if err := convert.Types(native, proto); err != nil {
@@ -140,8 +140,10 @@ func Test_Convert_SmdDevice(t *testing.T) {
 
 	test.AssertEqual(t, proto.Uuid, native.UUID, "uuid match")
 	test.AssertEqual(t, proto.TgtIds, native.TargetIDs, "targets match")
-	test.AssertEqual(t, NvmeDevState(proto.DevState), native.NvmeState, "nvme dev state match")
-	test.AssertEqual(t, LedState(proto.LedState), native.LedState, "dev led state match")
+	test.AssertEqual(t, NvmeDevState(proto.Ctrlr.DevState), native.Ctrlr.NvmeState,
+		"nvme dev state match")
+	test.AssertEqual(t, LedState(proto.Ctrlr.LedState), native.Ctrlr.LedState,
+		"dev led state match")
 	test.AssertEqual(t, OptionBits(proto.RoleBits), native.Roles.OptionBits, "roles match")
 
 	convertedNative := new(SmdDevice)
@@ -170,10 +172,12 @@ func Test_Convert_SmdDevice(t *testing.T) {
 		t.Fatal(err)
 	}
 	expOut := `{"role_bits":7,"uuid":"00000001-0001-0001-0001-000000000001","tgt_ids":[5,6,7,8],` +
-		`"dev_state":"EVICTED","led_state":"ON","rank":0,"total_bytes":0,"avail_bytes":0,` +
-		`"usable_bytes":0,"cluster_size":0,"meta_size":0,"meta_wal_size":0,"rdb_size":0,` +
-		`"rdb_wal_size":0,"health":null,"tr_addr":"0000:01:00.0","roles":"data,meta,wal",` +
-		`"has_sys_xs":true}`
+		`"rank":0,"total_bytes":0,"avail_bytes":0,"usable_bytes":0,"cluster_size":0,` +
+		`"meta_size":0,"meta_wal_size":0,"rdb_size":0,"rdb_wal_size":0,` +
+		`"roles":"data,meta,wal","has_sys_xs":true,"ctrlr":{"info":"","model":"",` +
+		`"serial":"","pci_addr":"0000:01:00.0","fw_rev":"","vendor_id":"","pci_type":"",` +
+		`"socket_id":0,"health_stats":null,"namespaces":null,"smd_devices":null,` +
+		`"dev_state":"EVICTED","led_state":"ON"},"ctrlr_namespace_id":0}`
 	if diff := cmp.Diff(expOut, string(out)); diff != "" {
 		t.Fatalf("expected json output to be human readable (-want, +got):\n%s\n", diff)
 	}
diff --git a/src/control/server/storage/mocks.go b/src/control/server/storage/mocks.go
index dcfd2cf34ec..57fec249ed1 100644
--- a/src/control/server/storage/mocks.go
+++ b/src/control/server/storage/mocks.go
@@ -102,10 +102,12 @@ func MockSmdDevice(parentTrAddr string, varIdx ...int32) *SmdDevice {
 	return &SmdDevice{
 		UUID:      test.MockUUID(idx),
 		TargetIDs: []int32{startTgt, startTgt + 1, startTgt + 2, startTgt + 3},
-		NvmeState: NvmeStateNormal,
-		LedState:  LedStateNormal,
-		TrAddr:    parentTrAddr,
 		Roles:     BdevRoles{OptionBits(BdevRoleAll)},
+		Ctrlr: NvmeController{
+			NvmeState: NvmeStateNormal,
+			LedState:  LedStateNormal,
+			PciAddr:   parentTrAddr,
+		},
 	}
 }
 
@@ -120,6 +122,8 @@ func MockNvmeController(varIdx ...int32) *NvmeController {
 		PciAddr:     pciAddr,
 		FwRev:       concat("fwRev", idx),
 		SocketID:    idx % 2,
+		NvmeState:   NvmeStateNormal,
+		LedState:    LedStateNormal,
 		HealthStats: MockNvmeHealth(idx),
 		Namespaces:  []*NvmeNamespace{MockNvmeNamespace(1)},
 		SmdDevices:  []*SmdDevice{MockSmdDevice(pciAddr, idx)},
diff --git a/src/control/server/storage/provider.go b/src/control/server/storage/provider.go
index 135d94bcee5..6856491b8b7 100644
--- a/src/control/server/storage/provider.go
+++ b/src/control/server/storage/provider.go
@@ -427,6 +427,7 @@ func (p *Provider) PrepareBdevs(req BdevPrepareRequest) (*BdevPrepareResponse, e
 
 	if err == nil && resp != nil && !req.CleanHugepagesOnly {
 		p.vmdEnabled = resp.VMDPrepared
+		p.log.Debugf("setting vmd=%v on storage provider", p.vmdEnabled)
 	}
 	return resp, err
 }
diff --git a/src/include/daos_srv/bio.h b/src/include/daos_srv/bio.h
index 37973f1fa7b..d052e853cdf 100644
--- a/src/include/daos_srv/bio.h
+++ b/src/include/daos_srv/bio.h
@@ -353,8 +353,8 @@ struct bio_dev_info {
 	uint32_t		bdi_tgt_cnt;
 	int		       *bdi_tgts;
 	char		       *bdi_traddr;
-	uint32_t		bdi_dev_type;	/* reserved */
-	uint32_t		bdi_dev_roles;	/* reserved */
+	uint32_t                bdi_dev_roles;
+	struct ctrlr_t         *bdi_ctrlr; /* defined in control.h */
 };
 
 static inline void
@@ -364,6 +364,19 @@ bio_free_dev_info(struct bio_dev_info *dev_info)
 		D_FREE(dev_info->bdi_tgts);
 	if (dev_info->bdi_traddr != NULL)
 		D_FREE(dev_info->bdi_traddr);
+	if (dev_info->bdi_ctrlr != NULL) {
+		if (dev_info->bdi_ctrlr->model != NULL)
+			D_FREE(dev_info->bdi_ctrlr->model);
+		if (dev_info->bdi_ctrlr->serial != NULL)
+			D_FREE(dev_info->bdi_ctrlr->serial);
+		if (dev_info->bdi_ctrlr->fw_rev != NULL)
+			D_FREE(dev_info->bdi_ctrlr->fw_rev);
+		if (dev_info->bdi_ctrlr->vendor_id != NULL)
+			D_FREE(dev_info->bdi_ctrlr->vendor_id);
+		if (dev_info->bdi_ctrlr->pci_type != NULL)
+			D_FREE(dev_info->bdi_ctrlr->pci_type);
+		D_FREE(dev_info->bdi_ctrlr);
+	}
 	D_FREE(dev_info);
 }
 
diff --git a/src/include/daos_srv/control.h b/src/include/daos_srv/control.h
index 5ac56072c35..9bb57e96c85 100644
--- a/src/include/daos_srv/control.h
+++ b/src/include/daos_srv/control.h
@@ -24,6 +24,9 @@
 extern const char *
 dpdk_cli_override_opts;
 
+#define NVME_PCI_DEV_TYPE_VMD           "vmd"
+#define NVME_DETAIL_BUFLEN              1024
+
 /** Device state flags */
 #define NVME_DEV_FL_PLUGGED	(1 << 0)	/* Device is present in slot */
 #define NVME_DEV_FL_INUSE	(1 << 1)	/* Used by DAOS (present in SMD) */
@@ -123,6 +126,31 @@ struct nvme_stats {
 	uint64_t    host_bytes_written; /* Host bytes written, 1count=32MiB) */
 };
 
+/**
+ * NVMe controller details.
+ */
+struct ctrlr_t {
+	char              *model;
+	char              *serial;
+	char              *pci_addr;
+	char              *fw_rev;
+	char              *pci_type;
+	char              *vendor_id;
+	int                socket_id;
+	struct ns_t       *nss;
+	struct nvme_stats *stats;
+	struct ctrlr_t    *next;
+};
+
+/**
+ * NVMe namespace details.
+ */
+struct ns_t {
+	uint32_t     id;
+	uint64_t     size;
+	struct ns_t *next;
+};
+
 /**
  * Parse input string and output ASCII as required by the NVMe spec.
  *
diff --git a/src/mgmt/smd.pb-c.c b/src/mgmt/smd.pb-c.c
index 4a3da682883..b3ed3284385 100644
--- a/src/mgmt/smd.pb-c.c
+++ b/src/mgmt/smd.pb-c.c
@@ -97,6 +97,57 @@ void   ctl__bio_health_resp__free_unpacked
   assert(message->base.descriptor == &ctl__bio_health_resp__descriptor);
   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 }
+void   ctl__nvme_controller__namespace__init
+                     (Ctl__NvmeController__Namespace         *message)
+{
+  static const Ctl__NvmeController__Namespace init_value = CTL__NVME_CONTROLLER__NAMESPACE__INIT;
+  *message = init_value;
+}
+void   ctl__nvme_controller__init
+                     (Ctl__NvmeController         *message)
+{
+  static const Ctl__NvmeController init_value = CTL__NVME_CONTROLLER__INIT;
+  *message = init_value;
+}
+size_t ctl__nvme_controller__get_packed_size
+                     (const Ctl__NvmeController *message)
+{
+  assert(message->base.descriptor == &ctl__nvme_controller__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t ctl__nvme_controller__pack
+                     (const Ctl__NvmeController *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &ctl__nvme_controller__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t ctl__nvme_controller__pack_to_buffer
+                     (const Ctl__NvmeController *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &ctl__nvme_controller__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+Ctl__NvmeController *
+       ctl__nvme_controller__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (Ctl__NvmeController *)
+     protobuf_c_message_unpack (&ctl__nvme_controller__descriptor,
+                                allocator, len, data);
+}
+void   ctl__nvme_controller__free_unpacked
+                     (Ctl__NvmeController *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &ctl__nvme_controller__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
 void   ctl__smd_device__init
                      (Ctl__SmdDevice         *message)
 {
@@ -373,12 +424,6 @@ void   ctl__smd_query_req__free_unpacked
   assert(message->base.descriptor == &ctl__smd_query_req__descriptor);
   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 }
-void   ctl__smd_query_resp__smd_device_with_health__init
-                     (Ctl__SmdQueryResp__SmdDeviceWithHealth         *message)
-{
-  static const Ctl__SmdQueryResp__SmdDeviceWithHealth init_value = CTL__SMD_QUERY_RESP__SMD_DEVICE_WITH_HEALTH__INIT;
-  *message = init_value;
-}
 void   ctl__smd_query_resp__pool__init
                      (Ctl__SmdQueryResp__Pool         *message)
 {
@@ -1393,51 +1438,175 @@ const ProtobufCMessageDescriptor ctl__bio_health_resp__descriptor =
   (ProtobufCMessageInit) ctl__bio_health_resp__init,
   NULL,NULL,NULL    /* reserved[123] */
 };
-static const ProtobufCFieldDescriptor ctl__smd_device__field_descriptors[15] =
+static const ProtobufCFieldDescriptor ctl__nvme_controller__namespace__field_descriptors[3] =
 {
   {
-    "uuid",
+    "id",
     1,
     PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_UINT32,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__NvmeController__Namespace, id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "size",
+    2,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_UINT64,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__NvmeController__Namespace, size),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ctrlr_pci_addr",
+    3,
+    PROTOBUF_C_LABEL_NONE,
     PROTOBUF_C_TYPE_STRING,
     0,   /* quantifier_offset */
-    offsetof(Ctl__SmdDevice, uuid),
+    offsetof(Ctl__NvmeController__Namespace, ctrlr_pci_addr),
     NULL,
     &protobuf_c_empty_string,
     0,             /* flags */
     0,NULL,NULL    /* reserved1,reserved2, etc */
   },
+};
+static const unsigned ctl__nvme_controller__namespace__field_indices_by_name[] = {
+  2,   /* field[2] = ctrlr_pci_addr */
+  0,   /* field[0] = id */
+  1,   /* field[1] = size */
+};
+static const ProtobufCIntRange ctl__nvme_controller__namespace__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 3 }
+};
+const ProtobufCMessageDescriptor ctl__nvme_controller__namespace__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "ctl.NvmeController.Namespace",
+  "Namespace",
+  "Ctl__NvmeController__Namespace",
+  "ctl",
+  sizeof(Ctl__NvmeController__Namespace),
+  3,
+  ctl__nvme_controller__namespace__field_descriptors,
+  ctl__nvme_controller__namespace__field_indices_by_name,
+  1,  ctl__nvme_controller__namespace__number_ranges,
+  (ProtobufCMessageInit) ctl__nvme_controller__namespace__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor ctl__nvme_controller__field_descriptors[12] =
+{
   {
-    "tgt_ids",
-    2,
-    PROTOBUF_C_LABEL_REPEATED,
-    PROTOBUF_C_TYPE_INT32,
-    offsetof(Ctl__SmdDevice, n_tgt_ids),
-    offsetof(Ctl__SmdDevice, tgt_ids),
+    "model",
+    1,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__NvmeController, model),
     NULL,
+    &protobuf_c_empty_string,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "serial",
+    2,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__NvmeController, serial),
     NULL,
+    &protobuf_c_empty_string,
     0,             /* flags */
     0,NULL,NULL    /* reserved1,reserved2, etc */
   },
   {
-    "tr_addr",
+    "pci_addr",
     3,
     PROTOBUF_C_LABEL_NONE,
     PROTOBUF_C_TYPE_STRING,
     0,   /* quantifier_offset */
-    offsetof(Ctl__SmdDevice, tr_addr),
+    offsetof(Ctl__NvmeController, pci_addr),
     NULL,
     &protobuf_c_empty_string,
     0,             /* flags */
     0,NULL,NULL    /* reserved1,reserved2, etc */
   },
   {
-    "dev_state",
+    "fw_rev",
     4,
     PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__NvmeController, fw_rev),
+    NULL,
+    &protobuf_c_empty_string,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "socket_id",
+    5,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_INT32,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__NvmeController, socket_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "health_stats",
+    6,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__NvmeController, health_stats),
+    &ctl__bio_health_resp__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "namespaces",
+    7,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_MESSAGE,
+    offsetof(Ctl__NvmeController, n_namespaces),
+    offsetof(Ctl__NvmeController, namespaces),
+    &ctl__nvme_controller__namespace__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "smd_devices",
+    8,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_MESSAGE,
+    offsetof(Ctl__NvmeController, n_smd_devices),
+    offsetof(Ctl__NvmeController, smd_devices),
+    &ctl__smd_device__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "dev_state",
+    9,
+    PROTOBUF_C_LABEL_NONE,
     PROTOBUF_C_TYPE_ENUM,
     0,   /* quantifier_offset */
-    offsetof(Ctl__SmdDevice, dev_state),
+    offsetof(Ctl__NvmeController, dev_state),
     &ctl__nvme_dev_state__descriptor,
     NULL,
     0,             /* flags */
@@ -1445,16 +1614,101 @@ static const ProtobufCFieldDescriptor ctl__smd_device__field_descriptors[15] =
   },
   {
     "led_state",
-    5,
+    10,
     PROTOBUF_C_LABEL_NONE,
     PROTOBUF_C_TYPE_ENUM,
     0,   /* quantifier_offset */
-    offsetof(Ctl__SmdDevice, led_state),
+    offsetof(Ctl__NvmeController, led_state),
     &ctl__led_state__descriptor,
     NULL,
     0,             /* flags */
     0,NULL,NULL    /* reserved1,reserved2, etc */
   },
+  {
+    "pci_dev_type",
+    11,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__NvmeController, pci_dev_type),
+    NULL,
+    &protobuf_c_empty_string,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "vendor_id",
+    12,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__NvmeController, vendor_id),
+    NULL,
+    &protobuf_c_empty_string,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned ctl__nvme_controller__field_indices_by_name[] = {
+  8,   /* field[8] = dev_state */
+  3,   /* field[3] = fw_rev */
+  5,   /* field[5] = health_stats */
+  9,   /* field[9] = led_state */
+  0,   /* field[0] = model */
+  6,   /* field[6] = namespaces */
+  2,   /* field[2] = pci_addr */
+  10,   /* field[10] = pci_dev_type */
+  1,   /* field[1] = serial */
+  7,   /* field[7] = smd_devices */
+  4,   /* field[4] = socket_id */
+  11,   /* field[11] = vendor_id */
+};
+static const ProtobufCIntRange ctl__nvme_controller__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 12 }
+};
+const ProtobufCMessageDescriptor ctl__nvme_controller__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "ctl.NvmeController",
+  "NvmeController",
+  "Ctl__NvmeController",
+  "ctl",
+  sizeof(Ctl__NvmeController),
+  12,
+  ctl__nvme_controller__field_descriptors,
+  ctl__nvme_controller__field_indices_by_name,
+  1,  ctl__nvme_controller__number_ranges,
+  (ProtobufCMessageInit) ctl__nvme_controller__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
+static const ProtobufCFieldDescriptor ctl__smd_device__field_descriptors[14] =
+{
+  {
+    "uuid",
+    1,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__SmdDevice, uuid),
+    NULL,
+    &protobuf_c_empty_string,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "tgt_ids",
+    2,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(Ctl__SmdDevice, n_tgt_ids),
+    offsetof(Ctl__SmdDevice, tgt_ids),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
   {
     "total_bytes",
     6,
@@ -1575,28 +1829,52 @@ static const ProtobufCFieldDescriptor ctl__smd_device__field_descriptors[15] =
     0,             /* flags */
     0,NULL,NULL    /* reserved1,reserved2, etc */
   },
+  {
+    "ctrlr",
+    16,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__SmdDevice, ctrlr),
+    &ctl__nvme_controller__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ctrlr_namespace_id",
+    17,
+    PROTOBUF_C_LABEL_NONE,
+    PROTOBUF_C_TYPE_UINT32,
+    0,   /* quantifier_offset */
+    offsetof(Ctl__SmdDevice, ctrlr_namespace_id),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
 };
 static const unsigned ctl__smd_device__field_indices_by_name[] = {
-  6,   /* field[6] = avail_bytes */
-  7,   /* field[7] = cluster_size */
-  3,   /* field[3] = dev_state */
-  4,   /* field[4] = led_state */
-  10,   /* field[10] = meta_size */
-  11,   /* field[11] = meta_wal_size */
-  8,   /* field[8] = rank */
-  12,   /* field[12] = rdb_size */
-  13,   /* field[13] = rdb_wal_size */
-  9,   /* field[9] = role_bits */
+  3,   /* field[3] = avail_bytes */
+  4,   /* field[4] = cluster_size */
+  12,   /* field[12] = ctrlr */
+  13,   /* field[13] = ctrlr_namespace_id */
+  7,   /* field[7] = meta_size */
+  8,   /* field[8] = meta_wal_size */
+  5,   /* field[5] = rank */
+  9,   /* field[9] = rdb_size */
+  10,   /* field[10] = rdb_wal_size */
+  6,   /* field[6] = role_bits */
   1,   /* field[1] = tgt_ids */
-  5,   /* field[5] = total_bytes */
-  2,   /* field[2] = tr_addr */
-  14,   /* field[14] = usable_bytes */
+  2,   /* field[2] = total_bytes */
+  11,   /* field[11] = usable_bytes */
   0,   /* field[0] = uuid */
 };
-static const ProtobufCIntRange ctl__smd_device__number_ranges[1 + 1] =
+static const ProtobufCIntRange ctl__smd_device__number_ranges[2 + 1] =
 {
   { 1, 0 },
-  { 0, 15 }
+  { 6, 2 },
+  { 0, 14 }
 };
 const ProtobufCMessageDescriptor ctl__smd_device__descriptor =
 {
@@ -1606,10 +1884,10 @@ const ProtobufCMessageDescriptor ctl__smd_device__descriptor =
   "Ctl__SmdDevice",
   "ctl",
   sizeof(Ctl__SmdDevice),
-  15,
+  14,
   ctl__smd_device__field_descriptors,
   ctl__smd_device__field_indices_by_name,
-  1,  ctl__smd_device__number_ranges,
+  2,  ctl__smd_device__number_ranges,
   (ProtobufCMessageInit) ctl__smd_device__init,
   NULL,NULL,NULL    /* reserved[123] */
 };
@@ -1905,57 +2183,6 @@ const ProtobufCMessageDescriptor ctl__smd_query_req__descriptor =
   (ProtobufCMessageInit) ctl__smd_query_req__init,
   NULL,NULL,NULL    /* reserved[123] */
 };
-static const ProtobufCFieldDescriptor ctl__smd_query_resp__smd_device_with_health__field_descriptors[2] =
-{
-  {
-    "details",
-    1,
-    PROTOBUF_C_LABEL_NONE,
-    PROTOBUF_C_TYPE_MESSAGE,
-    0,   /* quantifier_offset */
-    offsetof(Ctl__SmdQueryResp__SmdDeviceWithHealth, details),
-    &ctl__smd_device__descriptor,
-    NULL,
-    0,             /* flags */
-    0,NULL,NULL    /* reserved1,reserved2, etc */
-  },
-  {
-    "health",
-    2,
-    PROTOBUF_C_LABEL_NONE,
-    PROTOBUF_C_TYPE_MESSAGE,
-    0,   /* quantifier_offset */
-    offsetof(Ctl__SmdQueryResp__SmdDeviceWithHealth, health),
-    &ctl__bio_health_resp__descriptor,
-    NULL,
-    0,             /* flags */
-    0,NULL,NULL    /* reserved1,reserved2, etc */
-  },
-};
-static const unsigned ctl__smd_query_resp__smd_device_with_health__field_indices_by_name[] = {
-  0,   /* field[0] = details */
-  1,   /* field[1] = health */
-};
-static const ProtobufCIntRange ctl__smd_query_resp__smd_device_with_health__number_ranges[1 + 1] =
-{
-  { 1, 0 },
-  { 0, 2 }
-};
-const ProtobufCMessageDescriptor ctl__smd_query_resp__smd_device_with_health__descriptor =
-{
-  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
-  "ctl.SmdQueryResp.SmdDeviceWithHealth",
-  "SmdDeviceWithHealth",
-  "Ctl__SmdQueryResp__SmdDeviceWithHealth",
-  "ctl",
-  sizeof(Ctl__SmdQueryResp__SmdDeviceWithHealth),
-  2,
-  ctl__smd_query_resp__smd_device_with_health__field_descriptors,
-  ctl__smd_query_resp__smd_device_with_health__field_indices_by_name,
-  1,  ctl__smd_query_resp__smd_device_with_health__number_ranges,
-  (ProtobufCMessageInit) ctl__smd_query_resp__smd_device_with_health__init,
-  NULL,NULL,NULL    /* reserved[123] */
-};
 static const ProtobufCFieldDescriptor ctl__smd_query_resp__pool__field_descriptors[3] =
 {
   {
@@ -2041,7 +2268,7 @@ static const ProtobufCFieldDescriptor ctl__smd_query_resp__rank_resp__field_desc
     PROTOBUF_C_TYPE_MESSAGE,
     offsetof(Ctl__SmdQueryResp__RankResp, n_devices),
     offsetof(Ctl__SmdQueryResp__RankResp, devices),
-    &ctl__smd_query_resp__smd_device_with_health__descriptor,
+    &ctl__smd_device__descriptor,
     NULL,
     0,             /* flags */
     0,NULL,NULL    /* reserved1,reserved2, etc */
diff --git a/src/mgmt/smd.pb-c.h b/src/mgmt/smd.pb-c.h
index 45d159907ca..19ac9fc3d14 100644
--- a/src/mgmt/smd.pb-c.h
+++ b/src/mgmt/smd.pb-c.h
@@ -17,6 +17,8 @@ PROTOBUF_C__BEGIN_DECLS
 
 typedef struct _Ctl__BioHealthReq Ctl__BioHealthReq;
 typedef struct _Ctl__BioHealthResp Ctl__BioHealthResp;
+typedef struct _Ctl__NvmeController Ctl__NvmeController;
+typedef struct _Ctl__NvmeController__Namespace Ctl__NvmeController__Namespace;
 typedef struct _Ctl__SmdDevice Ctl__SmdDevice;
 typedef struct _Ctl__SmdDevReq Ctl__SmdDevReq;
 typedef struct _Ctl__SmdDevResp Ctl__SmdDevResp;
@@ -25,7 +27,6 @@ typedef struct _Ctl__SmdPoolResp Ctl__SmdPoolResp;
 typedef struct _Ctl__SmdPoolResp__Pool Ctl__SmdPoolResp__Pool;
 typedef struct _Ctl__SmdQueryReq Ctl__SmdQueryReq;
 typedef struct _Ctl__SmdQueryResp Ctl__SmdQueryResp;
-typedef struct _Ctl__SmdQueryResp__SmdDeviceWithHealth Ctl__SmdQueryResp__SmdDeviceWithHealth;
 typedef struct _Ctl__SmdQueryResp__Pool Ctl__SmdQueryResp__Pool;
 typedef struct _Ctl__SmdQueryResp__RankResp Ctl__SmdQueryResp__RankResp;
 typedef struct _Ctl__LedManageReq Ctl__LedManageReq;
@@ -222,33 +223,107 @@ struct  _Ctl__BioHealthResp
 
 
 /*
- * SmdDevice represents a DAOS BIO device, identified by a UUID written into a label stored on a
- * SPDK blobstore created on a NVMe namespace. Multiple SmdDevices may exist per NVMe controller.
+ * Namespace represents a namespace created on an NvmeController.
  */
-struct  _Ctl__SmdDevice
+struct  _Ctl__NvmeController__Namespace
 {
   ProtobufCMessage base;
   /*
-   * UUID of blobstore
+   * namespace id
    */
-  char *uuid;
+  uint32_t id;
   /*
-   * VOS target IDs
+   * device capacity in bytes
    */
-  size_t n_tgt_ids;
-  int32_t *tgt_ids;
+  uint64_t size;
+  /*
+   * parent controller PCI address
+   */
+  char *ctrlr_pci_addr;
+};
+#define CTL__NVME_CONTROLLER__NAMESPACE__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&ctl__nvme_controller__namespace__descriptor) \
+    , 0, 0, (char *)protobuf_c_empty_string }
+
+
+/*
+ * NvmeController represents an NVMe Controller (SSD).
+ */
+struct  _Ctl__NvmeController
+{
+  ProtobufCMessage base;
+  /*
+   * model name
+   */
+  char *model;
   /*
-   * Transport address of blobstore
+   * serial number
    */
-  char *tr_addr;
+  char *serial;
   /*
-   * NVMe device state
+   * pci address
+   */
+  char *pci_addr;
+  /*
+   * firmware revision
+   */
+  char *fw_rev;
+  /*
+   * NUMA socket ID
+   */
+  int32_t socket_id;
+  /*
+   * controller's health stats
+   */
+  Ctl__BioHealthResp *health_stats;
+  /*
+   * controller's namespaces
+   */
+  size_t n_namespaces;
+  Ctl__NvmeController__Namespace **namespaces;
+  /*
+   * controller's blobstores
+   */
+  size_t n_smd_devices;
+  Ctl__SmdDevice **smd_devices;
+  /*
+   * NVMe device operational state
    */
   Ctl__NvmeDevState dev_state;
   /*
-   * LED state
+   * NVMe device LED state
    */
   Ctl__LedState led_state;
+  /*
+   * PCI device type, vmd or pci
+   */
+  char *pci_dev_type;
+  /*
+   * controller's vendor ID
+   */
+  char *vendor_id;
+};
+#define CTL__NVME_CONTROLLER__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&ctl__nvme_controller__descriptor) \
+    , (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, 0, NULL, 0,NULL, 0,NULL, CTL__NVME_DEV_STATE__UNKNOWN, CTL__LED_STATE__OFF, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string }
+
+
+/*
+ * SmdDevice represents a DAOS BIO device, identified by a UUID written into a label stored on a
+ * SPDK blobstore created on a NVMe namespace. Multiple SmdDevices may exist per NVMe controller.
+ */
+struct  _Ctl__SmdDevice
+{
+  ProtobufCMessage base;
+  /*
+   * UUID of blobstore
+   */
+  char *uuid;
+  /*
+   * VOS target IDs
+   */
+  size_t n_tgt_ids;
+  int32_t *tgt_ids;
   /*
    * blobstore clusters total bytes
    */
@@ -289,10 +364,18 @@ struct  _Ctl__SmdDevice
    * Effective storage available for data
    */
   uint64_t usable_bytes;
+  /*
+   * Backing NVMe controller of SMD device
+   */
+  Ctl__NvmeController *ctrlr;
+  /*
+   * NVMe namespace id hosting SMD blobstore
+   */
+  uint32_t ctrlr_namespace_id;
 };
 #define CTL__SMD_DEVICE__INIT \
  { PROTOBUF_C_MESSAGE_INIT (&ctl__smd_device__descriptor) \
-    , (char *)protobuf_c_empty_string, 0,NULL, (char *)protobuf_c_empty_string, CTL__NVME_DEV_STATE__UNKNOWN, CTL__LED_STATE__OFF, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
+    , (char *)protobuf_c_empty_string, 0,NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, 0 }
 
 
 struct  _Ctl__SmdDevReq
@@ -389,20 +472,6 @@ struct  _Ctl__SmdQueryReq
     , 0, 0, 0, (char *)protobuf_c_empty_string, 0 }
 
 
-struct  _Ctl__SmdQueryResp__SmdDeviceWithHealth
-{
-  ProtobufCMessage base;
-  Ctl__SmdDevice *details;
-  /*
-   * optional BIO health
-   */
-  Ctl__BioHealthResp *health;
-};
-#define CTL__SMD_QUERY_RESP__SMD_DEVICE_WITH_HEALTH__INIT \
- { PROTOBUF_C_MESSAGE_INIT (&ctl__smd_query_resp__smd_device_with_health__descriptor) \
-    , NULL, NULL }
-
-
 struct  _Ctl__SmdQueryResp__Pool
 {
   ProtobufCMessage base;
@@ -437,7 +506,7 @@ struct  _Ctl__SmdQueryResp__RankResp
    * List of devices on the rank
    */
   size_t n_devices;
-  Ctl__SmdQueryResp__SmdDeviceWithHealth **devices;
+  Ctl__SmdDevice **devices;
   /*
    * List of pools on the rank
    */
@@ -659,6 +728,28 @@ Ctl__BioHealthResp *
 void   ctl__bio_health_resp__free_unpacked
                      (Ctl__BioHealthResp *message,
                       ProtobufCAllocator *allocator);
+/* Ctl__NvmeController__Namespace methods */
+void   ctl__nvme_controller__namespace__init
+                     (Ctl__NvmeController__Namespace         *message);
+/* Ctl__NvmeController methods */
+void   ctl__nvme_controller__init
+                     (Ctl__NvmeController         *message);
+size_t ctl__nvme_controller__get_packed_size
+                     (const Ctl__NvmeController   *message);
+size_t ctl__nvme_controller__pack
+                     (const Ctl__NvmeController   *message,
+                      uint8_t             *out);
+size_t ctl__nvme_controller__pack_to_buffer
+                     (const Ctl__NvmeController   *message,
+                      ProtobufCBuffer     *buffer);
+Ctl__NvmeController *
+       ctl__nvme_controller__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   ctl__nvme_controller__free_unpacked
+                     (Ctl__NvmeController *message,
+                      ProtobufCAllocator *allocator);
 /* Ctl__SmdDevice methods */
 void   ctl__smd_device__init
                      (Ctl__SmdDevice         *message);
@@ -776,9 +867,6 @@ Ctl__SmdQueryReq *
 void   ctl__smd_query_req__free_unpacked
                      (Ctl__SmdQueryReq *message,
                       ProtobufCAllocator *allocator);
-/* Ctl__SmdQueryResp__SmdDeviceWithHealth methods */
-void   ctl__smd_query_resp__smd_device_with_health__init
-                     (Ctl__SmdQueryResp__SmdDeviceWithHealth         *message);
 /* Ctl__SmdQueryResp__Pool methods */
 void   ctl__smd_query_resp__pool__init
                      (Ctl__SmdQueryResp__Pool         *message);
@@ -932,6 +1020,12 @@ typedef void (*Ctl__BioHealthReq_Closure)
 typedef void (*Ctl__BioHealthResp_Closure)
                  (const Ctl__BioHealthResp *message,
                   void *closure_data);
+typedef void (*Ctl__NvmeController__Namespace_Closure)
+                 (const Ctl__NvmeController__Namespace *message,
+                  void *closure_data);
+typedef void (*Ctl__NvmeController_Closure)
+                 (const Ctl__NvmeController *message,
+                  void *closure_data);
 typedef void (*Ctl__SmdDevice_Closure)
                  (const Ctl__SmdDevice *message,
                   void *closure_data);
@@ -953,9 +1047,6 @@ typedef void (*Ctl__SmdPoolResp_Closure)
 typedef void (*Ctl__SmdQueryReq_Closure)
                  (const Ctl__SmdQueryReq *message,
                   void *closure_data);
-typedef void (*Ctl__SmdQueryResp__SmdDeviceWithHealth_Closure)
-                 (const Ctl__SmdQueryResp__SmdDeviceWithHealth *message,
-                  void *closure_data);
 typedef void (*Ctl__SmdQueryResp__Pool_Closure)
                  (const Ctl__SmdQueryResp__Pool *message,
                   void *closure_data);
@@ -1000,6 +1091,8 @@ extern const ProtobufCEnumDescriptor    ctl__led_state__descriptor;
 extern const ProtobufCEnumDescriptor    ctl__led_action__descriptor;
 extern const ProtobufCMessageDescriptor ctl__bio_health_req__descriptor;
 extern const ProtobufCMessageDescriptor ctl__bio_health_resp__descriptor;
+extern const ProtobufCMessageDescriptor ctl__nvme_controller__descriptor;
+extern const ProtobufCMessageDescriptor ctl__nvme_controller__namespace__descriptor;
 extern const ProtobufCMessageDescriptor ctl__smd_device__descriptor;
 extern const ProtobufCMessageDescriptor ctl__smd_dev_req__descriptor;
 extern const ProtobufCMessageDescriptor ctl__smd_dev_resp__descriptor;
@@ -1008,7 +1101,6 @@ extern const ProtobufCMessageDescriptor ctl__smd_pool_resp__descriptor;
 extern const ProtobufCMessageDescriptor ctl__smd_pool_resp__pool__descriptor;
 extern const ProtobufCMessageDescriptor ctl__smd_query_req__descriptor;
 extern const ProtobufCMessageDescriptor ctl__smd_query_resp__descriptor;
-extern const ProtobufCMessageDescriptor ctl__smd_query_resp__smd_device_with_health__descriptor;
 extern const ProtobufCMessageDescriptor ctl__smd_query_resp__pool__descriptor;
 extern const ProtobufCMessageDescriptor ctl__smd_query_resp__rank_resp__descriptor;
 extern const ProtobufCMessageDescriptor ctl__led_manage_req__descriptor;
diff --git a/src/mgmt/srv_drpc.c b/src/mgmt/srv_drpc.c
index 11cabbf5990..de7b5c00c96 100644
--- a/src/mgmt/srv_drpc.c
+++ b/src/mgmt/srv_drpc.c
@@ -1961,6 +1961,33 @@ ds_mgmt_drpc_pool_query_targets(Drpc__Call *drpc_req, Drpc__Response *drpc_resp)
 	D_FREE(resp_infos);
 }
 
+void
+ds_mgmt_smd_free_dev(Ctl__SmdDevice *dev)
+{
+	if (dev->uuid != NULL)
+		D_FREE(dev->uuid);
+	if (dev->tgt_ids != NULL)
+		D_FREE(dev->tgt_ids);
+	if (dev->ctrlr != NULL) {
+		if (dev->ctrlr->model != NULL)
+			D_FREE(dev->ctrlr->model);
+		if (dev->ctrlr->serial != NULL)
+			D_FREE(dev->ctrlr->serial);
+		if (dev->ctrlr->pci_addr != NULL)
+			D_FREE(dev->ctrlr->pci_addr);
+		if (dev->ctrlr->fw_rev != NULL)
+			D_FREE(dev->ctrlr->fw_rev);
+		if (dev->ctrlr->vendor_id != NULL)
+			D_FREE(dev->ctrlr->vendor_id);
+		if (dev->ctrlr->pci_dev_type != NULL)
+			D_FREE(dev->ctrlr->pci_dev_type);
+		if (dev->ctrlr->namespaces != NULL) {
+			if (dev->ctrlr->namespaces[0] != NULL)
+				D_FREE(dev->ctrlr->namespaces[0]);
+		}
+	}
+}
+
 void
 ds_mgmt_drpc_smd_list_devs(Drpc__Call *drpc_req, Drpc__Response *drpc_resp)
 {
@@ -2016,12 +2043,7 @@ ds_mgmt_drpc_smd_list_devs(Drpc__Call *drpc_req, Drpc__Response *drpc_resp)
 
 	for (i = 0; i < resp->n_devices; i++) {
 		if (resp->devices[i] != NULL) {
-			if (resp->devices[i]->uuid != NULL)
-				D_FREE(resp->devices[i]->uuid);
-			if (resp->devices[i]->tgt_ids != NULL)
-				D_FREE(resp->devices[i]->tgt_ids);
-			if (resp->devices[i]->tr_addr != NULL)
-				D_FREE(resp->devices[i]->tr_addr);
+			ds_mgmt_smd_free_dev(resp->devices[i]);
 			D_FREE(resp->devices[i]);
 		}
 	}
diff --git a/src/mgmt/srv_internal.h b/src/mgmt/srv_internal.h
index 6bd142022ab..f9ca3182705 100644
--- a/src/mgmt/srv_internal.h
+++ b/src/mgmt/srv_internal.h
@@ -119,6 +119,8 @@ struct mgmt_bio_health {
 
 int ds_mgmt_bio_health_query(struct mgmt_bio_health *mbh, uuid_t uuid);
 int ds_mgmt_smd_list_devs(Ctl__SmdDevResp *resp);
+void
+     ds_mgmt_smd_free_dev(Ctl__SmdDevice *dev);
 int ds_mgmt_smd_list_pools(Ctl__SmdPoolResp *resp);
 int ds_mgmt_dev_set_faulty(uuid_t uuid, Ctl__DevManageResp *resp);
 int ds_mgmt_dev_manage_led(Ctl__LedManageReq *req, Ctl__DevManageResp *resp);
diff --git a/src/mgmt/srv_query.c b/src/mgmt/srv_query.c
index f858e4586ca..21d0bda6dba 100644
--- a/src/mgmt/srv_query.c
+++ b/src/mgmt/srv_query.c
@@ -10,6 +10,7 @@
 
 #include <daos_srv/bio.h>
 #include <daos_srv/smd.h>
+#include <daos_srv/control.h>
 
 #include "srv_internal.h"
 
@@ -293,14 +294,39 @@ bio_query_dev_list(void *arg)
 	return 0;
 }
 
+static int
+copy_str2ctrlr(char **dst, const char *src)
+{
+	int len;
+
+	D_ASSERT(src != NULL);
+	D_ASSERT(dst != NULL);
+
+	if ((*dst != NULL) && (strnlen(*dst, NVME_DETAIL_BUFLEN) != 0)) {
+		D_ERROR("attempting to copy to non-empty destination");
+		return -DER_INVAL;
+	}
+
+	len = strnlen(src, NVME_DETAIL_BUFLEN);
+	D_ALLOC(*dst, len + 1);
+	if (*dst == NULL)
+		return -DER_NOMEM;
+
+	if (copy_ascii(*dst, len + 1, src, len) != 0) {
+		D_ERROR("copy_ascii: '%s'\n", src);
+		return -DER_INVAL;
+	}
+
+	return 0;
+}
+
 int
 ds_mgmt_smd_list_devs(Ctl__SmdDevResp *resp)
 {
 	struct bio_dev_info		*dev_info = NULL, *tmp;
 	struct bio_list_devs_info	 list_devs_info = { 0 };
-	struct bio_led_manage_info	 led_info = { 0 };
-	Ctl__LedState		 led_state;
-	int				 buflen;
+	struct bio_led_manage_info       led_info       = {0};
+	Ctl__LedState                    led_state;
 	int				 rc = 0;
 	int				 i = 0, j;
 
@@ -332,10 +358,8 @@ ds_mgmt_smd_list_devs(Ctl__SmdDevResp *resp)
 		 * code mistakenly free the "empty string", let's reset them as
 		 * NULL.
 		 */
-		resp->devices[i]->uuid = NULL;
-		resp->devices[i]->tr_addr = NULL;
+		resp->devices[i]->uuid    = NULL;
 		resp->devices[i]->tgt_ids = NULL;
-		resp->devices[i]->led_state = CTL__LED_STATE__NA;
 
 		D_ALLOC(resp->devices[i]->uuid, DAOS_UUID_STR_SIZE);
 		if (resp->devices[i]->uuid == NULL) {
@@ -344,30 +368,113 @@ ds_mgmt_smd_list_devs(Ctl__SmdDevResp *resp)
 		}
 		uuid_unparse_lower(dev_info->bdi_dev_id, resp->devices[i]->uuid);
 
-		if (dev_info->bdi_traddr != NULL) {
-			buflen = strlen(dev_info->bdi_traddr) + 1;
-			D_ALLOC(resp->devices[i]->tr_addr, buflen);
-			if (resp->devices[i]->tr_addr == NULL) {
-				rc = -DER_NOMEM;
-				break;
-			}
-			/* Transport Addr -> Blobstore UUID mapping */
-			strncpy(resp->devices[i]->tr_addr, dev_info->bdi_traddr, buflen);
+		resp->devices[i]->role_bits = dev_info->bdi_dev_roles;
+
+		resp->devices[i]->n_tgt_ids = dev_info->bdi_tgt_cnt;
+		D_ALLOC(resp->devices[i]->tgt_ids, sizeof(int) * dev_info->bdi_tgt_cnt);
+		if (resp->devices[i]->tgt_ids == NULL) {
+			rc = -DER_NOMEM;
+			break;
+		}
+		for (j = 0; j < dev_info->bdi_tgt_cnt; j++)
+			resp->devices[i]->tgt_ids[j] = dev_info->bdi_tgts[j];
+
+		/* Populate NVMe controller details */
+
+		if (dev_info->bdi_ctrlr == NULL) {
+			D_ERROR("ctrlr not initialized in bio_dev_info");
+			rc = -DER_INVAL;
+			break;
+		}
+
+		D_ALLOC_PTR(resp->devices[i]->ctrlr);
+		if (resp->devices[i]->ctrlr == NULL) {
+			rc = -DER_NOMEM;
+			break;
+		}
+		ctl__nvme_controller__init(resp->devices[i]->ctrlr);
+
+		rc = copy_str2ctrlr(&resp->devices[i]->ctrlr->pci_addr, dev_info->bdi_traddr);
+		if (rc != 0) {
+			break;
+		}
+		rc = copy_str2ctrlr(&resp->devices[i]->ctrlr->model, dev_info->bdi_ctrlr->model);
+		if (rc != 0) {
+			break;
+		}
+		rc = copy_str2ctrlr(&resp->devices[i]->ctrlr->serial, dev_info->bdi_ctrlr->serial);
+		if (rc != 0) {
+			break;
 		}
+		rc = copy_str2ctrlr(&resp->devices[i]->ctrlr->fw_rev, dev_info->bdi_ctrlr->fw_rev);
+		if (rc != 0) {
+			break;
+		}
+		rc = copy_str2ctrlr(&resp->devices[i]->ctrlr->vendor_id,
+				    dev_info->bdi_ctrlr->vendor_id);
+		if (rc != 0) {
+			break;
+		}
+		rc = copy_str2ctrlr(&resp->devices[i]->ctrlr->pci_dev_type,
+				    dev_info->bdi_ctrlr->pci_type);
+		if (rc != 0) {
+			break;
+		}
+		resp->devices[i]->ctrlr->socket_id = dev_info->bdi_ctrlr->socket_id;
+
+		D_DEBUG(DB_MGMT, "ctrlr details: '%s' '%s' '%s' '%s' '%s' '%s' '%d'\n",
+			resp->devices[i]->ctrlr->pci_addr, resp->devices[i]->ctrlr->model,
+			resp->devices[i]->ctrlr->serial, resp->devices[i]->ctrlr->fw_rev,
+			resp->devices[i]->ctrlr->vendor_id, resp->devices[i]->ctrlr->pci_dev_type,
+			resp->devices[i]->ctrlr->socket_id);
+
+		/* Populate NVMe namespace id and capacity */
+
+		if (dev_info->bdi_ctrlr->nss == NULL) {
+			D_ERROR("nss not initialized in bio_dev_info");
+			rc = -DER_INVAL;
+			break;
+		}
+		D_ASSERT(dev_info->bdi_ctrlr->nss->next == NULL);
+
+		/* When describing a SMD, only one NVMe namespace is relevant */
+		D_ALLOC_ARRAY(resp->devices[i]->ctrlr->namespaces, 1);
+		if (resp->devices[i]->ctrlr->namespaces == NULL) {
+			rc = -DER_NOMEM;
+			break;
+		}
+		D_ALLOC_PTR(resp->devices[i]->ctrlr->namespaces[0]);
+		if (resp->devices[i]->ctrlr->namespaces[0] == NULL) {
+			rc = -DER_NOMEM;
+			break;
+		}
+		resp->devices[i]->ctrlr->n_namespaces = 1;
+		ctl__nvme_controller__namespace__init(resp->devices[i]->ctrlr->namespaces[0]);
+
+		resp->devices[i]->ctrlr->namespaces[0]->id   = dev_info->bdi_ctrlr->nss->id;
+		resp->devices[i]->ctrlr->namespaces[0]->size = dev_info->bdi_ctrlr->nss->size;
+
+		D_DEBUG(DB_MGMT, "ns id/size: '%d' '%ld'\n",
+			resp->devices[i]->ctrlr->namespaces[0]->id,
+			resp->devices[i]->ctrlr->namespaces[0]->size);
+
+		/* Populate NVMe device state */
 
 		if ((dev_info->bdi_flags & NVME_DEV_FL_PLUGGED) == 0) {
-			resp->devices[i]->dev_state = CTL__NVME_DEV_STATE__UNPLUGGED;
-			goto skip_dev;
+			resp->devices[i]->ctrlr->dev_state = CTL__NVME_DEV_STATE__UNPLUGGED;
+			goto next_dev;
 		}
 
 		if ((dev_info->bdi_flags & NVME_DEV_FL_FAULTY) != 0)
-			resp->devices[i]->dev_state = CTL__NVME_DEV_STATE__EVICTED;
+			resp->devices[i]->ctrlr->dev_state = CTL__NVME_DEV_STATE__EVICTED;
 		else if ((dev_info->bdi_flags & NVME_DEV_FL_INUSE) == 0)
-			resp->devices[i]->dev_state = CTL__NVME_DEV_STATE__NEW;
+			resp->devices[i]->ctrlr->dev_state = CTL__NVME_DEV_STATE__NEW;
 		else
-			resp->devices[i]->dev_state = CTL__NVME_DEV_STATE__NORMAL;
+			resp->devices[i]->ctrlr->dev_state = CTL__NVME_DEV_STATE__NORMAL;
 
-		resp->devices[i]->role_bits = dev_info->bdi_dev_roles;
+		if (strncmp(dev_info->bdi_ctrlr->pci_type, NVME_PCI_DEV_TYPE_VMD,
+			    strlen(NVME_PCI_DEV_TYPE_VMD)) != 0)
+			goto next_dev;
 
 		/* Fetch LED State if device is plugged */
 		uuid_copy(led_info.dev_uuid, dev_info->bdi_dev_id);
@@ -387,17 +494,9 @@ ds_mgmt_smd_list_devs(Ctl__SmdDevResp *resp)
 				break;
 			}
 		}
-		resp->devices[i]->led_state = led_state;
+		resp->devices[i]->ctrlr->led_state = led_state;
 
-		resp->devices[i]->n_tgt_ids = dev_info->bdi_tgt_cnt;
-		D_ALLOC(resp->devices[i]->tgt_ids, sizeof(int) * dev_info->bdi_tgt_cnt);
-		if (resp->devices[i]->tgt_ids == NULL) {
-			rc = -DER_NOMEM;
-			break;
-		}
-		for (j = 0; j < dev_info->bdi_tgt_cnt; j++)
-			resp->devices[i]->tgt_ids[j] = dev_info->bdi_tgts[j];
-skip_dev:
+next_dev:
 		d_list_del(&dev_info->bdi_link);
 		/* Frees sdi_tgts and dev_info */
 		bio_free_dev_info(dev_info);
@@ -414,12 +513,7 @@ ds_mgmt_smd_list_devs(Ctl__SmdDevResp *resp)
 		}
 		for (; i >= 0; i--) {
 			if (resp->devices[i] != NULL) {
-				if (resp->devices[i]->uuid != NULL)
-					D_FREE(resp->devices[i]->uuid);
-				if (resp->devices[i]->tgt_ids != NULL)
-					D_FREE(resp->devices[i]->tgt_ids);
-				if (resp->devices[i]->tr_addr != NULL)
-					D_FREE(resp->devices[i]->tr_addr);
+				ds_mgmt_smd_free_dev(resp->devices[i]);
 				D_FREE(resp->devices[i]);
 			}
 		}
@@ -615,7 +709,7 @@ ds_mgmt_dev_set_faulty(uuid_t dev_uuid, Ctl__DevManageResp *resp)
 	}
 	ctl__smd_device__init(resp->device);
 	resp->device->uuid = NULL;
-	resp->device->dev_state = CTL__NVME_DEV_STATE__EVICTED;
+	// resp->device->dev_state = CTL__NVME_DEV_STATE__EVICTED;
 
 	D_ALLOC(resp->device->uuid, DAOS_UUID_STR_SIZE);
 	if (resp->device->uuid == NULL) {
@@ -643,7 +737,7 @@ ds_mgmt_dev_set_faulty(uuid_t dev_uuid, Ctl__DevManageResp *resp)
 			goto out;
 		}
 	}
-	resp->device->led_state = led_state;
+	// resp->device->led_state = led_state;
 
 out:
 	smd_dev_free_info(dev_info);
@@ -666,21 +760,22 @@ ds_mgmt_dev_manage_led(Ctl__LedManageReq *req, Ctl__DevManageResp *resp)
 	}
 	ctl__smd_device__init(resp->device);
 	resp->device->uuid = NULL;
-	resp->device->tr_addr = NULL;
+	// resp->device->tr_addr = NULL;
 
-	D_ALLOC(resp->device->tr_addr, ADDR_STR_MAX_LEN + 1);
-	if (resp->device->tr_addr == NULL)
-		return -DER_NOMEM;
+	//	D_ALLOC(resp->device->tr_addr, ADDR_STR_MAX_LEN + 1);
+	//	if (resp->device->tr_addr == NULL)
+	//		return -DER_NOMEM;
 
-	if (((req->ids) == NULL) || (strlen(req->ids) == 0)) {
-		D_ERROR("Transport address not provided in request\n");
-		return -DER_INVAL;
-	}
+	//	if (((req->ids) == NULL) || (strlen(req->ids) == 0)) {
+	//		D_ERROR("Transport address not provided in request\n");
+	//		return -DER_INVAL;
+	//	}
 
-	strncpy(resp->device->tr_addr, req->ids, ADDR_STR_MAX_LEN + 1);
+	//	strncpy(resp->device->tr_addr, req->ids, ADDR_STR_MAX_LEN + 1);
 
 	/* tr_addr will be used if set and get populated if not */
-	led_info.tr_addr = resp->device->tr_addr;
+	//	led_info.tr_addr = resp->device->tr_addr;
+	led_info.tr_addr  = req->ids;
 	led_info.action = req->led_action;
 	led_state = req->led_state;
 	led_info.state = &led_state;
@@ -691,12 +786,12 @@ ds_mgmt_dev_manage_led(Ctl__LedManageReq *req, Ctl__DevManageResp *resp)
 			     init_xs_type(), 0, 0);
 	if (rc != 0) {
 		if (rc == -DER_NOSYS) {
-			resp->device->led_state = CTL__LED_STATE__NA;
+			// resp->device->led_state = CTL__LED_STATE__NA;
 			/* Reset rc for non-VMD case */
 			rc = 0;
 		}
-	} else {
-		resp->device->led_state = (Ctl__LedState)led_state;
+		//	} else {
+		//		resp->device->led_state = (Ctl__LedState)led_state;
 	}
 
 	return rc;
@@ -762,12 +857,12 @@ ds_mgmt_dev_replace(uuid_t old_dev_uuid, uuid_t new_dev_uuid, Ctl__DevManageResp
 	if (rc != 0) {
 		DL_ERROR(rc, "ULT did not complete storage_dev_replace");
 		/* BIO device state after unsuccessful reintegration */
-		resp->device->dev_state = CTL__NVME_DEV_STATE__EVICTED;
+		// resp->device->dev_state = CTL__NVME_DEV_STATE__EVICTED;
 		goto out;
 	}
 
 	/* BIO device state after successful reintegration */
-	resp->device->dev_state = CTL__NVME_DEV_STATE__NORMAL;
+	// resp->device->dev_state = CTL__NVME_DEV_STATE__NORMAL;
 out:
 	if (rc != 0) {
 		if (resp->device->uuid != NULL)
diff --git a/src/proto/ctl/firmware.proto b/src/proto/ctl/firmware.proto
index 50bbd8de058..c1b8de4e56b 100644
--- a/src/proto/ctl/firmware.proto
+++ b/src/proto/ctl/firmware.proto
@@ -10,7 +10,7 @@ package ctl;
 option go_package = "github.com/daos-stack/daos/src/control/common/proto/ctl";
 
 import "ctl/storage_scm.proto";
-import "ctl/storage_nvme.proto";
+import "ctl/smd.proto";
 
 message FirmwareQueryReq {
 	bool queryScm = 1; // Should we query SCM devices?
diff --git a/src/proto/ctl/smd.proto b/src/proto/ctl/smd.proto
index e8616fc166f..18b90798f41 100644
--- a/src/proto/ctl/smd.proto
+++ b/src/proto/ctl/smd.proto
@@ -91,14 +91,35 @@ enum LedState {
 	NA = 4;			// Equivalent to SPDK_VMD_LED_STATE_UNKNOWN	(VMD not enabled)
 }
 
+// NvmeController represents an NVMe Controller (SSD).
+message NvmeController {
+	// Namespace represents a namespace created on an NvmeController.
+	message Namespace {
+		uint32 id = 1;			// namespace id
+		uint64 size = 2;		// device capacity in bytes
+		string ctrlr_pci_addr = 3;	// parent controller PCI address
+	}
+
+	string model = 1;			// model name
+	string serial = 2;			// serial number
+	string pci_addr = 3;			// pci address
+	string fw_rev = 4;			// firmware revision
+	int32 socket_id = 5;			// NUMA socket ID
+	BioHealthResp health_stats = 6;		// controller's health stats
+	repeated Namespace namespaces = 7;	// controller's namespaces
+	repeated SmdDevice smd_devices = 8;     // controller's blobstores
+	NvmeDevState dev_state = 9;		// NVMe device operational state
+	LedState led_state = 10;		// NVMe device LED state
+	string pci_dev_type = 11;		// PCI device type, vmd or pci
+	string vendor_id = 12;			// controller's vendor ID
+}
+
 // SmdDevice represents a DAOS BIO device, identified by a UUID written into a label stored on a
 // SPDK blobstore created on a NVMe namespace. Multiple SmdDevices may exist per NVMe controller.
 message SmdDevice {
+	reserved 3,4,5;
 	string uuid = 1;		// UUID of blobstore
 	repeated int32 tgt_ids = 2;	// VOS target IDs
-	string tr_addr = 3;		// Transport address of blobstore
-	NvmeDevState dev_state = 4;	// NVMe device state
-	LedState led_state = 5;		// LED state
 	uint64 total_bytes = 6;		// blobstore clusters total bytes
 	uint64 avail_bytes = 7;		// Available RAW storage for data
 	uint64 cluster_size = 8;	// blobstore cluster size in bytes
@@ -109,6 +130,8 @@ message SmdDevice {
 	uint64 rdb_size = 13;		// Size of the RDB blob
 	uint64 rdb_wal_size = 14;	// Size of the RDB WAL blob
 	uint64 usable_bytes = 15;	// Effective storage available for data
+	NvmeController ctrlr = 16;	// Backing NVMe controller of SMD device
+	uint32 ctrlr_namespace_id = 17;	// NVMe namespace id hosting SMD blobstore
 }
 
 message SmdDevReq {}
@@ -139,10 +162,6 @@ message SmdQueryReq {
 }
 
 message SmdQueryResp {
-	message SmdDeviceWithHealth {
-		SmdDevice details = 1;
-		BioHealthResp health = 2; // optional BIO health
-	}
 	message Pool {
 		string uuid = 1; // UUID of VOS pool
 		repeated int32 tgt_ids = 2; // VOS target IDs
@@ -150,7 +169,7 @@ message SmdQueryResp {
 	}
 	message RankResp {
 		uint32 rank = 1; // rank to which this response corresponds
-		repeated SmdDeviceWithHealth devices = 2; // List of devices on the rank
+		repeated SmdDevice devices = 2; // List of devices on the rank
 		repeated Pool pools = 3; // List of pools on the rank
 	}
 	int32 status = 1; // DAOS error code
diff --git a/src/proto/ctl/storage_nvme.proto b/src/proto/ctl/storage_nvme.proto
index 6cc88a5c21b..edafa4e42ba 100644
--- a/src/proto/ctl/storage_nvme.proto
+++ b/src/proto/ctl/storage_nvme.proto
@@ -1,5 +1,5 @@
 //
-// (C) Copyright 2019-2022 Intel Corporation.
+// (C) Copyright 2019-2023 Intel Corporation.
 //
 // SPDX-License-Identifier: BSD-2-Clause-Patent
 //
@@ -15,25 +15,6 @@ import "ctl/smd.proto";
 // NVMe Storage Protobuf Definitions related to interactions between
 // DAOS control server and locally attached storage.
 
-// NvmeController represents an NVMe Controller (SSD).
-message NvmeController {
-	// Namespace represents a namespace created on an NvmeController.
-	message Namespace {
-		uint32 id = 1;			// namespace id
-		uint64 size = 2;		// device capacity in bytes
-		string ctrlr_pci_addr = 3;	// parent controller PCI address
-	}
-
-	string model = 1;			// model name
-	string serial = 2;			// serial number
-	string pci_addr = 3;			// pci address
-	string fw_rev = 4;			// firmware revision
-	int32 socket_id = 5;			// NUMA socket ID
-	BioHealthResp health_stats = 6;		// controller's health stats
-	repeated Namespace namespaces = 7;	// controller's namespaces
-	repeated SmdDevice smd_devices = 8;	// controller's blobstores
-}
-
 // NvmeControllerResult represents state of operation performed on controller.
 message NvmeControllerResult {
 	string pci_addr = 1;		// PCI address of NVMe controller