/*
 * 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
 */

/*
 * Take a controller snapshot. Roundtrip it through a save and restore and make
 * sure that all the data is the same across the two.
 */

#include <err.h>
#include <string.h>

#include "libnvme_test_common.h"

static bool
info_roundtrip_pci(nvme_ctrl_info_t *info, nvme_ctrl_info_t *rest_info)
{
        bool ret = true;
        uint32_t id32, rest_id32;
        uint16_t id16, rest_id16;
        uint8_t id8, rest_id8;

        if (!nvme_ctrl_info_pci_vid(info, &id16)) {
                libnvme_test_ctrl_info_warn(info, "failed to get PCI vendor "
                    "from original snapshot");
                ret = false;
        } else if (!nvme_ctrl_info_pci_vid(rest_info, &rest_id16)) {
                libnvme_test_ctrl_info_warn(info, "failed to get PCI vendor "
                    "from restored snapshot");
                ret = false;
        } else if (id16 != rest_id16) {
                warnx("TEST FAILED: PCI vendor mismatch: was %u now %u",
                    id16, rest_id16);
                ret = false;
        } else {
                (void) printf("TEST PASSED: PCI vendor successfully "
                    "restored\n");
        }

        if (!nvme_ctrl_info_pci_did(info, &id16)) {
                libnvme_test_ctrl_info_warn(info, "failed to get PCI device "
                    "from original snapshot");
                ret = false;
        } else if (!nvme_ctrl_info_pci_did(rest_info, &rest_id16)) {
                libnvme_test_ctrl_info_warn(info, "failed to get PCI device "
                    "from restored snapshot");
                ret = false;
        } else if (id16 != rest_id16) {
                warnx("TEST FAILED: PCI device mismatch: was %u now %u",
                    id16, rest_id16);
                ret = false;
        } else {
                (void) printf("TEST PASSED: PCI device successfully "
                    "restored\n");
        }

        if (!nvme_ctrl_info_pci_subvid(info, &id16)) {
                libnvme_test_ctrl_info_warn(info, "failed to get PCI subsystem "
                    "vendor from original snapshot");
                ret = false;
        } else if (!nvme_ctrl_info_pci_subvid(rest_info, &rest_id16)) {
                libnvme_test_ctrl_info_warn(info, "failed to get PCI subsystem "
                    "vendor from restored snapshot");
                ret = false;
        } else if (id16 != rest_id16) {
                warnx("TEST FAILED: PCI subsystem vendor mismatch: was %u "
                    "now %u", id16, rest_id16);
                ret = false;
        } else {
                (void) printf("TEST PASSED: PCI subsystem vendor successfully "
                    "restored\n");
        }

        if (!nvme_ctrl_info_pci_subsys(info, &id16)) {
                libnvme_test_ctrl_info_warn(info, "failed to get PCI subsystem "
                    "id from original snapshot");
                ret = false;
        } else if (!nvme_ctrl_info_pci_subsys(rest_info, &rest_id16)) {
                libnvme_test_ctrl_info_warn(info, "failed to get PCI subsystem "
                    "id from restored snapshot");
                ret = false;
        } else if (id16 != rest_id16) {
                warnx("TEST FAILED: PCI subsystem id mismatch: was %u "
                    "now %u", id16, rest_id16);
                ret = false;
        } else {
                (void) printf("TEST PASSED: PCI subsystem id successfully "
                    "restored\n");
        }

        if (!nvme_ctrl_info_pci_rev(info, &id8)) {
                libnvme_test_ctrl_info_warn(info, "failed to get PCI revision "
                    "from original snapshot");
                ret = false;
        } else if (!nvme_ctrl_info_pci_rev(rest_info, &rest_id8)) {
                libnvme_test_ctrl_info_warn(info, "failed to get PCI revision "
                    "from restored snapshot");
                ret = false;
        } else if (id8 != rest_id8) {
                warnx("TEST FAILED: PCI revision mismatch: was %u now %u",
                    id8, rest_id8);
                ret = false;
        } else {
                (void) printf("TEST PASSED: PCI revision successfully "
                    "restored\n");
        }

        if (!nvme_ctrl_info_pci_mps_min(info, &id32)) {
                libnvme_test_ctrl_info_warn(info, "failed to get PCI MPS min "
                    "from original snapshot");
                ret = false;
        } else if (!nvme_ctrl_info_pci_mps_min(rest_info, &rest_id32)) {
                libnvme_test_ctrl_info_warn(info, "failed to get PCI MPS min "
                    "from restored snapshot");
                ret = false;
        } else if (id32 != rest_id32) {
                warnx("TEST FAILED: PCI MPS min mismatch: was %u now %u",
                    id32, rest_id32);
                ret = false;
        } else {
                (void) printf("TEST PASSED: PCI MPS min successfully "
                    "restored\n");
        }

        if (!nvme_ctrl_info_pci_mps_max(info, &id32)) {
                libnvme_test_ctrl_info_warn(info, "failed to get PCI MPS max "
                    "from original snapshot");
                ret = false;
        } else if (!nvme_ctrl_info_pci_mps_max(rest_info, &rest_id32)) {
                libnvme_test_ctrl_info_warn(info, "failed to get PCI MPS max "
                    "from restored snapshot");
                ret = false;
        } else if (id32 != rest_id32) {
                warnx("TEST FAILED: PCI MPS max mismatch: was %u now %u",
                    id32, rest_id32);
                ret = false;
        } else {
                (void) printf("TEST PASSED: PCI MPS max successfully "
                    "restored\n");
        }

        if (!nvme_ctrl_info_pci_nintrs(info, &id32)) {
                libnvme_test_ctrl_info_warn(info, "failed to get PCI intr "
                    "count from original snapshot");
                ret = false;
        } else if (!nvme_ctrl_info_pci_nintrs(rest_info, &rest_id32)) {
                libnvme_test_ctrl_info_warn(info, "failed to get PCI intr "
                    "count from restored snapshot");
                ret = false;
        } else if (id32 != rest_id32) {
                warnx("TEST FAILED: PCI intr count mismatch: was %u now %u",
                    id32, rest_id32);
                ret = false;
        } else {
                (void) printf("TEST PASSED: PCI intr count successfully "
                    "restored\n");
        }

        return (ret);
}

