libnvme/common/libnvme_ctrl_info.c

/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2024 Oxide Computer Company
 */

/*
 * This file implements the logic behind the NVMe controller information
 * interface.
 *
 * The idea behind controller information is to gather all of the information
 * related to controller information in one structure that can then be
 * interrogated. This data should have its own lifetime and represents a point
 * in time snapshot. This then allows this information to be saved and restored
 * across systems.
 */

#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <sys/sysmacros.h>

#include "libnvme_impl.h"

bool
nvme_info_error(nvme_ctrl_info_t *ci, nvme_info_err_t err, int32_t sys,
    const char *fmt, ...)
{
	int ret;
	va_list ap;

	ci->nci_err = err;
	ci->nci_syserr = sys;
	va_start(ap, fmt);
	ret = vsnprintf(ci->nci_errmsg, sizeof (ci->nci_errmsg), fmt, ap);
	va_end(ap);
	if (ret >= sizeof (ci->nci_errmsg)) {
		ci->nci_errlen = sizeof (ci->nci_errmsg) - 1;
	} else if (ret <= 0) {
		ci->nci_errlen = 0;
		ci->nci_errmsg[0] = '\0';
	} else {
		ci->nci_errlen = (size_t)ret;
	}

	return (false);
}

bool
nvme_info_success(nvme_ctrl_info_t *ci)
{
	ci->nci_err = NVME_INFO_ERR_OK;
	ci->nci_syserr = 0;
	ci->nci_errmsg[0] = '\0';
	ci->nci_errlen = 0;

	return (true);
}

nvme_info_err_t
nvme_ctrl_info_err(nvme_ctrl_info_t *ci)
{
	return (ci->nci_err);
}

int32_t
nvme_ctrl_info_syserr(nvme_ctrl_info_t *ci)
{
	return (ci->nci_syserr);
}

const char *
nvme_ctrl_info_errmsg(nvme_ctrl_info_t *ci)
{
	return (ci->nci_errmsg);
}

size_t
nvme_ctrl_info_errlen(nvme_ctrl_info_t *ci)
{
	return (ci->nci_errlen);
}

/*
 * These errors are shared with the nvme_ns_info_t structures. While they both
 * allow for us to pass in their respective information objects, that's mostly
 * for future API changes. The namespace information variant of this just calls
 * this function with the control information set to NULL.
 */
const char *
nvme_ctrl_info_errtostr(nvme_ctrl_info_t *ci, nvme_info_err_t err)
{
	switch (err) {
	case NVME_INFO_ERR_OK:
		return ("NVME_INFO_ERR_OK");
	case NVME_INFO_ERR_TRANSPORT:
		return ("NVME_INFO_ERR_TRANSPORT");
	case NVME_INFO_ERR_VERSION:
		return ("NVME_INFO_ERR_VERSION");
	case NVME_INFO_ERR_MISSING_CAP:
		return ("NVME_INFO_ERR_MISSING_CAP");
	case NVME_INFO_ERR_BAD_LBA_FMT:
		return ("NVME_INFO_ERR_BAD_LBA_FMT");
	case NVME_INFO_ERR_PERSIST_NVL:
		return ("NVME_INFO_ERR_PERSIST_NVL");
	case NVME_INFO_ERR_BAD_FMT:
		return ("NVME_INFO_ERR_BAD_FMT");
	case NVME_INFO_ERR_BAD_FMT_DATA:
		return ("NVME_INFO_ERR_BAD_FMT_DATA");
	case NVME_INFO_ERR_NS_INACTIVE:
		return ("NVME_INFO_ERR_NS_INACTIVE");
	case NVME_INFO_ERR_NS_NO_BLKDEV:
		return ("NVME_INFO_ERR_NS_NO_BLKDEV");
	default:
		return ("unknown error");
	}
}

void
nvme_ctrl_info_free(nvme_ctrl_info_t *ci)
{
	free(ci);
}

/*
 * The caller is required to ensure that out is at least max_src + 1 bytes long.
 */
static void
nvme_ctrl_info_init_ident_str(const char *src, size_t max_src,
    char *out)
{
	while (max_src > 0 && src[max_src - 1] == ' ') {
		max_src--;
	}

	if (max_src == 0) {
		*out = '\0';
		return;
	}

	(void) memcpy(out, src, max_src);
	out[max_src] = '\0';
}

