/*
 * 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 2025 Oxide Computer Company
 */

/*
 * This implements support for Namespace Management and Namespace Attach
 * commands.
 */

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

#include "libnvme_impl.h"

void
nvme_ns_attach_req_fini(nvme_ns_attach_req_t *req)
{
        free(req);
}

static void
nvme_ns_attach_req_clear_need(nvme_ns_attach_req_t *req,
    nvme_ns_attach_req_field_t field)
{
        req->nar_need &= ~(1 << field);
}

bool
nvme_ns_attach_req_init_by_sel(nvme_ctrl_t *ctrl, uint32_t sel,
    nvme_ns_attach_req_t **reqp)
{
        nvme_ns_attach_req_t *req;
        nvme_valid_ctrl_data_t ctrl_data;

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

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

        if (!nvme_nsmgmt_cmds_supported(&ctrl_data)) {
                return (nvme_ctrl_error(ctrl, NVME_ERR_NS_MGMT_UNSUP_BY_DEV, 0,
                    "controller does not support namespace management"));
        }

        /*
         * See discussion in nvme_ns_create_req_init_by_csi() down below for
         * rationale around the single error here.
         */
        if (sel != NVME_NS_ATTACH_CTRL_ATTACH &&
            sel != NVME_NS_ATTACH_CTRL_DETACH) {
                return (nvme_ctrl_error(ctrl, NVME_ERR_NS_ATTACH_BAD_SEL, 0,
                    "the system (and possibly device) does not support "
                    "attaching namespaces with selector 0x%x", sel));
        }

        req = calloc(1, sizeof (nvme_ns_attach_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_ns_attach_req_t: %s",
                    strerror(e)));
        }

        req->nar_ctrl = ctrl;
        req->nar_sel = sel;
        for (size_t i = 0; i < nvme_ns_attach_nfields; i++) {
                if (nvme_ns_attach_fields[i].nlfi_def_req) {
                        req->nar_need |= 1 << i;
                }
        }
        nvme_ns_attach_req_clear_need(req, NVME_NS_ATTACH_REQ_FIELD_SEL);

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

static const nvme_field_check_t nvme_ns_attach_check_nsid = {
        nvme_ns_attach_fields, NVME_NS_ATTACH_REQ_FIELD_NSID,
        NVME_ERR_NS_RANGE, 0, 0
};

bool
nvme_ns_attach_req_set_nsid(nvme_ns_attach_req_t *req, uint32_t nsid)
{
        if (!nvme_field_check_one(req->nar_ctrl, nsid, "namespace attach",
            &nvme_ns_attach_check_nsid, 0)) {
                return (false);
        }

        req->nar_nsid = nsid;
        nvme_ns_attach_req_clear_need(req, NVME_NS_ATTACH_REQ_FIELD_NSID);
        return (nvme_ctrl_success(req->nar_ctrl));
}

/*
 * Right now we don't support setting an explicit controller list in the kernel
 * so this is a short-hand for saying just do it for my current controller
 * without requiring us to actually set anything here, we just need to clear
 * that this has been explicitly set that way the target is not implicit.
 */
bool
nvme_ns_attach_req_set_ctrlid_self(nvme_ns_attach_req_t *req)
{
        nvme_ns_attach_req_clear_need(req, NVME_NS_ATTACH_REQ_FIELD_DPTR);
        return (nvme_ctrl_success(req->nar_ctrl));
}

