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

/*
 * Field information for OCP logs.
 */

#include <err.h>
#include <string.h>
#include <sys/stddef.h>
#include <sys/sysmacros.h>
#include <sys/nvme/ocp.h>

#include "nvmeadm.h"

#define OCP_F_SMART(f)  .nf_off = offsetof(ocp_vul_smart_t, osh_##f), \
        .nf_len = sizeof (((ocp_vul_smart_t *)NULL)->osh_##f)

static const nvmeadm_field_bit_t ocp_vul_smart_block_bits[] = { {
        .nfb_lowbit = 0, .nfb_hibit = 47,
        .nfb_short = "raw",
        .nfb_desc = "Raw Count",
        .nfb_type = NVMEADM_FT_HEX,
}, {
        .nfb_lowbit = 48, .nfb_hibit = 63,
        .nfb_short = "norm",
        .nfb_desc = "Normalized Value",
        .nfb_type = NVMEADM_FT_PERCENT,
} };

static const nvmeadm_field_bit_t ocp_vul_smart_e2e_bits[] = { {
        .nfb_lowbit = 0, .nfb_hibit = 31,
        .nfb_short = "det",
        .nfb_desc = "Detected Errors",
        .nfb_type = NVMEADM_FT_HEX,
}, {
        .nfb_lowbit = 32, .nfb_hibit = 63,
        .nfb_short = "cor",
        .nfb_desc = "Corrected Errors",
        .nfb_type = NVMEADM_FT_HEX
} };

static const nvmeadm_field_bit_t ocp_vul_smart_udec_bits[] = { {
        .nfb_lowbit = 0, .nfb_hibit = 31,
        .nfb_short = "max",
        .nfb_desc = "Maximum Count",
        .nfb_type = NVMEADM_FT_HEX,
}, {
        .nfb_lowbit = 32, .nfb_hibit = 63,
        .nfb_short = "min",
        .nfb_desc = "Minimum Count",
        .nfb_type = NVMEADM_FT_HEX
} };

static const nvmeadm_field_bit_t ocp_vul_smart_therm_bits[] = { {
        .nfb_lowbit = 0, .nfb_hibit = 7,
        .nfb_short = "events",
        .nfb_desc = "Throttling Events",
        .nfb_type = NVMEADM_FT_HEX,
}, {
        .nfb_lowbit = 8, .nfb_hibit = 15,
        .nfb_short = "status",
        .nfb_desc = "Current Throttling Status",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unthrottled", "first level", "second level",
            "third level" }
} };

static const nvmeadm_field_bit_t ocp_vul_smart_dssd_bits[] = { {
        .nfb_lowbit = 0, .nfb_hibit = 7,
        .nfb_short = "errata",
        .nfb_desc = "Errata Version",
        .nfb_type = NVMEADM_FT_HEX,
}, {
        .nfb_lowbit = 8, .nfb_hibit = 23,
        .nfb_short = "point",
        .nfb_desc = "Point Version",
        .nfb_type = NVMEADM_FT_HEX,
}, {
        .nfb_lowbit = 24, .nfb_hibit = 39,
        .nfb_short = "minor",
        .nfb_desc = "Minor Version",
        .nfb_type = NVMEADM_FT_HEX,
}, {
        .nfb_lowbit = 40, .nfb_hibit = 47,
        .nfb_short = "major",
        .nfb_desc = "Major Version",
        .nfb_type = NVMEADM_FT_HEX,
} };

static const nvmeadm_field_t ocp_vul_smart_fields[] = { {
        OCP_F_SMART(pmed_write),
        .nf_short = "pmuw",
        .nf_desc = "Physical Media Units Written",
        .nf_type = NVMEADM_FT_BYTES
}, {
        OCP_F_SMART(pmed_read),
        .nf_short = "pmur",
        .nf_desc = "Physical Media Units Read",
        .nf_type = NVMEADM_FT_BYTES
}, {
        OCP_F_SMART(bunb),
        .nf_short = "bunb",
        .nf_desc = "Bad User NAND Blocks",
        NVMEADM_F_BITS(ocp_vul_smart_block_bits)
}, {
        OCP_F_SMART(bsnb),
        .nf_short = "bsnb",
        .nf_desc = "Bad System NAND Blocks",
        NVMEADM_F_BITS(ocp_vul_smart_block_bits)
}, {
        OCP_F_SMART(xor_rec),
        .nf_short = "xrc",
        .nf_desc = "XOR Recovery Count",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_SMART(read_unrec),
        .nf_short = "urec",
        .nf_desc = "Uncorrectable Read Error Count",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_SMART(soft_ecc_err),
        .nf_short = "seec",
        .nf_desc = "Soft ECC Error Count",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_SMART(e2e),
        .nf_short = "e2e",
        .nf_desc = "End to End Correction Counts",
        NVMEADM_F_BITS(ocp_vul_smart_e2e_bits)
}, {
        OCP_F_SMART(sys_used),
        .nf_short = "sdu",
        .nf_desc = "System Data Percent Used",
        .nf_type = NVMEADM_FT_PERCENT
}, {
        OCP_F_SMART(refresh),
        .nf_short = "refresh",
        .nf_desc = "Refresh Counts",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_SMART(udec),
        .nf_short = "udec",
        .nf_desc = "User Data Erase Counts",
        NVMEADM_F_BITS(ocp_vul_smart_udec_bits)
}, {
        OCP_F_SMART(therm),
        .nf_short = "therm",
        .nf_desc = "Thermal Throttling Status and Count",
        NVMEADM_F_BITS(ocp_vul_smart_therm_bits)
}, {
        OCP_F_SMART(dssd),
        .nf_short = "dssd",
        .nf_desc = "DSSD Specification Version",
        .nf_rev = 3,
        NVMEADM_F_BITS(ocp_vul_smart_dssd_bits)
}, {
        OCP_F_SMART(pcie_errcor),
        .nf_short = "pcicor",
        .nf_desc = "PCIe Correctable Error Count",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_SMART(inc_shut),
        .nf_short = "incshut",
        .nf_desc = "Incomplete Shutdowns",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_SMART(free),
        .nf_short = "freeblk",
        .nf_desc = "Percent Free Blocks",
        .nf_type = NVMEADM_FT_PERCENT
}, {
        OCP_F_SMART(cap_health),
        .nf_short = "cap",
        .nf_desc = "Capacitor Health",
        .nf_type = NVMEADM_FT_PERCENT
}, {
        OCP_F_SMART(nvme_base_errata),
        .nf_short = "baseev",
        .nf_desc = "NVMe Base Errata Version",
        .nf_rev = 3,
        .nf_type = NVMEADM_FT_ASCII
}, {
        OCP_F_SMART(nvme_cmd_errata),
        .nf_short = "cmdev",
        .nf_desc = "NVMe Command Set Errata Version",
        .nf_rev = 4,
        .nf_type = NVMEADM_FT_ASCII
}, {
        OCP_F_SMART(unaligned),
        .nf_short = "unalign",
        .nf_desc = "Unaligned I/O",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_SMART(sec_vers),
        .nf_short = "secvers",
        .nf_desc = "Security Version Number",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_SMART(nuse),
        .nf_short = "nuse",
        .nf_desc = "Total NUSE",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_SMART(plp_start),
        .nf_short = "plp",
        .nf_desc = "PLP Start Count",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_SMART(endurance),
        .nf_short = "endest",
        .nf_desc = "Endurance Estimate",
        .nf_type = NVMEADM_FT_BYTES
}, {
        OCP_F_SMART(pcie_retrain),
        .nf_short = "retrain",
        .nf_desc = "PCIe Link Retraining Count",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_SMART(ps_change),
        .nf_short = "pstate",
        .nf_desc = "Power State Change Count",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_SMART(min_fwrev),
        .nf_short = "minfw",
        .nf_desc = "Lowest Permitted Firmware Revision",
        .nf_type = NVMEADM_FT_ASCII
}, {
        OCP_F_SMART(vers),
        .nf_short = "lpv",
        .nf_desc = "Log Page Version",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_SMART(guid),
        .nf_short = "lpg",
        .nf_desc = "Log Page GUID",
        .nf_type = NVMEADM_FT_GUID
} };