static void
nvme_ctrl_info_init_ident(nvme_ctrl_info_t *ci)
{
	nvme_ctrl_info_init_ident_str(ci->nci_info.id_serial,
	    sizeof (ci->nci_info.id_serial), ci->nci_serial);
	nvme_ctrl_info_init_ident_str(ci->nci_info.id_model,
	    sizeof (ci->nci_info.id_model), ci->nci_model);
	nvme_ctrl_info_init_ident_str(ci->nci_info.id_fwrev,
	    sizeof (ci->nci_info.id_fwrev), ci->nci_fwrev);
}

bool
nvme_ctrl_info_restore(nvme_t *nvme, nvlist_t *nvl, nvme_ctrl_info_t **outp)
{
	int ret;
	uint32_t vers;
	nvme_ctrl_info_t *ci;
	char *path;
	uchar_t *ctrl, *ns;
	uint_t ctrl_len, ns_len;

	if (nvl == NULL) {
		return (nvme_error(nvme, NVME_ERR_BAD_PTR, 0, "encountered "
		    "invalid nvlist_t input pointer: %p", nvl));
	}

	if (outp == NULL) {
		return (nvme_error(nvme, NVME_ERR_BAD_PTR, 0, "encountered "
		    "invalid nvme_ctrl_info_t output pointer: %p", outp));
	}
	*outp = NULL;

	ci = calloc(1, sizeof (nvme_ctrl_info_t));
	if (ci == NULL) {
		int e = errno;
		return (nvme_error(nvme, NVME_ERR_NO_MEM, e, "failed to "
		    "allocate memory for a new nvme_ctrl_info: %s",
		    strerror(e)));
	}

	if ((ret = nvlist_lookup_uint32(nvl, NVME_NVL_CI_VERS, &vers)) != 0) {
		(void) nvme_error(nvme, NVME_ERR_BAD_RESTORE, ret, "failed "
		    "to get version key: %s", strerror(ret));
		goto err;
	}

	if (vers != NVME_NVL_CI_VERS_0) {
		(void) nvme_error(nvme, NVME_ERR_BAD_RESTORE, 0,
		    "found unsupported version key: 0x%x", vers);
		goto err;
	}

	ret = nvlist_lookup_pairs(nvl, 0,
	    NVME_NVL_CI_MAJOR, DATA_TYPE_UINT16, &ci->nci_vers.v_major,
	    NVME_NVL_CI_MINOR, DATA_TYPE_UINT16, &ci->nci_vers.v_minor,
	    NVME_NVL_CI_INST, DATA_TYPE_INT32, &ci->nci_inst,
	    NVME_NVL_CI_DEV_PATH, DATA_TYPE_STRING, &path,
	    NVME_NVL_CI_ID_CTRL, DATA_TYPE_BYTE_ARRAY, &ctrl, &ctrl_len,
	    NVME_NVL_CI_ID_NS, DATA_TYPE_BYTE_ARRAY, &ns, &ns_len,
	    NVME_NVL_CI_TPORT, DATA_TYPE_UINT32, &ci->nci_tport, NULL);
	if (ret != 0) {
		(void) nvme_error(nvme, NVME_ERR_BAD_RESTORE, ret,
		    "failed to retrieve required keys: %s", strerror(ret));
		goto err;
	}

	if (ci->nci_inst < 0) {
		(void) nvme_error(nvme, NVME_ERR_BAD_RESTORE, 0,
		    "instance data is negative");
		goto err;
	}

	if (ctrl_len != sizeof (ci->nci_info)) {
		(void) nvme_error(nvme, NVME_ERR_BAD_RESTORE, 0, "identify "
		    "controller information is the wrong length, expected "
		    "0x%zx bytes, found 0x%x", sizeof (ci->nci_info), ctrl_len);
		goto err;
	}

	if (ns_len != sizeof (ci->nci_ns)) {
		(void) nvme_error(nvme, NVME_ERR_BAD_RESTORE, 0, "identify "
		    "namespace information is the wrong length, expected "
		    "0x%zx bytes, found 0x%x", sizeof (ci->nci_info), ctrl_len);
		goto err;
	}

	(void) memcpy(&ci->nci_info, ctrl, ctrl_len);
	(void) memcpy(&ci->nci_ns, ns, ns_len);

	if (strlcpy(ci->nci_dev_path, path, sizeof (ci->nci_dev_path)) >=
	    sizeof (ci->nci_dev_path)) {
		(void) nvme_error(nvme, NVME_ERR_BAD_RESTORE, 0, "device "
		    "path would have overflowed");
		goto err;
	}

	if (ci->nci_tport != NVME_CTRL_TRANSPORT_PCI) {
		(void) nvme_error(nvme, NVME_ERR_BAD_RESTORE, 0, "found "
		    "unknown transport type: 0x%x", ci->nci_tport);
		goto err;
	}

	ret = nvlist_lookup_pairs(nvl, 0,
	    NVME_NVL_CI_PCI_VID, DATA_TYPE_UINT16, &ci->nci_vid,
	    NVME_NVL_CI_PCI_DID, DATA_TYPE_UINT16, &ci->nci_did,
	    NVME_NVL_CI_PCI_SUBVID, DATA_TYPE_UINT16, &ci->nci_subvid,
	    NVME_NVL_CI_PCI_SUBSYS, DATA_TYPE_UINT16, &ci->nci_subsys,
	    NVME_NVL_CI_PCI_REV, DATA_TYPE_UINT8, &ci->nci_rev,
	    NVME_NVL_CI_PCI_MPSMIN, DATA_TYPE_UINT32, &ci->nci_mps_min,
	    NVME_NVL_CI_PCI_MPSMAX, DATA_TYPE_UINT32, &ci->nci_mps_max,
	    NVME_NVL_CI_PCI_NINTRS, DATA_TYPE_UINT32, &ci->nci_nintrs, NULL);
	if (ret != 0) {
		(void) nvme_error(nvme, NVME_ERR_BAD_RESTORE, ret,
		    "failed to retrieve required PCI-specific keys: %s",
		    strerror(ret));
		goto err;
	}

	nvme_ctrl_info_init_ident(ci);
	*outp = ci;
	return (true);

err:
	nvme_ctrl_info_free(ci);
	return (false);
}