bool
nvme_ns_attach_req_exec(nvme_ns_attach_req_t *req)
{
        nvme_ctrl_t *ctrl = req->nar_ctrl;
        nvme_ioctl_common_t common;
        int code;

        if (req->nar_need != 0) {
                return (nvme_field_miss_err(ctrl, nvme_ns_attach_fields,
                    nvme_ns_attach_nfields,
                    NVME_ERR_NS_ATTACH_REQ_MISSING_FIELDS, "namespace attach",
                    req->nar_need));
        }

        (void) memset(&common, 0, sizeof (common));
        common.nioc_nsid = req->nar_nsid;

        code = req->nar_sel == NVME_NS_ATTACH_CTRL_ATTACH ?
            NVME_IOC_CTRL_ATTACH : NVME_IOC_CTRL_DETACH;
        if (ioctl(ctrl->nc_fd, code, &common) != 0) {
                int e = errno;
                return (nvme_ioctl_syserror(ctrl, e, "namespace attach"));
        }

        if (common.nioc_drv_err != NVME_IOCTL_E_OK) {
                return (nvme_ioctl_error(ctrl, &common, "namespace attach"));
        }

        return (nvme_ctrl_success(ctrl));
}

void
nvme_ns_delete_req_fini(nvme_ns_delete_req_t *req)
{
        free(req);
}

bool
nvme_ns_delete_req_init(nvme_ctrl_t *ctrl, nvme_ns_delete_req_t **reqp)
{
        nvme_ns_delete_req_t *req;
        nvme_valid_ctrl_data_t ctrl_data;

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

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

        if (!nvme_nsmgmt_cmds_supported(&ctrl_data)) {
                return (nvme_ctrl_error(ctrl, NVME_ERR_NS_MGMT_UNSUP_BY_DEV, 0,
                    "controller does not support namespace management"));
        }

        req = calloc(1, sizeof (nvme_ns_delete_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_ns_delete_req_t: %s",
                    strerror(e)));
        }

        req->ndr_ctrl = ctrl;
        for (size_t i = 0; i < nvme_ns_delete_nfields; i++) {
                if (nvme_ns_delete_fields[i].nlfi_def_req) {
                        req->ndr_need |= 1 << i;
                }
        }

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

static void
nvme_ns_delete_req_clear_need(nvme_ns_delete_req_t *req,
    nvme_ns_delete_req_field_t field)
{
        req->ndr_need &= ~(1 << field);
}

static const nvme_field_check_t nvme_ns_delete_check_nsid = {
        nvme_ns_delete_fields, NVME_NS_DELETE_REQ_FIELD_NSID,
        NVME_ERR_NS_RANGE, 0, 0
};

bool
nvme_ns_delete_req_set_nsid(nvme_ns_delete_req_t *req, uint32_t nsid)
{
        if (!nvme_field_check_one(req->ndr_ctrl, nsid, "namespace delete",
            &nvme_ns_delete_check_nsid, 0)) {
                return (false);
        }

        req->ndr_nsid = nsid;
        nvme_ns_delete_req_clear_need(req, NVME_NS_DELETE_REQ_FIELD_NSID);
        return (nvme_ctrl_success(req->ndr_ctrl));
}

bool
nvme_ns_delete_req_exec(nvme_ns_delete_req_t *req)
{
        nvme_ctrl_t *ctrl = req->ndr_ctrl;
        nvme_ioctl_common_t common;

        if (req->ndr_need != 0) {
                return (nvme_field_miss_err(ctrl, nvme_ns_delete_fields,
                    nvme_ns_delete_nfields,
                    NVME_ERR_NS_DELETE_REQ_MISSING_FIELDS, "namespace delete",
                    req->ndr_need));
        }

        (void) memset(&common, 0, sizeof (common));
        common.nioc_nsid = req->ndr_nsid;

        if (ioctl(ctrl->nc_fd, NVME_IOC_NS_DELETE, &common) != 0) {
                int e = errno;
                return (nvme_ioctl_syserror(ctrl, e, "namespace delete"));
        }

        if (common.nioc_drv_err != NVME_IOCTL_E_OK) {
                return (nvme_ioctl_error(ctrl, &common, "namespace delete"));
        }

        return (nvme_ctrl_success(ctrl));
}

void
nvme_ns_create_req_fini(nvme_ns_create_req_t *req)
{
        free(req);
}

