/*
 * 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 various aspects of reading the persistent event log from a device and
 * verify that we properly handle certain error conditions. In particular, we
 * want to verify the following:
 *
 * 1) Issuing a reset context while it's already reset is fine.
 * 2) Issuing a read without establish fails
 * 3) Issuing an establish context with one fails
 * 4) Otherwise basic read / establish / release works
 *
 * Because this requires device specific behavior is it not part of the default
 * non-destructive run.
 */

#include <err.h>

#include "libnvme_test_common.h"

static bool
pev_action(nvme_t *nvme, nvme_ctrl_t *ctrl, nvme_pev_log_lsp_t pev, bool exp,
    const char *desc)
{
        nvme_log_disc_t *disc;
        nvme_log_req_t *req;
        uint8_t *buf;
        size_t buflen = 512;
        bool ret = true, lret;

        if ((buf = calloc(buflen, sizeof (uint8_t))) == NULL) {
                err(EXIT_FAILURE, "INTERNAL TEST FAILURE: failed to allocate "
                    "%zu bytes for internal buffer", buflen);
        }

        if (!nvme_log_req_init_by_name(ctrl, "pev", 0, &disc, &req)) {
                libnvme_test_ctrl_fatal(ctrl, "%s: failed to initialize "
                    "persistent event log request", desc);
        }

        if (!nvme_log_req_set_output(req, buf, buflen)) {
                libnvme_test_ctrl_warn(ctrl, "%s: failed to set output buffer",
                    desc);
                ret = false;
                goto done;
        }

        if (!nvme_log_req_set_lsp(req, pev)) {
                libnvme_test_ctrl_warn(ctrl, "%s: failed to set lsp to 0x%x",
                    desc, pev);
                ret = false;
                goto done;
        }

        lret = nvme_log_req_exec(req);
        if (exp && !lret) {
                libnvme_test_ctrl_warn(ctrl, "%s: log request failed, but "
                    "expected success", desc);
                ret = false;
        } else if (!exp && lret) {
                warnx("TEST FAILED: %s: log request succeeded, but expected "
                    "failure", desc);
                ret = false;
        } else if (!lret) {
                nvme_err_t err;
                uint32_t sct, sc;

                err = nvme_ctrl_err(ctrl);
                nvme_ctrl_deverr(ctrl, &sct, &sc);

                if (err != NVME_ERR_CONTROLLER) {
                        warnx("TEST FAILED: %s: found controller error %s "
                            "(0x%x), but expected %s (0x%x)", desc,
                            nvme_errtostr(nvme, err), err,
                            nvme_errtostr(nvme, NVME_ERR_CONTROLLER),
                            NVME_ERR_CONTROLLER);
                        ret = false;
                } else if (sct != NVME_CQE_SCT_GENERIC) {
                        warnx("TEST FAILED: %s: found device sct %s (0x%x), "
                            "but expected %s (0x%x)", desc,
                            nvme_scttostr(ctrl, sct), sct,
                            nvme_scttostr(ctrl, NVME_CQE_SCT_GENERIC),
                            NVME_CQE_SCT_GENERIC);
                        ret = false;
                } else if (sc != NVME_CQE_SC_GEN_CMD_SEQ_ERR) {
                        warnx("TEST FAILED: %s: found device sc %s (0x%x), "
                            "but expected %s (0x%x)", desc,
                            nvme_sctostr(ctrl, NVME_CSI_NVM, sct, sc), sc,
                            nvme_sctostr(ctrl, NVME_CSI_NVM, sct,
                            NVME_CQE_SC_GEN_CMD_SEQ_ERR),
                            NVME_CQE_SC_GEN_CMD_SEQ_ERR);
                        ret = false;
                }
        } else if (pev == NVME_PEV_LSP_READ ||
            pev == NVME_PEV_LSP_EST_CTX_READ) {
                if (*buf != NVME_LOGPAGE_PEV) {
                        warnx("TEST FAILED: %s: returned data does not have "
                            "correct LID in byte 0, found 0x%x, expected 0x%x",
                            desc, *buf, NVME_LOGPAGE_PEV);
                        ret = false;
                }
        }

        if (ret) {
                (void) printf("TEST PASSED: %s\n", desc);
        }
done:
        nvme_log_disc_free(disc);
        nvme_log_req_fini(req);
        free(buf);
        return (ret);
}

int
main(void)
{
        int ret = EXIT_SUCCESS;
        nvme_t *nvme;
        nvme_ctrl_t *ctrl;

        libnvme_test_init(&nvme, &ctrl);
        if (!pev_action(nvme, ctrl, NVME_PEV_LSP_REL_CTX, true,
            "initial release context works")) {
                ret = EXIT_FAILURE;
        }

        if (!pev_action(nvme, ctrl, NVME_PEV_LSP_REL_CTX, true,
            "second release context works")) {
                ret = EXIT_FAILURE;
        }

        if (!pev_action(nvme, ctrl, NVME_PEV_LSP_READ, false,
            "read without context fails")) {
                ret = EXIT_FAILURE;
        }

        if (!pev_action(nvme, ctrl, NVME_PEV_LSP_EST_CTX_READ, true,
            "establish context and read works")) {
                ret = EXIT_FAILURE;
        }

        if (!pev_action(nvme, ctrl, NVME_PEV_LSP_EST_CTX_READ, false,
            "second establish context and read fails")) {
                ret = EXIT_FAILURE;
        }

        if (!pev_action(nvme, ctrl, NVME_PEV_LSP_READ, true,
            "read with context works")) {
                ret = EXIT_FAILURE;
        }

        if (!pev_action(nvme, ctrl, NVME_PEV_LSP_REL_CTX, true,
            "release after read works")) {
                ret = EXIT_FAILURE;
        }

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

        return (ret);
}