path: root/scsiprint.cpp

/*
 * scsiprint.cpp
 *
 * Home page of code is: https://www.smartmontools.org
 *
 * Copyright (C) 2002-11 Bruce Allen
 * Copyright (C) 2000 Michael Cornwell <cornwell@acm.org>
 * Copyright (C) 2003-23 Douglas Gilbert <dgilbert@interlog.com>
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */


#include "config.h"
#define __STDC_FORMAT_MACROS 1 // enable PRI* for C++

#include <inttypes.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>

#include "scsicmds.h"
#include "atacmds.h" // dont_print_serial_number
#include "dev_interface.h"
#include "scsiprint.h"
#include "smartctl.h"
#include "utility.h"
#include "sg_unaligned.h"

#include "farmcmds.h"
#include "farmprint.h"

#define GBUF_SIZE 65532

const char * scsiprint_c_cvsid = "$Id: scsiprint.cpp 5495 2023-07-10 13:17:30Z chrfranke $"
                                 SCSIPRINT_H_CVSID;

#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))

uint8_t gBuf[GBUF_SIZE];
#define LOG_RESP_LEN 252
#define LOG_RESP_LONG_LEN ((62 * 256) + 252)
#define LOG_RESP_TAPE_ALERT_LEN 0x144

/* Supported log pages + Supported log pages and subpages maximum count */
#define SCSI_SUPP_LOG_PAGES_MAX_COUNT (252 + (62 * 128) + 126)

/* Log pages supported */
static bool gSmartLPage = false;     /* Informational Exceptions log page */
static bool gTempLPage = false;
static bool gSelfTestLPage = false;
static bool gStartStopLPage = false;
static bool gReadECounterLPage = false;
static bool gWriteECounterLPage = false;
static bool gVerifyECounterLPage = false;
static bool gNonMediumELPage = false;
static bool gLastNErrorEvLPage = false;
static bool gBackgroundResultsLPage = false;
static bool gProtocolSpecificLPage = false;
static bool gTapeAlertsLPage = false;
static bool gSSMediaLPage = false;
static bool gFormatStatusLPage = false;
static bool gEnviroReportingLPage = false;
static bool gEnviroLimitsLPage = false;
static bool gUtilizationLPage = false;
static bool gPendDefectsLPage = false;
static bool gBackgroundOpLPage = false;
static bool gLPSMisalignLPage = false;
static bool gTapeDeviceStatsLPage = false;
static bool gZBDeviceStatsLPage = false;
static bool gGenStatsAndPerfLPage = false;

/* Vendor specific log pages */
static bool gSeagateCacheLPage = false;
static bool gSeagateFactoryLPage = false;
static bool gSeagateFarmLPage = false;

/* Mode pages supported */
static bool gIecMPage = true;    /* N.B. assume it until we know otherwise */

/* Remember last successful mode sense/select command */
static int modese_len = 0;

/* Remember this value from the most recent INQUIRY */
static int scsi_version;
#define SCSI_VERSION_SPC_4 0x6
#define SCSI_VERSION_SPC_5 0x7
#define SCSI_VERSION_SPC_6 0xd  /* T10/BSR INCITS 566, proposed in 23-015r0 */
#define SCSI_VERSION_HIGHEST SCSI_VERSION_SPC_6

/* T10 vendor identification. Should match entry in last Annex of SPC
 * drafts and standards (e.g. SPC-4). */
static char scsi_vendor[8+1];
#define T10_VENDOR_SEAGATE "SEAGATE"
#define T10_VENDOR_HITACHI_1 "HITACHI"
#define T10_VENDOR_HITACHI_2 "HL-DT-ST"
#define T10_VENDOR_HITACHI_3 "HGST"

static const char * logSenStr = "Log Sense";
static const char * logSenRspStr = "Log Sense response";
static const char * gsap_s = "General statistics and performance";
static const char * ssm_s = "Solid state media";
static const char * zbds_s = "Zoned block device statistics";
static const char * lp_s = "log page";


static bool
seagate_or_hitachi(void)
{
    return ((0 == memcmp(scsi_vendor, T10_VENDOR_SEAGATE,
                         strlen(T10_VENDOR_SEAGATE))) ||
            (0 == memcmp(scsi_vendor, T10_VENDOR_HITACHI_1,
                         strlen(T10_VENDOR_HITACHI_1))) ||
            (0 == memcmp(scsi_vendor, T10_VENDOR_HITACHI_2,
                         strlen(T10_VENDOR_HITACHI_2))) ||
            (0 == memcmp(scsi_vendor, T10_VENDOR_HITACHI_3,
                         strlen(T10_VENDOR_HITACHI_3))));
}

static bool
all_ffs(const uint8_t * bp, int b_len)
{
    if ((nullptr == bp) || (b_len <= 0))
        return false;
    for (--b_len; b_len >= 0; --b_len) {
        if (0xff != bp[b_len])
            return false;
    }
    return true;
}

// trim from right. By default trims whitespace.
static std::string rtrim(const std::string& s, const char* t = " \t\n\r\f\v")
{
    std::string r(s);

    r.erase(r.find_last_not_of(t) + 1);
    return r;
}

static void
scsiGetSupportedLogPages(scsi_device * device)
{
    bool got_subpages = false;
    int k, err, resp_len, num_unreported, num_unreported_spg;
    int supp_lpg_and_spg_count = 0;

    const uint8_t * up;
    uint8_t sup_lpgs[LOG_RESP_LEN];
    struct scsi_supp_log_pages supp_lpg_and_spg[SCSI_SUPP_LOG_PAGES_MAX_COUNT];

    memset(gBuf, 0, LOG_RESP_LEN);
    memset(supp_lpg_and_spg, 0, sizeof(supp_lpg_and_spg));

    if (SC_NO_SUPPORT == device->cmd_support_level(LOG_SENSE, false, 0)) {
        if (scsi_debugmode > 0)
            pout("%s: RSOC says %s not supported\n", __func__, logSenStr);
        return;
    }
    /* Get supported log pages */
    if ((err = scsiLogSense(device, SUPPORTED_LPAGES, 0, gBuf,
                            LOG_RESP_LEN, 0 /* do double fetch */))) {
        if (scsi_debugmode > 0)
            pout("%s for supported pages failed [%s]\n", logSenStr,
                 scsiErrString(err));
        /* try one more time with defined length, workaround for the bug #678
        found with ST8000NM0075/E001 */
        err = scsiLogSense(device, SUPPORTED_LPAGES, 0, gBuf,
                            LOG_RESP_LEN, 68); /* 64 max pages + 4b header */
        if (scsi_debugmode > 0)
            pout("%s for supported pages failed (second attempt) [%s]\n",
                 logSenStr, scsiErrString(err));
        if (err)
            return;
    }

    memcpy(sup_lpgs, gBuf, LOG_RESP_LEN);
    resp_len = gBuf[3];
    up = gBuf + LOGPAGEHDRSIZE;

    for (k = 0; k < resp_len; k += 1) {
        uint8_t page_code = 0x3f & up[k];
        supp_lpg_and_spg[supp_lpg_and_spg_count++] = {page_code, 0};
    }

    if (SC_NO_SUPPORT ==
        device->cmd_support_level(LOG_SENSE, false, 0,
                                  true /* does it support subpages ? */))
        goto skip_subpages;

    /* Get supported log pages and subpages. Most drives seems to include the
    supported log pages here as well, but some drives such as the Samsung
    PM1643a will only report the additional log pages with subpages here */
    if ((scsi_version >= SCSI_VERSION_SPC_4) &&
            (scsi_version <= SCSI_VERSION_HIGHEST)) {
        /* unclear what code T10 will choose for SPC-6 */
        if ((err = scsiLogSense(device, SUPPORTED_LPAGES, SUPP_SPAGE_L_SPAGE,
                                gBuf, LOG_RESP_LONG_LEN,
                                -1 /* just single not double fetch */))) {
            if (scsi_debugmode > 0)
                pout("%s for supported pages and subpages failed [%s]\n",
                     logSenStr, scsiErrString(err));
        } else {
            /* Ensure we didn't get the same answer than without the subpages */
            if (0 == memcmp(gBuf, sup_lpgs, LOG_RESP_LEN)) {
                if (scsi_debugmode > 0)
                    pout("%s: %s ignored subpage field, bad\n",
                         __func__, logSenRspStr);
            } else if (! ((0x40 & gBuf[0]) &&
                          (SUPP_SPAGE_L_SPAGE == gBuf[1]))) {
                if (scsi_debugmode > 0)
                    pout("%s supported subpages is bad SPF=%u SUBPG=%u\n",
                         logSenRspStr, !! (0x40 & gBuf[0]), gBuf[2]);
            } else {
                got_subpages = true;
            }
        }
    }

    if (got_subpages) {
        resp_len = sg_get_unaligned_be16(gBuf + 2);
        up = gBuf + LOGPAGEHDRSIZE;
        for (k = 0; k < resp_len; k += 2) {
            uint8_t page_code = 0x3f & up[k];
            uint8_t subpage_code = up[k+1];
            supp_lpg_and_spg[supp_lpg_and_spg_count++] = {page_code, subpage_code};
        }
    }

skip_subpages:
    num_unreported = 0;
    num_unreported_spg = 0;
    for (k = 0; k < supp_lpg_and_spg_count; k += 1) {
        struct scsi_supp_log_pages supp_lpg = supp_lpg_and_spg[k];

        switch (supp_lpg.page_code)
        {
            case SUPPORTED_LPAGES:
                if (! ((NO_SUBPAGE_L_SPAGE == supp_lpg.subpage_code) ||
                       (SUPP_SPAGE_L_SPAGE == supp_lpg.subpage_code))) {
                    if (scsi_debugmode > 1)
                        pout("%s: Strange Log page number: 0x0,0x%x\n",
                             __func__, supp_lpg.subpage_code);
                }
                break;
            case READ_ERROR_COUNTER_LPAGE:
                gReadECounterLPage = true;
                break;
            case WRITE_ERROR_COUNTER_LPAGE:
                gWriteECounterLPage = true;
                break;
            case VERIFY_ERROR_COUNTER_LPAGE:
                gVerifyECounterLPage = true;
                break;
            case LAST_N_ERROR_EVENTS_LPAGE:
                gLastNErrorEvLPage = true;
                break;
            case NON_MEDIUM_ERROR_LPAGE:
                gNonMediumELPage = true;
                break;
            case TEMPERATURE_LPAGE:
                if (NO_SUBPAGE_L_SPAGE == supp_lpg.subpage_code)
                    gTempLPage = true;
                else if (ENVIRO_REP_L_SPAGE == supp_lpg.subpage_code)
                    gEnviroReportingLPage = true;
                else if (ENVIRO_LIMITS_L_SPAGE == supp_lpg.subpage_code)
                    gEnviroLimitsLPage = true;
                else if (SUPP_SPAGE_L_SPAGE != supp_lpg.subpage_code) {
                    ++num_unreported;
                    ++num_unreported_spg;
                }
                /* WDC/HGST report <lpage>,0xff tuples for all supported
                   lpages; Seagate doesn't. T10 does not exclude the
                   reporting of <lpage>,0xff so it is not an error. */
                break;
            case STARTSTOP_CYCLE_COUNTER_LPAGE:
                if (NO_SUBPAGE_L_SPAGE == supp_lpg.subpage_code)
                    gStartStopLPage = true;
                else if (UTILIZATION_L_SPAGE == supp_lpg.subpage_code)
                    gUtilizationLPage = true;
                else if (SUPP_SPAGE_L_SPAGE != supp_lpg.subpage_code) {
                    ++num_unreported;
                    ++num_unreported_spg;
                }
                break;
            case SELFTEST_RESULTS_LPAGE:
                gSelfTestLPage = true;
                break;
            case IE_LPAGE:
                gSmartLPage = true;
                break;
            case DEVICE_STATS_LPAGE:
                if (NO_SUBPAGE_L_SPAGE == supp_lpg.subpage_code)
                    gTapeDeviceStatsLPage = true;
                else if (ZB_DEV_STATS_L_SPAGE == supp_lpg.subpage_code)
                    gZBDeviceStatsLPage = true;
                break;
            case BACKGROUND_RESULTS_LPAGE:
                if (NO_SUBPAGE_L_SPAGE == supp_lpg.subpage_code)
                    gBackgroundResultsLPage = true;
                else if (PEND_DEFECTS_L_SPAGE == supp_lpg.subpage_code)
                    gPendDefectsLPage = true;
                else if (BACKGROUND_OP_L_SPAGE == supp_lpg.subpage_code)
                    gBackgroundOpLPage = true;
                else if (LPS_MISALIGN_L_SPAGE == supp_lpg.subpage_code)
                    gLPSMisalignLPage = true;
                else if (SUPP_SPAGE_L_SPAGE != supp_lpg.subpage_code) {
                    ++num_unreported;
                    ++num_unreported_spg;
                }
                break;
            case PROTOCOL_SPECIFIC_LPAGE:
                gProtocolSpecificLPage = true;
                break;
            case GEN_STATS_PERF_LPAGE:
                gGenStatsAndPerfLPage = true;
                break;
            case TAPE_ALERTS_LPAGE:
                gTapeAlertsLPage = true;
                break;
            case SS_MEDIA_LPAGE:
                gSSMediaLPage = true;
                break;
            case FORMAT_STATUS_LPAGE:
                gFormatStatusLPage = true;
                break;
            case SEAGATE_CACHE_LPAGE:
                if (failuretest_permissive) {
                    gSeagateCacheLPage = true;
                    break;
                }
                if (seagate_or_hitachi())
                    gSeagateCacheLPage = true;
                break;
            case SEAGATE_FACTORY_LPAGE:
                if (failuretest_permissive) {
                    gSeagateFactoryLPage = true;
                    break;
                }
                if (seagate_or_hitachi())
                    gSeagateFactoryLPage = true;
                break;
            case SEAGATE_FARM_LPAGE:
                if (scsiIsSeagate(scsi_vendor)) {
                    if (SEAGATE_FARM_CURRENT_L_SPAGE == supp_lpg.subpage_code) {
                        gSeagateFarmLPage = true;
                    } else if (SUPP_SPAGE_L_SPAGE != supp_lpg.subpage_code) {
                        ++num_unreported;
                        ++num_unreported_spg;
                    }
                }
                break;
            default:
                if (supp_lpg.page_code < 0x30) {     /* don't count VS pages */
                    ++num_unreported;
                    if ((supp_lpg.subpage_code > 0) &&
                            (SUPP_SPAGE_L_SPAGE != supp_lpg.subpage_code))
                        ++num_unreported_spg;
                }
                break;
        }
    }
    if (scsi_debugmode > 1)
        pout("%s: number of unreported (standard) %ss: %d (sub-pages: %d)\n",
              __func__, lp_s, num_unreported, num_unreported_spg);
}

/* Returns 0 if ok, -1 if can't check IE, -2 if can check and bad
   (or at least something to report). */
static int
scsiGetSmartData(scsi_device * device, bool attribs)
{
    uint8_t asc;
    uint8_t ascq;
    uint8_t currenttemp = 255;
    uint8_t triptemp = 255;
    const char * cp;
    int err = 0;
    char b[128];

    print_on();
    if (scsiCheckIE(device, gSmartLPage, gTempLPage, &asc, &ascq,
                    &currenttemp, &triptemp)) {
        /* error message already announced */
        print_off();
        return -1;
    }
    print_off();
    cp = scsiGetIEString(asc, ascq, b, sizeof(b));
    if (cp) {
        err = -2;
        print_on();
        jout("SMART Health Status: %s [asc=%x, ascq=%x]\n", cp, asc, ascq);
        print_off();
        jglb["smart_status"]["passed"] = false;
        jglb["smart_status"]["scsi"]["asc"] = asc;
        jglb["smart_status"]["scsi"]["ascq"] = ascq;
        jglb["smart_status"]["scsi"]["ie_string"] = cp;
    }
    else if (gIecMPage) {
        jout("SMART Health Status: OK\n");
        jglb["smart_status"]["passed"] = true;
    }

    if (attribs && !gTempLPage) {
        if (255 == currenttemp)
            pout("Current Drive Temperature:     <not available>\n");
        else {
            jout("Current Drive Temperature:     %d C\n", currenttemp);
            jglb["temperature"]["current"] = currenttemp;
        }
        if (255 == triptemp)
            pout("Drive Trip Temperature:        <not available>\n");
        else {
            jout("Drive Trip Temperature:        %d C\n", triptemp);
            jglb["temperature"]["drive_trip"] = triptemp;
        }
    }
    pout("\n");
    return err;
}


// Returns number of logged errors or zero if none or -1 if fetching
// TapeAlerts fails
static const char * const severities = "CWI";