bool
nvme_ctrl_info_persist(nvme_ctrl_info_t *ci, nvlist_t **nvlp)
{
	int ret;
	nvlist_t *nvl;

	if ((ret = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0)) != 0) {
		return (nvme_info_error(ci, NVME_INFO_ERR_PERSIST_NVL,
		    ret, "failed to create initial nvlist_t *: %s",
		    strerror(ret)));
	}

	if ((ret = nvlist_add_uint32(nvl, NVME_NVL_CI_VERS,
	    NVME_NVL_CI_VERS_0)) != 0) {
		return (nvme_info_error(ci, NVME_INFO_ERR_PERSIST_NVL, ret,
		    "failed to persist %s to nvlist: %s", NVME_NVL_CI_VERS,
		    strerror(ret)));
	}

	if ((ret = nvlist_add_int32(nvl, NVME_NVL_CI_INST, ci->nci_inst)) !=
	    0) {
		return (nvme_info_error(ci, NVME_INFO_ERR_PERSIST_NVL, ret,
		    "failed to persist %s to nvlist: %s", NVME_NVL_CI_INST,
		    strerror(ret)));
	}

	if ((ret = nvlist_add_uint16(nvl, NVME_NVL_CI_MAJOR,
	    ci->nci_vers.v_major)) != 0 ||
	    (ret = nvlist_add_uint16(nvl, NVME_NVL_CI_MINOR,
	    ci->nci_vers.v_minor)) != 0) {
		return (nvme_info_error(ci, NVME_INFO_ERR_PERSIST_NVL, ret,
		    "failed to persist version data to nvlist: %s",
		    strerror(ret)));
	}

	if ((ret = nvlist_add_string(nvl, NVME_NVL_CI_DEV_PATH,
	    ci->nci_dev_path)) != 0) {
		return (nvme_info_error(ci, NVME_INFO_ERR_PERSIST_NVL, ret,
		    "failed to persist %s to nvlist: %s", NVME_NVL_CI_DEV_PATH,
		    strerror(ret)));
	}

	if ((ret = nvlist_add_byte_array(nvl, NVME_NVL_CI_ID_CTRL,
	    (void *)&ci->nci_info, sizeof (ci->nci_info))) != 0) {
		return (nvme_info_error(ci, NVME_INFO_ERR_PERSIST_NVL, ret,
		    "failed to persist %s to nvlist: %s", NVME_NVL_CI_ID_CTRL,
		    strerror(ret)));
	}

	if ((ret = nvlist_add_byte_array(nvl, NVME_NVL_CI_ID_NS,
	    (void *)&ci->nci_ns, sizeof (ci->nci_ns))) != 0) {
		return (nvme_info_error(ci, NVME_INFO_ERR_PERSIST_NVL, ret,
		    "failed to persist %s to nvlist: %s", NVME_NVL_CI_ID_NS,
		    strerror(ret)));
	}

	if ((ret = nvlist_add_uint32(nvl, NVME_NVL_CI_TPORT, ci->nci_tport)) !=
	    0) {
		return (nvme_info_error(ci, NVME_INFO_ERR_PERSIST_NVL, ret,
		    "failed to persist %s to nvlist: %s", NVME_NVL_CI_TPORT,
		    strerror(ret)));
	}

	if ((ret = nvlist_add_uint16(nvl, NVME_NVL_CI_PCI_VID,
	    ci->nci_vid)) != 0 ||
	    (ret = nvlist_add_uint16(nvl, NVME_NVL_CI_PCI_DID,
	    ci->nci_did)) != 0 ||
	    (ret = nvlist_add_uint16(nvl, NVME_NVL_CI_PCI_SUBVID,
	    ci->nci_subvid)) != 0 ||
	    (ret = nvlist_add_uint16(nvl, NVME_NVL_CI_PCI_SUBSYS,
	    ci->nci_subsys)) != 0 ||
	    (ret = nvlist_add_uint8(nvl, NVME_NVL_CI_PCI_REV,
	    ci->nci_rev)) != 0 ||
	    (ret = nvlist_add_uint32(nvl, NVME_NVL_CI_PCI_MPSMIN,
	    ci->nci_mps_min)) != 0 ||
	    (ret = nvlist_add_uint32(nvl, NVME_NVL_CI_PCI_MPSMAX,
	    ci->nci_mps_max)) != 0 ||
	    (ret = nvlist_add_uint32(nvl, NVME_NVL_CI_PCI_NINTRS,
	    ci->nci_nintrs)) != 0) {
		return (nvme_info_error(ci, NVME_INFO_ERR_PERSIST_NVL, ret,
		    "failed to persist PCI data to nvlist: %s", strerror(ret)));
	}

	*nvlp = nvl;
	return (true);
}