static uint32_t
ocp_vul_smart_getvers(const void *data, size_t len)
{
        if (len < sizeof (ocp_vul_smart_t)) {
                errx(-1, "cannot parse revision information, found 0x%zx "
                    "bytes, need at least 0x%zx", len,
                    sizeof (ocp_vul_smart_t));
        }

        const ocp_vul_smart_t *log = data;
        return (log->osh_vers);
}

const nvmeadm_log_field_info_t ocp_vul_smart_field_info = {
        .nlfi_log = "ocp/smart",
        .nlfi_fields = ocp_vul_smart_fields,
        .nlfi_nfields = ARRAY_SIZE(ocp_vul_smart_fields),
        .nlfi_min = sizeof (ocp_vul_smart_t),
        .nlfi_getrev = ocp_vul_smart_getvers
};

#define OCP_F_ERRREC(f) .nf_off = offsetof(ocp_vul_errrec_t, oer_##f), \
        .nf_len = sizeof (((ocp_vul_errrec_t *)NULL)->oer_##f)

static const nvmeadm_field_bit_t ocp_vul_errrec_pra_bits[] = { {
        .nfb_lowbit = 0, .nfb_hibit = 0,
        .nfb_short = "ctrl",
        .nfb_desc = "NVMe Controller Reset",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "not required", "required" }
}, {
        .nfb_lowbit = 1, .nfb_hibit = 1,
        .nfb_short = "subsys",
        .nfb_desc = "NVMe Subsystem Reset",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "not required", "required" }
}, {
        .nfb_lowbit = 2, .nfb_hibit = 2,
        .nfb_short = "flr",
        .nfb_desc = "PCIe Function Level Reset",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "not required", "required" }
}, {
        .nfb_lowbit = 3, .nfb_hibit = 3,
        .nfb_short = "perst",
        .nfb_desc = "PERST#",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "not required", "required" }
}, {
        .nfb_lowbit = 4, .nfb_hibit = 4,
        .nfb_short = "power",
        .nfb_desc = "Main Power Cycle",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "not required", "required" }
}, {
        .nfb_lowbit = 5, .nfb_hibit = 5,
        .nfb_short = "hotrst",
        .nfb_desc = "PCIe Conventional Hot Reset",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "not required", "required" }
} };

static const nvmeadm_field_bit_t ocp_vul_errrec_dra_bits[] = { {
        .nfb_lowbit = 0, .nfb_hibit = 0,
        .nfb_short = "none",
        .nfb_desc = "No Action",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "not required", "required" }
}, {
        .nfb_lowbit = 1, .nfb_hibit = 1,
        .nfb_short = "fmt",
        .nfb_desc = "Format NVM",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "not required", "required" }
}, {
        .nfb_lowbit = 2, .nfb_hibit = 2,
        .nfb_short = "vsc",
        .nfb_desc = "Vendor Specific Command",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "not required", "required" }
}, {
        .nfb_lowbit = 3, .nfb_hibit = 3,
        .nfb_short = "valys",
        .nfb_desc = "Vendor Analysis",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "not required", "required" }
}, {
        .nfb_lowbit = 4, .nfb_hibit = 4,
        .nfb_short = "rep",
        .nfb_desc = "Device Replacement",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "not required", "required" }
}, {
        .nfb_lowbit = 5, .nfb_hibit = 5,
        .nfb_short = "san",
        .nfb_desc = "Sanitize",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "not required", "required" }
}, {
        .nfb_lowbit = 6, .nfb_hibit = 6,
        .nfb_short = "udl",
        .nfb_desc = "User Data Loss",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "not required", "required" }
} };

static const nvmeadm_field_bit_t ocp_vul_errrec_devcap_bits[] = { {
        .nfb_lowbit = 0, .nfb_hibit = 0,
        .nfb_short = "aen",
        .nfb_desc = "Panic AEN",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 1, .nfb_hibit = 1,
        .nfb_short = "cfs",
        .nfb_desc = "Panic CFS",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
} };