static int
scsiPrintActiveTapeAlerts(scsi_device * device, int peripheral_type,
                          bool from_health)
{
    unsigned short pagelength;
    unsigned short parametercode;
    int i, k, j, m, err;
    const char *s;
    const char *ts;
    int failures = 0;
    const char * pad = from_health ? "" : "  ";
    static const char * const tapealert_s = "scsi_tapealert";

    jout("\nTapeAlert %s:\n", lp_s);
    print_on();
    if ((err = scsiLogSense(device, TAPE_ALERTS_LPAGE, 0, gBuf,
                        LOG_RESP_TAPE_ALERT_LEN, LOG_RESP_TAPE_ALERT_LEN))) {
        pout("%s Failed [%s]\n", __func__, scsiErrString(err));
        print_off();
        return -1;
    }
    if (gBuf[0] != 0x2e) {
        pout("%sTapeAlerts %s Failed\n", pad, logSenStr);
        print_off();
        return -1;
    }
    pagelength = sg_get_unaligned_be16(gBuf + 2);

    json::ref jref = jglb[tapealert_s]["status"];
    for (s=severities, k = 0, j = 0; *s; s++, ++k) {
        for (i = 4, m = 0; i < pagelength; i += 5, ++k, ++m) {
            parametercode = sg_get_unaligned_be16(gBuf + i);

            if (gBuf[i + 4]) {
                ts = SCSI_PT_MEDIUM_CHANGER == peripheral_type ?
                    scsiTapeAlertsChangerDevice(parametercode) :
                    scsiTapeAlertsTapeDevice(parametercode);
                if (*ts == *s) {
                    if (!failures)
                        jout("%sTapeAlert Errors (C=Critical, W=Warning, "
                             "I=Informational):\n", pad);
                    jout("%s[0x%02x] %s\n", pad, parametercode, ts);
                    jref[j]["descriptor_idx"] = m + 1;
                    jref[j]["parameter_code"] = parametercode;
                    jref[j]["string"] = ts;
                    ++j;
                    failures += 1;
                }
            }
        }
    }
    print_off();

    if (! failures) {
        jout("%sTapeAlert: OK\n", pad);
        jglb[tapealert_s]["status"] = "Good";
    }

    return failures;
}

static void
scsiGetStartStopData(scsi_device * device)
{
    int err, len, k, extra;
    unsigned char * ucp;
    char b[32];
    const char * q;
    static const char * jname = "scsi_start_stop_cycle_counter";

    if ((err = scsiLogSense(device, STARTSTOP_CYCLE_COUNTER_LPAGE, 0, gBuf,
                            LOG_RESP_LEN, 0))) {
        print_on();
        pout("%s Failed [%s]\n", __func__, scsiErrString(err));
        print_off();
        return;
    }
    if ((gBuf[0] & 0x3f) != STARTSTOP_CYCLE_COUNTER_LPAGE) {
        print_on();
        pout("StartStop %s Failed, page mismatch\n", logSenStr);
        print_off();
        return;
    }
    len = sg_get_unaligned_be16(gBuf + 2);
    ucp = gBuf + 4;
    for (k = len; k > 0; k -= extra, ucp += extra) {
        if (k < 3) {
            print_on();
            pout("StartStop %s: short\n", logSenRspStr);
            print_off();
            return;
        }
        extra = ucp[3] + 4;
        int pc = sg_get_unaligned_be16(ucp + 0);
        uint32_t u = (extra > 7) ? sg_get_unaligned_be32(ucp + 4) : 0;
        bool is_all_ffs = (extra > 7) ? all_ffs(ucp + 4, 4) : false;
        switch (pc) {
        case 1:
            if (10 == extra) {
                jout("Manufactured in week %.2s of year %.4s\n", ucp + 8,
                     ucp + 4);
                snprintf(b, sizeof(b), "%.4s", ucp + 4);
                jglb[jname]["year_of_manufacture"] = b;
                snprintf(b, sizeof(b), "%.2s", ucp + 8);
                jglb[jname]["week_of_manufacture"] = b;
            }
            break;
        case 2:
            /* ignore Accounting date */
            break;
        case 3:
            if ((extra > 7) && (! is_all_ffs)) {
                q = "Specified cycle count over device lifetime";
                jout("%s:  %u\n", q, u);
                jglb[jname][json::str2key(q)] = u;
            }
            break;
        case 4:
            if ((extra > 7) && (! is_all_ffs)) {
                q = "Accumulated start-stop cycles";
                jout("%s:  %u\n", q, u);
                jglb[jname][json::str2key(q)] = u;
            }
            break;
        case 5:
            if ((extra > 7) && (! is_all_ffs)) {
                q = "Specified load-unload count over device lifetime";
                jout("%s:  %u\n", q, u);
                jglb[jname][json::str2key(q)] = u;
            }
            break;
        case 6:
            if ((extra > 7) && (! is_all_ffs)) {
                q = "Accumulated load-unload cycles";
                jout("%s:  %u\n", q, u);
                jglb[jname][json::str2key(q)] = u;
            }
            break;
        default:
            /* ignore */
            break;
        }
    }
}
/* PENDING_DEFECTS_SUBPG [0x15,0x1]  introduced: SBC-4 */
static void
scsiPrintPendingDefectsLPage(scsi_device * device)
{
    static const char * pDefStr = "Pending Defects";
    static const char * jname = "scsi_pending_defects";

    int err;
    if ((err = scsiLogSense(device, BACKGROUND_RESULTS_LPAGE,
                            PEND_DEFECTS_L_SPAGE, gBuf, LOG_RESP_LONG_LEN,
                            0))) {
        print_on();
        pout("%s Failed [%s]\n", __func__, scsiErrString(err));
        print_off();
        return;
    }
    if (((gBuf[0] & 0x3f) != BACKGROUND_RESULTS_LPAGE) &&
        (gBuf[1] != PEND_DEFECTS_L_SPAGE)) {
        print_on();
        pout("%s %s, page mismatch\n", pDefStr, logSenRspStr);
        print_off();
        return;
    }
    int num = sg_get_unaligned_be16(gBuf + 2);
    if (num > LOG_RESP_LONG_LEN) {
        print_on();
        pout("%s %s too long\n", pDefStr, logSenRspStr);
        print_off();
        return;
    }
    const uint8_t * bp = gBuf + 4;
    while (num > 3) {
        int pc = sg_get_unaligned_be16(bp + 0);
        int pl = bp[3] + 4;
        uint32_t count, poh;
        uint64_t lba;

        switch (pc) {
        case 0x0:
            jout("  Pending defect count:");
            if ((pl < 8) || (num < 8)) {
                print_on();
                pout("%s truncated descriptor\n", pDefStr);
                print_off();
                return;
            }
            count = sg_get_unaligned_be32(bp + 4);
            jglb[jname]["count"] = count;
            if (0 == count)
                jout("0 %s\n", pDefStr);
            else if (1 == count)
                jout("1 Pending Defect, LBA and accumulated_power_on_hours "
                     "follow\n");
            else
                jout("%u %s: index, LBA and accumulated_power_on_hours "
                     "follow\n", count, pDefStr);
            break;
        default:
            if ((pl < 16) || (num < 16)) {
                print_on();
                pout("%s truncated descriptor\n", pDefStr);
                print_off();
                return;
            }
            poh = sg_get_unaligned_be32(bp + 4);
            lba = sg_get_unaligned_be64(bp + 8);
            jout("  %4d:  0x%-16" PRIx64 ",  %5u\n", pc, lba, poh);
            {
                json::ref jref = jglb[jname]["table"][pc];

                jref["lba"] = lba;
                jref["accum_power_on_hours"] = poh;
            }
            break;
        }
        num -= pl;
        bp += pl;
    }
}

static void
scsiPrintGrownDefectListLen(scsi_device * device, bool prefer12)
{
    bool got_rd12;
    int err, dl_format;
    unsigned int dl_len, div;
    static const char * hname = "Read defect list";

    memset(gBuf, 0, 8);
    if (prefer12) {
        err = scsiReadDefect12(device, 0 /* req_plist */, 1 /* req_glist */,
                               4 /* format: bytes from index */,
                               0 /* addr desc index */, gBuf, 8);
        got_rd12 = (0 == err);
        if (err) {
            if (scsi_debugmode > 0) {
                print_on();
                pout("%s (12) Failed: %s\n", hname, scsiErrString(err));
                print_off();
            }
        }
    } else {    /* still try Read Defect(12) first, if not found try RD(10) */
        err = scsiReadDefect12(device, 0 /* req_plist */, 1 /* req_glist */,
                               4 /* format: bytes from index */,
                               0 /* addr desc index */, gBuf, 8);
        if (2 == err) { /* command not supported */
            err = scsiReadDefect10(device, 0 /* req_plist */,
                                   1 /* req_glist */,
                                   4 /* format: bytes from index */, gBuf, 4);
            if (2 == err) { /* command not supported */
                if (scsi_debugmode > 0) {
                    print_on();
                    pout("%s (10) Failed: %s\n", hname, scsiErrString(err));
                    print_off();
                }
                return;
            } else if (101 == err)    /* Defect list not found, leave quietly */
                return;
            else {
                if (scsi_debugmode > 0) {
                    print_on();
                    pout("%s (12) Failed: %s\n", hname, scsiErrString(err));
                    print_off();
                }
                return;
            }
        } else
            got_rd12 = true;
    }

    if (got_rd12) {
        int generation = sg_get_unaligned_be16(gBuf + 2);
        if ((generation > 1) && (scsi_debugmode > 0)) {
            print_on();
            pout("%s (12): generation=%d\n", hname, generation);
            print_off();
        }
        dl_len = sg_get_unaligned_be32(gBuf + 4);
    } else
        dl_len = sg_get_unaligned_be16(gBuf + 2);
    if (0x8 != (gBuf[1] & 0x18)) {
        print_on();
        pout("%s: asked for grown list but didn't get it\n", hname);
        print_off();
        return;
    }
    div = 0;
    dl_format = (gBuf[1] & 0x7);
    switch (dl_format) {
        case 0:     /* short block */
            div = 4;
            break;
        case 1:     /* extended bytes from index */
        case 2:     /* extended physical sector */
            /* extended = 1; # might use in future */
            div = 8;
            break;
        case 3:     /* long block */
        case 4:     /* bytes from index */
        case 5:     /* physical sector */
            div = 8;
            break;
        case 6:     /* vendor specific */
            break;
        default:
            print_on();
            pout("defect list format %d unknown\n", dl_format);
            print_off();
            break;
    }
    if (0 == dl_len) {
        jout("Elements in grown defect list: 0\n\n");
        jglb["scsi_grown_defect_list"] = 0;
    }
    else {
        if (0 == div)
            pout("Grown defect list length=%u bytes [unknown "
                 "number of elements]\n\n", dl_len);
        else {
            jout("Elements in grown defect list: %u\n\n", dl_len / div);
            jglb["scsi_grown_defect_list"] = dl_len / div;
        }
    }
}

static uint64_t
variableLengthIntegerParam(const unsigned char * ucp)
{
    static const size_t sz_u64 = (int)sizeof(uint64_t);
    unsigned int u = ucp[3];
    const unsigned char * xp = ucp + 4;

    if (u > sz_u64) {
        xp += (u - sz_u64);
        u = sz_u64;
    }
    return sg_get_unaligned_be(u, xp + 0);
}

static void
scsiPrintSeagateCacheLPage(scsi_device * device)
{
    int num, pl, pc, err, len;
    unsigned char * ucp;
    static const char * seaCacStr = "Seagate Cache";

    if ((err = scsiLogSense(device, SEAGATE_CACHE_LPAGE, 0, gBuf,
                            LOG_RESP_LEN, 0))) {
        if (scsi_debugmode > 0) {
            print_on();
            pout("%s %s Failed: %s\n", seaCacStr, logSenStr,
                 scsiErrString(err));
            print_off();
        }
        return;
    }
    if ((gBuf[0] & 0x3f) != SEAGATE_CACHE_LPAGE) {
        if (scsi_debugmode > 0) {
            print_on();
            pout("%s %s, page mismatch\n", seaCacStr, logSenRspStr);
            print_off();
        }
        return;
    }
    len = sg_get_unaligned_be16(gBuf + 2) + 4;
    num = len - 4;
    ucp = &gBuf[0] + 4;
    while (num > 3) {
        pc = sg_get_unaligned_be16(ucp + 0);
        pl = ucp[3] + 4;
        switch (pc) {
        case 0: case 1: case 2: case 3: case 4:
            break;
        default:
            if (scsi_debugmode > 0) {
                print_on();
                pout("Vendor (%s) lpage has unexpected parameter, skip\n",
                     seaCacStr);
                print_off();
            }
            return;
        }
        num -= pl;
        ucp += pl;
    }
    pout("Vendor (%s) information\n", seaCacStr);
    num = len - 4;
    ucp = &gBuf[0] + 4;
    while (num > 3) {
        pc = sg_get_unaligned_be16(ucp + 0);
        pl = ucp[3] + 4;
        switch (pc) {
        case 0: pout("  Blocks sent to initiator"); break;
        case 1: pout("  Blocks received from initiator"); break;
        case 2: pout("  Blocks read from cache and sent to initiator"); break;
        case 3: pout("  Number of read and write commands whose size "
                       "<= segment size"); break;
        case 4: pout("  Number of read and write commands whose size "
                       "> segment size"); break;
        default: pout("  Unknown Seagate parameter code [0x%x]", pc); break;
        }
        pout(" = %" PRIu64 "\n", variableLengthIntegerParam(ucp));
        num -= pl;
        ucp += pl;
    }
    pout("\n");
}

static void
scsiPrintSeagateFactoryLPage(scsi_device * device)
{
    int num, pl, pc, len, err, good, bad;
    unsigned char * ucp;
    uint64_t ull;

    if ((err = scsiLogSense(device, SEAGATE_FACTORY_LPAGE, 0, gBuf,
                            LOG_RESP_LEN, 0))) {
        if (scsi_debugmode > 0) {
            print_on();
            pout("%s Failed [%s]\n", __func__, scsiErrString(err));
            print_off();
        }
        return;
    }
    if ((gBuf[0] & 0x3f) != SEAGATE_FACTORY_LPAGE) {
        if (scsi_debugmode > 0) {
            print_on();
            pout("Seagate/Hitachi Factory %s, page mismatch\n", logSenRspStr);
            print_off();
        }
        return;
    }
    len = sg_get_unaligned_be16(gBuf + 2) + 4;
    num = len - 4;
    ucp = &gBuf[0] + 4;
    good = 0;
    bad = 0;
    while (num > 3) {
        pc = sg_get_unaligned_be16(ucp + 0);
        pl = ucp[3] + 4;
        switch (pc) {
        case 0: case 8:
            ++good;
            break;
        default:
            ++bad;
            break;
        }
        num -= pl;
        ucp += pl;
    }
    if ((good < 2) || (bad > 4)) {  /* heuristic */
        if (scsi_debugmode > 0) {
            print_on();
            pout("\nVendor (Seagate/Hitachi) factory lpage has too many "
                 "unexpected parameters, skip\n");
            print_off();
        }
        return;
    }
    pout("Vendor (Seagate/Hitachi) factory information\n");
    num = len - 4;
    ucp = &gBuf[0] + 4;
    while (num > 3) {
        pc = sg_get_unaligned_be16(ucp + 0);
        pl = ucp[3] + 4;
        good = 0;
        switch (pc) {
        case 0: jout("  number of hours powered up");
            good = 1;
            break;
        case 8: pout("  number of minutes until next internal SMART test");
            good = 1;
            break;
        default:
            if (scsi_debugmode > 0) {
                print_on();
                pout("Vendor (Seagate/Hitachi) factory lpage: "
                     "unknown parameter code [0x%x]\n", pc);
                print_off();
            }
            break;
        }
        if (good) {
            ull = variableLengthIntegerParam(ucp);
            if (0 == pc) {
                jout(" = %.2f\n", ull / 60.0 );
                jglb["power_on_time"]["hours"] = ull / 60;
                jglb["power_on_time"]["minutes"] = ull % 60;
            }
            else
                pout(" = %" PRIu64 "\n", ull);
        }
        num -= pl;
        ucp += pl;
    }
    pout("\n");
}