static bool
nvme_ctrl_get_udi(nvme_ctrl_t *ctrl, di_node_t di, const char *prop,
    uint32_t *outp, uint32_t max)
{
	int *vals, nvals;

	nvals = di_prop_lookup_ints(DDI_DEV_T_ANY, di, prop, &vals);
	if (nvals < 0) {
		int e = errno;
		return (nvme_ctrl_error(ctrl, NVME_ERR_LIBDEVINFO, e, "failed "
		    "to get property %s while constructing controller "
		    "information: %s", prop, strerror(e)));
	} else if (nvals != 1) {
		return (nvme_ctrl_error(ctrl, NVME_ERR_BAD_DEVI_PROP, 0,
		    "found unexpected number of property values for %s while "
		    "constructing controller information, expected 1, found %d",
		    prop, nvals));
	}

	if (vals[0] < 0 || vals[0] > max) {
		return (nvme_ctrl_error(ctrl, NVME_ERR_BAD_DEVI_PROP, 0,
		    "property %s has value 0x%x outside the allowed range "
		    "[0x0, 0x%x]", prop, vals[0], max));
	}

	*outp = (uint32_t)vals[0];
	return (true);
}

bool
nvme_ctrl_info_snap(nvme_ctrl_t *ctrl, nvme_ctrl_info_t **outp)
{
	nvme_ctrl_info_t *ci;
	uint32_t val;
	nvme_ioctl_ctrl_info_t info;

	if (outp == NULL) {
		return (nvme_ctrl_error(ctrl, NVME_ERR_BAD_PTR, 0,
		    "encountered invalid nvme_ctrl_info_t output pointer: %p",
		    outp));
	}
	*outp = NULL;

	ci = calloc(1, sizeof (nvme_ctrl_info_t));
	if (ci == NULL) {
		int e = errno;
		return (nvme_ctrl_error(ctrl, NVME_ERR_NO_MEM, e, "failed to "
		    "allocate memory for a new nvme_ctrl_info: %s",
		    strerror(e)));
	}

	if (!nvme_ctrl_get_udi(ctrl, ctrl->nc_devi, "vendor-id", &val,
	    UINT16_MAX)) {
		goto err;
	}
	ci->nci_vid = (uint16_t)val;

	if (!nvme_ctrl_get_udi(ctrl, ctrl->nc_devi, "device-id", &val,
	    UINT16_MAX)) {
		goto err;
	}
	ci->nci_did = (uint16_t)val;

	/*
	 * The system will not create a subsystem-vendor-id or a subsystem-id if
	 * the subsytem vendor is zero. This should not be a fatal error.
	 * However, if a subsytem-vendor-id is present then we should expect a
	 * subsystem-id.
	 */
	if (nvme_ctrl_get_udi(ctrl, ctrl->nc_devi, "subsystem-vendor-id", &val,
	    UINT16_MAX)) {
		ci->nci_subvid = (uint16_t)val;

		if (!nvme_ctrl_get_udi(ctrl, ctrl->nc_devi, "subsystem-id",
		    &val, UINT16_MAX)) {
			goto err;
		}
	} else {
		ci->nci_subvid = 0;
		ci->nci_subsys = 0;
	}

	if (!nvme_ctrl_get_udi(ctrl, ctrl->nc_devi, "revision-id", &val,
	    UINT8_MAX)) {
		goto err;
	}
	ci->nci_rev = (uint8_t)val;

	/*
	 * As we only support PCI based NVMe devices right now, we simply always
	 * identify everything as PCI based. In the future, this would be
	 * something we'd want to get from either an ioctl or a devinfo
	 * property.
	 */
	ci->nci_tport = NVME_CTRL_TRANSPORT_PCI;

	if (!nvme_ioc_ctrl_info(ctrl, &info)) {
		goto err;
	}

	ci->nci_vers = info.nci_vers;
	ci->nci_info = info.nci_ctrl_id;
	ci->nci_ns = info.nci_common_ns;
	ci->nci_mps_min = info.nci_caps.cap_mpsmin;
	ci->nci_mps_max = info.nci_caps.cap_mpsmax;
	ci->nci_nintrs = info.nci_nintrs;

	nvme_ctrl_info_init_ident(ci);
	*outp = ci;
	return (nvme_ctrl_success(ctrl));

err:
	nvme_ctrl_info_free(ci);
	return (false);
}

