/*
 * 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 implements iterators for the various NVMe identify related features that
 * return lists of information (rather than the basic data structures). These
 * are all phrased as iterators to the user so that way we can abstract around
 * the fact that there may be additional commands required to make this happen
 * or eventually a number of namespaces that exceeds the basic amount supported
 * here.
 */

#include <string.h>
#include <unistd.h>

#include "libnvme_impl.h"

void
nvme_id_req_fini(nvme_id_req_t *idreq)
{
	free(idreq);
}

bool
nvme_id_req_init_by_cns(nvme_ctrl_t *ctrl, nvme_csi_t csi, uint32_t cns,
    nvme_id_req_t **idreqp)
{
	const nvme_identify_info_t *info = NULL;
	nvme_id_req_t *req;
	nvme_valid_ctrl_data_t ctrl_data;

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

	for (size_t i = 0; i < nvme_identify_ncmds; i++) {
		if (nvme_identify_cmds[i].nii_csi == csi &&
		    nvme_identify_cmds[i].nii_cns == cns) {
			info = &nvme_identify_cmds[i];
			break;
		}
	}

	if (info == NULL) {
		return (nvme_ctrl_error(ctrl, NVME_ERR_IDENTIFY_UNKNOWN, 0,
		    "unknown identify command CSI/CNS 0x%x/0x%x", csi, cns));
	}

	ctrl_data.vcd_vers = &ctrl->nc_vers;
	ctrl_data.vcd_id = &ctrl->nc_info;

	if (!nvme_identify_info_supported(info, &ctrl_data)) {
		return (nvme_ctrl_error(ctrl, NVME_ERR_IDENTIFY_UNSUP_BY_DEV, 0,
		    "device does not support identify command %s (CSI/CNS "
		    "0x%x/0x%x)", info->nii_name, info->nii_csi,
		    info->nii_cns));
	}

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

	req->nir_ctrl = ctrl;
	req->nir_info = info;

	/*
	 * The identify command always wants to write a 4 KiB buffer
	 * (NVME_IDENTIFY_BUFSIZE) out and therefore we manually tack this onto
	 * to the need and allow list.
	 */
	req->nir_need = info->nii_fields | (1 << NVME_ID_REQ_F_BUF);
	req->nir_allow = info->nii_fields | (1 << NVME_ID_REQ_F_BUF);

	*idreqp = req;
	return (nvme_ctrl_success(ctrl));
}

static void
nvme_id_req_set_need(nvme_id_req_t *req, nvme_identify_req_field_t field)
{
	req->nir_need |= 1 << field;
}

static void
nvme_id_req_clear_need(nvme_id_req_t *req, nvme_identify_req_field_t field)
{
	req->nir_need &= ~(1 << field);
}

static const nvme_field_check_t nvme_identify_check_nsid = {
	nvme_identify_fields, NVME_ID_REQ_F_NSID,
	NVME_ERR_NS_RANGE, 0, NVME_ERR_NS_UNUSE
};

bool
nvme_id_req_set_nsid(nvme_id_req_t *req, uint32_t nsid)
{
	nvme_ctrl_t *ctrl = req->nir_ctrl;
	nvme_identify_info_flags_t flags = req->nir_info->nii_flags;

	/*
	 * In some contexts the NSID here must refer to an actual valid
	 * namespace. In other cases it's referring to a search index and
	 * therefore all we care about is the value. Finally, sometimes the
	 * broadcast address is used to access things that are common across all
	 * namespaces. If we have a list operation, we just pass this through to
	 * the kernel. This unfortunately requires a bit more manual checking.
	 */
	if ((flags & NVME_IDENTIFY_INFO_F_NSID_LIST) == 0 &&
	    !nvme_field_check_one(req->nir_ctrl, nsid, "identify",
	    &nvme_identify_check_nsid, req->nir_allow)) {
		return (false);
	}

	if ((flags & NVME_IDENTIFY_INFO_F_NSID_LIST) == 0 &&
	    (req->nir_allow & (1 << NVME_ID_REQ_F_NSID)) != 0) {
		if (nsid == 0) {
			return (nvme_ctrl_error(ctrl, NVME_ERR_NS_RANGE, 0,
			    "namespaces id 0x%x is invalid, valid namespaces "
			    "are [0x%x, 0x%x]", nsid, NVME_NSID_MIN,
			    req->nir_ctrl->nc_info.id_nn));
		}

		if (nsid == NVME_NSID_BCAST &&
		    (flags & NVME_IDENTIFY_INFO_F_BCAST) == 0) {
			return (nvme_ctrl_error(ctrl, NVME_ERR_NS_RANGE, 0,
			    "the all namespaces/controller nsid (0x%x) is not "
			    "allowed for this identify command, valid "
			    "namespaces are [0x%x, 0x%x]", nsid,
			    NVME_NSID_MIN, req->nir_ctrl->nc_info.id_nn));

		}
	}

	req->nir_nsid = nsid;
	nvme_id_req_clear_need(req, NVME_ID_REQ_F_NSID);
	return (nvme_ctrl_success(req->nir_ctrl));
}