static void
scsiPrintErrorCounterLog(scsi_device * device)
{
    struct scsiErrorCounter errCounterArr[3];
    struct scsiErrorCounter * ecp;
    int found[3] = {0, 0, 0};

    if (gReadECounterLPage && (0 == scsiLogSense(device,
                READ_ERROR_COUNTER_LPAGE, 0, gBuf, LOG_RESP_LEN, 0))) {
        scsiDecodeErrCounterPage(gBuf, &errCounterArr[0], LOG_RESP_LEN);
        found[0] = 1;
    }
    if (gWriteECounterLPage && (0 == scsiLogSense(device,
                WRITE_ERROR_COUNTER_LPAGE, 0, gBuf, LOG_RESP_LEN, 0))) {
        scsiDecodeErrCounterPage(gBuf, &errCounterArr[1], LOG_RESP_LEN);
        found[1] = 1;
    }
    if (gVerifyECounterLPage && (0 == scsiLogSense(device,
                VERIFY_ERROR_COUNTER_LPAGE, 0, gBuf, LOG_RESP_LEN, 0))) {
        scsiDecodeErrCounterPage(gBuf, &errCounterArr[2], LOG_RESP_LEN);
        ecp = &errCounterArr[2];
        for (int k = 0; k < 7; ++k) {
            if (ecp->gotPC[k] && ecp->counter[k]) {
                found[2] = 1;
                break;
            }
        }
    }
    if (found[0] || found[1] || found[2]) {
        pout("Error counter log:\n");
        pout("           Errors Corrected by           Total   "
             "Correction     Gigabytes    Total\n");
        pout("               ECC          rereads/    errors   "
             "algorithm      processed    uncorrected\n");
        pout("           fast | delayed   rewrites  corrected  "
             "invocations   [10^9 bytes]  errors\n");

        json::ref jref = jglb["scsi_error_counter_log"];
        for (int k = 0; k < 3; ++k) {
            if (! found[k])
                continue;
            ecp = &errCounterArr[k];
            static const char * const pageNames[3] =
                                 {"read:   ", "write:  ", "verify: "};
            static const char * jpageNames[3] =
                                 {"read", "write", "verify"};
            jout("%s%8" PRIu64 " %8" PRIu64 "  %8" PRIu64 "  %8" PRIu64
                 "   %8" PRIu64, pageNames[k], ecp->counter[0],
                 ecp->counter[1], ecp->counter[2], ecp->counter[3],
                 ecp->counter[4]);
            double processed_gb = ecp->counter[5] / 1000000000.0;
            jout("   %12.3f    %8" PRIu64 "\n", processed_gb,
                 ecp->counter[6]);
            // Error counter log info
            jref[jpageNames[k]]["errors_corrected_by_eccfast"] = ecp->counter[0];
            jref[jpageNames[k]]["errors_corrected_by_eccdelayed"] = ecp->counter[1];
            jref[jpageNames[k]]["errors_corrected_by_rereads_rewrites"] = ecp->counter[2];
            jref[jpageNames[k]]["total_errors_corrected"] = ecp->counter[3];
            jref[jpageNames[k]]["correction_algorithm_invocations"] = ecp->counter[4];
            jref[jpageNames[k]]["gigabytes_processed"] = strprintf("%.3f", processed_gb);
            jref[jpageNames[k]]["total_uncorrected_errors"] = ecp->counter[6];
        }
    }
    else
        pout("Error Counter logging not supported\n");
    if (gNonMediumELPage && (0 == scsiLogSense(device,
                NON_MEDIUM_ERROR_LPAGE, 0, gBuf, LOG_RESP_LEN, 0))) {
        struct scsiNonMediumError nme;
        scsiDecodeNonMediumErrPage(gBuf, &nme, LOG_RESP_LEN);
        if (nme.gotPC0)
            pout("\nNon-medium error count: %8" PRIu64 "\n", nme.counterPC0);
        if (nme.gotTFE_H)
            pout("Track following error count [Hitachi]: %8" PRIu64 "\n",
                 nme.counterTFE_H);
        if (nme.gotPE_H)
            pout("Positioning error count [Hitachi]: %8" PRIu64 "\n",
                 nme.counterPE_H);
    }
    if (gLastNErrorEvLPage &&
        (0 == scsiLogSense(device, LAST_N_ERROR_EVENTS_LPAGE, 0, gBuf,
                           LOG_RESP_LONG_LEN, 0))) {
        int num = sg_get_unaligned_be16(gBuf + 2) + 4;
        int truncated = (num > LOG_RESP_LONG_LEN) ? num : 0;
        if (truncated)
            num = LOG_RESP_LONG_LEN;
        unsigned char * ucp = gBuf + 4;
        num -= 4;
        if (num < 4)
            pout("\nNo error events logged\n");
        else {
            pout("\nLast n error events %s\n", lp_s);
            for (int k = num, pl; k > 0; k -= pl, ucp += pl) {
                if (k < 3) {
                    pout("  <<short Last n error events %s>>\n", lp_s);
                    break;
                }
                pl = ucp[3] + 4;
                int pc = sg_get_unaligned_be16(ucp + 0);
                if (pl > 4) {
                    if ((ucp[2] & 0x1) && (ucp[2] & 0x2)) {
                        pout("  Error event %d:\n", pc);
                        pout("    [binary]:\n");
                        dStrHex((const uint8_t *)ucp + 4, pl - 4, 1);
                    } else if (ucp[2] & 0x1) {
                        pout("  Error event %d:\n", pc);
                        pout("    %.*s\n", pl - 4, (const char *)(ucp + 4));
                    } else {
                        if (scsi_debugmode > 0) {
                            pout("  Error event %d:\n", pc);
                            pout("    [data counter??]:\n");
                            dStrHex((const uint8_t *)ucp + 4, pl - 4, 1);
                        }
                    }
                }
            }
            if (truncated)
                pout(" >>>> log truncated, fetched %d of %d available "
                     "bytes\n", LOG_RESP_LONG_LEN, truncated);
        }
    }
    pout("\n");
}

static const char * self_test_code[] = {
        "Default         ",
        "Background short",
        "Background long ",
        "Reserved(3)     ",
        "Abort background",
        "Foreground short",
        "Foreground long ",
        "Reserved(7)     "
};

static const char * self_test_result[] = {
        "Completed                ",
        "Aborted (by user command)",
        "Aborted (device reset ?) ",
        "Unknown error, incomplete",
        "Completed, segment failed",
        "Failed in first segment  ",
        "Failed in second segment ",
        "Failed in segment",            /* special handling for result 7 */
        "Reserved(8)              ",
        "Reserved(9)              ",
        "Reserved(10)             ",
        "Reserved(11)             ",
        "Reserved(12)             ",
        "Reserved(13)             ",
        "Reserved(14)             ",
        "Self test in progress ..."
};

// See SCSI Primary Commands - 3 (SPC-3) rev 23 (draft) section 7.2.10 .
// Returns 0 if ok else FAIL* bitmask. Note that if any of the most recent
// 20 self tests fail (result code 3 to 7 inclusive) then FAILLOG and/or
// FAILSMART is returned.
static int
scsiPrintSelfTest(scsi_device * device)
{
    bool noheader = true;
    int num, k, err, durationSec;
    int retval = 0;
    uint8_t * ucp;
    struct scsi_sense_disect sense_info;
    static const char * hname = "Self-test";
    static const char * fixup_stres7 = " -->    ";  /* only for non-json */

    // check if test is running
    if (!scsiRequestSense(device, &sense_info) &&
                        (sense_info.asc == 0x04 && sense_info.ascq == 0x09 &&
                        sense_info.progress != -1)) {
        pout("%s execution status:\t\t%d%% of test remaining\n", hname,
             100 - ((sense_info.progress * 100) / 65535));
    }

    if ((err = scsiLogSense(device, SELFTEST_RESULTS_LPAGE, 0, gBuf,
                            LOG_RESP_SELF_TEST_LEN, 0))) {
        print_on();
        pout("%s: Failed [%s]\n", __func__, scsiErrString(err));
        print_off();
        return FAILSMART;
    }
    if ((gBuf[0] & 0x3f) != SELFTEST_RESULTS_LPAGE) {
        print_on();
        pout("%s %s, page mismatch\n", hname, logSenRspStr);
        print_off();
        return FAILSMART;
    }
    // compute page length
    num = sg_get_unaligned_be16(gBuf + 2);
    // Log sense page length 0x190 bytes
    if (num != 0x190) {
        print_on();
        pout("%s %s length is 0x%x not 0x190 bytes\n", hname, logSenStr, num);
        print_off();
        return FAILSMART;
    }
    // loop through the twenty possible entries
    for (k = 0, ucp = gBuf + 4; k < 20; ++k, ucp += 20 ) {
        // timestamp in power-on hours (or zero if test in progress)
        unsigned int poh = sg_get_unaligned_be16(ucp + 6);
        unsigned int u, tr;
        char st[32];

        snprintf(st, sizeof(st), "scsi_self_test_%d", k);
        // The spec says "all 20 bytes will be zero if no test" but
        // DG has found otherwise.  So this is a heuristic.
        if ((0 == poh) && (0 == ucp[4]))
            break;

        // only print header if needed
        if (noheader) {
            jout("SMART %s log\n", hname);
            jout("Num  Test              Status                 segment  "
                   "LifeTime  LBA_first_err [SK ASC ASQ]\n");
            jout("     Description                              number   "
                   "(hours)\n");
            noheader = false;
        }

        // print parameter code (test number) & self-test code text
        u = (ucp[4] >> 5) & 0x7;
        jout("#%2d  %s", sg_get_unaligned_be16(ucp + 0), self_test_code[u]);
        jglb[st]["code"]["value"] = u;
        jglb[st]["code"]["string"] = rtrim(self_test_code[u]);

        // check the self-test result nibble, using the self-test results
        // field table from T10/1416-D (SPC-3) Rev. 23, section 7.2.10:
        tr = ucp[4] & 0xf;
        switch (tr) {
        case 0x3:
            // an unknown error occurred while the device server
            // was processing the self-test and the device server
            // was unable to complete the self-test
            retval|=FAILSMART;
            break;
        case 0x4:
            // the self-test completed with a failure in a test
            // segment, and the test segment that failed is not
            // known
            retval|=FAILLOG;
            break;
        case 0x5:
            // the first segment of the self-test failed
            retval|=FAILLOG;
            break;
        case 0x6:
            // the second segment of the self-test failed
            retval|=FAILLOG;
            break;
        case 0x7:
            // another segment of the self-test failed and which
            // test is indicated by the contents of the SELF-TEST
            // NUMBER field
            retval|=FAILLOG;
            break;
        default:
            break;
        }
        jout("  %s%s", self_test_result[tr], (tr == 7 ? fixup_stres7 : ""));
        jglb[st]["result"]["value"] = tr;
        jglb[st]["result"]["string"] = rtrim(self_test_result[tr]);

        // self-test number identifies test that failed and consists
        // of either the number of the segment that failed during
        // the test, or the number of the test that failed and the
        // number of the segment in which the test was run, using a
        // vendor-specific method of putting both numbers into a
        // single byte.
        u = ucp[5];
        if (u > 0) {
            jout(" %3u",  u);
            jglb[st]["failed_segment"]["value"] = u;
            jglb[st]["failed_segment"]["aka"] = "self_test_number";
        } else
            jout("   -");

        // print time that the self-test was completed
        if (poh==0 && tr==0xf) {
        // self-test in progress
            jout("     NOW");
            jglb[st]["self_test_in_progress"] = true;
        } else {
            jout("   %5d", poh);
            jglb[st]["power_on_time"]["hours"] = poh;
            jglb[st]["power_on_time"]["aka"] = "accumulated_power_on_hours";
        }

        // construct 8-byte integer address of first failure
        uint64_t ull = sg_get_unaligned_be64(ucp + 8);
        bool is_all_ffs = all_ffs(ucp + 8, 8);
        // print Address of First Failure, if sensible
        if ((! is_all_ffs) && (tr > 0) && (tr < 0xf)) {
            char buff[32];

            // was hex but change to decimal to conform with ATA
            snprintf(buff, sizeof(buff), "%" PRIu64, ull);
            // snprintf(buff, sizeof(buff), "0x%" PRIx64, ull);
            jout("%18s", buff);
            jglb[st]["lba_first_failure"]["value"] = ull;
            jglb[st]["lba_first_failure"]["aka"] = "address_of_first_failure";
        } else
            jout("                 -");

        // if sense key nonzero, then print it, along with
        // additional sense code and additional sense code qualifier
        if (ucp[16] & 0xf) {
            char b[48];

            jout(" [0x%x 0x%x 0x%x]\n", ucp[16] & 0xf, ucp[17], ucp[18]);
            u = ucp[16] & 0xf;
            jglb[st]["sense_key"]["value"] = u;
            jglb[st]["sense_key"]["string"] =
                        scsi_get_sense_key_str(u, sizeof(b), b);
            jglb[st]["asc"] = ucp[17];
            jglb[st]["ascq"] = ucp[18];
            jglb[st]["vendor_specific"] = ucp[19];
        } else
            pout(" [-   -    -]\n");
    }

    // if header never printed, then there was no output
    if (noheader)
        jout("No %ss have been logged\n", hname);
    else if ((0 == scsiFetchExtendedSelfTestTime(device, &durationSec,
                        modese_len)) && (durationSec > 0)) {
        if (durationSec > 14400)
            jout("\nLong (extended) %s duration: %d seconds "
                 "[%.1f hours]\n", hname, durationSec, durationSec / 3600.0);
        else
            jout("\nLong (extended) %s duration: %d seconds "
                 "[%.1f minutes]\n", hname, durationSec, durationSec / 60.0);
        jglb["scsi_extended_self_test_seconds"] = durationSec;
    }
    jout("\n");
    return retval;
}

static const char * bms_status[] = {
    "no scans active",
    "scan is active",
    "pre-scan is active",
    "halted due to fatal error",
    "halted due to a vendor specific pattern of error",
    "halted due to medium formatted without P-List",
    "halted - vendor specific cause",
    "halted due to temperature out of range",
    "waiting until BMS interval timer expires", /* 8 */
};

static const char * reassign_status[] = {
    "Reserved [0x0]",
    "Require Write or Reassign Blocks command",
    "Successfully reassigned",
    "Reserved [0x3]",
    "Reassignment by disk failed",
    "Recovered via rewrite in-place",
    "Reassigned by app, has valid data",
    "Reassigned by app, has no valid data",
    "Unsuccessfully reassigned by app", /* 8 */
};

// See SCSI Block Commands - 3 (SBC-3) rev 6 (draft) section 6.2.2 .
// Returns 0 if ok else FAIL* bitmask. Note can have a status entry
// and up to 2048 events (although would hope to have less). May set
// FAILLOG if serious errors detected (in the future).
// When only_pow_time is true only print "Accumulated power on time"
// data, if available.
static int
scsiPrintBackgroundResults(scsi_device * device, bool only_pow_time)
{
    bool noheader = true;
    bool firstresult = true;
    int num, j, m, err, truncated;
    int retval = 0;
    unsigned int u;
    uint64_t lba;
    uint8_t * ucp;
    char b[48];
    char res_s[32];
    static const char * hname = "Background scan results";
    static const char * jname = "scsi_background_scan";

    if ((err = scsiLogSense(device, BACKGROUND_RESULTS_LPAGE, 0, gBuf,
                            LOG_RESP_LONG_LEN, 0))) {
        print_on();
        pout("%s Failed [%s]\n", __func__, scsiErrString(err));
        print_off();
        return FAILSMART;
    }
    if ((gBuf[0] & 0x3f) != BACKGROUND_RESULTS_LPAGE) {
        print_on();
        pout("%s %s, page mismatch\n", hname, logSenRspStr);
        print_off();
        return FAILSMART;
    }
    // compute page length
    num = sg_get_unaligned_be16(gBuf + 2) + 4;
    if (num < 20) {
        if (! only_pow_time) {
            print_on();
            pout("%s %s length is %d, no scan status\n", hname, logSenStr,
                 num);
            print_off();
        }
        return FAILSMART;
    }
    truncated = (num > LOG_RESP_LONG_LEN) ? num : 0;
    if (truncated)
        num = LOG_RESP_LONG_LEN;
    ucp = gBuf + 4;
    num -= 4;
    while (num > 3) {
        int pc = sg_get_unaligned_be16(ucp + 0);
        // pcb = ucp[2];
        int pl = ucp[3] + 4;
        switch (pc) {
        case 0:
            if (noheader) {
                noheader = false;
                if (! only_pow_time)
                    jout("%s log\n", hname);
            }
            if (! only_pow_time)
                jout("  Status: ");
            if ((pl < 16) || (num < 16)) {
                if (! only_pow_time)
                    jout("\n");
                break;
            }
            j = ucp[9];
            if (! only_pow_time) {
                if (j < (int)ARRAY_SIZE(bms_status)) {
                    jout("%s\n", bms_status[j]);
                    jglb[jname]["status"]["value"] = j;
                    jglb[jname]["status"]["string"] = bms_status[j];
                } else {
                    jout("unknown [0x%x] background scan status value\n", j);
                    jglb[jname]["status"]["value"] = j;
                }
            }
            j = sg_get_unaligned_be32(ucp + 4);
            jout("%sAccumulated power on time, hours:minutes %d:%02d",
                 (only_pow_time ? "" : "    "), (j / 60), (j % 60));
            if (only_pow_time)
                jout("\n");
            else
                jout(" [%d minutes]\n", j);
            jglb["power_on_time"]["hours"] = j / 60;
            jglb["power_on_time"]["minutes"] = j % 60;
            if (only_pow_time)
                break;
            u = sg_get_unaligned_be16(ucp + 10);
            jout("    Number of background scans performed: %u,  ", u);
            jglb[jname]["status"]["number_scans_performed"] = u;
            u = sg_get_unaligned_be16(ucp + 12);
            snprintf(b, sizeof(b), "%.2f%%", (double)u * 100.0 / 65536.0);
            jout("scan progress: %s\n", b);
            jglb[jname]["status"]["scan_progress"] = b;
            u = sg_get_unaligned_be16(ucp + 14);
            jout("    Number of background medium scans performed: %d\n", u);
            jglb[jname]["status"]["number_medium_scans_performed"] = u;
            break;
        default:
            if (noheader) {
                noheader = false;
                if (! only_pow_time)
                    jout("\n%s log\n", hname);
            }
            if (only_pow_time)
                break;
            if (firstresult) {
                firstresult = 0;
                jout("\n   #  when        lba(hex)    [sk,asc,ascq]    "
                     "reassign_status\n");
            }
            snprintf(res_s, sizeof(res_s), "result_%d", pc);
            jout(" %3d ", pc);
            jglb[jname][res_s]["parameter_code"] = pc;
            if ((pl < 24) || (num < 24)) {
                if (pl < 24)
                    jout("parameter length >= 24 expected, got %d\n", pl);
                break;
            }
            u = sg_get_unaligned_be32(ucp + 4);
            jout("%4u:%02u  ", (u / 60), (u % 60));
            jglb[jname][res_s]["accumulated_power_on"]["minutes"] = u;
            for (m = 0; m < 8; ++m)
                jout("%02x", ucp[16 + m]);
            lba = sg_get_unaligned_be64(ucp + 16);
            jglb[jname][res_s]["lba"] = lba;
            u = ucp[8] & 0xf;
            jout("  [%x,%x,%x]   ", u, ucp[9], ucp[10]);
            jglb[jname][res_s]["sense_key"]["value"] = u;
            jglb[jname][res_s]["sense_key"]["string"] =
                        scsi_get_sense_key_str(u, sizeof(b), b);
            jglb[jname][res_s]["asc"] = ucp[9];
            jglb[jname][res_s]["ascq"] = ucp[10];
            u = (ucp[8] >> 4) & 0xf;
            if (u < ARRAY_SIZE(reassign_status)) {
                jout("%s\n", reassign_status[u]);
                jglb[jname][res_s]["reassign_status"]["value"] = u;
                jglb[jname][res_s]["reassign_status"]["string"] =
                                                        reassign_status[u];
            } else {
                jout("Reassign status: reserved [0x%x]\n", u);
                jglb[jname][res_s]["reassign_status"]["value"] = u;
            }
            break;
        }
        num -= pl;
        ucp += pl;
    }
    if (truncated && (! only_pow_time))
        jout(" >>>> log truncated, fetched %d of %d available "
             "bytes\n", LOG_RESP_LONG_LEN, truncated);
#if 0
    if (! only_pow_time)
        jout("\n");
#endif
    return retval;
}