uint16_t
nvme_ctrl_info_vendor(nvme_ctrl_info_t *ci)
{
	return (ci->nci_info.id_vid);
}

const char *
nvme_ctrl_info_model(nvme_ctrl_info_t *ci)
{
	return (ci->nci_model);
}

const char *
nvme_ctrl_info_serial(nvme_ctrl_info_t *ci)
{
	return (ci->nci_serial);
}

uint32_t
nvme_ctrl_info_fwgran(nvme_ctrl_info_t *ci)
{
	nvme_valid_ctrl_data_t data;

	data.vcd_vers = &ci->nci_vers;
	data.vcd_id = &ci->nci_info;
	return (nvme_fw_load_granularity(&data));
}

const char *
nvme_ctrl_info_fwrev(nvme_ctrl_info_t *ci)
{
	return (ci->nci_fwrev);
}

const nvme_identify_ctrl_t *
nvme_ctrl_info_identify(nvme_ctrl_info_t *ci)
{
	return (&ci->nci_info);
}

const nvme_version_t *
nvme_ctrl_info_version(nvme_ctrl_info_t *ci)
{
	return (&ci->nci_vers);
}

nvme_ctrl_transport_t
nvme_ctrl_info_transport(nvme_ctrl_info_t *ci)
{
	return (ci->nci_tport);
}