static const nvmeadm_field_t ocp_vul_errrec_fields[] = { {
        OCP_F_ERRREC(prwt),
        .nf_short = "prwt",
        .nf_desc = "Panic Reset Wait Time",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_ERRREC(pra),
        .nf_short = "pra",
        .nf_desc = "Panic Reset Action",
        NVMEADM_F_BITS(ocp_vul_errrec_pra_bits)
}, {
        OCP_F_ERRREC(dra),
        .nf_short = "dra",
        .nf_desc = "Device Recovery Action 1",
        NVMEADM_F_BITS(ocp_vul_errrec_dra_bits)
}, {
        OCP_F_ERRREC(panic_id),
        .nf_short = "id",
        .nf_desc = "Panic ID",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_ERRREC(devcap),
        .nf_short = "devcap",
        .nf_desc = "Device Capabilities",
        NVMEADM_F_BITS(ocp_vul_errrec_devcap_bits)
}, {
        OCP_F_ERRREC(vsr_opcode),
        .nf_short = "vsro",
        .nf_desc = "Vendor Specific Recovery Opcode",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_ERRREC(vsr_cdw12),
        .nf_short = "vcdw12",
        .nf_desc = "Vendor Specific Command CDW12",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_ERRREC(vsr_cdw13),
        .nf_short = "vcdw13",
        .nf_desc = "Vendor Specific Command CDW13",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_ERRREC(vsr_to),
        .nf_short = "vsct",
        .nf_desc = "Vendor Specific Command Timeout",
        .nf_rev = 2,
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_ERRREC(dra2),
        .nf_short = "dra2",
        .nf_desc = "Device Recovery Action 2",
        .nf_rev = 3,
        NVMEADM_F_BITS(ocp_vul_errrec_dra_bits)
}, {
        OCP_F_ERRREC(dra2_to),
        .nf_short = "dra2to",
        .nf_desc = "Device Recovery Action 2 Timeout",
        .nf_rev = 3,
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_ERRREC(npanic),
        .nf_short = "npanic",
        .nf_desc = "Panic Count",
        .nf_rev = 3,
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_ERRREC(old_panics[0]),
        .nf_short = "ppanic1",
        .nf_desc = "Previous Panic N-1",
        .nf_rev = 3,
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_ERRREC(old_panics[1]),
        .nf_short = "ppanic2",
        .nf_desc = "Previous Panic N-2",
        .nf_rev = 3,
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_ERRREC(old_panics[2]),
        .nf_short = "ppanic3",
        .nf_desc = "Previous Panic N-3",
        .nf_rev = 3,
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_ERRREC(old_panics[3]),
        .nf_short = "ppanic4",
        .nf_desc = "Previous Panic N-4",
        .nf_rev = 3,
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_ERRREC(vers),
        .nf_short = "lpv",
        .nf_desc = "Log Page Version",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_ERRREC(guid),
        .nf_short = "lpg",
        .nf_desc = "Log Page GUID",
        .nf_type = NVMEADM_FT_GUID
} };

static uint32_t
ocp_vul_errrec_getvers(const void *data, size_t len)
{
        if (len < sizeof (ocp_vul_errrec_t)) {
                errx(-1, "cannot parse revision information, found 0x%zx "
                    "bytes, need at least 0x%zx", len,
                    sizeof (ocp_vul_errrec_t));
        }

        const ocp_vul_errrec_t *log = data;
        return (log->oer_vers);
}

const nvmeadm_log_field_info_t ocp_vul_errrec_field_info = {
        .nlfi_log = "ocp/errrec",
        .nlfi_fields = ocp_vul_errrec_fields,
        .nlfi_nfields = ARRAY_SIZE(ocp_vul_errrec_fields),
        .nlfi_min = sizeof (ocp_vul_errrec_t),
        .nlfi_getrev = ocp_vul_errrec_getvers
};

#define OCP_F_DEVCAP(f) .nf_off = offsetof(ocp_vul_devcap_t, odc_##f), \
        .nf_len = sizeof (((ocp_vul_devcap_t *)NULL)->odc_##f)

#define OCP_F_DEVCAP_PSD(f)     { .nf_off = offsetof(ocp_vul_devcap_t, \
        odc_dssd[f]), \
        .nf_len = sizeof (((ocp_vul_devcap_t *)NULL)->odc_dssd[f]), \
        .nf_short = "psd" #f, .nf_desc = "DSSD Power State Descriptor " #f, \
        NVMEADM_F_BITS(ocp_vul_devcap_psd_bits) }

static const nvmeadm_field_bit_t ocp_vul_devcap_oob_bits[] = { {
        .nfb_lowbit = 0, .nfb_hibit = 0,
        .nfb_short = "smbus",
        .nfb_desc = "MCTP over SMBus",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 1, .nfb_hibit = 1,
        .nfb_short = "vdm",
        .nfb_desc = "MCTP over PCIe VDM",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 2, .nfb_hibit = 2,
        .nfb_short = "bmc",
        .nfb_desc = "NVMe Basic Management Command",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 15, .nfb_hibit = 15,
        .nfb_short = "pass",
        .nfb_desc = "Meets OOB Management Requirements",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "no", "yes" }
} };

static const nvmeadm_field_bit_t ocp_vul_devcap_wz_bits[] = { {
        .nfb_lowbit = 0, .nfb_hibit = 0,
        .nfb_short = "wz",
        .nfb_desc = "Write Zeros Command",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 1, .nfb_hibit = 1,
        .nfb_short = "deac",
        .nfb_desc = "Setting DEAC Bit",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 2, .nfb_hibit = 2,
        .nfb_short = "fua",
        .nfb_desc = "Setting FUA Bit",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 3, .nfb_hibit = 3,
        .nfb_short = "io5",
        .nfb_desc = "NVMe-IO-5 Requirements",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 4, .nfb_hibit = 4,
        .nfb_short = "io6",
        .nfb_desc = "NVMe-IO-6 Requirements",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 15, .nfb_hibit = 15,
        .nfb_short = "pass",
        .nfb_desc = "Meets Write Zeros Requirements",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "no", "yes" }
} };

static const nvmeadm_field_bit_t ocp_vul_devcap_san_bits[] = { {
        .nfb_lowbit = 0, .nfb_hibit = 0,
        .nfb_short = "san",
        .nfb_desc = "Sanitize Command",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 1, .nfb_hibit = 1,
        .nfb_short = "crypto",
        .nfb_desc = "Crypto-Erase",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 2, .nfb_hibit = 2,
        .nfb_short = "block",
        .nfb_desc = "Block Erase",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 3, .nfb_hibit = 3,
        .nfb_short = "ovr",
        .nfb_desc = "Overwrite",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 4, .nfb_hibit = 4,
        .nfb_short = "dea",
        .nfb_desc = "Deallocate LBAs",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 15, .nfb_hibit = 15,
        .nfb_short = "pass",
        .nfb_desc = "Meets Sanitize Requirements",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "no", "yes" }
} };

static const nvmeadm_field_bit_t ocp_vul_devcap_ds_bits[] = { {
        .nfb_lowbit = 0, .nfb_hibit = 0,
        .nfb_short = "dsmgmt",
        .nfb_desc = "Dataset Management Command",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 1, .nfb_hibit = 1,
        .nfb_short = "ad",
        .nfb_desc = "Attribute Deallocate",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 15, .nfb_hibit = 15,
        .nfb_short = "pass",
        .nfb_desc = "Meets Dataset Management Requirements",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "no", "yes" }
} };