static bool
info_roundtrip_ns(nvme_ctrl_info_t *info, nvme_ctrl_info_t *rest_info)
{
        bool ret = true;
        nvme_uint128_t u128, rest_u128;
        const nvme_identify_nsid_t *idns, *rest_idns;

        if (!nvme_ctrl_info_cap(info, &u128)) {
                libnvme_test_ctrl_info_warn(info, "failed to get NVM capacity "
                    "from original snapshot");
                ret = false;
        } else if (!nvme_ctrl_info_cap(rest_info, &rest_u128)) {
                libnvme_test_ctrl_info_warn(info, "failed to get NVM capacity "
                    "from restored snapshot");
                ret = false;
        } else if (memcmp(&u128, &rest_u128, sizeof (nvme_uint128_t)) != 0) {
                warnx("TEST FAILED: NVM capacity mismatch");
                ret = false;
        } else {
                (void) printf("TEST PASSED: NVM capacity successfully "
                    "restored\n");
        }

        if (!nvme_ctrl_info_unalloc_cap(info, &u128)) {
                libnvme_test_ctrl_info_warn(info, "failed to get NVM "
                    "unallocated capacity from original snapshot");
                ret = false;
        } else if (!nvme_ctrl_info_unalloc_cap(rest_info, &rest_u128)) {
                libnvme_test_ctrl_info_warn(info, "failed to get NVM "
                    "unallocated capacity from restored snapshot");
                ret = false;
        } else if (memcmp(&u128, &rest_u128, sizeof (nvme_uint128_t)) != 0) {
                warnx("TEST FAILED: NVM unallocated capacity mismatch");
                ret = false;
        } else {
                (void) printf("TEST PASSED: NVM unallocated capacity "
                    "successfully restored\n");
        }

        if (!nvme_ctrl_info_common_ns(info, &idns)) {
                libnvme_test_ctrl_info_warn(info, "failed to get common ns "
                    "from original snapshot");
                ret = false;
        } else if (!nvme_ctrl_info_common_ns(rest_info, &rest_idns)) {
                libnvme_test_ctrl_info_warn(info, "failed to get common ns "
                    "from restored snapshot");
                ret = false;
        } else if (memcmp(idns, rest_idns,
            sizeof (nvme_identify_nsid_t)) != 0) {
                warnx("TEST FAILED: Common Identify Namespace mismatch");
                ret = false;
        } else {
                (void) printf("TEST PASSED: common identify namespace "
                    "successfully restored\n");
        }

        return (ret);
}

