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

/*
 * Test namespace information snapshots. Because devices are all different, we
 * mostly try to get a device's identify namespace and then compare that to the
 * fields we have here.
 */

#include <stdlib.h>
#include <stdbool.h>
#include <err.h>
#include <umem.h>

#include "libnvme_test_common.h"

static bool
ns_info_test_inactive(nvme_ns_info_t *info, uint32_t nsid)
{
        uint8_t guid[16];
        bool ret = true;
        uint64_t val;
        const nvme_nvm_lba_fmt_t *fmt;
        const char *bd;

        if (nvme_ns_info_nguid(info, guid)) {
                warnx("TEST FAILED: ns %u returned a namespace guid in error",
                    nsid);
                ret = false;
        } else if (nvme_ns_info_err(info) != NVME_INFO_ERR_NS_INACTIVE) {
                warnx("TEST FAILED: ns %u nvme_ns_info_nguid() returned "
                    "wrong error %s (0x%x), not NVME_INFO_ERR_NS_INACTIVE "
                    "(0x%x)", nsid, nvme_ns_info_errtostr(info,
                    nvme_ns_info_err(info)), nvme_ns_info_err(info),
                    NVME_INFO_ERR_NS_INACTIVE);
                ret = false;
        } else {
                (void) printf("TEST PASSED: ns %u: nvme_ns_info_nguid() "
                    "returned NVME_INFO_ERR_NS_INACTIVE\n", nsid);
        }

        if (nvme_ns_info_eui64(info, guid)) {
                warnx("TEST FAILED: ns %u returned a namespace eui64 in error",
                    nsid);
                ret = false;
        } else if (nvme_ns_info_err(info) != NVME_INFO_ERR_NS_INACTIVE) {
                warnx("TEST FAILED: ns %u nvme_ns_info_eui64() returned "
                    "wrong error %s (0x%x), not NVME_INFO_ERR_NS_INACTIVE "
                    "(0x%x)", nsid, nvme_ns_info_errtostr(info,
                    nvme_ns_info_err(info)), nvme_ns_info_err(info),
                    NVME_INFO_ERR_NS_INACTIVE);
                ret = false;
        } else {
                (void) printf("TEST PASSED: ns %u: nvme_ns_info_eui64() "
                    "returned NVME_INFO_ERR_NS_INACTIVE\n", nsid);
        }

        if (nvme_ns_info_size(info, &val)) {
                warnx("TEST FAILED: ns %u returned a namespace size in error",
                    nsid);
                ret = false;
        } else if (nvme_ns_info_err(info) != NVME_INFO_ERR_NS_INACTIVE) {
                warnx("TEST FAILED: ns %u nvme_ns_info_size() returned "
                    "wrong error %s (0x%x), not NVME_INFO_ERR_NS_INACTIVE "
                    "(0x%x)", nsid, nvme_ns_info_errtostr(info,
                    nvme_ns_info_err(info)), nvme_ns_info_err(info),
                    NVME_INFO_ERR_NS_INACTIVE);
                ret = false;
        } else {
                (void) printf("TEST PASSED: ns %u: nvme_ns_info_size() "
                    "returned NVME_INFO_ERR_NS_INACTIVE\n", nsid);
        }

        if (nvme_ns_info_cap(info, &val)) {
                warnx("TEST FAILED: ns %u returned a namespace cap in error",
                    nsid);
                ret = false;
        } else if (nvme_ns_info_err(info) != NVME_INFO_ERR_NS_INACTIVE) {
                warnx("TEST FAILED: ns %u nvme_ns_info_cap() returned "
                    "wrong error %s (0x%x), not NVME_INFO_ERR_NS_INACTIVE "
                    "(0x%x)", nsid, nvme_ns_info_errtostr(info,
                    nvme_ns_info_err(info)), nvme_ns_info_err(info),
                    NVME_INFO_ERR_NS_INACTIVE);
                ret = false;
        } else {
                (void) printf("TEST PASSED: ns %u: nvme_ns_info_cap() "
                    "returned NVME_INFO_ERR_NS_INACTIVE\n", nsid);
        }

        if (nvme_ns_info_use(info, &val)) {
                warnx("TEST FAILED: ns %u returned a namespace use in error",
                    nsid);
                ret = false;
        } else if (nvme_ns_info_err(info) != NVME_INFO_ERR_NS_INACTIVE) {
                warnx("TEST FAILED: ns %u nvme_ns_info_use() returned "
                    "wrong error %s (0x%x), not NVME_INFO_ERR_NS_INACTIVE "
                    "(0x%x)", nsid, nvme_ns_info_errtostr(info,
                    nvme_ns_info_err(info)), nvme_ns_info_err(info),
                    NVME_INFO_ERR_NS_INACTIVE);
                ret = false;
        } else {
                (void) printf("TEST PASSED: ns %u: nvme_ns_info_use() "
                    "returned NVME_INFO_ERR_NS_INACTIVE\n", nsid);
        }

        if (nvme_ns_info_curformat(info, &fmt)) {
                warnx("TEST FAILED: ns %u returned a current format in error",
                    nsid);
                ret = false;
        } else if (nvme_ns_info_err(info) != NVME_INFO_ERR_NS_INACTIVE) {
                warnx("TEST FAILED: ns %u nvme_ns_info_curformat() returned "
                    "wrong error %s (0x%x), not NVME_INFO_ERR_NS_INACTIVE "
                    "(0x%x)", nsid, nvme_ns_info_errtostr(info,
                    nvme_ns_info_err(info)), nvme_ns_info_err(info),
                    NVME_INFO_ERR_NS_INACTIVE);
                ret = false;
        } else {
                (void) printf("TEST PASSED: ns %u: nvme_ns_info_curformat() "
                    "returned NVME_INFO_ERR_NS_INACTIVE\n", nsid);
        }

        if (nvme_ns_info_format(info, 0, &fmt)) {
                warnx("TEST FAILED: ns %u returned format 0 in error",
                    nsid);
                ret = false;
        } else if (nvme_ns_info_err(info) != NVME_INFO_ERR_NS_INACTIVE) {
                warnx("TEST FAILED: ns %u nvme_ns_info_format() returned "
                    "wrong error %s (0x%x), not NVME_INFO_ERR_NS_INACTIVE "
                    "(0x%x)", nsid, nvme_ns_info_errtostr(info,
                    nvme_ns_info_err(info)), nvme_ns_info_err(info),
                    NVME_INFO_ERR_NS_INACTIVE);
                ret = false;
        } else {
                (void) printf("TEST PASSED: ns %u: nvme_ns_info_curformat() "
                    "returned NVME_INFO_ERR_NS_INACTIVE\n", nsid);
        }

        if (nvme_ns_info_bd_addr(info, &bd)) {
                warnx("TEST FAILED: ns %u returned a blkdev address in error",
                    nsid);
                ret = false;
        } else if (nvme_ns_info_err(info) != NVME_INFO_ERR_NS_NO_BLKDEV) {
                warnx("TEST FAILED: ns %u nvme_ns_info_bd_addr() returned "
                    "wrong error %s (0x%x), not NVME_INFO_ERR_NS_NO_BLKDEV "
                    "(0x%x)", nsid, nvme_ns_info_errtostr(info,
                    nvme_ns_info_err(info)), nvme_ns_info_err(info),
                    NVME_INFO_ERR_NS_NO_BLKDEV);
                ret = false;
        } else {
                (void) printf("TEST PASSED: ns %u: nvme_ns_info_curformat() "
                    "returned NVME_INFO_ERR_NS_NO_BLKDEV\n", nsid);
        }

        return (ret);
}