bool
nvme_ns_create_req_init_by_csi(nvme_ctrl_t *ctrl, nvme_csi_t csi,
    nvme_ns_create_req_t **reqp)
{
        nvme_ns_create_req_t *req;
        nvme_valid_ctrl_data_t ctrl_data;

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

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

        if (!nvme_nsmgmt_cmds_supported(&ctrl_data)) {
                return (nvme_ctrl_error(ctrl, NVME_ERR_NS_MGMT_UNSUP_BY_DEV, 0,
                    "controller does not support namespace management"));
        }

        /*
         * The CSI determines what fields are supported and required. Not all
         * CSIs support namespace creation and in addition, we only support the
         * NVM CSI. The notion of CSIs was added in NVMe 2.0. There are several
         * things that could go wrong here:
         *
         * - We could have an NVMe controller that is pre-2.0 and therefore
         *   anything other than the NVM CSI is invalid (it's implicit pre-2.0).
         * - We could have a CSI that's just not defined by any version of the
         *   spec.
         * - We could have a CSI that's defined by a spec that's newer than the
         *   device.
         * - The CSI may not support namespace creation. The device may not even
         *   support the CSI!
         *
         * In addition, the kernel doesn't support anything other than the NVM
         * CSI today. Rather than break these all apart, we give a generic error
         * message about this. We can make this higher fidelity in the future.
         */
        if (csi != NVME_CSI_NVM) {
                return (nvme_ctrl_error(ctrl, NVME_ERR_NS_CREATE_BAD_CSI, 0,
                    "the system (and possibly device) does not support "
                    "creating namespaces with CSI 0x%x", csi));
        }

        req = calloc(1, sizeof (nvme_ns_create_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_ns_create_req_t: %s",
                    strerror(e)));
        }

        for (size_t i = 0; i < nvme_ns_create_fields_nvm_nreq; i++) {
                req->ncr_need |= 1 << nvme_ns_create_fields_nvm_req[i];
        }

        for (size_t i = 0; i < nvme_ns_create_fields_nvm_nallow; i++) {
                req->ncr_allow |= 1 << nvme_ns_create_fields_nvm_allow[i];
        }

        req->ncr_ctrl = ctrl;
        req->ncr_csi = csi;

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

static void
nvme_ns_create_req_clear_need(nvme_ns_create_req_t *req,
    nvme_ns_create_req_field_t field)
{
        req->ncr_need &= ~(1 << field);
}

static const nvme_field_check_t nvme_ns_create_check_flbas = {
        nvme_ns_create_fields, NVME_NS_CREATE_REQ_FIELD_FLBAS,
        NVME_ERR_NS_CREATE_FLBAS_RANGE, 0, 0
};

bool
nvme_ns_create_req_set_flbas(nvme_ns_create_req_t *req, uint32_t flbas)
{
        if (!nvme_field_check_one(req->ncr_ctrl, flbas, "namespace create",
            &nvme_ns_create_check_flbas, req->ncr_allow)) {
                return (false);
        }

        req->ncr_flbas = flbas;
        nvme_ns_create_req_clear_need(req, NVME_NS_CREATE_REQ_FIELD_FLBAS);
        return (nvme_ctrl_success(req->ncr_ctrl));
}

static const nvme_field_check_t nvme_ns_create_check_nsze = {
        nvme_ns_create_fields, NVME_NS_CREATE_REQ_FIELD_NSZE,
        NVME_ERR_NS_CREATE_NSZE_RANGE, 0, 0
};

bool
nvme_ns_create_req_set_nsze(nvme_ns_create_req_t *req, uint64_t nsze)
{
        if (!nvme_field_check_one(req->ncr_ctrl, nsze, "namespace create",
            &nvme_ns_create_check_nsze, req->ncr_allow)) {
                return (false);
        }

        req->ncr_nsze = nsze;
        nvme_ns_create_req_clear_need(req, NVME_NS_CREATE_REQ_FIELD_NSZE);
        return (nvme_ctrl_success(req->ncr_ctrl));
}