static bool
info_roundtrip_lba(nvme_ctrl_info_t *info, nvme_ctrl_info_t *rest_info)
{
        bool ret = true;
        const uint32_t nlbas = nvme_ctrl_info_nformats(info);

        for (uint32_t i = 0; i < nlbas; i++) {
                const nvme_nvm_lba_fmt_t *fmt, *rest_fmt;

                if (!nvme_ctrl_info_format(info, i, &fmt)) {
                        /*
                         * Some devices like the Kioxia KCD6XLUL3T84 have holes
                         * in their LBA space. Skip such instances.
                         */
                        if (nvme_ctrl_info_err(info) == NVME_INFO_ERR_BAD_FMT) {
                                continue;
                        }

                        libnvme_test_ctrl_info_warn(info, "failed to get "
                            "LBA format %u from original snapshot", i);
                        ret = false;
                        continue;
                }

                if (!nvme_ctrl_info_format(rest_info, i, &rest_fmt)) {
                        libnvme_test_ctrl_info_warn(info, "failed to get "
                            "LBA format %u from restored snapshot", i);
                        ret = false;
                        continue;
                }

                (void) printf("TEST PASSED: successfully got LBA format %u\n",
                    i);
                if (nvme_nvm_lba_fmt_id(fmt) != i) {
                        warnx("TEST FAILED: format %u from original snapshot "
                            "has wrong format id: %u\n", i,
                            nvme_nvm_lba_fmt_id(fmt));
                        ret = false;
                }

                if (nvme_nvm_lba_fmt_id(rest_fmt) != i) {
                        warnx("TEST FAILED: format %u from restored snapshot "
                            "has wrong format id: %u\n", i,
                            nvme_nvm_lba_fmt_id(rest_fmt));
                        ret = false;
                }

                if (nvme_nvm_lba_fmt_meta_size(fmt) !=
                    nvme_nvm_lba_fmt_meta_size(rest_fmt)) {
                        warnx("TEST FAILED: LBA %u metadata size mismatch: "
                            "was %u, now %u", i,
                            nvme_nvm_lba_fmt_meta_size(fmt),
                            nvme_nvm_lba_fmt_meta_size(rest_fmt));
                        ret = false;
                } else {
                        (void) printf("TEST PASSED: LBA %u metadata "
                            "successfully restored\n", i);
                }

                if (nvme_nvm_lba_fmt_data_size(fmt) !=
                    nvme_nvm_lba_fmt_data_size(rest_fmt)) {
                        warnx("TEST FAILED: LBA %u data size mismatch: "
                            "was %" PRIu64 ", now %" PRIu64, i,
                            nvme_nvm_lba_fmt_data_size(fmt),
                            nvme_nvm_lba_fmt_data_size(rest_fmt));
                        ret = false;
                } else {
                        (void) printf("TEST PASSED: LBA %u data size "
                            "successfully restored\n", i);
                }

                if (nvme_nvm_lba_fmt_rel_perf(fmt) !=
                    nvme_nvm_lba_fmt_rel_perf(rest_fmt)) {
                        warnx("TEST FAILED: LBA %u relative perf mismatch: "
                            "was %u, now %u", i,
                            nvme_nvm_lba_fmt_rel_perf(fmt),
                            nvme_nvm_lba_fmt_rel_perf(rest_fmt));
                        ret = false;
                } else {
                        (void) printf("TEST PASSED: LBA %u relative perf "
                            "successfully restored\n", i);
                }
        }

        return (ret);
}