static int64_t
scsiGetTimeUnitInNano(const uint8_t * ucp, int num, uint16_t ti_pc) 
{
    uint16_t loop_pc, pl;
    uint32_t a_exp, a_int, casc;
    int64_t res = -1;

    while (num > 3) {
        loop_pc = sg_get_unaligned_be16(ucp + 0);
        pl = ucp[3] + 4;

        if (loop_pc == ti_pc) {
            /* assume this pc corresponds to Time Interval param */
            if (pl < 12) {
                print_on();
                pout("%s Time interval log parameter too short (pl=%d)\n",
                     __func__, pl);
                print_off();
                return res;
            }
            a_exp = sg_get_unaligned_be32(ucp + 4);
            a_int = sg_get_unaligned_be32(ucp + 8);
            if (0 == a_int)
                return 0;
            else
                res = a_int;
            if (a_exp > 10)
                return -2;
            if (10 == a_exp) {
                if (a_int < 10)
                    return -2;
                return a_int / 10;
            }
            casc = 9 - a_exp;
            while (casc > 0) {
                res *= 10;
                --casc;
            }
            return res;
        }
        num -= pl;
        ucp += pl;
    }
    return res;
}

static void
scsiPrintTimeUnitInNano(int leadin_spaces, uint64_t intervals,
                        int64_t timeUnitInNS)
{
    if ((intervals > 0) && (timeUnitInNS > 0)) {
        intervals *= timeUnitInNS;
        intervals /= 1000000; /* now in milliseconds */
        jout("%*cin seconds: %" PRIu64 ".%03" PRIu64 "\n",
             leadin_spaces, ' ', intervals / 1000, intervals % 1000);
        if (intervals > 3600000) {
            intervals /= 3600; /* now in 3.6 second units */
            jout("%*cin hours: %" PRIu64 ".%03" PRIu64 "\n",
                 leadin_spaces, ' ', intervals / 1000, intervals % 1000);
        }
    }
}

// See SCSI Primary Commands - 6 (SPC-6) General Statistics and Performance
// log page [lp: 0x19,0x0]
static int
scsiPrintGStatsPerf(scsi_device * device)
{
    int num, err, truncated;
    int retval = 0;
    int64_t timeUnitInNS;
    uint64_t ull;
    const char * ccp;
    uint8_t * ucp;
    // const char * q;
    json::ref jref = jglb["scsi_general_statistics_and_performance_log"];
    json::ref jref1 = jref["general_access"];
    json::ref jref2 = jref["idle_time"];
    json::ref jref3 = jref["time_interval"];
    json::ref jref4 = jref["fua_stats"];
    static const char * p1name = "General access statistics and performance";
    static const char * p2name = "Idle time";
    static const char * p3name = "Time interval";
    static const char * p4name = "Force Unit Access statistics and "
                                 "performance";

    jout("\n%s %s:\n", gsap_s, lp_s);
    if ((err = scsiLogSense(device, GEN_STATS_PERF_LPAGE, 0, gBuf,
                            LOG_RESP_LONG_LEN, 0))) {
        print_on();
        pout("%s: Failed [%s]\n", __func__, scsiErrString(err));
        print_off();
        return FAILSMART;
    }
    if ((gBuf[0] & 0x3f) != GEN_STATS_PERF_LPAGE) {
        print_on();
        pout("%s %s, page mismatch\n", gsap_s, logSenStr);
        print_off();
        return FAILSMART;
    }
    // compute page length
    num = sg_get_unaligned_be16(gBuf + 2) + 4;
    if (num < 12) {
        print_on();
        pout("%s %s length is %d, too short\n", gsap_s, logSenStr, num);
        print_off();
        return FAILSMART;
    }
    truncated = (num > LOG_RESP_LONG_LEN) ? num : 0;
    if (truncated)
        num = LOG_RESP_LONG_LEN;
    ucp = gBuf + 4;
    num -= 4;
    timeUnitInNS = scsiGetTimeUnitInNano(ucp, num, 0x3 /* Time Interval */);
    if (timeUnitInNS < 0) {
        if (scsi_debugmode > 1) {
            print_on();
            pout("%s unable to decode time unit [%d]\n", gsap_s,
                 (int)timeUnitInNS);
            print_off();
        }
        timeUnitInNS = 0;
    }

    while (num > 3) {
        int pc = sg_get_unaligned_be16(ucp + 0);
        // pcb = ucp[2];
        int pl = ucp[3] + 4;

        switch (pc) {
        case 1: /* General access statistics and performance log parameter */
            if (pl < 0x40 + 4) {
                print_on();
                pout("%s %s log parameter too short (pl=%d)\n", gsap_s,
                     p1name, pl);
                print_off();
                return FAILSMART;
            }
            jout("  %s:\n", p1name);
            ccp =  "Number of read commands";
            ull = sg_get_unaligned_be64(ucp + 4);
            jout("    %s: %" PRIu64 "\n", ccp, ull);
            jref1[ccp] = ull;
            ccp =  "Number of write commands";
            ull = sg_get_unaligned_be64(ucp + 12);
            jout("    %s: %" PRIu64 "\n", ccp, ull);
            jref1[ccp] = ull;
            ccp =  "number of logical blocks received";
            ull = sg_get_unaligned_be64(ucp + 20);
            jout("    %s: %" PRIu64 "\n", ccp, ull);
            jref1[ccp] = ull;
            ccp =  "number of logical blocks transmitted";
            ull = sg_get_unaligned_be64(ucp + 28);
            jout("    %s: %" PRIu64 "\n", ccp, ull);
            jref1[ccp] = ull;
            ccp = "read command processing intervals";
            ull = sg_get_unaligned_be64(ucp + 36);
            jout("    %s: %" PRIu64 "\n", ccp, ull);
            scsiPrintTimeUnitInNano(6, ull, timeUnitInNS);
            jref1[ccp] = ull;
            ccp = "write command processing intervals";
            ull = sg_get_unaligned_be64(ucp + 44);
            jout("    %s: %" PRIu64 "\n", ccp, ull);
            scsiPrintTimeUnitInNano(6, ull, timeUnitInNS);
            jref1[ccp] = ull;
            ccp = "weighted number of read commands plus write commands";
            ull = sg_get_unaligned_be64(ucp + 52);
            jout("    %s: %" PRIu64 "\n", ccp, ull);
            jref1[ccp] = ull;
            ccp = "weighted read command processing plus write command "
                  "processing";
            ull = sg_get_unaligned_be64(ucp + 60);
            scsiPrintTimeUnitInNano(6, ull, timeUnitInNS);
            jout("    %s: %" PRIu64 "\n", ccp, ull);
            jref1[ccp] = ull;
            break;
        case 2:     /* Idle time log parameter */
            if (pl < 0x8 + 4) {
                print_on();
                pout("%s %s log parameter too short (pl=%d)\n", gsap_s,
                     p2name, pl);
                print_off();
                return FAILSMART;
            }
            jout("  %s:\n", p2name);
            ccp = "Idle time intervals";
            ull = sg_get_unaligned_be64(ucp + 4);
            jout("    %s: %" PRIu64 "\n", ccp, ull);
            scsiPrintTimeUnitInNano(6, ull, timeUnitInNS);
            jref2[ccp] = ull;
            break;
        case 3:    /* Time interval log parameter (shared with other lpages */
            /* only produce JSON for this parameter */
            if (pl < 0x8 + 4) {
                print_on();
                pout("%s %s log parameter too short (pl=%d)\n", gsap_s,
                     p3name, pl);
                print_off();
                return FAILSMART;
            }
            ccp = "Exponent";
            ull = sg_get_unaligned_be32(ucp + 4);
            jref3[ccp] = ull;
            ccp = "Integer";
            ull = sg_get_unaligned_be32(ucp + 8);
            jref3[ccp] = ull;
            break;
        case 4:     /* FUA statistics and performance log parameter */
            if (pl < 0x40 + 4) {
                print_on();
                pout("%s %s log parameter too short (pl=%d)\n", gsap_s,
                     p4name, pl);
                print_off();
                return FAILSMART;
            }
            jout("  %s:\n", p4name);
            ccp = "Number of read FUA commands";
            ull = sg_get_unaligned_be64(ucp + 4);
            jout("    %s: %" PRIu64 "\n", ccp, ull);
            jref4[ccp] = ull;
            ccp = "Number of write FUA commands";
            ull = sg_get_unaligned_be64(ucp + 12);
            jout("    %s: %" PRIu64 "\n", ccp, ull);
            jref4[ccp] = ull;
            ccp = "Number of read FUA_NV commands";
            ull = sg_get_unaligned_be64(ucp + 20);
            jout("    %s: %" PRIu64 "\n", ccp, ull);
            jref4[ccp] = ull;
            ccp = "Number of write FUA_NV commands";
            ull = sg_get_unaligned_be64(ucp + 28);
            jout("    %s: %" PRIu64 "\n", ccp, ull);
            jref4[ccp] = ull;
            ccp = "Number of read FUA intervals";
            ull = sg_get_unaligned_be64(ucp + 36);
            jout("    %s: %" PRIu64 "\n", ccp, ull);
            scsiPrintTimeUnitInNano(6, ull, timeUnitInNS);
            jref4[ccp] = ull;
            ccp = "Number of write FUA intervals";
            ull = sg_get_unaligned_be64(ucp + 44);
            jout("    %s: %" PRIu64 "\n", ccp, ull);
            jref4[ccp] = ull;
            ccp = "Number of read FUA_NV intervals";
            ull = sg_get_unaligned_be64(ucp + 52);
            jout("    %s: %" PRIu64 "\n", ccp, ull);
            scsiPrintTimeUnitInNano(6, ull, timeUnitInNS);
            jref4[ccp] = ull;
            ccp = "Number of write FUA_NV intervals";
            ull = sg_get_unaligned_be64(ucp + 60);
            jout("    %s: %" PRIu64 "\n", ccp, ull);
            scsiPrintTimeUnitInNano(6, ull, timeUnitInNS);
            jref4[ccp] = ull;
            break;
        default:        /* ignore other parameter codes */
            break;
        }
        num -= pl;
        ucp += pl;
    }           /* end of long for loop */
    return retval;
}

// Print Solid state media log page.
// See SCSI Block Commands - 3 (SBC-3) rev 27 (draft) section 6.3.6 .
// Returns 0 if ok else FAIL* bitmask. Note can have a status entry
// and up to 2048 events (although would hope to have less). May set
// FAILLOG if serious errors detected (in the future).
static int
scsiPrintSSMedia(scsi_device * device)
{
    int num, err, truncated;
    int retval = 0;
    uint8_t * ucp;
    const char * q;

    if ((err = scsiLogSense(device, SS_MEDIA_LPAGE, 0, gBuf,
                            LOG_RESP_LONG_LEN, 0))) {
        print_on();
        pout("%s: Failed [%s]\n", __func__, scsiErrString(err));
        print_off();
        return FAILSMART;
    }
    if ((gBuf[0] & 0x3f) != SS_MEDIA_LPAGE) {
        print_on();
        pout("%s %s, page mismatch\n", ssm_s, logSenStr);
        print_off();
        return FAILSMART;
    }
    // compute page length
    num = sg_get_unaligned_be16(gBuf + 2) + 4;
    if (num < 12) {
        print_on();
        pout("%s %s length is %d, too short\n", ssm_s, logSenStr, num);
        print_off();
        return FAILSMART;
    }
    truncated = (num > LOG_RESP_LONG_LEN) ? num : 0;
    if (truncated)
        num = LOG_RESP_LONG_LEN;
    ucp = gBuf + 4;
    num -= 4;
    while (num > 3) {
        int pc = sg_get_unaligned_be16(ucp + 0);
        // pcb = ucp[2];
        int pl = ucp[3] + 4;
        switch (pc) {
        case 1:
            if (pl < 8) {
                print_on();
                pout("%s Percentage used endurance indicator parameter "
                     "too short (pl=%d)\n", ssm_s, pl);
                print_off();
                return FAILSMART;
            }
            q = "Percentage used endurance indicator";
            jout("%s: %d%%\n", q, ucp[7]);
            jglb[std::string("scsi_") + json::str2key(q)] = ucp[7];
        default:        /* ignore other parameter codes */
            break;
        }
        num -= pl;
        ucp += pl;
    }
    return retval;
}

static int
scsiPrintZBDeviceStats(scsi_device * device)
{
    int num, err, truncated;
    int retval = 0;
    uint32_t u;
    uint8_t * ucp;
    const char * q;
    static const char * jname = "scsi_zoned_block_device_statistics";

    jout("\n%s %s:\n", zbds_s, lp_s);
    if ((err = scsiLogSense(device, DEVICE_STATS_LPAGE, ZB_DEV_STATS_L_SPAGE,
                            gBuf, LOG_RESP_LONG_LEN, 0))) {
        print_on();
        pout("%s: Failed [%s]\n", __func__, scsiErrString(err));
        print_off();
        return FAILSMART;
    }
    if (((gBuf[0] & 0x3f) != DEVICE_STATS_LPAGE) &&
        (gBuf[1] == ZB_DEV_STATS_L_SPAGE)) {
        print_on();
        pout("%s %s, page mismatch\n", zbds_s, logSenStr);
        print_off();
        return FAILSMART;
    }
    // compute page length
    num = sg_get_unaligned_be16(gBuf + 2) + 4;
    if (num < 12) {
        print_on();
        pout("%s %s length is %d, too short\n", zbds_s, logSenStr, num);
        print_off();
        return FAILSMART;
    }
    truncated = (num > LOG_RESP_LONG_LEN) ? num : 0;
    if (truncated)
        num = LOG_RESP_LONG_LEN;
    ucp = gBuf + 4;
    num -= 4;
    while (num > 3) {
        int pc = sg_get_unaligned_be16(ucp + 0);
        // pcb = ucp[2];
        int pl = ucp[3] + 4;

        if (pl < 12)
            goto skip;  /* DC HC650 has non-compliant 4 byte parameters */
        switch (pc) {
        case 0:
            q = "Maximum open zones";
            u = sg_get_unaligned_be32(ucp + 8);
            jout("    %s: %u\n", q, u);
            jglb[jname][json::str2key(q)] = u;
            break;
        case 1:
            q = "Maximum explicitly open zones";
            u = sg_get_unaligned_be32(ucp + 8);
            jout("    %s: %u\n", q, u);
            jglb[jname][json::str2key(q)] = u;
            break;
        case 2:
            q = "Maximum implicitly open zones";
            u = sg_get_unaligned_be32(ucp + 8);
            jout("    %s: %u\n", q, u);
            jglb[jname][json::str2key(q)] = u;
            break;
        case 3:
            q = "Minimum empty zones";
            u = sg_get_unaligned_be32(ucp + 8);
            jout("    %s: %u\n", q, u);
            jglb[jname][json::str2key(q)] = u;
            break;
        case 4:
            q = "Maximum nonseq zones";
            u = sg_get_unaligned_be32(ucp + 8);
            jout("    %s: %u\n", q, u);
            jglb[jname][json::str2key(q)] = u;
            break;
        case 5:
            q = "Zones emptied";
            u = sg_get_unaligned_be32(ucp + 8);
            jout("    %s: %u\n", q, u);
            jglb[jname][json::str2key(q)] = u;
            break;
        case 6:
            q = "Suboptimal write commands";
            u = sg_get_unaligned_be32(ucp + 8);
            jout("    %s: %u\n", q, u);
            jglb[jname][json::str2key(q)] = u;
            break;
        case 7:
            q = "Commands exceeding optinmal limit";
            u = sg_get_unaligned_be32(ucp + 8);
            jout("    %s: %u\n", q, u);
            jglb[jname][json::str2key(q)] = u;
            break;
        case 8:
            q = "Failed explicit opens";
            u = sg_get_unaligned_be32(ucp + 8);
            jout("    %s: %u\n", q, u);
            jglb[jname][json::str2key(q)] = u;
            break;
        case 9:
            q = "Read rule violations";
            u = sg_get_unaligned_be32(ucp + 8);
            jout("    %s: %u\n", q, u);
            jglb[jname][json::str2key(q)] = u;
            break;
        case 0xa:
            q = "Write rule violations";
            u = sg_get_unaligned_be32(ucp + 8);
            jout("    %s: %u\n", q, u);
            jglb[jname][json::str2key(q)] = u;
            break;
        case 0xb:
            q = "Maximum implicitly open sequential or before required zones";
            u = sg_get_unaligned_be32(ucp + 8);
            jout("    %s: %u\n", q, u);
            jglb[jname][json::str2key(q)] = u;
            break;
        default:        /* ignore other parameter codes */
            break;
        }
skip:
        num -= pl;
        ucp += pl;
    }
    return retval;
}