static bool
ns_info_test_size(nvme_ns_info_t *info,
    bool (*func)(nvme_ns_info_t *, uint64_t *), uint64_t exp_size,
    const char *name, uint32_t nsid)
{
        uint64_t val;

        if (!func(info, &val)) {
                libnvme_test_ns_info_warn(info, "ns %u nvme_ns_info_%s() "
                    "unexpected failed", nsid, name);
                return (false);
        } else if (val != exp_size) {
                warnx("TEST FAILED: ns %u: nvme_ns_info_%s() value was 0x%"
                    PRIx64 ", but expected 0x%" PRIx64, nsid, name, val,
                    exp_size);
                return (false);
        } else {
                (void) printf("TEST PASSED: ns %u: nvme_ns_info_%s() returned "
                    "correct value\n", nsid, name);
                return (true);
        }
}

static bool
ns_info_test(nvme_ctrl_t *ctrl, const nvme_version_t *vers, uint32_t nsid)
{
        bool ret = true;
        nvme_ns_t *ns = NULL;
        nvme_ns_info_t *info = NULL;
        nvme_ns_disc_level_t level;
        const nvme_identify_nsid_t *idns;
        const nvme_nvm_lba_fmt_t *fmt;
        uint32_t nfmt;

        /*
         * We do this to test both ways of taking a snapshot.
         */
        if ((nsid % 2) == 0) {
                if (!nvme_ns_init(ctrl, nsid, &ns)) {
                        libnvme_test_ctrl_warn(ctrl, "failed to init ns %u",
                            nsid);
                        ret = false;
                        goto done;
                }

                if (!nvme_ns_info_snap(ns, &info)) {
                        libnvme_test_ctrl_warn(ctrl, "failed to take snapshot "
                            "of ns %u", nsid);
                        ret = false;
                        goto done;
                }
        } else {
                if (!nvme_ctrl_ns_info_snap(ctrl, nsid, &info)) {
                        libnvme_test_ctrl_warn(ctrl, "failed to take snapshot "
                            "of ns %u", nsid);
                        ret = false;
                        goto done;
                }
        }

        (void) printf("TEST PASSED: ns %u: successfully got info snapshot\n",
            nsid);
        if (nvme_ns_info_nsid(info) != nsid) {
                warnx("TEST FAILED: nsid %u info snapshot returned wrong "
                    "nsid: %u", nsid, nvme_ns_info_nsid(info));
                ret = false;
        } else {
                (void) printf("TEST PASSED: ns %u: info snapshot had correct "
                    "nsid\n", nsid);
        }

        /*
         * The rest of the information snapshot APIs depend on if the namespace
         * is active in the controller. If it is not, then we expect each
         * function to fail. Even if we have an active namespace, this may fail
         * if a controller isn't of a sufficient version.
         */
        level = nvme_ns_info_level(info);
        if (level < NVME_NS_DISC_F_ACTIVE) {
                if (!ns_info_test_inactive(info, nsid)) {
                        ret = false;
                }
                goto done;
        }

        idns = nvme_ns_info_identify(info);

        /*
         * We don't explicitly test the GUID logic or blkdev address here. That
         * is done in the ns-disc.c test.
         */

        if (!ns_info_test_size(info, nvme_ns_info_size, idns->id_nsize, "size",
            nsid)) {
                ret = false;
        }

        if (!ns_info_test_size(info, nvme_ns_info_cap, idns->id_ncap, "cap",
            nsid)) {
                ret = false;
        }

        if (!ns_info_test_size(info, nvme_ns_info_use, idns->id_nuse, "use",
            nsid)) {
                ret = false;
        }

        if (!nvme_ns_info_curformat(info, &fmt)) {
                libnvme_test_ns_info_warn(info, "ns %u failed to get current "
                    "format", nsid);
                ret = false;
        } else if (nvme_nvm_lba_fmt_id(fmt) != idns->id_flbas.lba_format) {
                warnx("TEST FAILED: current LBA format 0x%x does not match "
                    "identify namespace 0x%x", nvme_nvm_lba_fmt_id(fmt),
                    idns->id_flbas.lba_format);
                ret = false;
        } else {
                (void) printf("TEST PASSED: ns %u: nvme_ns_info_curformat() "
                    "returned correct format\n", nsid);
        }

        if (!nvme_ns_info_nformats(info, &nfmt)) {
                libnvme_test_ns_info_warn(info, "ns %u failed to get number "
                    "of formats", nsid);
                ret = false;
        } else if (nfmt != idns->id_nlbaf + 1) {
                warnx("TEST FAILED: number of LBA formats 0x%x does not match "
                    "identify namespace 0x%x", nvme_nvm_lba_fmt_id(fmt),
                    idns->id_nlbaf + 1);
                ret = false;
        } else {
                (void) printf("TEST PASSED: ns %u: nvme_ns_info_nformats() "
                    "returned correct number of formats\n", nsid);
        }

        if (nvme_ns_info_format(info, 0x7777, &fmt)) {
                warnx("TEST FAILED: ns %u erroneously returned info for format "
                    "0x7777", nsid);
                ret = false;
        } else if (nvme_ns_info_err(info) != NVME_INFO_ERR_BAD_FMT) {
                warnx("TEST FAILED: ns %u nvme_ns_info_format() returned "
                    "wrong error %s (0x%x), not NVME_INFO_ERR_BAD_FMT "
                    "(0x%x)", nsid, nvme_ns_info_errtostr(info,
                    nvme_ns_info_err(info)), nvme_ns_info_err(info),
                    NVME_INFO_ERR_BAD_FMT);
                ret = false;
        } else {
                (void) printf("TEST PASSED: ns %u: invalid format id 0x7777 "
                    "correctly rejected\n", nsid);
        }

done:
        nvme_ns_info_free(info);
        nvme_ns_fini(ns);
        return (ret);
}