static const nvme_field_check_t nvme_identify_check_ctrlid = {
	nvme_identify_fields, NVME_ID_REQ_F_CTRLID,
	NVME_ERR_IDENTIFY_CTRLID_RANGE, NVME_ERR_IDENTIFY_CTRLID_UNSUP,
	NVME_ERR_IDENTIFY_CTRLID_UNUSE
};

bool
nvme_id_req_set_ctrlid(nvme_id_req_t *req, uint32_t ctrlid)
{
	if (!nvme_field_check_one(req->nir_ctrl, ctrlid, "identify",
	    &nvme_identify_check_ctrlid, req->nir_allow)) {
		return (false);
	}

	req->nir_ctrlid = ctrlid;
	nvme_id_req_clear_need(req, NVME_ID_REQ_F_CTRLID);
	return (nvme_ctrl_success(req->nir_ctrl));
}

bool
nvme_id_req_set_output(nvme_id_req_t *req, void *buf, size_t len)
{
	nvme_ctrl_t *ctrl = req->nir_ctrl;

	if (buf == NULL) {
		return (nvme_ctrl_error(ctrl, NVME_ERR_BAD_PTR, 0,
		    "identify output buffer cannot be NULL"));
	}

	if (len < NVME_IDENTIFY_BUFSIZE) {
		return (nvme_ctrl_error(ctrl, NVME_ERR_IDENTIFY_OUTPUT_RANGE, 0,
		    "identify buffer size must be at least %u bytes large",
		    NVME_IDENTIFY_BUFSIZE));
	}

	req->nir_buf = buf;
	nvme_id_req_clear_need(req, NVME_ID_REQ_F_BUF);
	return (nvme_ctrl_success(req->nir_ctrl));
}

bool
nvme_id_req_clear_output(nvme_id_req_t *req)
{
	req->nir_buf = NULL;

	/*
	 * This field is always required so we can just toss a blanket set need
	 * on here.
	 */
	nvme_id_req_set_need(req, NVME_ID_REQ_F_BUF);
	return (nvme_ctrl_success(req->nir_ctrl));
}

bool
nvme_id_req_exec(nvme_id_req_t *req)
{
	nvme_ctrl_t *ctrl = req->nir_ctrl;
	nvme_ioctl_identify_t id;

	if (req->nir_need != 0) {
		return (nvme_field_miss_err(ctrl, nvme_identify_fields,
		    nvme_identify_nfields, NVME_ERR_IDENTIFY_REQ_MISSING_FIELDS,
		    "identify", req->nir_need));
	}

	(void) memset(&id, 0, sizeof (nvme_ioctl_identify_t));
	id.nid_common.nioc_nsid = req->nir_nsid;
	id.nid_cns = req->nir_info->nii_cns;
	id.nid_ctrlid = req->nir_ctrlid;
	id.nid_data = (uintptr_t)req->nir_buf;

	if (ioctl(req->nir_ctrl->nc_fd, NVME_IOC_IDENTIFY, &id) != 0) {
		int e = errno;
		return (nvme_ioctl_syserror(ctrl, e, "identify"));
	}

	if (id.nid_common.nioc_drv_err != NVME_IOCTL_E_OK) {
		return (nvme_ioctl_error(ctrl, &id.nid_common, "identify"));
	}

	return (nvme_ctrl_success(ctrl));
}