static int
scsiPrintTapeDeviceStats(scsi_device * device)
{
    int num, err, truncated;
    int retval = 0;
    uint32_t k, n, u;
    uint64_t ull;
    uint8_t * ucp;
    const char * q;
    static const char * hname = "Device statistics (SSC, tape)";
    static const char * jname = "scsi_device_statistics";

    jout("\n%s %s:\n", hname, lp_s);
    if ((err = scsiLogSense(device, DEVICE_STATS_LPAGE, 0,
                            gBuf, LOG_RESP_LONG_LEN, 0))) {
        print_on();
        pout("%s: Failed [%s]\n", __func__, scsiErrString(err));
        print_off();
        return FAILSMART;
    }
    if (((gBuf[0] & 0x3f) != DEVICE_STATS_LPAGE) &&
        (gBuf[1] != 0)) {
        print_on();
        pout("%s %s, page mismatch\n", hname, logSenStr);
        print_off();
        return FAILSMART;
    }
    // compute page length
    num = sg_get_unaligned_be16(gBuf + 2) + 4;
    if (num < 12) {
        print_on();
        pout("%s %s length is %d, too short\n", hname, logSenStr, num);
        print_off();
        return FAILSMART;
    }
    truncated = (num > LOG_RESP_LONG_LEN) ? num : 0;
    if (truncated)
        num = LOG_RESP_LONG_LEN;
    ucp = gBuf + 4;
    num -= 4;
    while (num > 3) {
        int pc = sg_get_unaligned_be16(ucp + 0);
        // pcb = ucp[2];
        int pl = ucp[3] + 4;
        std::string s;

        switch (pc) {
        case 0:
            q = "Lifetime volume loads";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 1:
            q = "Lifetime cleaning operations";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 2:
            q = "Lifetime power on hours";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 3:
            q = "Lifetime medium motion hours";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 4:
            q = "Lifetime meters of tape processed";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 5:
            q = "Lifetime medium motion hours at last incompatible volume "
                "load";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 6:
            q = "Lifetime power on hours at last temperature condition "
                "occurrence";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 7:
            q = "Lifetime power on hours at last power consumption condition "
                "occurrence";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 8:
            q = "Medium motion hours since last successful cleaning "
                "operation";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 9:
            q = "Medium motion hours since second to last successful "
                "cleaning operation";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 0xa:
            q = "Medium motion hours since third to last successful "
                "cleaning operation";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 0xb:
            q = "Lifetime power on hours at last operator initiated forced "
                "reset and/or emergency eject occurrence";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 0xc:
            q = "Lifetime power cycles";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 0xd:
            q = "Volume loads since last parameter reset";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 0xe:
            q = "Hard write errors";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 0xf:
            q = "Hard read errors";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 0x10:
            q = "Duty cycle sample time";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 0x11:
            q = "Read duty cycle";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 0x12:
            q = "Write duty cycle";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 0x13:
            q = "Activity duty cycle";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 0x14:
            q = "Volume not present duty cycle";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 0x15:
            q = "Ready duty cycle";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 0x16:
            q = "Megabytes transferred from application client in duty cycle"
                "sample time";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 0x17:
            q = "Megabytes transferred to application client in duty cycle"
                "sample time";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 0x40:
            {
                std::string v((const char *)(ucp + 4), ucp[3]);
                q = "Drive manufacturer's serial number";
                jout("    %s: %s\n", q, v.c_str());
                jglb[jname][json::str2key(q)] = v;
            }
            break;
        case 0x41:
            {
                std::string v((const char *)(ucp + 4), ucp[3]);
                q = "Drive serial number";
                jout("    %s: %s\n", q, v.c_str());
                jglb[jname][json::str2key(q)] = v;
            }
            break;
        case 0x42:
            {
                std::string v((const char *)(ucp + 4), ucp[3]);
                q = "Manufacturing date year,month,day";
                jout("    %s: %s\n", q, v.c_str());
                jglb[jname][json::str2key(q)] = v;
            }
            break;
        case 0x43:
            {
                std::string v((const char *)(ucp + 4), ucp[3]);
                q = "Manufacturing date year,week";
                jout("    %s: %s\n", q, v.c_str());
                jglb[jname][json::str2key(q)] = v;
            }
            break;
        case 0x44:
            {
                std::string v((const char *)(ucp + 4), ucp[3]);
                q = "Manufacturing date year,week";
                jout("    %s: %s\n", q, v.c_str());
                jglb[jname][json::str2key(q)] = v;
            }
            break;
        case 0x80:
            q = "Medium removal prevented";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 0x81:
            q = "Maximum recommended mechanism temperature exceeded";
            ull = variableLengthIntegerParam(ucp);
            jout("    %s: %" PRIu64 "\n", q, ull);
            jglb[jname][json::str2key(q)] = ull;
            break;
        case 0x1000:
            q = "Medium motion hours for each medium type";
            s = json::str2key(q);
            n = ucp[3] / 8;
            jout("    %s, number of element: %u\n", q, n);
            for (k = 0; k < n; ++k, ucp += 8) {
                u = sg_get_unaligned_be32(ucp + 8);
                jout("      [%d] density code: %u, density code: %u, hours: "
                     "%u\n", k + 1, ucp[6], ucp[7], u);
                jglb[jname][s][k]["density_code"] = ucp[6];
                jglb[jname][s][k]["medium_type"] = ucp[7];
                jglb[jname][s][k]["medium_motion_hours"] = u;
            }
            break;
        default:        /* ignore other parameter codes */
            break;
        }
        num -= pl;
        ucp += pl;
    }
    return retval;
}

static int
scsiPrintFormatStatus(scsi_device * device)
{
    int num, err, truncated;
    int retval = 0;
    uint64_t ull;
    uint8_t * ucp;
    static const char * hname = "Format Status";
    static const char * jname = "scsi_format_status";

    if ((err = scsiLogSense(device, FORMAT_STATUS_LPAGE, 0, gBuf,
                            LOG_RESP_LONG_LEN, 0))) {
        print_on();
        jout("%s: Failed [%s]\n", __func__, scsiErrString(err));
        print_off();
        return FAILSMART;
    }
    if ((gBuf[0] & 0x3f) != FORMAT_STATUS_LPAGE) {
        print_on();
        jout("%s %s, page mismatch\n", hname, logSenRspStr);
        print_off();
        return FAILSMART;
    }
    // compute page length
    num = sg_get_unaligned_be16(gBuf + 2) + 4;
    if (num < 12) {
        print_on();
        jout("%s %s length is %d, too short\n", hname, logSenStr, num);
        print_off();
        return FAILSMART;
    }
    truncated = (num > LOG_RESP_LONG_LEN) ? num : 0;
    if (truncated)
        num = LOG_RESP_LONG_LEN;
    ucp = gBuf + 4;
    num -= 4;
    while (num > 3) {
        int pc = sg_get_unaligned_be16(ucp + 0);
        // pcb = ucp[2];
        int pl = ucp[3] + 4;

        bool is_count = true;
        const char * jout_str = "";
        const char * jglb_str = "x";
        switch (pc) {
        case 0:
            if (scsi_debugmode > 1) {
                if (pl < 5)
                    jout("Format data out: <empty>\n");
                else {
                    if (all_ffs(ucp + 4, pl - 4))
                        jout("Format data out: <not available>\n");
                    else {
                        jout("Format data out:\n");
                        dStrHex((const uint8_t *)ucp + 4, pl - 4, 0);
                    }
                }
            }
            is_count = false;
            break;
        case 1:
            jout_str = "Grown defects during certification";
            jglb_str = "grown_defects_during_cert";
            break;
        case 2:
            jout_str = "Total blocks reassigned during format";
            jglb_str = "blocks_reassigned_during_format";
            break;
        case 3:
            jout_str = "Total new blocks reassigned";
            jglb_str = "total_new_block_since_format";
            break;
        case 4:
            jout_str = "Power on minutes since format";
            jglb_str = "power_on_minutes_since_format";
            break;
        default:
            if (scsi_debugmode > 3) {
                pout("  Unknown Format parameter code = 0x%x\n", pc);
                dStrHex((const uint8_t *)ucp, pl, 0);
            }
            is_count = false;
            break;
        }
        if (is_count) {
            if (all_ffs(ucp + 4, ucp[3])) {
                pout("%s <not available>\n", jout_str);
            } else {
                ull = variableLengthIntegerParam(ucp);
                jout("%s = %" PRIu64 "\n", jout_str, ull);
                jglb[jname][jglb_str] = ull;
            }
        } else
        num -= pl;
        ucp += pl;
    }
    return retval;

}

static void
show_sas_phy_event_info(const json::ref & jref, int peis, unsigned int val,
                        unsigned thresh_val)
{
    unsigned int u;
    const char * q;
    static const char * pvd_th = "Peak value detector threshold";
    static const char * pvd_th_j = "pvd_threshold";

    switch (peis) {
    case 0:
        jout("     No event\n");
        break;
    case 0x1:   /* 0x1 to 0x4 will be duplicates so append "_2" to name */
        q = "Invalid dword count";
        jout("     %s: %u\n", q, val);
        jref[std::string(q) + "_2"] = val;
        break;
    case 0x2:
        q = "Running disparity error count";
        jout("     %s: %u\n", q, val);
        jref[std::string(q) + "_2"] = val;
        break;
    case 0x3:
        q = "Loss of dword synchronization count";
        jout("     %s: %u\n", q, val);
        jref[std::string(q) + "_2"] = val;
        break;
    case 0x4:
        q = "Phy reset problem count";
        jout("     %s: %u\n", q, val);
        jref[std::string(q) + "_2"] = val;
        break;
    case 0x5:
        q = "Elasticity buffer overflow count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x6:
        q = "Received ERROR count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x20:
        q = "Received address frame error count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x21:
        q = "Transmitted abandon-class OPEN_REJECT count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x22:
        q = "Received abandon-class OPEN_REJECT count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x23:
        q = "Transmitted retry-class OPEN_REJECT count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x24:
        q = "Received retry-class OPEN_REJECT count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x25:
        q = "Received AIP (WAITING ON PARTIAL) count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x26:
        q = "Received AIP (WAITING ON CONNECTION) count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x27:
        q = "Transmitted BREAK count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x28:
        q = "Received BREAK count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x29:
        q = "Break timeout count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x2a:
        q = "Connection count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x2b:
        q = "Peak transmitted pathway blocked";
        jout("     %s count: %u\n", q, val & 0xff);
        jout("         %s: %u\n", pvd_th, thresh_val & 0xff);
        jref[q]["count"] = val & 0xff;
        jref[q][pvd_th_j] = thresh_val & 0xff;
        break;
    case 0x2c:
        q = "Peak transmitted arbitration wait time";
        u = val & 0xffff;
        if (u < 0x8000) {
            jout("     %s (us): %u\n", q, u);
            jref[std::string(q) + "_us"]["event"] = u;
        } else {
            jout("     %s (ms): %u\n", q, 33 + (u - 0x8000));
            jref[std::string(q) + "_ms"]["event"] = 33 + (u - 0x8000);
        }
        u = thresh_val & 0xffff;
        if (u < 0x8000) {
            jout("         %s (us): %u\n", pvd_th, u);
            jref[std::string(q) + "_us"][pvd_th_j] = u;
        } else {
            jout("         %s (ms): %u\n", pvd_th, 33 + (u - 0x8000));
            jref[std::string(q) + "_ms"][pvd_th_j] = 33 + (u - 0x8000);
        }
        break;
    case 0x2d:
        q = "Peak arbitration time";
        jout("     %s (us): %u\n", q, val);
        jref[std::string(q) + "_us"]["event"] = val;
        jout("         %s: %u\n", pvd_th, thresh_val);
        jref[std::string(q) + "_us"][pvd_th_j] = thresh_val;
        break;
    case 0x2e:
        q = "Peak connection time";
        jout("     %s (us): %u\n", q, val);
        jref[std::string(q) + "_us"]["event"] = val;
        jout("         %s: %u\n", pvd_th, thresh_val);
        jref[std::string(q) + "_us"][pvd_th_j] = thresh_val;
        break;
    case 0x40:
        q = "Transmitted SSP frame count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x41:
        q = "Received SSP frame count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x42:
        q = "Transmitted SSP frame error count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x43:
        q = "Received SSP frame error count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x44:
        q = "Transmitted CREDIT_BLOCKED count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x45:
        q = "Received CREDIT_BLOCKED count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x50:
        q = "Transmitted SATA frame count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x51:
        q = "Received SATA frame count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x52:
        q = "SATA flow control buffer overflow count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x60:
        q = "Transmitted SMP frame count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x61:
        q = "Received SMP frame count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    case 0x63:
        q = "Received SMP frame error count";
        jout("     %s: %u\n", q, val);
        jref[q] = val;
        break;
    default:
        break;
    }
}

static void
show_sas_port_param(int port_num, unsigned char * ucp, int param_len)
{
    int k, j, m, nphys, t, sz, spld_len;
    char pn[32];
    unsigned char * vcp;
    char s[64];
    const char * q;

    snprintf(pn, sizeof(pn), "scsi_sas_port_%d", port_num);
    sz = sizeof(s);
    // pcb = ucp[2];
    t = sg_get_unaligned_be16(ucp + 0);
    jout("relative target port id = %d\n", t);
    jglb[pn]["relative_target_port_id"] = t;
    jout("  generation code = %d\n", ucp[6]);
    jglb[pn]["generation_code"] = ucp[6];
    nphys = ucp[7];
    jout("  number of phys = %d\n", nphys);
    jglb[pn]["number_of_phys"] = nphys;

    for (j = 0, k = 0, vcp = ucp + 8; j < (param_len - 8);
         vcp += spld_len, j += spld_len, ++k) {
        char yn[32];

        snprintf(yn, sizeof(yn), "phy_%d", k);
        json::ref jref = jglb[pn][yn];
        jout("  phy identifier = %d\n", vcp[1]);
        jref["identifier"] = vcp[1];
        spld_len = vcp[3];
        if (spld_len < 44)
            spld_len = 48;      /* in SAS-1 and SAS-1.1 vcp[3]==0 */
        else
            spld_len += 4;
        t = ((0x70 & vcp[4]) >> 4);
        switch (t) {
        case 0: snprintf(s, sz, "no device attached"); break;
        case 1: snprintf(s, sz, "SAS or SATA device"); break;
        case 2: snprintf(s, sz, "expander device"); break;
        case 3: snprintf(s, sz, "expander device (fanout)"); break;
        default: snprintf(s, sz, "reserved [%d]", t); break;
        }
        q = "attached device type";
        jout("    %s: %s\n", q, s);
        jref[q] = s;
        t = 0xf & vcp[4];
        switch (t) {
        case 0: snprintf(s, sz, "unknown"); break;
        case 1: snprintf(s, sz, "power on"); break;
        case 2: snprintf(s, sz, "hard reset"); break;
        case 3: snprintf(s, sz, "SMP phy control function"); break;
        case 4: snprintf(s, sz, "loss of dword synchronization"); break;
        case 5: snprintf(s, sz, "mux mix up"); break;
        case 6: snprintf(s, sz, "I_T nexus loss timeout for STP/SATA");
            break;
        case 7: snprintf(s, sz, "break timeout timer expired"); break;
        case 8: snprintf(s, sz, "phy test function stopped"); break;
        case 9: snprintf(s, sz, "expander device reduced functionality");
             break;
        default: snprintf(s, sz, "reserved [0x%x]", t); break;
        }
        q = "attached reason";
        jout("    %s: %s\n", q, s);
        jref[q] = s;
        t = (vcp[5] & 0xf0) >> 4;
        switch (t) {
        case 0: snprintf(s, sz, "unknown"); break;
        case 1: snprintf(s, sz, "power on"); break;
        case 2: snprintf(s, sz, "hard reset"); break;
        case 3: snprintf(s, sz, "SMP phy control function"); break;
        case 4: snprintf(s, sz, "loss of dword synchronization"); break;
        case 5: snprintf(s, sz, "mux mix up"); break;
        case 6: snprintf(s, sz, "I_T nexus loss timeout for STP/SATA");
            break;
        case 7: snprintf(s, sz, "break timeout timer expired"); break;
        case 8: snprintf(s, sz, "phy test function stopped"); break;
        case 9: snprintf(s, sz, "expander device reduced functionality");
             break;
        default: snprintf(s, sz, "reserved [0x%x]", t); break;
        }
        q = "reason";
        jout("    %s: %s\n", q, s);
        jref[q] = s;
        t = (0xf & vcp[5]);
        switch (t) {
        case 0: snprintf(s, sz, "phy enabled; unknown");
                     break;
        case 1: snprintf(s, sz, "phy disabled"); break;
        case 2: snprintf(s, sz, "phy enabled; speed negotiation failed");
                     break;
        case 3: snprintf(s, sz, "phy enabled; SATA spinup hold state");
                     break;
        case 4: snprintf(s, sz, "phy enabled; port selector");
                     break;
        case 5: snprintf(s, sz, "phy enabled; reset in progress");
                     break;
        case 6: snprintf(s, sz, "phy enabled; unsupported phy attached");
                     break;
        case 8: snprintf(s, sz, "phy enabled; 1.5 Gbps"); break;
        case 9: snprintf(s, sz, "phy enabled; 3 Gbps"); break;
        case 0xa: snprintf(s, sz, "phy enabled; 6 Gbps"); break;
        case 0xb: snprintf(s, sz, "phy enabled; 12 Gbps"); break;
        default: snprintf(s, sz, "reserved [%d]", t); break;
        }
        q = "negotiated logical link rate";
        jout("    %s: %s\n", q, s);
        jref[q] = s;
        q = "attached initiator port";
        jout("    %s: ssp=%d stp=%d smp=%d\n", q,
               !! (vcp[6] & 8), !! (vcp[6] & 4), !! (vcp[6] & 2));
        snprintf(s, sz, "%03d", ((vcp[6] & 8) ? 100 : 0) +
                 ((vcp[6] & 4) ? 10 : 0) + ((vcp[6] & 2) ? 1 : 0));
        jref[q]["ssp_stp_smp"] = s;
        q = "attached target port";
        jout("    %s: ssp=%d stp=%d smp=%d\n", q,
               !! (vcp[7] & 8), !! (vcp[7] & 4), !! (vcp[7] & 2));
        snprintf(s, sz, "%03d", ((vcp[7] & 8) ? 100 : 0) +
                 ((vcp[7] & 4) ? 10 : 0) + ((vcp[7] & 2) ? 1 : 0));
        jref[q]["ssp_stp_smp"] = s;
        if (!dont_print_serial_number) {
            uint64_t ull = sg_get_unaligned_be64(vcp + 8);
            char b[32];

            snprintf(b, sizeof(b), "0x%" PRIx64, ull);
            q = "SAS address";
            jout("    %s = %s\n", q, b);
            jref[q] = b;
            ull = sg_get_unaligned_be64(vcp + 16);
            snprintf(b, sizeof(b), "0x%" PRIx64, ull);
            q = "attached SAS address";
            jout("    %s = %s\n", q, b);
            jref[q] = b;
        }
        q = "attached phy identifier";
        jout("    %s = %d\n", q, vcp[24]);
        jref[q] = vcp[24];
        unsigned int ui = sg_get_unaligned_be32(vcp + 32);

        q = "Invalid DWORD count";
        jout("    %s = %u\n", q, ui);
        jref[q] = ui;
        ui = sg_get_unaligned_be32(vcp + 36);
        q = "Running disparity error count";
        jout("    %s = %u\n", q, ui);
        jref[q] = ui;
        ui = sg_get_unaligned_be32(vcp + 40);
        q = "Loss of DWORD synchronization count";
        jout("    %s = %u\n", q, ui);
        jref[q] = ui;
        ui = sg_get_unaligned_be32(vcp + 44);
        q = "Phy reset problem count";
        jout("    %s = %u\n", q, ui);
        jref[q] = ui;
        if (spld_len > 51) {
            bool header_given = false;
            bool allow_dupl = (scsi_debugmode > 0);
            int num_ped;
            unsigned char * xcp;

            num_ped = vcp[51];
            xcp = vcp + 52;
            for (m = 0; m < (num_ped * 12); m += 12, xcp += 12) {
                int peis;
                unsigned int pvdt;

                peis = xcp[3];
                ui = sg_get_unaligned_be32(xcp + 4);
                pvdt = sg_get_unaligned_be32(xcp + 8);
                if (allow_dupl || (peis > 0x4)) {
                    if (! header_given) {
                        header_given = true;
                        jout("    Phy event descriptors:\n");
                    }
                    show_sas_phy_event_info(jref, peis, ui, pvdt);
                }
            }
        }
    }
}

