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

/*
 * Logic to gather the physical interface receiver eye opening measurement and
 * slice and dice it.
 */

#include <err.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/debug.h>
#include <sys/sysmacros.h>
#include <sys/mman.h>
#include <sys/bitext.h>
#include <ofmt.h>

#include "nvmeadm.h"

/*
 * Pick a reasonable buffer size that we think will fit within a device's
 * maximum payload. For now we use 64 KiB somewhat arbitrarily.
 */
#define PHYEYE_BUFSIZE  (64 * 1024)

/*
 * Maximum values for PCIe lanes and eyes. We use 16 lanes for PCIe as while
 * most devices are only x4, that's the largest sized slot that's typically
 * implemented.
 *
 * For the maximum number of eyes there is only 1 for NRZ and today 3 for PAM4.
 * So we pick the PAM4 default.
 */
#define PHYEYE_MAX_LANE 16
#define PHYEYE_MAX_EYE  3

typedef struct {
        const char *pm_output;
        nvme_eom_lsp_mqual_t pm_qual;
} phyeye_measure_t;

typedef enum {
        PHYEYE_REPORT_M_ASCII,
        PHYEYE_REPORT_M_OED
} phyeye_report_mode_t;

typedef struct {
        nvme_process_arg_t *pr_npa;
        const char *pr_input;
        phyeye_report_mode_t pr_mode;
        uint8_t pr_lane;
        uint8_t pr_eye;
        bool pr_print;
} phyeye_report_t;

static const nvmeadm_field_bit_t phyeye_eom_odp_bits[] = { {
        .nfb_lowbit = 0, .nfb_hibit = 0,
        .nfb_short = "pefp",
        .nfb_desc = "Printable Eye Field Present",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "not present", "present" }
}, {
        .nfb_lowbit = 1, .nfb_hibit = 1,
        .nfb_short = "edfp",
        .nfb_desc = "Eye Data Field Present",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "not present", "present" }
} };

static const nvmeadm_field_bit_t phyeye_eom_lspfc_bits[] = { {
        .nfb_lowbit = 0, .nfb_hibit = 6,
        .nfb_short = "lspfv",
        .nfb_desc = "Log Specific Parameter Field Value",
        .nfb_type = NVMEADM_FT_HEX
} };

static const nvmeadm_field_bit_t phyeye_eom_linfo_bits[] = { {
        .nfb_lowbit = 0, .nfb_hibit = 3,
        .nfb_short = "mls",
        .nfb_desc = "Measurement Link Speed",
        .nfb_type = NVMEADM_FT_HEX
} };

#define PHYEYE_F_EOM(f) .nf_off = offsetof(nvme_eom_hdr_t, eom_##f), \
        .nf_len = sizeof (((nvme_eom_hdr_t *)NULL)->eom_##f), \
        .nf_short = #f

static const nvmeadm_field_t phyeye_eom_fields[] = { {
        PHYEYE_F_EOM(lid),
        .nf_desc = "Log Identifier",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_EOM(eomip),
        .nf_desc = "EOM In Progress",
        .nf_type = NVMEADM_FT_STRMAP,
        .nf_strs = { "no measurement", "in progress", "completed" },
}, {
        PHYEYE_F_EOM(hsize),
        .nf_desc = "Header Size",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_EOM(rsz),
        .nf_desc = "Result Size",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_EOM(edgn),
        .nf_desc = "EOM Data Generation Number",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_EOM(lrev),
        .nf_desc = "Log Revision",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_EOM(odp),
        .nf_desc = "Optional Data Present",
        NVMEADM_F_BITS(phyeye_eom_odp_bits)
}, {
        PHYEYE_F_EOM(lns),
        .nf_desc = "Lanes",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_EOM(epl),
        .nf_desc = "Eyes Per Lane",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_EOM(lspfc),
        .nf_desc = "Log Specific Parameter Field Copy",
        NVMEADM_F_BITS(phyeye_eom_lspfc_bits)
}, {
        PHYEYE_F_EOM(linfo),
        .nf_desc = "Link Information",
        NVMEADM_F_BITS(phyeye_eom_linfo_bits)
}, {
        PHYEYE_F_EOM(lsic),
        .nf_desc = "Log Specific Identifier Copy",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_EOM(ds),
        .nf_desc = "Descriptor Size",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_EOM(nd),
        .nf_desc = "Number of Descriptors",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_EOM(maxtb),
        .nf_desc = "Maximum Top Bottom",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_EOM(maxlr),
        .nf_desc = "Maximum Left Right",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_EOM(etgood),
        .nf_desc = "Estimated Time for Good Quality",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_EOM(etbetter),
        .nf_desc = "Estimated Time for Better Quality",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_EOM(etbest),
        .nf_desc = "Estimated Time for Best Quality",
        .nf_type = NVMEADM_FT_HEX
} };

static const nvmeadm_field_bit_t phyeye_eld_mstat_bits[] = { {
        .nfb_lowbit = 0, .nfb_hibit = 0,
        .nfb_short = "mscs",
        .nfb_desc = "Measurement Successful",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "no", "yes" }
} };