int
main(void)
{
        int ret = EXIT_SUCCESS;
        nvme_t *nvme;
        nvme_ctrl_t *ctrl;
        nvme_ctrl_info_t *info, *rest_info;
        nvlist_t *nvl;
        const nvme_identify_ctrl_t *ctrlid, *rest_ctrlid;
        const nvme_version_t *vers, *rest_vers;

        libnvme_test_init(&nvme, &ctrl);
        if (!nvme_ctrl_info_snap(ctrl, &info)) {
                libnvme_test_ctrl_fatal(ctrl, "failed to take a snapshot");
        }

        if (!nvme_ctrl_info_persist(info, &nvl)) {
                libnvme_test_ctrl_info_fatal(info, "failed to persist the "
                    "controller snapshot");
        }

        if (!nvme_ctrl_info_restore(nvme, nvl, &rest_info)) {
                libnvme_test_hdl_fatal(nvme, "failed to restore controller "
                    "snapshot");
        }

        if (nvme_ctrl_info_vendor(info) != nvme_ctrl_info_vendor(rest_info)) {
                warnx("TEST FAILED: vendor mismatch: orig 0x%x, restored: 0x%x",
                    nvme_ctrl_info_vendor(info),
                    nvme_ctrl_info_vendor(rest_info));
                ret = EXIT_FAILURE;
        } else {
                (void) printf("TEST PASSED: successfully matched vendor id\n");
        }

        ctrlid = nvme_ctrl_info_identify(info);
        rest_ctrlid = nvme_ctrl_info_identify(rest_info);
        if (memcmp(ctrlid, rest_ctrlid, sizeof (nvme_identify_ctrl_t)) != 0) {
                warnx("TEST FAILED: Identify info mismatched after restore");
                ret = EXIT_FAILURE;
        } else {
                (void) printf("TEST PASSED: identify controller successfully "
                    "restored\n");
        }

        vers = nvme_ctrl_info_version(info);
        rest_vers = nvme_ctrl_info_version(rest_info);
        if (vers->v_major != rest_vers->v_major) {
                warnx("TEST FAILED: mismatched major version: was %u, found %u",
                    vers->v_major, rest_vers->v_major);
                ret = EXIT_FAILURE;
        } else {
                (void) printf("TEST PASSED: major version successfully "
                    "restored\n");
        }

        if (vers->v_minor != rest_vers->v_minor) {
                warnx("TEST FAILED: mismatched minor version: was %u, found %u",
                    vers->v_minor, rest_vers->v_minor);
                ret = EXIT_FAILURE;
        } else {
                (void) printf("TEST PASSED: minor version successfully "
                    "restored\n");
        }

        if (strcmp(nvme_ctrl_info_model(info),
            nvme_ctrl_info_model(rest_info)) != 0) {
                warnx("TEST FAILED: model string mismatch");
                ret = EXIT_FAILURE;
        } else {
                (void) printf("TEST PASSED: model successfully restored\n");
        }

        if (strcmp(nvme_ctrl_info_serial(info),
            nvme_ctrl_info_serial(rest_info)) != 0) {
                warnx("TEST FAILED: serial string mismatch");
                ret = EXIT_FAILURE;
        } else {
                (void) printf("TEST PASSED: serial successfully restored\n");
        }

        if (strcmp(nvme_ctrl_info_fwrev(info),
            nvme_ctrl_info_fwrev(rest_info)) != 0) {
                warnx("TEST FAILED: fwrev string mismatch");
                ret = EXIT_FAILURE;
        } else {
                (void) printf("TEST PASSED: fwrev successfully restored\n");
        }

        if (nvme_ctrl_info_nns(info) != nvme_ctrl_info_nns(rest_info)) {
                warnx("TEST FAILED: number of namespaces mismatch: was %u, "
                    "now %u", nvme_ctrl_info_nns(info),
                    nvme_ctrl_info_nns(rest_info));
                ret = EXIT_FAILURE;
        } else {
                (void) printf("TEST PASSED: number of namespaces successfully "
                    "restored\n");
        }

        if (nvme_ctrl_info_type(info) != nvme_ctrl_info_type(rest_info)) {
                warnx("TEST FAILED: controller type mismatch: was %u, "
                    "now %u", nvme_ctrl_info_type(info),
                    nvme_ctrl_info_type(rest_info));
                ret = EXIT_FAILURE;
        } else {
                (void) printf("TEST PASSED: controller type successfully "
                    "restored\n");
        }

        if (nvme_ctrl_info_transport(info) !=
            nvme_ctrl_info_transport(rest_info)) {
                warnx("TEST FAILED: controller transport mismatch: was %u, "
                    "now %u", nvme_ctrl_info_transport(info),
                    nvme_ctrl_info_transport(rest_info));
                ret = EXIT_FAILURE;
        } else {
                (void) printf("TEST PASSED: controller transport successfully "
                    "restored\n");
        }

        if (nvme_ctrl_info_transport(info) == NVME_CTRL_TRANSPORT_PCI &&
            !info_roundtrip_pci(info, rest_info)) {
                ret = EXIT_FAILURE;
        }

        if (ctrlid->id_oacs.oa_nsmgmt != 0 && !info_roundtrip_ns(info,
            rest_info)) {
                ret = EXIT_FAILURE;
        }

        if (nvme_ctrl_info_nformats(info) !=
            nvme_ctrl_info_nformats(rest_info)) {
                warnx("TEST FAILED: number of LBA formats mismatch: was %u, "
                    "now %u", nvme_ctrl_info_nformats(info),
                    nvme_ctrl_info_nformats(rest_info));
                ret = EXIT_FAILURE;
        } else {
                (void) printf("TEST PASSED: number of LBA formats successfully "
                    "restored\n");
        }

        if (nvme_ctrl_info_nformats(info) > 0 && !info_roundtrip_lba(info,
            rest_info)) {
                ret = EXIT_FAILURE;
        }

        nvme_ctrl_info_free(rest_info);
        nvme_ctrl_info_free(info);
        nvme_ctrl_fini(ctrl);
        nvme_fini(nvme);

        if (ret == EXIT_SUCCESS) {
                (void) printf("All tests exited successfully\n");
        }

        return (ret);
}