// Returns 1 if okay, 0 if non SAS descriptors
static int
show_protocol_specific_port_page(unsigned char * resp, int len)
{
    int k, j, num;
    unsigned char * ucp;

    num = len - 4;
    for (k = 0, j = 0, ucp = resp + 4; k < num; ++j) {
        int param_len = ucp[3] + 4;
        if (SCSI_TPROTO_SAS != (0xf & ucp[4]))
            return 0;   /* only decode SAS log page */
        if (0 == k)
            jout("\nProtocol Specific port %s for SAS SSP\n", lp_s);
        show_sas_port_param(j, ucp, param_len);
        k += param_len;
        ucp += param_len;
    }
    pout("\n");
    return 1;
}


// See Serial Attached SCSI (SPL-3) (e.g. revision 6g) the Protocol Specific
// log page [0x18]. Returns 0 if ok else FAIL* bitmask.
static int
scsiPrintSasPhy(scsi_device * device, int reset)
{
    int num, err;
    static const char * hname = "Protocol specific port";

    if ((err = scsiLogSense(device, PROTOCOL_SPECIFIC_LPAGE, 0, gBuf,
                            LOG_RESP_LONG_LEN, 0))) {
        print_on();
        pout("%s %s Failed [%s]\n\n", __func__, logSenStr,
             scsiErrString(err));
        print_off();
        return FAILSMART;
    }
    if ((gBuf[0] & 0x3f) != PROTOCOL_SPECIFIC_LPAGE) {
        print_on();
        pout("%s %s, page mismatch\n\n", hname, logSenRspStr);
        print_off();
        return FAILSMART;
    }
    // compute page length
    num = sg_get_unaligned_be16(gBuf + 2);
    if (1 != show_protocol_specific_port_page(gBuf, num + 4)) {
        print_on();
        pout("Only support %s %s on SAS devices\n\n", hname, lp_s);
        print_off();
        return FAILSMART;
    }
    if (reset) {
        if ((err = scsiLogSelect(device, 1 /* pcr */, 0 /* sp */, 0 /* pc */,
                                 PROTOCOL_SPECIFIC_LPAGE, 0, nullptr, 0))) {
            print_on();
            pout("%s Log Select (reset) Failed [%s]\n\n", __func__,
                 scsiErrString(err));
            print_off();
            return FAILSMART;
        }
    }
    return 0;
}


static const char * peripheral_dt_arr[32] = {
        "disk",
        "tape",
        "printer",
        "processor",
        "optical disk(4)",
        "CD/DVD",
        "scanner",
        "optical disk(7)",
        "medium changer",
        "communications",
        "graphics(10)",
        "graphics(11)",
        "storage array",
        "enclosure",
        "simplified disk",
        "optical card reader",
        "reserved [0x10]",
        "object based storage",
        "automation/driver interface",
        "security manager device",
        "host managed zoned block device",
        "reserved [0x15]",
        "reserved [0x16]",
        "reserved [0x17]",
        "reserved [0x18]",
        "reserved [0x19]",
        "reserved [0x1a]",
        "reserved [0x1b]",
        "reserved [0x1c]",
        "reserved [0x1d]",
        "well known logical unit",
        "unknown or no device type",
};

/* Symbolic indexes to this array SCSI_TPROTO_* in scscmds.h */
static const char * transport_proto_arr[] = {
        "Fibre channel (FCP-4)",
        "Parallel SCSI (SPI-4)",        /* obsolete */
        "SSA",
        "IEEE 1394 (SBP-3)",
        "RDMA (SRP)",
        "iSCSI",
        "SAS (SPL-4)",
        "ADT",
        "ATA (ACS-2)",
        "UAS",
        "SOP",
        "PCIe",
        "0xc",
        "0xd",
        "0xe",
        "None given [0xf]"
};

/* Returns 0 on success, 1 on general error and 2 for early, clean exit */
static int
scsiGetDriveInfo(scsi_device * device, uint8_t * peripheral_type,
                 bool & have_zbc, bool all)
{
    bool ok;
    bool is_tape = false;
    int err, iec_err, len, req_len, avail_len;
    int peri_dt = 0;
    int transport = -1;
    int form_factor = 0;
    int haw_zbc = 0;
    int protect = 0;
    const char * q;
    struct scsi_iec_mode_page iec;

    memset(gBuf, 0, 96);
    have_zbc = false;
    req_len = 36;
    if ((err = scsiStdInquiry(device, gBuf, req_len))) {
        print_on();
        pout("Standard Inquiry (36 bytes) failed [%s]\n", scsiErrString(err));
        pout("Retrying with a 64 byte Standard Inquiry\n");
        print_off();
        /* Marvell controllers fail with 36 byte StdInquiry, but 64 is ok */
        req_len = 64;
        if ((err = scsiStdInquiry(device, gBuf, req_len))) {
            print_on();
            pout("Standard Inquiry (64 bytes) failed [%s]\n",
                 scsiErrString(err));
            print_off();
            return 1;
        }
    }
    avail_len = gBuf[4] + 5;
    len = (avail_len < req_len) ? avail_len : req_len;
    peri_dt = gBuf[0] & 0x1f;
    *peripheral_type = peri_dt;
    if (SCSI_PT_HOST_MANAGED == peri_dt)
        have_zbc = true;
    if ((SCSI_PT_SEQUENTIAL_ACCESS == peri_dt) ||
        (SCSI_PT_MEDIUM_CHANGER == peri_dt))
        is_tape = true;

    if (len < 36) {
        print_on();
        pout("Short INQUIRY response, skip product id\n");
        print_off();
        return 1;
    }
    // Upper bits of version bytes were used in older standards
    // Only interested in SPC-4 (0x6) and SPC-5 (assumed to be 0x7)
    scsi_version = gBuf[2] & 0x7;

    if (all && (0 != strncmp((char *)&gBuf[8], "ATA", 3))) {
        char product[16+1], revision[4+1];
        scsi_format_id_string(scsi_vendor, &gBuf[8], 8);
        scsi_format_id_string(product, &gBuf[16], 16);
        scsi_format_id_string(revision, &gBuf[32], 4);

        pout("=== START OF INFORMATION SECTION ===\n");
        jout("Vendor:               %.8s\n", scsi_vendor);
        jglb["scsi_vendor"] = scsi_vendor;
        jout("Product:              %.16s\n", product);
        jglb["scsi_product"] = product;
        jglb["scsi_model_name"] = strprintf("%s%s%s",
          scsi_vendor, (*scsi_vendor && *product ? " " : ""), product);
        if (gBuf[32] >= ' ') {
            jout("Revision:             %.4s\n", revision);
            // jglb["firmware_version"] = revision;
            jglb["scsi_revision"] = revision;
        }
        if ((scsi_version > 0x3) && (scsi_version < 0x8)) {
            char sv_arr[8];

            snprintf(sv_arr, sizeof(sv_arr), "SPC-%d", scsi_version - 2);
            jout("Compliance:           %s\n", sv_arr);
            jglb["scsi_version"] = sv_arr;
        }
    }

    if (!*device->get_req_type()/*no type requested*/ &&
               (0 == strncmp((char *)&gBuf[8], "ATA", 3))) {
        pout("\nProbable ATA device behind a SAT layer\n"
             "Try an additional '-d ata' or '-d sat' argument.\n");
        return 2;
    }
    if (! all)
        return 0;

    protect = gBuf[5] & 0x1;    /* from and including SPC-3 */

    if (! is_tape) {    /* assume disk if not tape drive (or tape changer) */
        struct scsi_readcap_resp srr;
        int lbpme = -1;
        int lbprz = -1;
        unsigned char lb_prov_resp[8];
        uint64_t capacity = scsiGetSize(device, false /*avoid_rcap16 */,
                                        &srr);
        static const char * lb_prov_j = "scsi_lb_provisioning";

        if (capacity) {
            char cap_str[64], si_str[64];
            format_with_thousands_sep(cap_str, sizeof(cap_str), capacity);
            format_capacity(si_str, sizeof(si_str), capacity);
            jout("User Capacity:        %s bytes [%s]\n", cap_str, si_str);
            if (srr.lb_size)
              jglb["user_capacity"]["blocks"].set_unsafe_uint64(capacity /
                                                                srr.lb_size);
            jglb["user_capacity"]["bytes"].set_unsafe_uint64(capacity);
            jout("Logical block size:   %u bytes\n", srr.lb_size);
            jglb["logical_block_size"] = srr.lb_size;
            if (protect || srr.lb_p_pb_exp) {
                if (srr.lb_p_pb_exp > 0) {
                    unsigned pb_size = srr.lb_size * (1 << srr.lb_p_pb_exp);
                    jout("Physical block size:  %u bytes\n", pb_size);
                    jglb["physical_block_size"] = pb_size;
                    if (srr.l_a_lba > 0)  // not common so cut the clutter
                        pout("Lowest aligned LBA:   %u\n", srr.l_a_lba);
                }
                if (srr.prot_type > 0) {
                    switch (srr.prot_type) {
                    case 1 :
                        pout("Formatted with type 1 protection\n");
                        break;
                    case 2 :
                        pout("Formatted with type 2 protection\n");
                        break;
                    case 3 :
                        pout("Formatted with type 3 protection\n");
                        break;
                    default:
                        pout("Formatted with unknown protection type [%d]\n",
                             srr.prot_type);
                        break;
                    }
                    jglb["scsi_protection_type"] = srr.prot_type;
                    unsigned p_i_per_lb = (1 << srr.p_i_exp);
                    const unsigned pi_sz = 8;   /* ref-tag(4 bytes),
                                                   app-tag(2), tag-mask(2) */

                    if (p_i_per_lb > 1) {
                        jout("%d protection information intervals per "
                             "logical block\n", p_i_per_lb);
                        jglb["scsi_protection_intervals_per_lb"] = srr.prot_type;
                    }
                    jout("%d bytes of protection information per logical "
                         "block\n", pi_sz * p_i_per_lb);
                    jglb["scsi_protection_interval_bytes_per_lb"] =
                                                        pi_sz * p_i_per_lb;
                }
                /* Pick up some LB provisioning info since its available */
                lbpme = (int)srr.lbpme;
                lbprz = (int)srr.lbprz;
            }
        }
        /* Thin Provisioning VPD page renamed Logical Block Provisioning VPD
         * page in sbc3r25; some fields changed their meaning so that the
         * new page covered both thin and resource provisioned LUs. */
        if (0 == scsiInquiryVpd(device, SCSI_VPD_LOGICAL_BLOCK_PROVISIONING,
                                lb_prov_resp, sizeof(lb_prov_resp))) {
            int prov_type = lb_prov_resp[6] & 0x7;      /* added sbc3r27 */
            int vpd_lbprz = ((lb_prov_resp[5]  >> 2) & 0x7);  /* sbc4r07 */

            if (-1 == lbprz)
                lbprz = vpd_lbprz;
            else if ((0 == vpd_lbprz) && (1 == lbprz))
                ;  /* vpd_lbprz introduced in sbc3r27, expanded in sbc4r07 */
            else
                lbprz = vpd_lbprz;
            switch (prov_type) {
            case 0:
                if (lbpme <= 0) {
                    jout("LU is fully provisioned");
                    jglb[lb_prov_j]["name"] = "fully provisioned";
                    if (lbprz)
                        jout(" [LBPRZ=%d]\n", lbprz);
                    else
                        jout("\n");
                } else {
                    jout("LB provisioning type: not reported [LBPME=1, "
                         "LBPRZ=%d]\n", lbprz);
                    jglb[lb_prov_j]["name"] = "not reported";
                }
                break;
            case 1:
                jout("LU is resource provisioned, LBPRZ=%d\n", lbprz);
                jglb[lb_prov_j]["name"] = "resource provisioned";
                break;
            case 2:
                jout("LU is thin provisioned, LBPRZ=%d\n", lbprz);
                jglb[lb_prov_j]["name"] = "thin provisioned";
                break;
            default:
                jout("LU provisioning type reserved [%d], LBPRZ=%d\n",
                     prov_type, lbprz);
                jglb[lb_prov_j]["name"] = "reserved";
                break;
            }
            jglb[lb_prov_j]["value"] = prov_type;
            jglb[lb_prov_j]["management_enabled"]["name"] = "LBPME";
            jglb[lb_prov_j]["management_enabled"]["value"] = lbpme;
            jglb[lb_prov_j]["read_zeros"]["name"] = "LBPRZ";
            jglb[lb_prov_j]["read_zeros"]["value"] = lbprz;
        } else if (1 == lbpme) {
            if (scsi_debugmode > 0)
                jout("rcap_16 sets LBPME but no LB provisioning VPD page\n");
            jout("Logical block provisioning enabled, LBPRZ=%d\n", lbprz);
        }

        int rpm = scsiGetRPM(device, modese_len, &form_factor, &haw_zbc);
        if (rpm >= 0) {
            if (0 == rpm)
                ;       // Not reported
            else if (1 == rpm)
                jout("Rotation Rate:        Solid State Device\n");
            else if ((rpm <= 0x400) || (0xffff == rpm))
                ;       // Reserved
            else
                jout("Rotation Rate:        %d rpm\n", rpm);
            jglb["rotation_rate"] = (rpm == 1 ? 0 : rpm);
        }
        if (form_factor > 0) {
            const char * cp = nullptr;

            switch (form_factor) {
            case 1:
                cp = "5.25";
                break;
            case 2:
                cp = "3.5";
                break;
            case 3:
                cp = "2.5";
                break;
            case 4:
                cp = "1.8";
                break;
            case 5:
                cp = "< 1.8";
                break;
            }
            jglb["form_factor"]["scsi_value"] = form_factor;
            if (cp) {
                jout("Form Factor:          %s inches\n", cp);
                jglb["form_factor"]["name"] = strprintf("%s inches", cp);
            }
        }
        if (haw_zbc == 1) {
            have_zbc = true;
            q = "Host aware zoned block capable";
            jout("%s\n", q);
            jglb[std::string("scsi_") + json::str2key(q)] = true;
        } else if (haw_zbc == 2) {
            have_zbc = true;
            q = "Device managed zoned block capable";
            jout("%s\n", q);
            jglb[std::string("scsi_") + json::str2key(q)] = true;
        } else {
            supported_vpd_pages * s_vpd_pp = supported_vpd_pages_p;

            if (s_vpd_pp &&
                s_vpd_pp->is_supported(SCSI_VPD_ZONED_BLOCK_DEV_CHAR)) {
                // TODO: need to read that VPD page and look at the
                // 'Zoned block device extension' field

            }
        }
    }

    /* Do this here to try and detect badly conforming devices (some USB
       keys) that will lock up on a InquiryVpd or log sense or ... */
    if ((iec_err = scsiFetchIECmpage(device, &iec, modese_len))) {
        if (SIMPLE_ERR_BAD_RESP == iec_err) {
            pout(">> Terminate command early due to bad response to IEC "
                 "mode page\n");
            print_off();
            gIecMPage = 0;
            return 1;
        }
    } else
        modese_len = iec.modese_len;

    if (! dont_print_serial_number) {
        if (0 == (err = scsiInquiryVpd(device, SCSI_VPD_DEVICE_IDENTIFICATION,
                                       gBuf, 252))) {
            char s[256];

            len = gBuf[3];
            scsi_decode_lu_dev_id(gBuf + 4, len, s, sizeof(s), &transport);
            if (strlen(s) > 0) {
                jout("Logical Unit id:      %s\n", s);
                jglb["logical_unit_id"] = s;
            }
        } else if (scsi_debugmode > 0) {
            print_on();
            if (SIMPLE_ERR_BAD_RESP == err)
                pout("Vital Product Data (VPD) bit ignored in INQUIRY\n");
            else
                pout("Vital Product Data (VPD) INQUIRY failed [%d]\n", err);
            print_off();
        }
        if (0 == (err = scsiInquiryVpd(device, SCSI_VPD_UNIT_SERIAL_NUMBER,
                                       gBuf, 252))) {
            char serial[256];
            len = gBuf[3];

            gBuf[4 + len] = '\0';
            scsi_format_id_string(serial, &gBuf[4], len);
            jout("Serial number:        %s\n", serial);
            jglb["serial_number"] = serial;
        } else if (scsi_debugmode > 0) {
            print_on();
            if (SIMPLE_ERR_BAD_RESP == err)
                pout("Vital Product Data (VPD) bit ignored in INQUIRY\n");
            else
                pout("Vital Product Data (VPD) INQUIRY failed [%d]\n", err);
            print_off();
        }
    }

    // print SCSI peripheral device type
    jglb["device_type"]["scsi_terminology"] = "Peripheral Device Type [PDT]";
    jglb["device_type"]["scsi_value"] = peri_dt;
    if (peri_dt < (int)(ARRAY_SIZE(peripheral_dt_arr))) {
        jout("Device type:          %s\n", peripheral_dt_arr[peri_dt]);
        jglb["device_type"]["name"] = peripheral_dt_arr[peri_dt];
    }
    else
        jout("Device type:          <%d>\n", peri_dt);

    // See if transport protocol is known
    if (transport < 0)
        transport = scsiFetchTransportProtocol(device, modese_len);
    if ((transport >= 0) && (transport <= 0xf)) {
        jout("Transport protocol:   %s\n", transport_proto_arr[transport]);
        jglb["scsi_transport_protocol"]["name"] = transport_proto_arr[transport];
        jglb["scsi_transport_protocol"]["value"] = transport;
    }

    jout_startup_datetime("Local Time is:        ");

    // See if unit accepts SCSI commands from us
    if ((err = scsiTestUnitReady(device))) {
        if (SIMPLE_ERR_NOT_READY == err) {
            print_on();
            if (!is_tape)
                pout("device is NOT READY (e.g. spun down, busy)\n");
            else
                pout("device is NOT READY (e.g. no tape)\n");
            print_off();
        } else if (SIMPLE_ERR_NO_MEDIUM == err) {
            print_on();
            if (is_tape)
                pout("NO tape present in drive\n");
            else
                pout("NO MEDIUM present in device\n");
            print_off();
        } else if (SIMPLE_ERR_BECOMING_READY == err) {
            print_on();
            pout("device becoming ready (wait)\n");
            print_off();
        } else {
            print_on();
            pout("device Test Unit Ready  [%s]\n", scsiErrString(err));
            print_off();
        }
        if (! is_tape) {
            // TODO: exit with FAILID if failuretest returns
            failuretest(MANDATORY_CMD, FAILID);
        }
    }

    if (iec_err) {
        if (!is_tape) {
            print_on();
            jout("SMART support is:     Unavailable - device lacks SMART "
                 "capability.\n");
            jglb["smart_support"]["available"] = false;
            if (scsi_debugmode > 0)
                pout(" [%s]\n", scsiErrString(iec_err));
            print_off();
        }
        gIecMPage = 0;
        return 0;
    }

    if (!is_tape) {
        ok = scsi_IsExceptionControlEnabled(&iec);
        jout("SMART support is:     Available - device has SMART capability.\n"
             "SMART support is:     %s\n", ok ? "Enabled" : "Disabled");
        jglb["smart_support"]["available"] = true;
        jglb["smart_support"]["enabled"] = ok;
    }
    ok = scsi_IsWarningEnabled(&iec);
    jout("Temperature Warning:  %s\n",
         ok ? "Enabled" : "Disabled or Not Supported");
    jglb["temperature_warning"]["enabled"] = ok;
    return 0;
}