#define PHYEYE_F_ELD(f) .nf_off = offsetof(nvme_eom_lane_desc_t, eld_##f), \
        .nf_len = sizeof (((nvme_eom_lane_desc_t *)NULL)->eld_##f), \
        .nf_short = #f

static const nvmeadm_field_t phyeye_elm_fields[] = { {
        PHYEYE_F_ELD(mstat),
        .nf_desc = "Measurement Status",
        NVMEADM_F_BITS(phyeye_eld_mstat_bits)
}, {
        PHYEYE_F_ELD(ln),
        .nf_desc = "Lane",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_ELD(eye),
        .nf_desc = "Eye",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_ELD(top),
        .nf_desc = "Top",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_ELD(btm),
        .nf_desc = "Bottom",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_ELD(lft),
        .nf_desc = "Left",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_ELD(rgt),
        .nf_desc = "Right",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_ELD(nrows),
        .nf_desc = "Number of Rows",
        .nf_type = NVMEADM_FT_HEX
}, {
        PHYEYE_F_ELD(ncols),
        .nf_desc = "Number of Columns",
        .nf_type = NVMEADM_FT_HEX
}, {
        /*
         * The size of this field changed between revision 2 and 3 from 2 bytes
         * to 4 bytes.
         */
        .nf_off = offsetof(nvme_eom_lane_desc_t, eld_edlen),
        .nf_len = sizeof (uint16_t),
        .nf_short = "edlen",
        .nf_desc = "Eye Data Length",
        .nf_type = NVMEADM_FT_HEX,
        .nf_rev = 2
}, {
        PHYEYE_F_ELD(edlen),
        .nf_desc = "Eye Data Length",
        .nf_type = NVMEADM_FT_HEX,
        .nf_rev = 3
} };

void
usage_measure_phyeye_cmd(const char *c_name)
{
        (void) fprintf(stderr, "%s -o output [-Q good | better | best] "
            "<ctl>\n\n", c_name);
        (void) fprintf(stderr, "  Gather physical eye opening measurements "
            "from the named controller and save\n  them to the specified "
            "output file. The best quality measurement is taken by\n  "
            "default. No other administrative operations can be executed "
            "during the eye\n  measurement.\n");
}

void
optparse_measure_phyeye_cmd(nvme_process_arg_t *npa)
{
        int c;
        phyeye_measure_t *phy;

        if ((phy = calloc(1, sizeof (phyeye_measure_t))) == NULL) {
                err(-1, "failed to allocate memory for option tracking");
        }

        /*
         * Default to best quality if not otherwise requested.
         */
        phy->pm_qual = NVME_EOM_LSP_MQUAL_BEST;

        while ((c = getopt(npa->npa_argc, npa->npa_argv, ":o:Q:")) != -1) {
                switch (c) {
                case 'o':
                        phy->pm_output = optarg;
                        break;
                case 'Q':
                        if (strcasecmp(optarg, "good") == 0) {
                                phy->pm_qual = NVME_EOM_LSP_MQUAL_GOOD;
                        } else if (strcasecmp(optarg, "better") == 0) {
                                phy->pm_qual = NVME_EOM_LSP_MQUAL_BETTER;

                        } else if (strcasecmp(optarg, "best") == 0) {
                                phy->pm_qual = NVME_EOM_LSP_MQUAL_BEST;

                        } else {
                                errx(-1, "invalid quality value %s: valid "
                                    "values are 'good', 'better', or 'best'",
                                    optarg);
                        }
                        break;
                case '?':
                        errx(-1, "unknown option: -%c", optopt);
                case ':':
                        errx(-1, "option -%c requires an argument", optopt);
                }
        }

        if (phy->pm_output == NULL) {
                errx(-1, "missing required output file (-o)");
        }

        npa->npa_cmd_arg = phy;
}

/*
 * Poll the log page until it is done and ready. We always do the initial wait.
 * The specification says that this may take longer due to activity on the
 * device. We will wait up to 3x the amount of time that was indicated for this
 * measurement. We will begin using a 1 second delay after this point.
 *
 * This explicitly uses a volatile pointer for 'eom' due to the fact that the
 * log page execution will update the data that it points to.
 */
static void
nvmeadm_phyeye_wait(const nvme_process_arg_t *npa, nvme_log_req_t *req,
    volatile nvme_eom_hdr_t *eom, uint16_t wait, const char *qual)
{
        hrtime_t start = gethrtime();
        hrtime_t end = start + wait * NANOSEC;
        hrtime_t now = start;
        hrtime_t max = start + wait * 3 * NANOSEC;
        const bool tty = isatty(STDOUT_FILENO);

        (void) printf("device indicates a minimum %u second wait for %s "
            "quality phyeye measurement\n", wait, qual);
        while (now < end) {
                if (tty) {
                        (void) printf("\r%u/%u seconds elapsed",
                            (now - start) / NANOSEC, wait);
                        (void) fflush(stdout);
                }
                (void) sleep(1);
                now = gethrtime();
        }

        if (tty) {
                (void) printf("\r%u/%u seconds elapsed\n", wait, wait);
        }

        if (!nvme_log_req_exec(req)) {
                nvmeadm_fatal(npa, "failed to retrieve phyeye measurement log "
                    "request");
        }

        if (eom->eom_eomip == NVME_EOM_DONE) {
                return;
        }

        (void) printf("Measurement incomplete, proceeding to check over an "
            "additional %u seconds\n", max - wait);
        uint32_t extra = 0;
        now = gethrtime();
        hrtime_t phase2 = now;
        while (now < max) {
                (void) sleep(1);

                if (!nvme_log_req_exec(req)) {
                        nvmeadm_fatal(npa, "failed to issue start phyeye "
                            "measurement log request");
                }

                now = gethrtime();

                if (eom->eom_eomip == NVME_EOM_DONE) {
                        return;
                }

                extra++;
                if (tty) {
                        (void) printf("\rMeasurement still not available after "
                            "%u attempts (%u seconds)", extra, (now - phase2) /
                            NANOSEC);
                        (void) fflush(stdout);
                }
        }

        errx(-1, "timed out waiting for the phyeye measurement to finish after "
            "%u seconds: final measurement state: %u", wait * 3,
            eom->eom_eomip);
}

static void
nvmeadm_phyeye_read(const nvme_process_arg_t *npa, nvme_log_req_t *req,
    void *buf, size_t len, uint64_t off)
{
        if (!nvme_log_req_set_output(req, buf, len)) {
                nvmeadm_fatal(npa, "failed to set output buffer");
        }

        if (!nvme_log_req_set_offset(req, off)) {
                nvmeadm_fatal(npa, "failed to set offset to 0x%lx", off);
        }

        if (!nvme_log_req_exec(req)) {
                nvmeadm_fatal(npa, "failed to read %zu bytes at 0x%lx", len,
                    off);
        }
}

static void
nvmeadm_phyeye_write(int fd, const void *buf, size_t len, off_t off)
{
        size_t loff = 0;

        while (len > 0) {
                ssize_t ret = pwrite(fd, buf + loff, len, off + loff);
                if (ret < 0) {
                        err(EXIT_FAILURE, "failed to write to physical eye "
                            "measurement output file");
                }

                loff += (size_t)ret;
                len -= (size_t)ret;
        }
}

/*
 * Perform a physical eye measurement. This consists of a few different steps to
 * execute it successfully:
 *
 * 1. First determine that we can actually issue this command.
 * 2. Open the output file early. While this may mean we truncate something,
 *    given that this command may take some time, that's better than finding out
 *    after you've already done all the work.
 * 3. We issue the first phy eye get log page command with the request to begin
 *    a new measurement at the requested quality. We need to set the LSP, LSI,
 *    and output buffer for this.
 * 4. We wait for the requested number of seconds before beginning to query for
 *    result data.
 * 5. Once a second, we issue commands trying to see if it's done.
 * 6. Once it's finally done, then we'll go ahead and actually finish getting
 *    the log page data and write it out to disk.
 * 7. When we're done with all the data, confirm that the generation is still
 *    the same as when we started.
 */
int
do_measure_phyeye_cmd(const nvme_process_arg_t *npa)
{
        int fd = -1;
        nvme_log_req_t *req = NULL;
        nvme_log_disc_t *disc = NULL;
        nvme_eom_lsp_t lsp;
        const phyeye_measure_t *phy = npa->npa_cmd_arg;
        void *buf = NULL;
        uint64_t min_len;
        nvme_log_size_kind_t lkind;

        if (!nvme_log_req_init_by_name(npa->npa_ctrl, "phyeye", 0, &disc,
            &req)) {
                nvmeadm_fatal(npa, "failed to initialize phyeye log request");
        }

        if ((fd = open(phy->pm_output, O_RDWR | O_CREAT | O_TRUNC, 0644)) < 0) {
                err(-1, "failed to open output file %s", phy->pm_output);
        }

        if ((buf = malloc(PHYEYE_BUFSIZE)) == NULL) {
                err(-1, "failed to allocate internal phy data buffer");
        }

        if (!nvme_log_req_set_lsi(req, npa->npa_idctl->id_cntlid)) {
                nvmeadm_fatal(npa, "failed to set lsi for phyeye measurement");
        }

        (void) memset(&lsp, 0, sizeof (lsp));
        lsp.nel_mqual = phy->pm_qual;
        lsp.nel_act = NVME_EOM_LSP_START;

        if (!nvme_log_req_set_lsp(req, lsp.r)) {
                nvmeadm_fatal(npa, "failed to set lsp for phyeye measurement");
        }

        lkind = nvme_log_disc_size(disc, &min_len);
        VERIFY3U(lkind, ==, NVME_LOG_SIZE_K_VAR);
        VERIFY3U(min_len, >=, sizeof (nvme_eom_hdr_t));

        if (!nvme_log_req_set_output(req, buf, min_len)) {
                nvmeadm_fatal(npa, "failed to set initial output buffer and "
                    "length");
        }

        if (!nvme_log_req_exec(req)) {
                nvmeadm_fatal(npa, "failed to issue start phyeye measurement "
                    "log request");
        }

        /*
         * Update the request for the rest of this to always be a read request
         * of the existing measurement.
         */
        lsp.nel_act = NVME_EOM_LSP_READ;
        if (!nvme_log_req_set_lsp(req, lsp.r)) {
                nvmeadm_fatal(npa, "failed to update lsp for phyeye "
                    "measurement");
        }

        /*
         * The use of volatile here is probably a little weird. But this is
         * aliasing memory that the log req exec will constantly be updating.
         */
        const volatile nvme_eom_hdr_t *eom = buf;
        if (eom->eom_eomip != NVME_EOM_IN_PROGRESS) {
                warnx("EOM in progress in header is not in-progress, found %u: "
                    "waiting the appropriate time regardless", eom->eom_eomip);
        }

        const uint8_t eom_gen = eom->eom_edgn;

        uint16_t wait;
        const char *desc;
        if (phy->pm_qual == NVME_EOM_LSP_MQUAL_GOOD) {
                wait = eom->eom_etgood;
                desc = "good";
        } else if (phy->pm_qual == NVME_EOM_LSP_MQUAL_BETTER) {
                wait = eom->eom_etbetter;
                desc = "better";
        } else {
                wait = eom->eom_etbest;
                desc = "best";
        }
        nvmeadm_phyeye_wait(npa, req, buf, wait, desc);

        /*
         * Go ahead and calculate the final size. At this point we'll issue
         * requests that adjust the overall offset until we read everything and
         * write that out.
         */
        uint64_t act_len, off = 0;
        if (!nvme_log_disc_calc_size(disc, &act_len, buf, min_len)) {
                errx(-1, "failed to determine full phyeye log length");
        }

        while (off < act_len) {
                size_t to_read = MIN(act_len - off, PHYEYE_BUFSIZE);
                nvmeadm_phyeye_read(npa, req, buf, to_read, off);
                nvmeadm_phyeye_write(fd, buf, to_read, off);
                off += to_read;
        }

        /*
         * Now that we're done, get the initial header's worth of data again and
         * verify its generation to make sure nothing has changed on us.
         */
        nvmeadm_phyeye_read(npa, req, buf, sizeof (nvme_eom_hdr_t), 0);
        if (eom->eom_edgn != eom_gen) {
                (void) unlink(phy->pm_output);
                errx(-1, "PHY eye measurement generation unexpectedly changed: "
                    "was 0x%x, now is 0x%x: aborting", eom_gen, eom->eom_edgn);
        }

        /*
         * Note we don't actually clear the data here and basically are willing
         * to leave this in the controller at this point.
         */
        (void) printf("phyeye successfully written to %s\n", phy->pm_output);

        free(buf);
        if (fd >= 0) {
                VERIFY0(close(fd));
        }
        nvme_log_disc_free(disc);
        nvme_log_req_fini(req);
        return (0);
}

void
usage_report_phyeye_cmd(const char *c_name)
{
        (void) fprintf(stderr, "%s -f file [-l lane] [-e eye] [-m mode] "
            "<ctl>\n\n", c_name);
        (void) fprintf(stderr, "  Report information about a physical eye "
            "measurement. Eye measurements can be\n  taken with \"nvmeadm "
            "measure-phyeye\".\n");
}

void
optparse_report_phyeye_cmd(nvme_process_arg_t *npa)
{
        int c;
        phyeye_report_t *phy;

        if ((phy = calloc(1, sizeof (phyeye_report_t))) == NULL) {
                err(-1, "failed to allocate memory for option tracking");
        }

        phy->pr_npa = npa;
        phy->pr_mode = PHYEYE_REPORT_M_ASCII;
        phy->pr_lane = UINT8_MAX;
        phy->pr_eye = UINT8_MAX;

        while ((c = getopt(npa->npa_argc, npa->npa_argv, ":e:f:l:m:")) != -1) {
                const char *errstr;

                switch (c) {
                case 'e':
                        phy->pr_eye = strtonumx(optarg, 0, PHYEYE_MAX_EYE,
                            &errstr, 0);
                        if (errstr != NULL) {
                                errx(-1, "failed to parse eye: value %s is "
                                    "%s: valid values are in the range [%u, "
                                    "%u]", optarg, errstr, 0, PHYEYE_MAX_EYE);
                        }
                        break;
                case 'f':
                        phy->pr_input = optarg;
                        break;
                case 'l':
                        phy->pr_lane = strtonumx(optarg, 0, PHYEYE_MAX_LANE,
                            &errstr, 0);
                        if (errstr != NULL) {
                                errx(-1, "failed to parse lane: value %s is "
                                    "%s: valid values are in the range [%u, "
                                    "%u]", optarg, errstr, 0, PHYEYE_MAX_LANE);
                        }
                        break;
                case 'm':
                        if (strcasecmp(optarg, "print-eye") == 0) {
                                phy->pr_mode = PHYEYE_REPORT_M_ASCII;
                        } else if (strcasecmp(optarg, "eye-data") == 0) {
                                phy->pr_mode = PHYEYE_REPORT_M_OED;
                        } else {
                                errx(-1, "invalid mode value: %s: valid values "
                                    "are 'print-eye' or 'eye-data'", optarg);
                        }
                        break;
                case '?':
                        errx(-1, "unknown option: -%c", optopt);
                case ':':
                        errx(-1, "option -%c requires an argument", optopt);

                }
        }

        if (phy->pr_input == NULL) {
                errx(-1, "missing required input file to process (-f)");
        }

        npa->npa_cmd_arg = phy;
}

/*
 * Normalize the optional eye data length. This is a uint32_t in revision 3
 * logs, but a uint16_t in revision 2 logs.
 */
static uint32_t
phyeye_eol_oed_len(const nvme_eom_hdr_t *hdr, const nvme_eom_lane_desc_t *desc)
{
        uint16_t u16;

        if (hdr->eom_lrev >= 3) {
                return (desc->eld_edlen);
        }

        (void) memcpy(&u16, &desc->eld_edlen, sizeof (uint16_t));
        return (u16);
}

typedef void (*phyeye_lane_iter_cb_f)(uint8_t, const nvme_eom_hdr_t *,
    const nvme_eom_lane_desc_t *, void *);

static bool
phyeye_lane_iter(const nvme_eom_hdr_t *hdr, off_t max,
    void *arg, phyeye_lane_iter_cb_f func, uint8_t lane, uint8_t eye)
{
        off_t cur_off = sizeof (nvme_eom_hdr_t);
        bool ret = true;

        for (uint16_t i = 0; i < hdr->eom_nd; i++) {
                const nvme_eom_lane_desc_t *desc = NULL;
                size_t dlen = sizeof (nvme_eom_lane_desc_t);

                if (cur_off + hdr->eom_ds > max) {
                        errx(-1, "failed to iterate EOM Lane descriptors: "
                            "descriptor %u starts at offset 0x%lx, but its "
                            "size (0x%x) would exceed the maximum file length "
                            "of 0x%lx", i, cur_off, hdr->eom_ds, max);
                }

                desc = (const nvme_eom_lane_desc_t *)((uintptr_t)hdr + cur_off);

                if (hdr->eom_odp.odp_pefp != 0) {
                        if (desc->eld_nrows == 0 || desc->eld_ncols == 0) {
                                errx(-1, "printable eye feature present but "
                                    "both NROWS (0x%x) and NCOLS (0x%x) are "
                                    "not non-zero", desc->eld_nrows,
                                    desc->eld_ncols);
                        }

                        dlen += desc->eld_nrows * desc->eld_ncols;
                } else if (desc->eld_nrows != 0 || desc->eld_ncols != 0) {
                        errx(-1, "printable eye feature not present but both "
                            "NROWS (0x%x) and NCOLS (0x%x) are not zero",
                            desc->eld_nrows, desc->eld_ncols);
                }

                const uint32_t oed_len = phyeye_eol_oed_len(hdr, desc);
                if (hdr->eom_odp.odp_edfp != 0) {
                        if (oed_len == 0) {
                                errx(-1, "optional eye data feature present, "
                                    "but eye data has a zero-length");
                        }

                        dlen += oed_len;
                } else if (oed_len != 0) {
                        errx(-1, "optional eye data feature not present, but "
                            "eye data has a non-zero length (0x%x)", oed_len);
                }

                if (dlen > hdr->eom_ds) {
                        errx(-1, "failed to iterate EOM Lane descriptors: "
                            "descriptor %u starts at offset 0x%lx, has a "
                            "calculated size (0x%zx) that exceeds the "
                            "header's max descriptor size (0x%x)", i, cur_off,
                            dlen, hdr->eom_ds);
                }

                /*
                 * Now that we've validated this we need to check a few things
                 * before we call the command:
                 *
                 * 1. This matches our eye and lane filter.
                 * 2. The data is valid.
                 */
                if (lane != UINT8_MAX && desc->eld_ln != lane)
                        goto next;
                if (eye != UINT8_MAX && desc->eld_eye != eye)
                        goto next;
                if (desc->eld_mstat.mstat_mcsc == 0) {
                        warnx("lane %u, eye %u data does not have a successful "
                            "measurement", desc->eld_ln, desc->eld_eye);
                        ret = false;
                        goto next;
                }

                func(i, hdr, desc, arg);

next:
                cur_off += dlen;
        }

        return (ret);
}

/*
 * Validate the data that we have. In particular we need to confirm:
 *
 * 1. The data file covers the entire header.
 * 2. This is a log revision we know about.
 * 3. The measurement is completed.
 * 4. The header size reported is what we expect.
 * 5. The result size is covered by the file.
 * 6. If a specific mode requires optional data, it is present.
 * 7. There is a non-zero number of descriptors.
 * 8. The descriptor size covers at least the Lane descriptor structure.
 * 9. DS * NDS is within the result size.
 *
 * The specifics of each descriptor are checked when we iterate over them in
 * phyeye_eol_iter().
 */
static void
phyeye_report_sanity_check(const nvme_eom_hdr_t *hdr, off_t len,
    const phyeye_report_t *phy)
{
        if (len < sizeof (nvme_eom_hdr_t)) {
                errx(-1, "data file is too short: file does not cover the "
                    "0x%lx bytes required for the Eye Opening Measurement "
                    "header", sizeof (nvme_eom_hdr_t));
        }

        /*
         * This specification was first introduced in the NVMe PCIe revision 1.1
         * at log revision 2. It moved to version 3 with NVMe PCIe 1.2. However,
         * some devices report log revision 1 which means they likely implement
         * a draft version of the TP. We don't know what's different between
         * version 1 and 2, but hope for the sake of understanding right now
         * it doesn't impact our ability to translate this.
         */
        if (hdr->eom_lrev < 1 || hdr->eom_lrev > 3) {
                errx(-1, "encountered unknown log header revision: 0x%x",
                    hdr->eom_lrev);
        }

        /*
         * Only worry about complete measurements if we're doing a report, not
         * if we're just printing the log.
         */
        if (phy != NULL && hdr->eom_eomip != NVME_EOM_DONE) {
                errx(-1, "data file measurement in progress field does not "
                    "indicate a finished measurement (%u): found %u",
                    NVME_EOM_DONE, hdr->eom_eomip);
        }

        if (hdr->eom_hsize != sizeof (nvme_eom_hdr_t)) {
                errx(-1, "data file has unexpected header length: found 0x%x, "
                    "expected 0x%zx", hdr->eom_hsize, sizeof (nvme_eom_hdr_t));
        }

        if (hdr->eom_rsz > len) {
                errx(-1, "data file reports that the log is 0x%x bytes, but "
                    "file is only 0x%lx bytes", hdr->eom_rsz, len);
        }

        if (phy != NULL && phy->pr_mode == PHYEYE_REPORT_M_ASCII &&
            hdr->eom_odp.odp_pefp == 0) {
                errx(-1, "Printable Eye requested, but field not present in "
                    "data file");
        }

        if (phy != NULL && phy->pr_mode == PHYEYE_REPORT_M_OED &&
            hdr->eom_odp.odp_edfp == 0) {
                errx(-1, "Eye Data Field requested, but field not present in "
                    "data file");
        }

        if (phy != NULL && hdr->eom_nd == 0) {
                errx(-1, "data file reports no EOM lane descriptors present");
        }

        if (hdr->eom_nd > 0 && hdr->eom_ds < sizeof (nvme_eom_lane_desc_t)) {
                errx(-1, "data file reports the descriptor size is 0x%x, but "
                    "that is less than the base descriptor size of 0x%zx",
                    hdr->eom_ds, sizeof (nvme_eom_lane_desc_t));
        }
}

static void
phyeye_report_ascii(uint8_t descno, const nvme_eom_hdr_t *hdr,
    const nvme_eom_lane_desc_t *desc, void *arg)
{
        phyeye_report_t *phy = arg;

        phy->pr_print = true;
        (void) printf("Lane %u, Eye %u: Printable Eye\n", desc->eld_ln,
            desc->eld_eye);
        for (uint16_t row = 0; row < desc->eld_nrows; row++) {
                for (uint16_t col = 0; col < desc->eld_ncols; col++) {
                        const uint32_t off = row * desc->eld_ncols + col;
                        uint8_t c = desc->eld_data[off];
                        if (c != '0' && c != '1')
                                c = '?';
                        (void) putc(c, stdout);
                }
                (void) putc('\n', stdout);
        }
}

static void
phyeye_report_oed(uint8_t descno, const nvme_eom_hdr_t *hdr,
    const nvme_eom_lane_desc_t *desc, void *arg)
{
        phyeye_report_t *phy = arg;

        size_t off = desc->eld_nrows * desc->eld_ncols;

        phy->pr_print = true;
        (void) printf("Lane %u, Eye %u: Eye Data\n", desc->eld_ln,
            desc->eld_eye);
        nvmeadm_dump_hex(&desc->eld_data[off], desc->eld_edlen);
}

int
do_report_phyeye_cmd(const nvme_process_arg_t *npa)
{
        int fd = -1, ret = EXIT_SUCCESS;
        struct stat st;
        void *data;
        phyeye_report_t *phy = npa->npa_cmd_arg;
        phyeye_lane_iter_cb_f func = NULL;

        if (npa->npa_argc > 0) {
                errx(-1, "extraneous arguments beginning with '%s'",
                    npa->npa_argv[0]);
        }

        if ((fd = open(phy->pr_input, O_RDONLY)) < 0) {
                err(-1, "failed to open input file %s", phy->pr_input);
        }

        if (fstat(fd, &st) != 0) {
                err(-1, "failed to stat %s", phy->pr_input);
        }

        if (st.st_size > NVMEADM_MAX_MMAP) {
                errx(-1, "%s file size of 0x%lx exceeds maximum allowed size "
                    "of 0x%llx", phy->pr_input, st.st_size, NVMEADM_MAX_MMAP);
        }

        data = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
        if (data == MAP_FAILED) {
                errx(-1, "failed to mmap %s", phy->pr_input);
        }

        phyeye_report_sanity_check(data, st.st_size, phy);

        switch (phy->pr_mode) {
        case PHYEYE_REPORT_M_ASCII:
                func = phyeye_report_ascii;
                break;
        case PHYEYE_REPORT_M_OED:
                func = phyeye_report_oed;
                break;
        }

        if (!phyeye_lane_iter(data, st.st_size, phy, func, phy->pr_lane,
            phy->pr_eye)) {
                ret = -1;
        }

        /*
         * If nothing was printed, warn and error about this if we had an eye
         * constraint, a lane constraint, or the mode isn't decoding. We want to
         * be able to decode a log that has no data.
         */
        if (!phy->pr_print) {
                warnx("failed to match and print any data");
                ret = -1;
        }

        VERIFY0(munmap(data, st.st_size));
        if (fd >= 0) {
                VERIFY0(close(fd));
        }

        return (ret);
}

static uint32_t
phyeye_log_getrev(const void *data, size_t len)
{
        const nvme_eom_hdr_t *hdr = data;
        return (hdr->eom_lrev);
}

static void
phyeye_log_drive_lane_cb(uint8_t descno, const nvme_eom_hdr_t *hdr,
    const nvme_eom_lane_desc_t *desc, void *arg)
{
        char base[32];
        char header[128];
        nvmeadm_field_print_t *print = arg;

        (void) snprintf(base, sizeof (base), "eld%u", descno);
        (void) snprintf(header, sizeof (header), "EOM Lane Descriptor %u",
            descno);

        print->fp_header = header;
        print->fp_fields = phyeye_elm_fields;
        print->fp_nfields = ARRAY_SIZE(phyeye_elm_fields);
        print->fp_base = base;
        print->fp_data = desc;
        print->fp_dlen = hdr->eom_ds;
        print->fp_off = (uintptr_t)desc - (uintptr_t)hdr;

        nvmeadm_field_print(print);
}

static bool
phyeye_log_drive(nvmeadm_field_print_t *print, const void *data, size_t len)
{
        print->fp_header = "EOM Header";
        print->fp_fields = phyeye_eom_fields;
        print->fp_nfields = ARRAY_SIZE(phyeye_eom_fields);
        print->fp_base = "eom";
        print->fp_data = data;
        print->fp_dlen = len;
        print->fp_off = 0;

        phyeye_report_sanity_check(data, len, NULL);
        nvmeadm_field_print(print);

        return (phyeye_lane_iter(data, len, print, phyeye_log_drive_lane_cb,
            UINT8_MAX, UINT8_MAX));
}

const nvmeadm_log_field_info_t phyeye_field_info = {
        .nlfi_log = "phyeye",
        .nlfi_min = sizeof (nvme_eom_hdr_t),
        .nlfi_getrev = phyeye_log_getrev,
        .nlfi_drive = phyeye_log_drive
};