nvme_ctrl_type_t
nvme_ctrl_info_type(nvme_ctrl_info_t *ci)
{
	if (nvme_vers_ctrl_info_atleast(ci, &nvme_vers_1v4)) {
		switch (ci->nci_info.id_cntrltype) {
		case NVME_CNTRLTYPE_IO:
			return (NVME_CTRL_TYPE_IO);
		case NVME_CNTRLTYPE_DISC:
			return (NVME_CTRL_TYPE_DISCOVERY);
		case NVME_CNTRLTYPE_ADMIN:
			return (NVME_CTRL_TYPE_ADMIN);
		default:
			return (NVME_CTRL_TYPE_UNKNOWN);
		}
	} else {
		return (NVME_CTRL_TYPE_IO);
	}
}

static bool
nvme_ctrl_info_pci_tport(nvme_ctrl_info_t *ci)
{
	if (ci->nci_tport != NVME_CTRL_TRANSPORT_PCI) {
		return (nvme_info_error(ci, NVME_INFO_ERR_TRANSPORT, 0,
		    "cannot get PCI data from device with type %s (0x%x)",
		    nvme_tporttostr(ci->nci_tport), ci->nci_tport));
	}

	return (true);
}

bool
nvme_ctrl_info_pci_vid(nvme_ctrl_info_t *ci, uint16_t *u16p)
{
	if (!nvme_ctrl_info_pci_tport(ci))
		return (false);

	*u16p = ci->nci_vid;
	return (nvme_info_success(ci));
}

bool
nvme_ctrl_info_pci_did(nvme_ctrl_info_t *ci, uint16_t *u16p)
{
	if (!nvme_ctrl_info_pci_tport(ci))
		return (false);

	*u16p = ci->nci_did;
	return (nvme_info_success(ci));
}

bool
nvme_ctrl_info_pci_subvid(nvme_ctrl_info_t *ci, uint16_t *u16p)
{
	if (!nvme_ctrl_info_pci_tport(ci))
		return (false);

	*u16p = ci->nci_subvid;
	return (nvme_info_success(ci));
}

bool
nvme_ctrl_info_pci_subsys(nvme_ctrl_info_t *ci, uint16_t *u16p)
{
	if (!nvme_ctrl_info_pci_tport(ci))
		return (false);

	*u16p = ci->nci_subsys;
	return (nvme_info_success(ci));
}

bool
nvme_ctrl_info_pci_rev(nvme_ctrl_info_t *ci, uint8_t *u8p)
{
	if (!nvme_ctrl_info_pci_tport(ci))
		return (false);

	*u8p = ci->nci_rev;
	return (nvme_info_success(ci));
}

bool
nvme_ctrl_info_pci_mps_min(nvme_ctrl_info_t *ci, uint32_t *u32p)
{
	if (!nvme_ctrl_info_pci_tport(ci))
		return (false);

	*u32p = ci->nci_mps_min;
	return (nvme_info_success(ci));
}

bool
nvme_ctrl_info_pci_mps_max(nvme_ctrl_info_t *ci, uint32_t *u32p)
{
	if (!nvme_ctrl_info_pci_tport(ci))
		return (false);

	*u32p = ci->nci_mps_max;
	return (nvme_info_success(ci));
}

bool
nvme_ctrl_info_pci_nintrs(nvme_ctrl_info_t *ci, uint32_t *u32p)
{
	if (!nvme_ctrl_info_pci_tport(ci))
		return (false);

	*u32p = ci->nci_nintrs;
	return (nvme_info_success(ci));
}

static bool
nvme_ctrl_info_nsmgmt(nvme_ctrl_info_t *ci)
{
	if (!nvme_vers_ctrl_info_atleast(ci, &nvme_vers_1v2)) {
		return (nvme_info_error(ci, NVME_INFO_ERR_VERSION, 0,
		    "cannot provide information, device must be at least "
		    "version 1.2, but is %u.%u", ci->nci_vers.v_major,
		    ci->nci_vers.v_minor));
	}

	if (ci->nci_info.id_oacs.oa_nsmgmt == 0) {
		return (nvme_info_error(ci, NVME_INFO_ERR_MISSING_CAP, 0,
		    "cannot provide information, device does not support "
		    "namespace management"));

	}

	return (true);
}