static int
scsiSmartEnable(scsi_device * device)
{
    struct scsi_iec_mode_page iec;
    int err;

    if ((err = scsiFetchIECmpage(device, &iec, modese_len))) {
        print_on();
        pout("unable to fetch IEC (SMART) mode page [%s]\n",
             scsiErrString(err));
        print_off();
        return 1;
    } else
        modese_len = iec.modese_len;

    if ((err = scsiSetExceptionControlAndWarning(device, 1, &iec))) {
        print_on();
        pout("unable to enable Exception control and warning [%s]\n",
             scsiErrString(err));
        print_off();
        return 1;
    }
    /* Need to refetch 'iec' since could be modified by previous call */
    if ((err = scsiFetchIECmpage(device, &iec, modese_len))) {
        pout("unable to fetch IEC (SMART) mode page [%s]\n",
             scsiErrString(err));
        return 1;
    } else
        modese_len = iec.modese_len;

    pout("Informational Exceptions (SMART) %s\n",
         scsi_IsExceptionControlEnabled(&iec) ? "enabled" : "disabled");
    pout("Temperature warning %s\n",
         scsi_IsWarningEnabled(&iec) ? "enabled" : "disabled");
    return 0;
}

static int
scsiSmartDisable(scsi_device * device)
{
    struct scsi_iec_mode_page iec;
    int err;

    if ((err = scsiFetchIECmpage(device, &iec, modese_len))) {
        print_on();
        pout("unable to fetch IEC (SMART) mode page [%s]\n",
             scsiErrString(err));
        print_off();
        return 1;
    } else
        modese_len = iec.modese_len;

    if ((err = scsiSetExceptionControlAndWarning(device, 0, &iec))) {
        print_on();
        pout("unable to disable Exception control and warning [%s]\n",
             scsiErrString(err));
        print_off();
        return 1;
    }
    /* Need to refetch 'iec' since could be modified by previous call */
    if ((err = scsiFetchIECmpage(device, &iec, modese_len))) {
        pout("unable to fetch IEC (SMART) mode page [%s]\n",
             scsiErrString(err));
        return 1;
    } else
        modese_len = iec.modese_len;

    pout("Informational Exceptions (SMART) %s\n",
         scsi_IsExceptionControlEnabled(&iec) ? "enabled" : "disabled");
    pout("Temperature warning %s\n",
         scsi_IsWarningEnabled(&iec) ? "enabled" : "disabled");
    return 0;
}

static void
scsiPrintTemp(scsi_device * device)
{
    uint8_t temp = 255;
    uint8_t trip = 255;

    if (scsiGetTemp(device, &temp, &trip))
        return;

    if (255 == temp)
        pout("Current Drive Temperature:     <not available>\n");
    else {
        jout("Current Drive Temperature:     %d C\n", temp);
        jglb["temperature"]["current"] = temp;
    }
    if (255 == trip)
        pout("Drive Trip Temperature:        <not available>\n");
    else {
        jout("Drive Trip Temperature:        %d C\n", trip);
        jglb["temperature"]["drive_trip"] = trip;
    }
    pout("\n");
}

static void
scsiPrintEnviroReporting(scsi_device * device)
{
    int len, num, err;
    int temp_num = 0;
    int humid_num = 0;
    unsigned char * ucp;
    const char * q;
    static const char * hname = "Environmental Reports";
    static const char * jname = "scsi_environmental_reports";
    static const char * rh_n = "relative humidity";
    static const char * temp_n = "temperature";
    static const char * sop_n = "since power on";
    static const char * unkn_n = "unknown";

   if ((err = scsiLogSense(device, TEMPERATURE_LPAGE, ENVIRO_REP_L_SPAGE,
                           gBuf, LOG_RESP_LEN, -1 /* single fetch */))) {
        print_on();
        pout("%s Failed [%s]\n", __func__, scsiErrString(err));
        print_off();
        return;
    }
    if (((gBuf[0] & 0x3f) != TEMPERATURE_LPAGE) ||
        (gBuf[1] != ENVIRO_REP_L_SPAGE)) {
        print_on();
        pout("%s %s Failed, page mismatch\n", hname, logSenStr);
        print_off();
        return;
    }
    if (! (gBuf[0] & 0x40)) {
        if (scsi_debugmode > 0) {
            print_on();
            pout("Another flaky device that doesn't set the SPF bit\n");
            print_off();
        }
    }
    len = sg_get_unaligned_be16(gBuf + 2);
    num = len - 4;
    ucp = &gBuf[0] + 4;

    while (num > 3) {
        int pc = sg_get_unaligned_be16(ucp + 0);
        int pl = ucp[3] + 4;
        char pc_s[32];
        std::string s;

        if ((pc < 0x100) && (pl == 12)) {
            snprintf(pc_s, sizeof(pc_s), "temperature_%d", ++temp_num);
            /* temperature is two's complement 8 bit in centigrade */
            int temp = (int)(int8_t)ucp[5];

            jglb[jname][pc_s]["parameter_code"] = pc;
            q = "Current";
            s = json::str2key(q);
            if (ucp[5] == 0x80) {
                jout("%s %s = %s\n", q, temp_n, unkn_n);
                jglb[jname][pc_s][s] = unkn_n;
            } else {
                jout("%s %s = %d\n", q, temp_n, temp);
                jglb[jname][pc_s][s] = temp;
            }
            temp = (int)(int8_t)ucp[6];
            q = "Lifetime maximum";
            s = json::str2key(q);
            if (ucp[6] == 0x80) {
                jout("%s %s = %s\n", q, temp_n, unkn_n);
                jglb[jname][pc_s][s] = unkn_n;
            } else {
                jout("%s %s = %d\n", q, temp_n, temp);
                jglb[jname][pc_s][s] = temp;
            }
            temp = (int)(int8_t)ucp[7];
            q = "Lifetime minimum";
            s = json::str2key(q);
            if (ucp[7] == 0x80) {
                jout("%s %s = %s\n", q, temp_n, unkn_n);
                jglb[jname][pc_s][s] = unkn_n;
            } else {
                jout("%s %s = %d\n", q, temp_n, temp);
                jglb[jname][pc_s][s] = temp;
            }
            temp = (int)(int8_t)ucp[8];
            q = "Maximum since power on";
            s = json::str2key(q);
            if (ucp[8] == 0x80) {
                jout("Maximum %s %s = %s\n", temp_n, sop_n, unkn_n);
                jglb[jname][pc_s][s] = unkn_n;
            } else {
                jout("Maximum %s %s = %d\n", temp_n, sop_n, temp);
                jglb[jname][pc_s][s] = temp;
            }
            temp = (int)(int8_t)ucp[9];
            q = "Minimum since power on";
            s = json::str2key(q);
            if (ucp[9] == 0x80) {
                jout("Minimum %s %s = %s\n", temp_n, sop_n, unkn_n);
                jglb[jname][pc_s][s] = unkn_n;
            } else {
                jout("Minimum %s %s = %d\n", temp_n, sop_n, temp);
                jglb[jname][pc_s][s] = temp;
            }
            if ((ucp[4] & 0x3) == 1) {  /* OTV field set to 1 */
                temp = (int)(int8_t)ucp[10];
                q = "Maximum other";
                s = json::str2key(q);
                if (ucp[10] == 0x80) {
                    jout("%s %s = %s\n", q, temp_n, unkn_n);
                    jglb[jname][pc_s][s] = unkn_n;
                } else {
                    jout("%s %s = %d\n", q, temp_n, temp);
                    jglb[jname][pc_s][s] = temp;
                }
                temp = (int)(int8_t)ucp[11];
                q = "Minimum other";
                s = json::str2key(q);
                if (ucp[11] == 0x80) {
                    jout("%s %s = %s\n", q, temp_n, unkn_n);
                    jglb[jname][pc_s][s] = unkn_n;
                } else {
                    jout("%s %s = %d\n", q, temp_n, temp);
                    jglb[jname][pc_s][s] = temp;
                }
            }
        } else if ((pc < 0x200) && (pl == 12)) {
            snprintf(pc_s, sizeof(pc_s), "relative_humidity_%d", ++humid_num);
            jglb[jname][pc_s]["parameter_code"] = pc;
            jout("Relative humidity = %u\n", ucp[5]);
            jglb[jname][pc_s]["current"] = ucp[5];
            q = "Lifetime maximum";
            s = json::str2key(q);
            jout("%s %s = %d\n", q, rh_n, ucp[6]);
            jglb[jname][pc_s][s] = ucp[6];
            q = "Lifetime minimum";
            s = json::str2key(q);
            jout("%s %s = %d\n", q, rh_n, ucp[7]);
            jglb[jname][pc_s][s] = ucp[7];
            jout("Maximum %s %s = %d\n", rh_n, sop_n, ucp[8]);
            jglb[jname][pc_s]["maximum_since_power_on"] = ucp[8];
            jout("Minimum %s %s = %d\n", rh_n, sop_n, ucp[9]);
            jglb[jname][pc_s]["minimum_since_power_on"] = ucp[9];
            if ((ucp[4] & 0x3) == 1) {  /* ORHV field set to 1 */
                q = "Maximum other";
                s = json::str2key(q);
                jout("%s %s = %d\n", q, rh_n, ucp[10]);
                jglb[jname][pc_s][s] = ucp[10];
                q = "Minimum other";
                s = json::str2key(q);
                jout("%s %s = %d\n", q, rh_n, ucp[11]);
                jglb[jname][pc_s][s] = ucp[11];
            }
        } else {
            if (scsi_debugmode > 0) {
                print_on();
                if ((pc < 0x200) && (pl != 12))
                    pout("%s sub-lpage unexpected parameter length [%d], skip\n",
                         hname, pl);
                else
                    pout("%s sub-lpage has unexpected parameter [0x%x], skip\n",
                         hname, pc);
                print_off();
            }
            return;
        }
        num -= pl;
        ucp += pl;
    }
}