static const nvme_field_check_t nvme_ns_create_check_ncap = {
        nvme_ns_create_fields, NVME_NS_CREATE_REQ_FIELD_NCAP,
        NVME_ERR_NS_CREATE_NCAP_RANGE, 0, 0
};

bool
nvme_ns_create_req_set_ncap(nvme_ns_create_req_t *req, uint64_t ncap)
{
        if (!nvme_field_check_one(req->ncr_ctrl, ncap, "namespace create",
            &nvme_ns_create_check_ncap, req->ncr_allow)) {
                return (false);
        }

        req->ncr_ncap = ncap;
        nvme_ns_create_req_clear_need(req, NVME_NS_CREATE_REQ_FIELD_NCAP);
        return (nvme_ctrl_success(req->ncr_ctrl));
}

static const nvme_field_check_t nvme_ns_create_check_nmic = {
        nvme_ns_create_fields, NVME_NS_CREATE_REQ_FIELD_NMIC,
        NVME_ERR_NS_CREATE_NMIC_RANGE, 0, 0
};

bool
nvme_ns_create_req_set_nmic(nvme_ns_create_req_t *req, uint32_t nmic)
{
        if (!nvme_field_check_one(req->ncr_ctrl, nmic, "namespace create",
            &nvme_ns_create_check_nmic, req->ncr_allow)) {
                return (false);
        }

        req->ncr_nmic = nmic;
        nvme_ns_create_req_clear_need(req, NVME_NS_CREATE_REQ_FIELD_NMIC);
        return (nvme_ctrl_success(req->ncr_ctrl));
}

bool
nvme_ns_create_req_get_nsid(nvme_ns_create_req_t *req, uint32_t *nsid)
{
        if (nsid == NULL) {
                return (nvme_ctrl_error(req->ncr_ctrl, NVME_ERR_BAD_PTR, 0,
                    "encountered invalid nsid output pointer: %p", nsid));
        }

        if (!req->ncr_results_valid) {
                return (nvme_ctrl_error(req->ncr_ctrl,
                    NVME_ERR_NS_CREATE_NO_RESULTS, 0, "namespace create "
                    "results are not currently valid and cannot be returned"));
        }

        *nsid = req->ncr_nsid;
        return (nvme_ctrl_success(req->ncr_ctrl));
}

bool
nvme_ns_create_req_exec(nvme_ns_create_req_t *req)
{
        nvme_ctrl_t *ctrl = req->ncr_ctrl;
        nvme_ioctl_ns_create_t create;

        /*
         * Immediately invalidate our results if someone calls this again.
         */
        req->ncr_results_valid = false;
        req->ncr_nsid = 0;

        if (req->ncr_need != 0) {
                return (nvme_field_miss_err(ctrl, nvme_ns_create_fields,
                    nvme_ns_create_nfields,
                    NVME_ERR_NS_CREATE_REQ_MISSING_FIELDS, "namespace create",
                    req->ncr_need));
        }

        (void) memset(&create, 0, sizeof (create));
        create.nnc_nsze = req->ncr_nsze;
        create.nnc_ncap = req->ncr_ncap;
        create.nnc_csi = req->ncr_csi;
        create.nnc_flbas = req->ncr_flbas;
        create.nnc_nmic = req->ncr_nmic;

        if (ioctl(ctrl->nc_fd, NVME_IOC_NS_CREATE, &create) != 0) {
                int e = errno;
                return (nvme_ioctl_syserror(ctrl, e, "namespace create"));
        }

        if (create.nnc_common.nioc_drv_err != NVME_IOCTL_E_OK) {
                return (nvme_ioctl_error(ctrl, &create.nnc_common,
                    "namespace create"));
        }

        req->ncr_results_valid = true;
        req->ncr_nsid = create.nnc_nsid;
        return (nvme_ctrl_success(ctrl));
}