bool
nvme_ctrl_info_cap(nvme_ctrl_info_t *ci, nvme_uint128_t *u128p)
{
	if (!nvme_ctrl_info_nsmgmt(ci)) {
		return (false);
	}

	(void) memcpy(u128p, &ci->nci_info.ap_tnvmcap, sizeof (nvme_uint128_t));
	return (nvme_info_success(ci));
}

bool
nvme_ctrl_info_unalloc_cap(nvme_ctrl_info_t *ci, nvme_uint128_t *u128p)
{
	if (!nvme_ctrl_info_nsmgmt(ci)) {
		return (false);
	}

	(void) memcpy(u128p, &ci->nci_info.ap_unvmcap, sizeof (nvme_uint128_t));
	return (nvme_info_success(ci));
}

bool
nvme_ctrl_info_common_ns(nvme_ctrl_info_t *ci, const nvme_identify_nsid_t **idp)
{
	if (!nvme_ctrl_info_nsmgmt(ci)) {
		return (false);
	}

	*idp = &ci->nci_ns;
	return (nvme_info_success(ci));
}

uint32_t
nvme_ctrl_info_nformats(nvme_ctrl_info_t *ci)
{
	return (MIN(ci->nci_ns.id_nlbaf + 1, NVME_MAX_LBAF));
}

uint32_t
nvme_ctrl_info_nns(nvme_ctrl_info_t *ci)
{
	return (ci->nci_info.id_nn);
}

bool
nvme_ctrl_info_format(nvme_ctrl_info_t *ci, uint32_t idx,
    const nvme_nvm_lba_fmt_t **outp)
{
	const uint32_t max = nvme_ctrl_info_nformats(ci);
	if (idx >= max) {
		return (nvme_info_error(ci, NVME_INFO_ERR_BAD_FMT, 0,
		    "requested index %u is invalid: valid range is [0, %u]",
		    idx, max - 1));
	}

	if (!ci->nci_lbaf_valid[idx]) {
		uint8_t lbads = ci->nci_ns.id_lbaf[idx].lbaf_lbads;

		if (lbads == 0) {
			return (nvme_info_error(ci, NVME_INFO_ERR_BAD_FMT, 0,
			    "format %u is not actually valid due to 0 LBA "
			    "data size even though it is considered a valid "
			    "LBA format by NLBAF", lbads));
		}

		if (lbads < 9) {
			return (nvme_info_error(ci, NVME_INFO_ERR_BAD_FMT_DATA,
			    0, "NVMe devices are not allowed to have a LBA "
			    "data size of less than 512 bytes, found raw "
			    "shift value of %u for format %u", lbads, idx));
		}

		if (lbads >= 64) {
			return (nvme_info_error(ci, NVME_INFO_ERR_BAD_FMT_DATA,
			    0, "LBA format %u has LBA data size greater "
			    "than 64 (%u), cannot be represented as a byte "
			    "size", idx, lbads));
		}

		ci->nci_lbaf[idx].nnlf_id = idx;
		ci->nci_lbaf[idx].nnlf_ms = ci->nci_ns.id_lbaf[idx].lbaf_ms;
		ci->nci_lbaf[idx].nnlf_lbasz = 1ULL << lbads;
		ci->nci_lbaf[idx].nnlf_rel = ci->nci_ns.id_lbaf[idx].lbaf_rp;
		ci->nci_lbaf_valid[idx] = true;
	}

	*outp = &ci->nci_lbaf[idx];
	return (nvme_info_success(ci));
}

uint32_t
nvme_nvm_lba_fmt_id(const nvme_nvm_lba_fmt_t *lbaf)
{
	return (lbaf->nnlf_id);
}

uint32_t
nvme_nvm_lba_fmt_meta_size(const nvme_nvm_lba_fmt_t *lbaf)
{
	return (lbaf->nnlf_ms);
}

uint64_t
nvme_nvm_lba_fmt_data_size(const nvme_nvm_lba_fmt_t *lbaf)
{
	return (lbaf->nnlf_lbasz);
}

uint32_t
nvme_nvm_lba_fmt_rel_perf(const nvme_nvm_lba_fmt_t *lbaf)
{
	return (lbaf->nnlf_rel);
}