/* Main entry point used by smartctl command. Return 0 for success */
int
scsiPrintMain(scsi_device * device, const scsi_print_options & options)
{
    bool envRepDone = false;
    uint8_t peripheral_type = 0;
    int returnval = 0;
    int res, durationSec;
    struct scsi_sense_disect sense_info;
    bool is_disk;
    bool is_zbc;
    bool is_tape;
    bool any_output = options.drive_info;

// Enable -n option for SCSI Drives
    const char * powername = nullptr;
    bool powerchg = false;

    if (options.powermode) {
        scsiRequestSense(device, &sense_info) ;
        if (sense_info.asc == 0x5E) {
            unsigned char powerlimit = 0xff;
            int     powermode = sense_info.ascq ;

            // 5Eh/00h  DZTPRO A  K    LOW POWER CONDITION ON
            // 5Eh/01h  DZTPRO A  K    IDLE CONDITION ACTIVATED BY TIMER
            // 5Eh/02h  DZTPRO A  K    STANDBY CONDITION ACTIVATED BY TIMER
            // 5Eh/03h  DZTPRO A  K    IDLE CONDITION ACTIVATED BY COMMAND
            // 5Eh/04h  DZTPRO A  K    STANDBY CONDITION ACTIVATED BY COMMAND
            // 5Eh/05h  DZTPRO A  K    IDLE_B CONDITION ACTIVATED BY TIMER
            // 5Eh/06h  DZTPRO A  K    IDLE_B CONDITION ACTIVATED BY COMMAND
            // 5Eh/07h  DZTPRO A  K    IDLE_C CONDITION ACTIVATED BY TIMER
            // 5Eh/08h  DZTPRO A  K    IDLE_C CONDITION ACTIVATED BY COMMAND
            // 5Eh/09h  DZTPRO A  K    STANDBY_Y CONDITION ACTIVATED BY TIMER
            // 5Eh/0Ah  DZTPRO A  K    STANDBY_Y CONDITION ACTIVATED BY COMMAND
            // 5Eh/41h           B     POWER STATE CHANGE TO ACTIVE
            // 5Eh/42h           B     POWER STATE CHANGE TO IDLE
            // 5Eh/43h           B     POWER STATE CHANGE TO STANDBY
            // 5Eh/45h           B     POWER STATE CHANGE TO SLEEP
            // 5Eh/47h           BK    POWER STATE CHANGE TO DEVICE CONTROL

            switch (powermode) {
            case -1:
               if (device->is_syscall_unsup()) {
                   pout("CHECK POWER MODE not implemented, ignoring -n option\n"); break;
                }
                powername = "SLEEP";   powerlimit = 2;
                break;

            case 0x00: // LOW POWER CONDITION ON
                powername = "LOW POWER"; powerlimit = 2; break;
            case 0x01: // IDLE CONDITION ACTIVATED BY TIMER
                powername = "IDLE BY TIMER"; powerlimit = 4; break;
            case 0x02: // STANDBY CONDITION ACTIVATED BY TIMER
                powername = "STANDBY BY TIMER";    powerlimit = 2; break;
            case 0x03: // IDLE CONDITION ACTIVATED BY COMMAND
                powername = "IDLE BY COMMAND";  powerlimit = 4; break;
            case 0x04: // STANDBY CONDITION ACTIVATED BY COMMAND
                powername = "STANDBY BY COMMAND";  powerlimit = 2; break;
            case 0x05: // IDLE_B CONDITION ACTIVATED BY TIMER
                powername = "IDLE BY TIMER";  powerlimit = 4; break;
            case 0x06: // IDLE_B CONDITION ACTIVATED BY COMMAND
                powername = "IDLE_ BY COMMAND";  powerlimit = 4; break;
            case 0x07: // IDLE_C CONDITION ACTIVATED BY TIMER
                powername = "IDLE_C BY TIMER";  powerlimit = 4; break;
            case 0x08: // IDLE_C CONDITION ACTIVATED BY COMMAND
                powername = "IDLE_C BY COMMAND";  powerlimit = 4; break;
            case 0x09: // STANDBY_Y CONDITION ACTIVATED BY TIMER
                powername = "STANDBY_Y BY TIMER";    powerlimit = 2; break;
            case 0x0A: // STANDBY_Y CONDITION ACTIVATED BY COMMAND
                powername = "STANDBY_Y BY COMMAND";  powerlimit = 2; break;

            default:
                pout("CHECK POWER MODE returned unknown value 0x%02x, "
                     "ignoring -n option\n", powermode);
                break;
            }
            if (powername) {
                if (options.powermode >= powerlimit) {
                    jinf("Device is in %s mode, exit(%d)\n", powername, options.powerexit);
                    return options.powerexit;
                }
                powerchg = (powermode != 0xff);
            }
        } else
            powername = "ACTIVE";
    }

    delete supported_vpd_pages_p;
    supported_vpd_pages_p = new supported_vpd_pages(device);

    res = scsiGetDriveInfo(device, &peripheral_type, is_zbc,
                           options.drive_info || options.farm_log);
    if (res) {
        if (2 == res)
            return 0;
        else
            failuretest(MANDATORY_CMD, returnval |= FAILID);
        any_output = true;
    }
    is_disk = ((SCSI_PT_DIRECT_ACCESS == peripheral_type) ||
               (SCSI_PT_HOST_MANAGED == peripheral_type));
    is_tape = ((SCSI_PT_SEQUENTIAL_ACCESS == peripheral_type) ||
               (SCSI_PT_MEDIUM_CHANGER == peripheral_type));
    bool ge_spc4 = device->is_spc4_or_higher();
    if (ge_spc4 && (! device->checked_cmd_support())) {
        if (! device->query_cmd_support()) {
            if (scsi_debugmode)
                pout("%s: query_cmd_support() failed\n", __func__);
        }
    }

    short int wce = -1, rcd = -1;
    // Print read look-ahead status for disks
    if (options.get_rcd || options.get_wce) {
        if (is_disk) {
            res = scsiGetSetCache(device, modese_len, &wce, &rcd);
            if (options.get_rcd)
                pout("Read Cache is:        %s\n",
                     res ? "Unavailable" : // error
                     rcd ? "Disabled" : "Enabled");
            if (options.get_wce)
                pout("Writeback Cache is:   %s\n",
                     res ? "Unavailable" : // error
                     !wce ? "Disabled" : "Enabled");
        }
        any_output = true;
    }

    if (options.drive_info) {
        if (powername)   // Print power condition if requested -n (nocheck)
            pout("Power mode %s       %s\n", (powerchg?"was:":"is: "), powername);
        pout("\n");
    }

    // START OF THE ENABLE/DISABLE SECTION OF THE CODE
    if (options.smart_disable           || options.smart_enable ||
        options.smart_auto_save_disable || options.smart_auto_save_enable)
        pout("=== START OF ENABLE/DISABLE COMMANDS SECTION ===\n");

    if (options.smart_enable) {
        if (scsiSmartEnable(device))
            failuretest(MANDATORY_CMD, returnval |= FAILSMART);
        any_output = true;
    }

    if (options.smart_disable) {
        if (scsiSmartDisable(device))
            failuretest(MANDATORY_CMD,returnval |= FAILSMART);
        any_output = true;
    }

    if (options.smart_auto_save_enable) {
        if (scsiSetControlGLTSD(device, 0, modese_len)) {
            pout("Enable autosave (clear GLTSD bit) failed\n");
            failuretest(OPTIONAL_CMD,returnval |= FAILSMART);
        } else
            pout("Autosave enabled (GLTSD bit cleared).\n");
        any_output = true;
    }

    // Enable/Disable write cache
    if (options.set_wce && is_disk) {
        short int enable = wce = (options.set_wce > 0);

        rcd = -1;
        if (scsiGetSetCache(device, modese_len, &wce, &rcd)) {
            pout("Write cache %sable failed: %s\n", (enable ? "en" : "dis"),
                 device->get_errmsg());
            failuretest(OPTIONAL_CMD,returnval |= FAILSMART);
        } else
            pout("Write cache %sabled\n", (enable ? "en" : "dis"));
        any_output = true;
    }

    // Enable/Disable read cache
    if (options.set_rcd && is_disk) {
        short int enable =  (options.set_rcd > 0);

        rcd = !enable;
        wce = -1;
        if (scsiGetSetCache(device, modese_len, &wce, &rcd)) {
            pout("Read cache %sable failed: %s\n", (enable ? "en" : "dis"),
                device->get_errmsg());
            failuretest(OPTIONAL_CMD,returnval |= FAILSMART);
        } else
            pout("Read cache %sabled\n", (enable ? "en" : "dis"));
        any_output = true;
    }

    if (options.smart_auto_save_disable) {
        if (scsiSetControlGLTSD(device, 1, modese_len)) {
            pout("Disable autosave (set GLTSD bit) failed\n");
            failuretest(OPTIONAL_CMD,returnval |= FAILSMART);
        } else
            pout("Autosave disabled (GLTSD bit set).\n");
        any_output = true;
    }
    if (options.smart_disable           || options.smart_enable ||
        options.smart_auto_save_disable || options.smart_auto_save_enable)
        pout("\n"); // END OF THE ENABLE/DISABLE SECTION OF THE CODE

    // START OF READ-ONLY OPTIONS APART FROM -V and -i
    if (options.smart_check_status  || options.smart_ss_media_log ||
        options.smart_vendor_attrib || options.smart_error_log ||
        options.smart_selftest_log  || options.smart_background_log ||
        options.sasphy)
        pout("=== START OF READ SMART DATA SECTION ===\n");

    // Most of the following need log page data. Check for the supported log
    // pages unless we have been told by RSOC that LOG SENSE is not supported
    if (SC_NO_SUPPORT != device->cmd_support_level(LOG_SENSE, false, 0))
        scsiGetSupportedLogPages(device);

    if (options.smart_check_status) {
        if (is_tape) {
            if (gTapeAlertsLPage) {
                if (options.drive_info) {
                    jout("TapeAlert Supported\n");
                    jglb["tapealert"]["supported"] = true;
                }
                if (options.health_opt_count > 1) {
                    if (-1 == scsiPrintActiveTapeAlerts(device, peripheral_type, true))
                        failuretest(OPTIONAL_CMD, returnval |= FAILSMART);
                }
            } else {
                jout("TapeAlert Not Supported\n");
                jglb["tapealert"]["supported"] = false;
            }
        } else { /* disk, cd/dvd, enclosure, etc */
            if ((res = scsiGetSmartData(device,
                                        options.smart_vendor_attrib))) {
                if (-2 == res)
                    returnval |= FAILSTATUS;
                else
                    returnval |= FAILSMART;
            }
        }
        any_output = true;
    }

    if (is_disk && options.smart_ss_media_log) {
        res = 0;
        if (gSSMediaLPage)
            res = scsiPrintSSMedia(device);
        if (0 != res)
            failuretest(OPTIONAL_CMD, returnval|=res);
        if (gFormatStatusLPage)
            res = scsiPrintFormatStatus(device);
        if (0 != res)
            failuretest(OPTIONAL_CMD, returnval|=res);
        any_output = true;
    }
    if (options.smart_vendor_attrib) {
        if (gEnviroReportingLPage && options.smart_env_rep) {
            scsiPrintEnviroReporting(device);
            envRepDone = true;
        } else if (gTempLPage)
            scsiPrintTemp(device);
        // in the 'smartctl -A' case only want: "Accumulated power on time"
        if ((! options.smart_background_log) && is_disk) {
            res = 0;
            if (gBackgroundResultsLPage)
                res = scsiPrintBackgroundResults(device, true);
            (void)res; // not yet used below, suppress warning
        }
        if (gStartStopLPage)
            scsiGetStartStopData(device);
        if (is_disk) {
            enum scsi_cmd_support rdefect10 =
                        device->cmd_support_level(READ_DEFECT_10, false, 0);
            enum scsi_cmd_support rdefect12 =
                        device->cmd_support_level(READ_DEFECT_12, false, 0);

            if ((SC_NO_SUPPORT == rdefect10) && (SC_NO_SUPPORT == rdefect12))
                ;
            else if (SC_SUPPORT == rdefect12)
                scsiPrintGrownDefectListLen(device, true);
            else
                scsiPrintGrownDefectListLen(device, false);

            if (gSeagateCacheLPage)
                scsiPrintSeagateCacheLPage(device);
            if (gSeagateFactoryLPage)
                scsiPrintSeagateFactoryLPage(device);
        }
        any_output = true;
    }
    // Print SCSI FARM log for Seagate SCSI drive
    if (options.farm_log || options.farm_log_suggest) {
        bool farm_supported = true;
        // Check if drive is a Seagate drive that supports FARM
        if (gSeagateFarmLPage) {
            // If -x/-xall or -a/-all is run without explicit -l farm, suggests FARM log
            if (options.farm_log_suggest && !options.farm_log) {
                jout("Seagate FARM log supported [try: -l farm]\n\n");
            // Otherwise, actually pull the FARM log
            } else {
                scsiFarmLog farmLog;
                if (!scsiReadFarmLog(device, farmLog)) {
                    pout("\nRead FARM log (SCSI Log page 0x3d, sub-page 0x3) failed\n\n");
                    farm_supported = false;
                } else {
                    scsiPrintFarmLog(farmLog);
                }
            }
        } else {
            if (options.farm_log) {
                jout("\nFARM log (SCSI Log page 0x3d, sub-page 0x3) not supported\n\n");
            }
            farm_supported = false;
        }
        jglb["seagate_farm_log"]["supported"] = farm_supported;
    }
    if (options.smart_error_log || options.scsi_pending_defects) {
        if (options.smart_error_log) {
            scsiPrintErrorCounterLog(device);
            any_output = true;
        }
        if (gPendDefectsLPage) {
            scsiPrintPendingDefectsLPage(device);
            any_output = true;
        }
        if (options.smart_error_log) {
            if (1 == scsiFetchControlGLTSD(device, modese_len, 1)) {
                pout("\n[GLTSD (Global Logging Target Save Disable) set. "
                     "Enable Save with '-S on']\n");
                any_output = true;
            }
        }
    }
    if (options.smart_selftest_log) {
        res = 0;
        if (gSelfTestLPage)
            res = scsiPrintSelfTest(device);
        else {
            pout("Device does not support Self Test logging\n");
            if (! is_tape)
                failuretest(OPTIONAL_CMD, returnval|=FAILSMART);
        }
        if (0 != res)
            failuretest(OPTIONAL_CMD, returnval|=res);
        any_output = true;
    }
    if (options.smart_background_log && is_disk) {
        res = 0;
        if (gBackgroundResultsLPage)
            res = scsiPrintBackgroundResults(device, false);
        else {
            pout("Device does not support Background scan results logging\n");
            failuretest(OPTIONAL_CMD, returnval|=FAILSMART);
        }
        if (0 != res)
            failuretest(OPTIONAL_CMD, returnval|=res);
        any_output = true;
    }
    if (options.zoned_device_stats && is_zbc) {
        res = 0;
        if (gZBDeviceStatsLPage)
            res = scsiPrintZBDeviceStats(device);
        else {
            pout("Device does not support %s logging\n", zbds_s);
            failuretest(OPTIONAL_CMD, returnval|=FAILSMART);
        }
        if (0 != res)
            failuretest(OPTIONAL_CMD, returnval|=res);
        any_output = true;
    }
    if (options.general_stats_and_perf) {
        res = 0;
        if (gGenStatsAndPerfLPage)
            res = scsiPrintGStatsPerf(device);
        else {
            pout("Device does not support %s logging\n", gsap_s);
            failuretest(OPTIONAL_CMD, returnval|=FAILSMART);
        }
        if (0 != res)
            failuretest(OPTIONAL_CMD, returnval|=res);
        any_output = true;

    }
    if (is_tape) {
        if (options.tape_device_stats) {
            res = 0;
            if (gTapeDeviceStatsLPage) {
                res = scsiPrintTapeDeviceStats(device);
            } else {
                pout("Device does not support (tape) device characteristics "
                     "(SSC) logging\n");
                failuretest(OPTIONAL_CMD, returnval|=FAILSMART);
            }
            if (0 != res)
                failuretest(OPTIONAL_CMD, returnval|=res);
            any_output = true;
        }
        if (options.tape_alert) {
            res = 0;
            if (gTapeAlertsLPage) {
                res = scsiPrintActiveTapeAlerts(device, peripheral_type, false);
            } else {
                pout("Device does not support TapeAlert logging\n");
                failuretest(OPTIONAL_CMD, returnval|=FAILSMART);
            }
            if (res < 0)
                failuretest(OPTIONAL_CMD, returnval|=res);
            if ((scsi_debugmode > 0) && (res == 0))
                pout("TapeAlerts only printed if active, so none printed is good\n");
            any_output = true;
        }
    }
    if (options.smart_default_selftest) {
        if (scsiSmartDefaultSelfTest(device))
            return returnval | FAILSMART;
        pout("Default Self Test Successful\n");
        any_output = true;
    }
    if (options.smart_short_cap_selftest) {
        if (scsiSmartShortCapSelfTest(device))
            return returnval | FAILSMART;
        pout("Short Foreground Self Test Successful\n");
        any_output = true;
    }
    // check if another test is running
    if (options.smart_short_selftest || options.smart_extend_selftest) {
        if (!scsiRequestSense(device, &sense_info) &&
            (sense_info.asc == 0x04 && sense_info.ascq == 0x09)) {
            if (!options.smart_selftest_force) {
                pout("Can't start self-test without aborting current test");
                if (sense_info.progress != -1)
                    pout(" (%d%% remaining)",
                         100 - sense_info.progress * 100 / 65535);
                pout(",\nadd '-t force' option to override, or run "
                     "'smartctl -X' to abort test.\n");
                return -1;
            } else
                scsiSmartSelfTestAbort(device);
        }
    }
    if (options.smart_short_selftest) {
        if (scsiSmartShortSelfTest(device))
            return returnval | FAILSMART;
        pout("Short Background Self Test has begun\n");
        pout("Use smartctl -X to abort test\n");
        any_output = true;
    }
    if (options.smart_extend_selftest) {
        if (scsiSmartExtendSelfTest(device))
            return returnval | FAILSMART;
        pout("Extended Background Self Test has begun\n");
        if ((0 == scsiFetchExtendedSelfTestTime(device, &durationSec,
                        modese_len)) && (durationSec > 0)) {
            time_t t = time(nullptr);

            t += durationSec;
            pout("Please wait %d minutes for test to complete.\n",
                 durationSec / 60);
            char comptime[DATEANDEPOCHLEN];
            dateandtimezoneepoch(comptime, t);
            pout("Estimated completion time: %s\n", comptime);
        }
        pout("Use smartctl -X to abort test\n");
        any_output = true;
    }
    if (options.smart_extend_cap_selftest) {
        if (scsiSmartExtendCapSelfTest(device))
            return returnval | FAILSMART;
        pout("Extended Foreground Self Test Successful\n");
    }
    if (options.smart_selftest_abort) {
        if (scsiSmartSelfTestAbort(device))
            return returnval | FAILSMART;
        pout("Self Test returned without error\n");
        any_output = true;
    }
    if (options.sasphy) {
        if (gProtocolSpecificLPage) {
            if (scsiPrintSasPhy(device, options.sasphy_reset))
                return returnval | FAILSMART;
            any_output = true;
        }
    }
    if (options.smart_env_rep && ! envRepDone) {
        if (gEnviroReportingLPage) {
            scsiPrintEnviroReporting(device);
            any_output = true;
        }
    }

    if (options.set_standby == 1) {
        if (scsiSetPowerCondition(device, SCSI_POW_COND_ACTIVE)) {
            pout("SCSI SSU(ACTIVE) command failed: %s\n",
                 device->get_errmsg());
            returnval |= FAILSMART;
        } else
            pout("Device placed in ACTIVE mode\n");
    } else if (options.set_standby > 1) {
        pout("SCSI SSU(STANDBY) with timeout not supported yet\n");
        returnval |= FAILSMART;
    } else if (options.set_standby_now) {
        if (scsiSetPowerCondition(device, SCSI_POW_COND_STANDBY)) {
            pout("SCSI STANDBY command failed: %s\n", device->get_errmsg());
            returnval |= FAILSMART;
        } else
            pout("Device placed in STANDBY mode\n");
    }

    if (!any_output && powername) // Output power mode if -n (nocheck)
        pout("Device is in %s mode\n", powername);

    if (!any_output)
        pout("SCSI device successfully opened\n\nUse 'smartctl -a' (or '-x') "
             "to print SMART (and more) information\n\n");

    return returnval;
}