← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/sg3-utils/oneiric

« back to all changes in this revision

Viewing changes to src/sg_logs.c

  • Committer: Bazaar Package Importer
  • Author(s): Michael Biebl
  • Date: 2009-11-05 20:42:13 UTC
  • mfrom: (5.2.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20091105204213-ug7wrb6m7l9kmvyg
Tags: 1.28-2
* QA upload.
* Add libsgutils2-2.symbols.kfreebsd. Some of the symbols are Linux
  specific causing FTBFS on kfreebsd.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/sg_logs.c
25
25
 
26
26
*/
27
27
 
28
 
static char * version_str = "0.84 20090327";    /* SPC-4 revision 18 */
 
28
static char * version_str = "0.91 20090918";    /* SPC-4 revision 21 */
29
29
 
30
30
#define MX_ALLOC_LEN (0xfffc)
31
31
#define SHORT_RESP_LEN 128
32
32
 
33
 
#define ALL_PAGE_LPAGE 0x0
 
33
#define SUPP_PAGES_LPAGE 0x0
34
34
#define BUFF_OVER_UNDER_LPAGE 0x1
35
35
#define WRITE_ERR_LPAGE 0x2
36
36
#define READ_ERR_LPAGE 0x3
39
39
#define NON_MEDIUM_LPAGE 0x6
40
40
#define LAST_N_ERR_LPAGE 0x7
41
41
#define LAST_N_DEFERRED_LPAGE 0xb
 
42
#define THIN_PROV_LPAGE 0xc
42
43
#define TEMPERATURE_LPAGE 0xd
43
44
#define START_STOP_LPAGE 0xe
44
45
#define APP_CLIENT_LPAGE 0xf
45
46
#define SELF_TEST_LPAGE 0x10
46
47
#define PORT_SPECIFIC_LPAGE 0x18
47
 
#define GSP_LPAGE 0x19
 
48
#define STATS_LPAGE 0x19
48
49
#define PCT_LPAGE 0x1a
49
50
#define TAPE_ALERT_LPAGE 0x2e
50
51
#define IE_LPAGE 0x2f
51
 
#define NOT_SUBPG_LOG 0x0
52
 
#define ALL_SUBPG_LOG 0xff
 
52
#define NOT_SPG_SUBPG 0x0
 
53
#define SUPP_SPGS_SUBPG 0xff
 
54
#define LOW_GRP_STATS_SUBPG 0x1
 
55
#define HIGH_GRP_STATS_SUBPG 0x1f
 
56
#define CACHE_STATS_SUBPG 0x20
53
57
 
54
58
#define PCB_STR_LEN 128
55
59
 
629
633
 
630
634
    memset(b, 0, sizeof(b));
631
635
    /* first process log pages that do not depend on peripheral type */
632
 
    if (NOT_SUBPG_LOG == subpg_code)
 
636
    if (NOT_SPG_SUBPG == subpg_code)
633
637
        snprintf(b, sizeof(b) - 1, "    0x%02x        ", pg_code);
634
638
    else
635
639
        snprintf(b, sizeof(b) - 1, "    0x%02x,0x%02x   ", pg_code,
636
640
                 subpg_code);
637
641
    done = 1;
638
 
    if ((NOT_SUBPG_LOG == subpg_code) || (ALL_SUBPG_LOG == subpg_code)) {
 
642
    if ((NOT_SPG_SUBPG == subpg_code) || (SUPP_SPGS_SUBPG == subpg_code)) {
639
643
        switch (pg_code) {
640
 
        case ALL_PAGE_LPAGE: printf("%sSupported log pages", b); break;
 
644
        case SUPP_PAGES_LPAGE: printf("%sSupported log pages", b); break;
641
645
        case BUFF_OVER_UNDER_LPAGE:
642
646
            printf("%sBuffer over-run/under-run", b);
643
647
            break;
656
660
        case APP_CLIENT_LPAGE: printf("%sApplication client", b); break;
657
661
        case SELF_TEST_LPAGE: printf("%sSelf-test results", b); break;
658
662
        case PORT_SPECIFIC_LPAGE: printf("%sProtocol specific port", b); break;
659
 
        case GSP_LPAGE:
 
663
        case STATS_LPAGE:
660
664
            printf("%sGeneral statistics and performance", b);
661
665
            break;
662
666
        case PCT_LPAGE:
663
667
            printf("%sPower condition transition", b);
664
668
            break;
665
 
        case IE_LPAGE: printf("%sInformational exceptions (SMART)", b); break;
666
 
        default : done = 0; break;
 
669
        case IE_LPAGE:
 
670
            printf("%sInformational exceptions (SMART)", b);
 
671
            break;
 
672
        default:
 
673
            done = 0;
 
674
            break;
667
675
        }
668
676
        if (done) {
669
 
            if (ALL_SUBPG_LOG == subpg_code)
 
677
            if (SUPP_SPGS_SUBPG == subpg_code)
670
678
                printf(" and subpages\n");
671
679
            else
672
680
                printf("\n");
673
681
            return;
674
682
        }
675
683
    }
676
 
    if ((GSP_LPAGE == pg_code) && (subpg_code > 0) && (subpg_code < 32)) {
677
 
        printf("%sGroup statistics and performance (%d)\n", b, subpg_code);
678
 
        return;
 
684
 
 
685
    /* There are not many log subpages currently */
 
686
    if (STATS_LPAGE == pg_code) {
 
687
        if ((subpg_code >= LOW_GRP_STATS_SUBPG) &&
 
688
            (subpg_code <= HIGH_GRP_STATS_SUBPG)) {
 
689
            printf("%sGroup statistics and performance (%d)\n", b, subpg_code);
 
690
            return;
 
691
        } else if (subpg_code == CACHE_STATS_SUBPG) {
 
692
            printf("%sCache memory statistics\n", b);
 
693
            return;
 
694
        }
679
695
    }
680
696
    if (subpg_code > 0) {
681
697
        printf("%s??\n", b);
691
707
            case 0x8:
692
708
                printf("%sFormat status (sbc-2)\n", b);
693
709
                break;
 
710
            case THIN_PROV_LPAGE:       /* 0xc */
 
711
                printf("%sThin provisioning (sbc-3)\n", b);
 
712
                break;
694
713
            case 0x15:
695
714
                printf("%sBackground scan results (sbc-3)\n", b);
696
715
                break;
 
716
            case 0x16:
 
717
                printf("%sATA pass-through results (sat-2)\n", b);
 
718
                break;
697
719
            case 0x17:
698
720
                printf("%sNon-volatile cache (sbc-2)\n", b);
699
721
                break;
798
820
    }
799
821
    if (done)
800
822
        return;
801
 
    printf("%s??\n", b);
 
823
    if (pg_code >= 0x30)
 
824
        printf("%s[unknown vendor specific page code]\n", b);
 
825
    else
 
826
        printf("%s??\n", b);
802
827
}
803
828
 
804
829
static void
1704
1729
            unsigned int pvdt;
1705
1730
 
1706
1731
            num_ped = vcp[51];
 
1732
            if (optsp->do_verbose > 1)
 
1733
                printf("    <<Phy event descriptors: %d, spld_len: %d, "
 
1734
                       "calc_ped: %d>>\n", num_ped, spld_len,
 
1735
                       (spld_len - 52) / 12);
1707
1736
            if (num_ped > 0) {
1708
1737
                if (optsp->do_name) {
1709
1738
                   printf("      phy_event_desc_num=%d\n", num_ped);
1748
1777
    return 1;
1749
1778
}
1750
1779
 
 
1780
/* Returns 1 if processed page, 0 otherwise */
1751
1781
static int
1752
1782
show_stats_perform_page(unsigned char * resp, int len,
1753
1783
                        const struct opts_t * optsp)
1765
1795
    spf = !!(resp[0] & 0x40);
1766
1796
    subpg_code = spf ? resp[1] : 0;
1767
1797
    if (nam) {
1768
 
        printf("log_page=0x%x\n", GSP_LPAGE);
 
1798
        printf("log_page=0x%x\n", STATS_LPAGE);
1769
1799
        if (subpg_code > 0)
1770
1800
            printf("log_subpage=0x%x\n", subpg_code);
1771
1801
    }
1843
1873
                                "intervals = ";
1844
1874
                printf("  %s%" PRIu64 "\n", ccp, ull);
1845
1875
                break;
1846
 
            case 3:     /* Time interval log parameter */
 
1876
            case 3:     /* Time interval log parameter for general stats */
1847
1877
                ccp = nam ? "parameter_code=3" : "Time interval log "
1848
 
                        "parameter";
 
1878
                        "parameter for general stats";
1849
1879
                printf("%s\n", ccp);
1850
1880
                for (n = 0, ull = ucp[4]; n < 4; ++n) {
1851
1881
                    ull <<= 8; ull |= ucp[4 + n];
1852
1882
                }
1853
 
                ccp = nam ? "time_interval_exp=" : "time interval "
1854
 
                                "exponent = ";
 
1883
                ccp = nam ? "time_interval_neg_exp=" : "time interval "
 
1884
                                "negative exponent = ";
1855
1885
                printf("  %s%" PRIu64 "\n", ccp, ull);
1856
1886
                for (n = 0, ull = ucp[8]; n < 4; ++n) {
1857
1887
                    ull <<= 8; ull |= ucp[8 + n];
1913
1943
                          : "write FUA_NV command processing intervals = ";
1914
1944
                printf("  %s%" PRIu64 "\n", ccp, ull);
1915
1945
                break;
 
1946
            case 6:     /* Time interval log parameter for cache stats */
 
1947
                ccp = nam ? "parameter_code=6" : "Time interval log "
 
1948
                        "parameter for cache stats";
 
1949
                printf("%s\n", ccp);
 
1950
                for (n = 0, ull = ucp[4]; n < 4; ++n) {
 
1951
                    ull <<= 8; ull |= ucp[4 + n];
 
1952
                }
 
1953
                ccp = nam ? "time_interval_neg_exp=" : "time interval "
 
1954
                                "negative exponent = ";
 
1955
                printf("  %s%" PRIu64 "\n", ccp, ull);
 
1956
                for (n = 0, ull = ucp[8]; n < 4; ++n) {
 
1957
                    ull <<= 8; ull |= ucp[8 + n];
 
1958
                }
 
1959
                ccp = nam ? "time_interval_int=" : "time interval "
 
1960
                                "integer = ";
 
1961
                printf("  %s%" PRIu64 "\n", ccp, ull);
 
1962
                break;
1916
1963
            default:
1917
1964
                if (nam) {
1918
1965
                    printf("parameter_code=%d\n", param_code);
2056
2103
    return 1;
2057
2104
}
2058
2105
 
 
2106
/* Returns 1 if processed page, 0 otherwise */
 
2107
static int
 
2108
show_cache_stats_page(unsigned char * resp, int len,
 
2109
                      const struct opts_t * optsp)
 
2110
{
 
2111
    int k, num, n, pc, spf, subpg_code, extra;
 
2112
    int pcb, nam;
 
2113
    unsigned char * ucp;
 
2114
    const char * ccp;
 
2115
    uint64_t ull;
 
2116
    char pcb_str[PCB_STR_LEN];
 
2117
 
 
2118
    nam = optsp->do_name;
 
2119
    num = len - 4;
 
2120
    ucp = resp + 4;
 
2121
    if (num < 4) {
 
2122
        printf("badly formed Cache memory statistics log page\n");
 
2123
        return 0;
 
2124
    }
 
2125
    spf = !!(resp[0] & 0x40);
 
2126
    subpg_code = spf ? resp[1] : 0;
 
2127
    if (nam) {
 
2128
        printf("log_page=0x%x\n", STATS_LPAGE);
 
2129
        if (subpg_code > 0)
 
2130
            printf("log_subpage=0x%x\n", subpg_code);
 
2131
    } else
 
2132
        printf("Cache memory statistics log page\n");
 
2133
 
 
2134
    for (k = num; k > 0; k -= extra, ucp += extra) {
 
2135
        if (k < 3) {
 
2136
            printf("short Cache memory statistics log page\n");
 
2137
            return 0;
 
2138
        }
 
2139
        if (8 != ucp[3]) {
 
2140
            printf("Cache memory statistics log page parameter length not "
 
2141
                   "8\n");
 
2142
            return 0;
 
2143
        }
 
2144
        extra = ucp[3] + 4;
 
2145
        pc = (ucp[0] << 8) + ucp[1];
 
2146
        pcb = ucp[2];
 
2147
        switch (pc) {
 
2148
        case 1:     /* Read cache memory hits log parameter */
 
2149
            ccp = nam ? "parameter_code=1" :
 
2150
                        "Read cache memory hits log parameter";
 
2151
            printf("%s\n", ccp);
 
2152
            for (n = 0, ull = ucp[4]; n < 8; ++n) {
 
2153
                ull <<= 8; ull |= ucp[4 + n];
 
2154
            }
 
2155
            ccp = nam ? "read_cache_memory_hits=" :
 
2156
                        "read cache memory hits = ";
 
2157
            printf("  %s%" PRIu64 "\n", ccp, ull);
 
2158
            break;
 
2159
        case 2:     /* Reads to cache memory log parameter */
 
2160
            ccp = nam ? "parameter_code=2" :
 
2161
                        "Reads to cache memory log parameter";
 
2162
            printf("%s\n", ccp);
 
2163
            for (n = 0, ull = ucp[4]; n < 8; ++n) {
 
2164
                ull <<= 8; ull |= ucp[4 + n];
 
2165
            }
 
2166
            ccp = nam ? "reads_to_cache_memory=" :
 
2167
                        "reads to cache memory = ";
 
2168
            printf("  %s%" PRIu64 "\n", ccp, ull);
 
2169
            break;
 
2170
        case 3:     /* Write cache memory hits log parameter */
 
2171
            ccp = nam ? "parameter_code=3" :
 
2172
                        "Write cache memory hits log parameter";
 
2173
            printf("%s\n", ccp);
 
2174
            for (n = 0, ull = ucp[4]; n < 8; ++n) {
 
2175
                ull <<= 8; ull |= ucp[4 + n];
 
2176
            }
 
2177
            ccp = nam ? "write_cache_memory_hits=" :
 
2178
                        "write cache memory hits = ";
 
2179
            printf("  %s%" PRIu64 "\n", ccp, ull);
 
2180
            break;
 
2181
        case 4:     /* Writes from cache memory log parameter */
 
2182
            ccp = nam ? "parameter_code=4" :
 
2183
                        "Writes from cache memory log parameter";
 
2184
            printf("%s\n", ccp);
 
2185
            for (n = 0, ull = ucp[4]; n < 8; ++n) {
 
2186
                ull <<= 8; ull |= ucp[4 + n];
 
2187
            }
 
2188
            ccp = nam ? "writes_from_cache_memory=" :
 
2189
                        "writes from cache memory = ";
 
2190
            printf("  %s%" PRIu64 "\n", ccp, ull);
 
2191
            break;
 
2192
        case 5:     /* Time from last hard reset log parameter */
 
2193
            ccp = nam ? "parameter_code=5" :
 
2194
                        "Time from last hard reset log parameter";
 
2195
            printf("%s\n", ccp);
 
2196
            for (n = 0, ull = ucp[4]; n < 8; ++n) {
 
2197
                ull <<= 8; ull |= ucp[4 + n];
 
2198
            }
 
2199
            ccp = nam ? "time_from_last_hard_reset=" :
 
2200
                        "time from last hard reset = ";
 
2201
            printf("  %s%" PRIu64 "\n", ccp, ull);
 
2202
            break;
 
2203
        case 6:     /* Time interval log parameter for cache stats */
 
2204
            ccp = nam ? "parameter_code=6" :
 
2205
                        "Time interval log parameter";
 
2206
            printf("%s\n", ccp);
 
2207
            for (n = 0, ull = ucp[4]; n < 4; ++n) {
 
2208
                ull <<= 8; ull |= ucp[4 + n];
 
2209
            }
 
2210
            ccp = nam ? "time_interval_neg_exp=" : "time interval "
 
2211
                            "negative exponent = ";
 
2212
            printf("  %s%" PRIu64 "\n", ccp, ull);
 
2213
            for (n = 0, ull = ucp[8]; n < 4; ++n) {
 
2214
                ull <<= 8; ull |= ucp[8 + n];
 
2215
            }
 
2216
            ccp = nam ? "time_interval_int=" : "time interval "
 
2217
                            "integer = ";
 
2218
            printf("  %s%" PRIu64 "\n", ccp, ull);
 
2219
            break;
 
2220
        default:
 
2221
            if (nam) {
 
2222
                printf("parameter_code=%d\n", pc);
 
2223
                printf("  unknown=1\n");
 
2224
            } else
 
2225
                fprintf(stderr, "show_performance...  unknown parameter "
 
2226
                        "code %d\n", pc);
 
2227
            if (optsp->do_verbose)
 
2228
                dStrHex((const char *)ucp, extra, 1);
 
2229
            break;
 
2230
        }
 
2231
        if ((optsp->do_pcb) && (0 == optsp->do_name)) {
 
2232
            get_pcb_str(pcb, pcb_str, sizeof(pcb_str));
 
2233
            printf("    <%s>\n", pcb_str);
 
2234
        }
 
2235
    }
 
2236
    return 1;
 
2237
}
 
2238
 
2059
2239
static void
2060
2240
show_format_status_page(unsigned char * resp, int len, int show_pcb)
2061
2241
{
2079
2259
            dStrHex((const char *)ucp, pl, 0);
2080
2260
            break;
2081
2261
        case 1: printf("  Grown defects during certification"); break;
2082
 
        case 2: printf("  Total blocks relocated during format"); break;
2083
 
        case 3: printf("  Total new blocks relocated"); break;
 
2262
        case 2: printf("  Total blocks reassigned during format"); break;
 
2263
        case 3: printf("  Total new blocks reassigned"); break;
2084
2264
        case 4: printf("  Power on minutes since format"); break;
2085
2265
        default:
2086
2266
            printf("  Unknown Format status code = 0x%x\n", pc);
2198
2378
 
2199
2379
static const char * bms_status[] = {
2200
2380
    "no background scans active",
2201
 
    "background scan is active",
 
2381
    "background medium scan is active",
2202
2382
    "background pre-scan is active",
2203
2383
    "background scan halted due to fatal error",
2204
2384
    "background scan halted due to a vendor specific pattern of error",
2205
2385
    "background scan halted due to medium formatted without P-List",
2206
2386
    "background scan halted - vendor specific cause",
2207
2387
    "background scan halted due to temperature out of range",
2208
 
    "background scan halted until BM interval timer expires", /* 8 */
 
2388
    "background scan enabled, none active (waiting for BMS interval timer "
 
2389
        "to expire)", /* 8 */
2209
2390
};
2210
2391
 
2211
2392
static const char * reassign_status[] = {
2259
2440
            j = (ucp[10] << 8) + ucp[11];
2260
2441
            printf("    Number of background scans performed: %d\n", j);
2261
2442
            j = (ucp[12] << 8) + ucp[13];
2262
 
#ifdef SG3_UTILS_MINGW
 
2443
#ifdef SG_LIB_MINGW
2263
2444
            printf("    Background medium scan progress: %g%%\n",
2264
2445
                   (double)(j * 100.0 / 65536.0));
2265
2446
#else
2268
2449
#endif
2269
2450
            j = (ucp[14] << 8) + ucp[15];
2270
2451
            if (0 == j)
2271
 
                printf("    Number of background medium scans performed: "
2272
 
                       "not reported [0]\n");
 
2452
                printf("    Number of background medium scans performed: 0 "
 
2453
                       "[not reported]\n");
2273
2454
            else
2274
2455
                printf("    Number of background medium scans performed: "
2275
2456
                       "%d\n", j);
2276
2457
            break;
2277
2458
        default:
2278
 
            printf("  Medium scan parameter # %d\n", pc);
 
2459
            if (pc > 0x800) {
 
2460
                if ((pc >= 0x8000) && (pc <= 0xafff))
 
2461
                    printf("  Medium scan parameter # %d [0x%x], vendor "
 
2462
                           "specific\n", pc, pc);
 
2463
                else
 
2464
                    printf("  Medium scan parameter # %d [0x%x], "
 
2465
                           "reserved\n", pc, pc);
 
2466
                dStrHex((const char *)ucp, ((pl < num) ? pl : num), 0);
 
2467
                break;
 
2468
            } else
 
2469
                printf("  Medium scan parameter # %d [0x%x]\n", pc, pc);
2279
2470
            if ((pl < 24) || (num < 24)) {
2280
2471
                if (num < 24)
2281
2472
                    fprintf(stderr, "    truncated by response length, "
2992
3183
    pg_code = resp[0] & 0x3f;
2993
3184
    subpg_code = spf ? resp[1] : 0;
2994
3185
 
2995
 
    if ((ALL_PAGE_LPAGE != pg_code ) && (ALL_SUBPG_LOG == subpg_code)) {
 
3186
    if ((SUPP_PAGES_LPAGE != pg_code ) && (SUPP_SPGS_SUBPG == subpg_code)) {
2996
3187
        printf("Supported subpages for log page=0x%x\n", pg_code);
2997
3188
        for (k = 0; k < num; k += 2)
2998
3189
            show_page_name((int)resp[4 + k], (int)resp[4 + k + 1],
3000
3191
        return;
3001
3192
    }
3002
3193
    switch (pg_code) {
3003
 
    case ALL_PAGE_LPAGE:
 
3194
    case SUPP_PAGES_LPAGE:
3004
3195
        if (spf) {
3005
3196
            printf("Supported log pages and subpages:\n");
3006
3197
            for (k = 0; k < num; k += 2)
3126
3317
    case PORT_SPECIFIC_LPAGE:
3127
3318
        done = show_protocol_specific_page(resp, len, optsp);
3128
3319
        break;
3129
 
    case GSP_LPAGE: /* defined for subpages 0 to 31 inclusive */
3130
 
        done = show_stats_perform_page(resp, len, optsp);
 
3320
    case STATS_LPAGE: /* defined for subpages 0 to 32 inclusive */
 
3321
        if (subpg_code <= HIGH_GRP_STATS_SUBPG)
 
3322
            done = show_stats_perform_page(resp, len, optsp);
 
3323
        else if (subpg_code == CACHE_STATS_SUBPG)
 
3324
            done = show_cache_stats_page(resp, len, optsp);
 
3325
        else
 
3326
            done = 0;
3131
3327
        break;
3132
3328
    case PCT_LPAGE:
3133
3329
        show_power_condition_transitions_page(resp, len, optsp->do_pcb);
3182
3378
               resp[0] & 0x3f);
3183
3379
        if (len > 128) {
3184
3380
            dStrHex((const char *)resp, 64, 1);
3185
 
            printf(" .....  [truncated after 64 of %d bytes (use '-h' to "
 
3381
            printf(" .....  [truncated after 64 of %d bytes (use '-H' to "
3186
3382
                   "see the rest)]\n", len);
3187
3383
        }
3188
3384
        else
3198
3394
    int res = 0;
3199
3395
 
3200
3396
    optsp->pg_code = TEMPERATURE_LPAGE;
3201
 
    optsp->subpg_code = NOT_SUBPG_LOG;
 
3397
    optsp->subpg_code = NOT_SPG_SUBPG;
3202
3398
    res = do_logs(sg_fd, resp, max_len, 0, optsp);
3203
3399
    if (0 == res) {
3204
3400
        len = (resp[2] << 8) + resp[3] + 4;
3276
3472
        }
3277
3473
    }
3278
3474
    if (opts.do_list || opts.do_all) {
3279
 
        opts.pg_code = ALL_PAGE_LPAGE;
 
3475
        opts.pg_code = SUPP_PAGES_LPAGE;
3280
3476
        if ((opts.do_list > 1) || (opts.do_all > 1))
3281
 
            opts.subpg_code = ALL_SUBPG_LOG;
 
3477
            opts.subpg_code = SUPP_SPGS_SUBPG;
3282
3478
    }
3283
3479
    if (opts.do_transport) {
3284
3480
        if ((opts.pg_code > 0) || (opts.subpg_code > 0) ||
3313
3509
        if (k) {
3314
3510
            if (SG_LIB_CAT_NOT_READY == k)
3315
3511
                fprintf(stderr, "log_select: device not ready\n");
 
3512
            else if (SG_LIB_CAT_ILLEGAL_REQ == res)
 
3513
                fprintf(stderr, "log_select: field in cdb illegal\n");
3316
3514
            else if (SG_LIB_CAT_INVALID_OP == k)
3317
3515
                fprintf(stderr, "log_select: not supported\n");
3318
3516
            else if (SG_LIB_CAT_UNIT_ATTENTION == k)
3319
3517
                fprintf(stderr, "log_select: unit attention\n");
3320
3518
            else if (SG_LIB_CAT_ABORTED_COMMAND == k)
3321
3519
                fprintf(stderr, "log_select: aborted command\n");
 
3520
            else
 
3521
                fprintf(stderr, "log_select: failed (%d), try '-v' for more "
 
3522
                        "information\n", k);
3322
3523
        }
3323
3524
        return (k >= 0) ?  k : SG_LIB_CAT_OTHER;
3324
3525
    }
3383
3584
            if (spf)
3384
3585
                opts.subpg_code = parr[++k];
3385
3586
            else
3386
 
                opts.subpg_code = NOT_SUBPG_LOG;
 
3587
                opts.subpg_code = NOT_SPG_SUBPG;
3387
3588
 
3388
3589
            res = do_logs(sg_fd, rsp_buff, resp_len, 1, &opts);
3389
3590
            if (0 == res) {
3422
3623
                fprintf(stderr, "log_sense: unit attention\n");
3423
3624
            else if (SG_LIB_CAT_ABORTED_COMMAND == res)
3424
3625
                fprintf(stderr, "log_sense: aborted command\n");
 
3626
            else
 
3627
                fprintf(stderr, "log_sense: failed, try '-v' for more "
 
3628
                        "information\n");
3425
3629
        }
3426
3630
    }
3427
3631
    sg_cmds_close_device(sg_fd);