static bool
ns_info_bad_snap(nvme_ctrl_t *ctrl, uint32_t nsid, nvme_ns_info_t **infop,
    nvme_err_t exp_err, const char *desc)
{
        if (nvme_ctrl_ns_info_snap(ctrl, nsid, infop)) {
                warnx("TEST FAILED: nvme_ctrl_ns_info_snap() erroneously "
                    "passed despite %s", desc);
                return (false);
        } else if (nvme_ctrl_err(ctrl) != exp_err) {
                warnx("TEST FAILED: nvme_ctrl_ns_info_snap() returned "
                    "wrong error %s (0x%x), not %s (0x%x)",
                    nvme_ctrl_errtostr(ctrl, nvme_ctrl_err(ctrl)),
                    nvme_ctrl_err(ctrl), nvme_ctrl_errtostr(ctrl,
                    exp_err), exp_err);

                return (false);
        } else {
                (void) printf("TEST PASSED: nvme_ctrl_ns_info_snap() failed "
                    "correctly for %s\n", desc);
                return (true);
        }
}

int
main(void)
{
        int ret = EXIT_SUCCESS;
        nvme_t *nvme;
        nvme_ctrl_t *ctrl;
        nvme_ctrl_info_t *info;
        nvme_ns_info_t *ns_info;
        uint32_t nns;
        const nvme_version_t *vers;

        libnvme_test_init(&nvme, &ctrl);

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

        nns = nvme_ctrl_info_nns(info);
        if (nns == 0) {
                errx(EXIT_FAILURE, "TEST FAILED: somehow discovered 0 "
                    "namespaces");
        }

        vers = nvme_ctrl_info_version(info);
        for (uint32_t i = 1; i <= nns; i++) {
                if (!ns_info_test(ctrl, vers, i)) {
                        ret = EXIT_FAILURE;
                }
        }

        /*
         * Explicitly verify a few failures of namespace information snapshots.
         */
        if (!ns_info_bad_snap(ctrl, NVME_NSID_BCAST, &ns_info,
            NVME_ERR_NS_RANGE, "invalid nsid")) {
                ret = EXIT_FAILURE;
        }

        if (!ns_info_bad_snap(ctrl, 1, NULL, NVME_ERR_BAD_PTR,
            "invalid output pointer")) {
                ret = EXIT_FAILURE;
        }

        umem_setmtbf(1);
        if (!ns_info_bad_snap(ctrl, 1, &ns_info, NVME_ERR_NO_MEM,
            "no memory")) {
                ret = EXIT_FAILURE;
        }
        umem_setmtbf(0);

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

        nvme_ctrl_info_free(info);
        nvme_ctrl_fini(ctrl);
        nvme_fini(nvme);
        return (ret);
}