static const nvmeadm_field_bit_t ocp_vul_devcap_wu_bits[] = { {
        .nfb_lowbit = 0, .nfb_hibit = 0,
        .nfb_short = "wu",
        .nfb_desc = "Write Uncorrectable Command",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 1, .nfb_hibit = 1,
        .nfb_short = "slba",
        .nfb_desc = "Single LBA",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 2, .nfb_hibit = 2,
        .nfb_short = "maxlba",
        .nfb_desc = "Maximum Number of LBAs",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 3, .nfb_hibit = 3,
        .nfb_short = "io14",
        .nfb_desc = "NVMe-IO-14",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 15, .nfb_hibit = 15,
        .nfb_short = "pass",
        .nfb_desc = "Meets Write Uncorrectable Requirements",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "no", "yes" }
} };

static const nvmeadm_field_bit_t ocp_vul_devcap_fuse_bits[] = { {
        .nfb_lowbit = 0, .nfb_hibit = 0,
        .nfb_short = "cmpwr",
        .nfb_desc = "Compare and Write Fused Command",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "unsupported", "supported" }
}, {
        .nfb_lowbit = 15, .nfb_hibit = 15,
        .nfb_short = "pass",
        .nfb_desc = "Meets Fused Command Requirements",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "no", "yes" }
} };

static const nvmeadm_field_bit_t ocp_vul_devcap_psd_bits[] = {  {
        .nfb_lowbit = 0, .nfb_hibit = 4,
        .nfb_short = "ps",
        .nfb_desc = "NVMe Power State",
        .nfb_type = NVMEADM_FT_HEX
}, {
        .nfb_lowbit = 7, .nfb_hibit = 7,
        .nfb_short = "valid",
        .nfb_desc = "Valid DSSD Power State",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "no", "yes" }
} };

static const nvmeadm_field_t ocp_vul_devcap_fields[] = { {
        OCP_F_DEVCAP(nports),
        .nf_short = "nports",
        .nf_desc = "PCI Express Ports",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_DEVCAP(oob_sup),
        .nf_short = "oob",
        .nf_desc = "OOB Management Support",
        NVMEADM_F_BITS(ocp_vul_devcap_oob_bits)
}, {
        OCP_F_DEVCAP(wz_sup),
        .nf_short = "wz",
        .nf_desc = "Write Zeroes Command Support",
        NVMEADM_F_BITS(ocp_vul_devcap_wz_bits)
}, {
        OCP_F_DEVCAP(san_sup),
        .nf_short = "san",
        .nf_desc = "Sanitize Command Support",
        NVMEADM_F_BITS(ocp_vul_devcap_san_bits)
}, {
        OCP_F_DEVCAP(dsmgmt_sup),
        .nf_short = "ds",
        .nf_desc = "Dataset Management Support",
        NVMEADM_F_BITS(ocp_vul_devcap_ds_bits)
}, {
        OCP_F_DEVCAP(wunc_sup),
        .nf_short = "wu",
        .nf_desc = "Write Uncorrectable Command Support",
        NVMEADM_F_BITS(ocp_vul_devcap_wu_bits)
}, {
        OCP_F_DEVCAP(fuse_sup),
        .nf_short = "fuse",
        .nf_desc = "Fused Operations Support",
        NVMEADM_F_BITS(ocp_vul_devcap_fuse_bits)
}, {
        OCP_F_DEVCAP(dssd_min_valid),
        .nf_short = "minps",
        .nf_desc = "Minimum Valid DSSD Power State",
        .nf_type = NVMEADM_FT_HEX
},
        OCP_F_DEVCAP_PSD(1), OCP_F_DEVCAP_PSD(2), OCP_F_DEVCAP_PSD(3),
        OCP_F_DEVCAP_PSD(4), OCP_F_DEVCAP_PSD(5), OCP_F_DEVCAP_PSD(6),
        OCP_F_DEVCAP_PSD(7), OCP_F_DEVCAP_PSD(8), OCP_F_DEVCAP_PSD(9),
        OCP_F_DEVCAP_PSD(10), OCP_F_DEVCAP_PSD(11), OCP_F_DEVCAP_PSD(12),
        OCP_F_DEVCAP_PSD(13), OCP_F_DEVCAP_PSD(14), OCP_F_DEVCAP_PSD(15),
        OCP_F_DEVCAP_PSD(16), OCP_F_DEVCAP_PSD(17), OCP_F_DEVCAP_PSD(18),
        OCP_F_DEVCAP_PSD(19), OCP_F_DEVCAP_PSD(20), OCP_F_DEVCAP_PSD(21),
        OCP_F_DEVCAP_PSD(22), OCP_F_DEVCAP_PSD(23), OCP_F_DEVCAP_PSD(24),
        OCP_F_DEVCAP_PSD(25), OCP_F_DEVCAP_PSD(26), OCP_F_DEVCAP_PSD(27),
        OCP_F_DEVCAP_PSD(28), OCP_F_DEVCAP_PSD(29), OCP_F_DEVCAP_PSD(30),
        OCP_F_DEVCAP_PSD(31), OCP_F_DEVCAP_PSD(32), OCP_F_DEVCAP_PSD(33),
        OCP_F_DEVCAP_PSD(34), OCP_F_DEVCAP_PSD(35), OCP_F_DEVCAP_PSD(36),
        OCP_F_DEVCAP_PSD(37), OCP_F_DEVCAP_PSD(38), OCP_F_DEVCAP_PSD(39),
        OCP_F_DEVCAP_PSD(40), OCP_F_DEVCAP_PSD(41), OCP_F_DEVCAP_PSD(42),
        OCP_F_DEVCAP_PSD(43), OCP_F_DEVCAP_PSD(44), OCP_F_DEVCAP_PSD(45),
        OCP_F_DEVCAP_PSD(46), OCP_F_DEVCAP_PSD(47), OCP_F_DEVCAP_PSD(48),
        OCP_F_DEVCAP_PSD(49), OCP_F_DEVCAP_PSD(50), OCP_F_DEVCAP_PSD(51),
        OCP_F_DEVCAP_PSD(52), OCP_F_DEVCAP_PSD(53), OCP_F_DEVCAP_PSD(54),
        OCP_F_DEVCAP_PSD(55), OCP_F_DEVCAP_PSD(56), OCP_F_DEVCAP_PSD(57),
        OCP_F_DEVCAP_PSD(58), OCP_F_DEVCAP_PSD(59), OCP_F_DEVCAP_PSD(60),
        OCP_F_DEVCAP_PSD(61), OCP_F_DEVCAP_PSD(62), OCP_F_DEVCAP_PSD(63),
        OCP_F_DEVCAP_PSD(64), OCP_F_DEVCAP_PSD(65), OCP_F_DEVCAP_PSD(66),
        OCP_F_DEVCAP_PSD(67), OCP_F_DEVCAP_PSD(68), OCP_F_DEVCAP_PSD(69),
        OCP_F_DEVCAP_PSD(70), OCP_F_DEVCAP_PSD(71), OCP_F_DEVCAP_PSD(72),
        OCP_F_DEVCAP_PSD(73), OCP_F_DEVCAP_PSD(74), OCP_F_DEVCAP_PSD(75),
        OCP_F_DEVCAP_PSD(76), OCP_F_DEVCAP_PSD(77), OCP_F_DEVCAP_PSD(78),
        OCP_F_DEVCAP_PSD(79), OCP_F_DEVCAP_PSD(80), OCP_F_DEVCAP_PSD(81),
        OCP_F_DEVCAP_PSD(82), OCP_F_DEVCAP_PSD(83), OCP_F_DEVCAP_PSD(84),
        OCP_F_DEVCAP_PSD(85), OCP_F_DEVCAP_PSD(86), OCP_F_DEVCAP_PSD(87),
        OCP_F_DEVCAP_PSD(88), OCP_F_DEVCAP_PSD(89), OCP_F_DEVCAP_PSD(90),
        OCP_F_DEVCAP_PSD(91), OCP_F_DEVCAP_PSD(92), OCP_F_DEVCAP_PSD(93),
        OCP_F_DEVCAP_PSD(94), OCP_F_DEVCAP_PSD(95), OCP_F_DEVCAP_PSD(96),
        OCP_F_DEVCAP_PSD(97), OCP_F_DEVCAP_PSD(98), OCP_F_DEVCAP_PSD(99),
        OCP_F_DEVCAP_PSD(100), OCP_F_DEVCAP_PSD(101), OCP_F_DEVCAP_PSD(102),
        OCP_F_DEVCAP_PSD(103), OCP_F_DEVCAP_PSD(104), OCP_F_DEVCAP_PSD(105),
        OCP_F_DEVCAP_PSD(106), OCP_F_DEVCAP_PSD(107), OCP_F_DEVCAP_PSD(108),
        OCP_F_DEVCAP_PSD(109), OCP_F_DEVCAP_PSD(110), OCP_F_DEVCAP_PSD(111),
        OCP_F_DEVCAP_PSD(112), OCP_F_DEVCAP_PSD(113), OCP_F_DEVCAP_PSD(114),
        OCP_F_DEVCAP_PSD(115), OCP_F_DEVCAP_PSD(116), OCP_F_DEVCAP_PSD(117),
        OCP_F_DEVCAP_PSD(118), OCP_F_DEVCAP_PSD(119), OCP_F_DEVCAP_PSD(120),
        OCP_F_DEVCAP_PSD(121), OCP_F_DEVCAP_PSD(122), OCP_F_DEVCAP_PSD(123),
        OCP_F_DEVCAP_PSD(124), OCP_F_DEVCAP_PSD(125), OCP_F_DEVCAP_PSD(126),
        OCP_F_DEVCAP_PSD(127),
{
        OCP_F_DEVCAP(vers),
        .nf_short = "lpv",
        .nf_desc = "Log Page Version",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_DEVCAP(guid),
        .nf_short = "lpg",
        .nf_desc = "Log Page GUID",
        .nf_type = NVMEADM_FT_GUID
} };

static uint32_t
ocp_vul_devcap_getvers(const void *data, size_t len)
{
        if (len < sizeof (ocp_vul_devcap_t)) {
                errx(-1, "cannot parse revision information, found 0x%zx "
                    "bytes, need at least 0x%zx", len,
                    sizeof (ocp_vul_devcap_t));
        }

        const ocp_vul_devcap_t *log = data;
        return (log->odc_vers);
}

const nvmeadm_log_field_info_t ocp_vul_devcap_field_info = {
        .nlfi_log = "ocp/devcap",
        .nlfi_fields = ocp_vul_devcap_fields,
        .nlfi_nfields = ARRAY_SIZE(ocp_vul_devcap_fields),
        .nlfi_min = sizeof (ocp_vul_devcap_t),
        .nlfi_getrev = ocp_vul_devcap_getvers
};

#define OCP_F_UNSUP(f)  .nf_off = offsetof(ocp_vul_unsup_req_t, our_##f), \
        .nf_len = sizeof (((ocp_vul_unsup_req_t *)NULL)->our_##f)

static const nvmeadm_field_t ocp_vul_unsup_fields_head[] = { {
        OCP_F_UNSUP(nunsup),
        .nf_short = "count",
        .nf_desc = "Unsupported Count",
        .nf_type = NVMEADM_FT_HEX
} };

static const nvmeadm_field_t ocp_vul_unsup_fields_tail[] = { {
        OCP_F_UNSUP(vers),
        .nf_short = "lpv",
        .nf_desc = "Log Page Version",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_UNSUP(guid),
        .nf_short = "lpg",
        .nf_desc = "Log Page GUID",
        .nf_type = NVMEADM_FT_GUID
} };

static uint32_t
ocp_vul_unsup_getvers(const void *data, size_t len)
{
        if (len < sizeof (ocp_vul_unsup_req_t)) {
                errx(-1, "cannot parse revision information, found 0x%zx "
                    "bytes, need at least 0x%zx", len,
                    sizeof (ocp_vul_unsup_req_t));
        }

        const ocp_vul_unsup_req_t *log = data;
        return (log->our_vers);
}

/*
 * We manually drive this so we can create the appropriate number of entries for
 * the string table as there are a variable number of these.
 */
static bool
ocp_vul_unsup_drive(nvmeadm_field_print_t *print, const void *data, size_t len)
{
        print->fp_header = NULL;
        print->fp_fields = ocp_vul_unsup_fields_head;
        print->fp_nfields = ARRAY_SIZE(ocp_vul_unsup_fields_head);
        print->fp_base = NULL;
        print->fp_data = data;
        print->fp_dlen = len;
        print->fp_off = 0;
        nvmeadm_field_print(print);

        /*
         * Look at the data and make sure we have an appropriate number of
         * entries specified. While there is a uint16_t worth of entries the
         * specification indicates there can be a maximum of 253.
         */
        const ocp_vul_unsup_req_t *log = data;
        if (log->our_nunsup > 253) {
                warnx("log page has questionable data: log page count of "
                    "unsupported requirements %u exceeds spec max of 253",
                    log->our_nunsup);
        }
        size_t nlogs = MIN(log->our_nunsup, 253);
        for (size_t i = 0; i < nlogs; i++) {
                nvmeadm_field_t field;
                char shrt[32];
                char desc[128];

                (void) snprintf(shrt, sizeof (shrt), "ureq%zu", i);
                (void) snprintf(desc, sizeof (desc), "Unsupported Requirement "
                    "%zu", i);
                (void) memset(&field, 0, sizeof (nvmeadm_field_t));
                field.nf_off = offsetof(ocp_vul_unsup_req_t, our_reqs[i]);
                field.nf_len = sizeof (ocp_req_str_t);
                field.nf_short = shrt;
                field.nf_desc = desc;
                field.nf_type = NVMEADM_FT_ASCIIZ;

                print->fp_fields = &field;
                print->fp_nfields = 1;
                nvmeadm_field_print(print);
        }

        print->fp_fields = ocp_vul_unsup_fields_tail;
        print->fp_nfields = ARRAY_SIZE(ocp_vul_unsup_fields_tail);
        nvmeadm_field_print(print);
        return (true);
}

const nvmeadm_log_field_info_t ocp_vul_unsup_field_info = {
        .nlfi_log = "ocp/unsup",
        .nlfi_min = sizeof (ocp_vul_unsup_req_t),
        .nlfi_getrev = ocp_vul_unsup_getvers,
        .nlfi_drive = ocp_vul_unsup_drive
};

#define OCP_F_TELSTR(f) .nf_off = offsetof(ocp_vul_telstr_t, ots_##f), \
        .nf_len = sizeof (((ocp_vul_telstr_t *)NULL)->ots_##f)

static const nvmeadm_field_t ocp_vul_telstr_fields[] = { {
        OCP_F_TELSTR(vers),
        .nf_short = "lpv",
        .nf_desc = "Log Page Version",
        .nf_type = NVMEADM_FT_HEX
}, {
        OCP_F_TELSTR(guid),
        .nf_short = "lpg",
        .nf_desc = "Log Page GUID",
        .nf_type = NVMEADM_FT_GUID
}, {
        OCP_F_TELSTR(sls),
        .nf_short = "sls",
        .nf_desc = "Telemetry String Log Size",
        .nf_type = NVMEADM_FT_HEX,
        .nf_addend = { .nfa_shift = 2 }
}, {
        OCP_F_TELSTR(sits),
        .nf_short = "sits",
        .nf_desc = "Statistics Identifier String Table Start",
        .nf_type = NVMEADM_FT_HEX,
        .nf_addend = { .nfa_shift = 2 }
}, {
        OCP_F_TELSTR(sitz),
        .nf_short = "sitz",
        .nf_desc = "Statistics Identifier String Table Size",
        .nf_type = NVMEADM_FT_HEX,
        .nf_addend = { .nfa_shift = 2 }
}, {
        OCP_F_TELSTR(ests),
        .nf_short = "ests",
        .nf_desc = "Event String Table Start",
        .nf_type = NVMEADM_FT_HEX,
        .nf_addend = { .nfa_shift = 2 }
}, {
        OCP_F_TELSTR(estz),
        .nf_short = "estz",
        .nf_desc = "Event String Table Size",
        .nf_type = NVMEADM_FT_HEX,
        .nf_addend = { .nfa_shift = 2 }
}, {
        OCP_F_TELSTR(vuests),
        .nf_short = "vuests",
        .nf_desc = "VU Event String Table Start",
        .nf_type = NVMEADM_FT_HEX,
        .nf_addend = { .nfa_shift = 2 }
}, {
        OCP_F_TELSTR(vuestz),
        .nf_short = "vuestz",
        .nf_desc = "VU Event String Table Size",
        .nf_type = NVMEADM_FT_HEX,
        .nf_addend = { .nfa_shift = 2 }
}, {
        OCP_F_TELSTR(ascts),
        .nf_short = "asctss",
        .nf_desc = "ASCII Table Start",
        .nf_type = NVMEADM_FT_HEX,
        .nf_addend = { .nfa_shift = 2 }
}, {
        OCP_F_TELSTR(asctz),
        .nf_short = "asctsz",
        .nf_desc = "ASCII Table Size",
        .nf_type = NVMEADM_FT_HEX,
        .nf_addend = { .nfa_shift = 2 }
} };

#define OCP_F_TELSTR_SIT(f)     .nf_off = offsetof(ocp_vul_telstr_sit_t, \
        ocp_sit_##f), \
        .nf_len = sizeof (((ocp_vul_telstr_sit_t *)NULL)->ocp_sit_##f)

static const nvmeadm_field_t ocp_vul_telstr_sit_fields[] = { {
        OCP_F_TELSTR_SIT(id),
        .nf_short = "id",
        .nf_desc = "Vendor Unique Statistic Identifier",
        .nf_type = NVMEADM_FT_HEX,
}, {
        OCP_F_TELSTR_SIT(len),
        .nf_short = "len",
        .nf_desc = "ASCII ID Length",
        .nf_type = NVMEADM_FT_HEX,
        .nf_addend = { .nfa_addend = 1 }
}, {
        OCP_F_TELSTR_SIT(off),
        .nf_short = "off",
        .nf_desc = "ASCII ID Offset",
        .nf_type = NVMEADM_FT_HEX,
        .nf_addend = { .nfa_shift = 2 }
} };

#define OCP_F_TELSTR_EST(f)     .nf_off = offsetof(ocp_vul_telstr_est_t, \
        ocp_est_##f), \
        .nf_len = sizeof (((ocp_vul_telstr_est_t *)NULL)->ocp_est_##f)

/*
 * This is the same currently for both the vendor unique and regular events so
 * we use the same structure for the time being.
 */
static const nvmeadm_field_t ocp_vul_telstr_est_fields[] = { {
        OCP_F_TELSTR_EST(class),
        .nf_short = "class",
        .nf_desc = "Debug Event Class",
        .nf_type = NVMEADM_FT_HEX,
}, {
        OCP_F_TELSTR_EST(eid),
        .nf_short = "id",
        .nf_desc = "Event Identifier",
        .nf_type = NVMEADM_FT_HEX,
}, {
        OCP_F_TELSTR_EST(len),
        .nf_short = "len",
        .nf_desc = "ASCII ID Length",
        .nf_type = NVMEADM_FT_HEX,
        .nf_addend = { .nfa_addend = 1 }
}, {
        OCP_F_TELSTR_EST(off),
        .nf_short = "off",
        .nf_desc = "ASCII ID Offset",
        .nf_type = NVMEADM_FT_HEX,
        .nf_addend = { .nfa_shift = 2 }
} };

static uint32_t
ocp_vul_telstr_getvers(const void *data, size_t len)
{
        if (len < sizeof (ocp_vul_telstr_t)) {
                errx(-1, "cannot parse revision information, found 0x%zx "
                    "bytes, need at least 0x%zx", len,
                    sizeof (ocp_vul_telstr_t));
        }

        const ocp_vul_telstr_t *log = data;
        return (log->ots_vers);
}

static bool
ocp_vul_telstr_sanity(const char *name, uint64_t off_dw, uint64_t len_dw,
    size_t flen)
{
        const uint64_t max_dw = UINT64_MAX / sizeof (uint32_t);

        /*
         * These values are in units of uint32_t's. Make sure we can represent
         * them.
         */
        if (off_dw > max_dw) {
                warnx("telemetry log %s offset does not fit in a 64-bit "
                    "quantity", name);
                return (false);
        }

        if (len_dw > max_dw) {
                warnx("telemetry log %s length does not fit in a 64-bit "
                    "quantity", name);
                return (false);
        }

        const uint64_t off_bytes = off_dw << 2;
        const uint64_t len_bytes = len_dw << 2;

        if (len_bytes > UINT64_MAX - off_bytes) {
                warnx("telemetry log %s final offset would overflow a 64-bit "
                    "quantity", name);
                return (false);
        }

        const uint64_t end = off_bytes + len_bytes;
        if (end > flen) {
                warnx("telemetry log %s exceeds beyond the end of the file",
                    name);
                return (false);
        }

        return (true);
}

/*
 * Set up a field to print an ASCII string and error if the embedded information
 * is not useful.
 */
static bool
ocp_vul_telstr_field_str(nvmeadm_field_t *field, uint16_t len0, uint64_t off_dw,
    uint64_t ascii_start, uint64_t ascii_len)
{
        const uint64_t max_dw = UINT64_MAX / sizeof (uint32_t);

        (void) memset(field, 0, sizeof (nvmeadm_field_t));

        if (off_dw > max_dw) {
                warnx("telemetry log ASCII string offset 0x%" PRIx64 " is "
                    "not representable in a 64-bit quantity", off_dw);
                return (false);
        }

        const uint64_t off = off_dw << 2;
        const uint64_t len = len0 + 1;
        if (len > UINT64_MAX - off) {
                warnx("telemetry log ASCII string would overflow a 64-bit "
                    "quantity: offset 0x%" PRIx64 ", length: %" PRIu64,
                    off, len);
                return (false);
        }

        if (off + len > ascii_start + ascii_len) {
                warnx("telemetry log ASCII string exceeds ASCII table");
                return (false);
        }

        field->nf_len = len;
        field->nf_off = off + ascii_start;
        field->nf_short = "str";
        field->nf_desc = "String";
        /*
         * Vendors are inconsistent as to whether the string table is padded
         * with zeros or spaces. Use ASCIIZ here to account for both.
         */
        field->nf_type = NVMEADM_FT_ASCIIZ;

        return (true);
}

/*
 * The telemetry string table is comprised of a fixed section and then a number
 * of variable sections that point into the ASCII table, somewhat analogous to
 * an ELF string table. There is no good way to see where the various strings
 * begin and end in the ASCII table. There is no strict separator between
 * entries. Entries are space padded to the next u32 aligned point generally;
 * however, the presence or lack of spaces doesn't tell us where something
 * begins or ends.
 *
 * As such, we manually drive this and relate the ASCII strings to the
 * corresponding other tables that we encounter. This isn't the most eloquent;
 * however, there's no other good way to do display this programmatically.
 */
static bool
ocp_vul_telstr_drive(nvmeadm_field_print_t *print, const void *data, size_t len)
{
        const ocp_vul_telstr_t *telstr = data;
        bool ret = true;

        print->fp_header = "Telemetry String Header";
        print->fp_fields = ocp_vul_telstr_fields;
        print->fp_nfields = ARRAY_SIZE(ocp_vul_telstr_fields);
        print->fp_base = "tsh";
        print->fp_data = data;
        print->fp_dlen = len;
        print->fp_off = 0;
        nvmeadm_field_print(print);

        /*
         * First take care of the 16 FIFOs. If a FIFO has a totally zero string,
         * then we should ignore it. This is the last data entry that we're
         * guaranteed we have space for. Everything else after this needs to be
         * checked for paranoia and consistency.
         */
        for (size_t i = 0; i < 16; i++) {
                char shrt[32], desc[128];
                nvmeadm_field_t field;
                const uint8_t empty[16] = { 0 };

                (void) snprintf(shrt, sizeof (shrt), "fifo%zu", i);
                (void) snprintf(desc, sizeof (desc), "FIFO %zu", i);
                (void) memset(&field, 0, sizeof (nvmeadm_field_t));
                field.nf_len = sizeof (((ocp_vul_telstr_t *)NULL)->ots_fifo0);
                field.nf_off = offsetof(ocp_vul_telstr_t, ots_fifo0) +
                    i * field.nf_len;
                field.nf_short = shrt;
                field.nf_desc = desc;
                field.nf_type = NVMEADM_FT_ASCIIZ;

                if (memcmp(data + field.nf_off, empty, sizeof (empty)) == 0) {
                        continue;
                }

                print->fp_header = NULL;
                print->fp_fields = &field;
                print->fp_nfields = 1;
                nvmeadm_field_print(print);
        }

        /*
         * Sanity check that the rest of this makes sense. In particular, this
         * is supposed to be ordered SITS, ESTS, VUETS, ASCTS. Make sure these
         * don't overlap, that the offsets don't cause an overflow when we
         * expand them, etc.
         */
        if (!ocp_vul_telstr_sanity("sit", telstr->ots_sits, telstr->ots_sitz,
            len) ||
            !ocp_vul_telstr_sanity("est", telstr->ots_ests, telstr->ots_estz,
            len) ||
            !ocp_vul_telstr_sanity("vuest", telstr->ots_vuests,
            telstr->ots_vuestz, len) ||
            !ocp_vul_telstr_sanity("asct", telstr->ots_ascts, telstr->ots_asctz,
            len)) {
                return (false);
        }

        const uint64_t sit_start = telstr->ots_sits << 2;
        const uint64_t sit_len = telstr->ots_sitz << 2;
        const uint64_t est_start = telstr->ots_ests << 2;
        const uint64_t est_len = telstr->ots_estz << 2;
        const uint64_t vu_start = telstr->ots_vuests << 2;
        const uint64_t vu_len = telstr->ots_vuestz << 2;
        const uint64_t ascii_start = telstr->ots_ascts << 2;
        const uint64_t ascii_len = telstr->ots_asctz << 2;

        if (sit_start != offsetof(ocp_vul_telstr_t, ots_data)) {
                warnx("invalid telemetry string table: SIT table starts at "
                    "unexpected offset 0x%" PRIx64, sit_start);
                return (false);
        }

        if (est_start < sit_start + sit_len) {
                warnx("invalid telemetry string table: EST table starts before "
                    "SIT table ends");
                return (false);
        }

        if (vu_start < est_start + est_len) {
                warnx("invalid telemetry string table: VUEST table starts "
                    "before EST table ends");
                return (false);
        }

        if (ascii_start < vu_start + vu_len) {
                warnx("invalid telemetry string table: ASCT table starts "
                    "before VUEST table ends");
                return (false);
        }

        print->fp_header = "Statistic Identifier Table";
        print->fp_base = "sit";
        const uint64_t sit_nents = sit_len / sizeof (ocp_vul_telstr_sit_t);
        for (uint64_t i = 0; i < sit_nents; i++) {
                char shrt[32], desc[128];
                const size_t off = sit_start + i *
                    sizeof (ocp_vul_telstr_sit_t);
                const ocp_vul_telstr_sit_t *sit = data + off;
                nvmeadm_field_t cont;
                nvmeadm_field_t fields[ARRAY_SIZE(ocp_vul_telstr_sit_fields) +
                    1];

                (void) memcpy(fields, ocp_vul_telstr_sit_fields,
                    sizeof (ocp_vul_telstr_sit_fields));
                if (!ocp_vul_telstr_field_str(&fields[ARRAY_SIZE(fields) - 1],
                    sit->ocp_sit_len, sit->ocp_sit_off, ascii_start,
                    ascii_len)) {
                        ret = false;
                        continue;
                }

                for (size_t f = 0; f < ARRAY_SIZE(fields) - 1; f++) {
                        fields[f].nf_off += off;
                }

                (void) snprintf(shrt, sizeof (shrt), "%" PRIu64, i);
                (void) snprintf(desc, sizeof (desc), "SIT Entry %" PRIu64, i);
                (void) memset(&cont, 0, sizeof (nvmeadm_field_t));
                cont.nf_off = 0;
                cont.nf_len = sizeof (ocp_vul_telstr_sit_t);
                cont.nf_short = shrt;
                cont.nf_desc = desc;
                cont.nf_type = NVMEADM_FT_CONTAINER;
                cont.nf_fields = fields;
                cont.nf_nfields = ARRAY_SIZE(fields);

                if (i > 0) {
                        print->fp_header = NULL;
                }
                print->fp_fields = &cont;
                print->fp_nfields = 1;

                nvmeadm_field_print(print);

        }

        print->fp_header = "Event Identifier Table";
        print->fp_base = "est";
        const uint64_t est_nents = est_len / sizeof (ocp_vul_telstr_est_t);
        for (uint64_t i = 0; i < est_nents; i++) {
                char shrt[32], desc[128];
                const size_t off = est_start + i *
                    sizeof (ocp_vul_telstr_est_t);
                const ocp_vul_telstr_est_t *est = data + off;
                nvmeadm_field_t cont;
                nvmeadm_field_t fields[ARRAY_SIZE(ocp_vul_telstr_est_fields) +
                    1];

                (void) memcpy(fields, ocp_vul_telstr_est_fields,
                    sizeof (ocp_vul_telstr_est_fields));
                if (!ocp_vul_telstr_field_str(&fields[ARRAY_SIZE(fields) - 1],
                    est->ocp_est_len, est->ocp_est_off, ascii_start,
                    ascii_len)) {
                        ret = false;
                        continue;
                }

                for (size_t f = 0; f < ARRAY_SIZE(fields) - 1; f++) {
                        fields[f].nf_off += off;
                }

                (void) snprintf(shrt, sizeof (shrt), "%" PRIu64, i);
                (void) snprintf(desc, sizeof (desc), "EST Entry %" PRIu64, i);
                (void) memset(&cont, 0, sizeof (nvmeadm_field_t));
                cont.nf_off = 0;
                cont.nf_len = sizeof (ocp_vul_telstr_est_t);
                cont.nf_short = shrt;
                cont.nf_desc = desc;
                cont.nf_type = NVMEADM_FT_CONTAINER;
                cont.nf_fields = fields;
                cont.nf_nfields = ARRAY_SIZE(fields);

                if (i > 0) {
                        print->fp_header = NULL;
                }
                print->fp_fields = &cont;
                print->fp_nfields = 1;

                nvmeadm_field_print(print);
        }

        print->fp_header = "Vendor Unique Event Identifier Table";
        print->fp_base = "vuest";
        const uint64_t vuest_nents = vu_len / sizeof (ocp_vul_telstr_vuest_t);
        for (uint64_t i = 0; i < vuest_nents; i++) {
                char shrt[32], desc[128];
                const size_t off = vu_start + i *
                    sizeof (ocp_vul_telstr_vuest_t);
                const ocp_vul_telstr_vuest_t *vuest = data + off;
                nvmeadm_field_t cont;
                nvmeadm_field_t fields[ARRAY_SIZE(ocp_vul_telstr_est_fields) +
                    1];

                (void) memcpy(fields, ocp_vul_telstr_est_fields,
                    sizeof (ocp_vul_telstr_est_fields));
                if (!ocp_vul_telstr_field_str(&fields[ARRAY_SIZE(fields) - 1],
                    vuest->ocp_vuest_len, vuest->ocp_vuest_off, ascii_start,
                    ascii_len)) {
                        ret = false;
                        continue;
                }

                for (size_t f = 0; f < ARRAY_SIZE(fields) - 1; f++) {
                        fields[f].nf_off += off;
                }

                (void) snprintf(shrt, sizeof (shrt), "%" PRIu64, i);
                (void) snprintf(desc, sizeof (desc), "VUEST Entry %" PRIu64, i);
                (void) memset(&cont, 0, sizeof (nvmeadm_field_t));
                cont.nf_off = 0;
                cont.nf_len = sizeof (ocp_vul_telstr_vuest_t);
                cont.nf_short = shrt;
                cont.nf_desc = desc;
                cont.nf_type = NVMEADM_FT_CONTAINER;
                cont.nf_fields = fields;
                cont.nf_nfields = ARRAY_SIZE(fields);

                if (i > 0) {
                        print->fp_header = NULL;
                }
                print->fp_fields = &cont;
                print->fp_nfields = 1;

                nvmeadm_field_print(print);
        }

        return (ret);
}

const nvmeadm_log_field_info_t ocp_vul_telstr_field_info = {
        .nlfi_log = "ocp/telstr",
        .nlfi_min = sizeof (ocp_vul_telstr_t),
        .nlfi_getrev = ocp_vul_telstr_getvers,
        .nlfi_drive = ocp_vul_telstr_drive
};