Annotation of embedaddon/smartmontools/scsicmds.cpp, revision 1.1
1.1 ! misho 1: /*
! 2: * scsicmds.cpp
! 3: *
! 4: * Home page of code is: http://smartmontools.sourceforge.net
! 5: *
! 6: * Copyright (C) 2002-8 Bruce Allen <smartmontools-support@lists.sourceforge.net>
! 7: * Copyright (C) 1999-2000 Michael Cornwell <cornwell@acm.org>
! 8: *
! 9: * Additional SCSI work:
! 10: * Copyright (C) 2003-10 Douglas Gilbert <dgilbert@interlog.com>
! 11: *
! 12: * This program is free software; you can redistribute it and/or modify
! 13: * it under the terms of the GNU General Public License as published by
! 14: * the Free Software Foundation; either version 2, or (at your option)
! 15: * any later version.
! 16: *
! 17: * You should have received a copy of the GNU General Public License
! 18: * (for example COPYING); if not, write to the Free
! 19: * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
! 20: *
! 21: * This code was originally developed as a Senior Thesis by Michael Cornwell
! 22: * at the Concurrent Systems Laboratory (now part of the Storage Systems
! 23: * Research Center), Jack Baskin School of Engineering, University of
! 24: * California, Santa Cruz. http://ssrc.soe.ucsc.edu/
! 25: *
! 26: *
! 27: * In the SCSI world "SMART" is a dead or withdrawn standard. In recent
! 28: * SCSI standards (since SCSI-3) it goes under the awkward name of
! 29: * "Informational Exceptions" ["IE" or "IEC" (with the "C" for "control")].
! 30: * The relevant information is spread around several SCSI draft
! 31: * standards available at http://www.t10.org . Reference is made in the
! 32: * code to the following acronyms:
! 33: * - SAM [SCSI Architectural model, versions 2 or 3]
! 34: * - SPC [SCSI Primary commands, versions 2 or 3]
! 35: * - SBC [SCSI Block commands, versions 2]
! 36: *
! 37: * Some SCSI disk vendors have snippets of "SMART" information in their
! 38: * product manuals.
! 39: */
! 40:
! 41: #include <stdio.h>
! 42: #include <string.h>
! 43: #include <errno.h>
! 44:
! 45: #include "config.h"
! 46: #include "int64.h"
! 47: #include "scsicmds.h"
! 48: #include "atacmds.h" // FIXME: for smart_command_set only
! 49: #include "dev_interface.h"
! 50: #include "utility.h"
! 51:
! 52: const char *scsicmds_c_cvsid="$Id: scsicmds.cpp 3302 2011-03-25 23:04:36Z dpgilbert $"
! 53: SCSICMDS_H_CVSID;
! 54:
! 55: // Print SCSI debug messages?
! 56: unsigned char scsi_debugmode = 0;
! 57:
! 58: /* output binary in hex and optionally ascii */
! 59: void dStrHex(const char* str, int len, int no_ascii)
! 60: {
! 61: const char* p = str;
! 62: unsigned char c;
! 63: char buff[82];
! 64: int a = 0;
! 65: const int bpstart = 5;
! 66: const int cpstart = 60;
! 67: int cpos = cpstart;
! 68: int bpos = bpstart;
! 69: int i, k;
! 70:
! 71: if (len <= 0) return;
! 72: memset(buff,' ',80);
! 73: buff[80]='\0';
! 74: k = sprintf(buff + 1, "%.2x", a);
! 75: buff[k + 1] = ' ';
! 76: if (bpos >= ((bpstart + (9 * 3))))
! 77: bpos++;
! 78:
! 79: for(i = 0; i < len; i++)
! 80: {
! 81: c = *p++;
! 82: bpos += 3;
! 83: if (bpos == (bpstart + (9 * 3)))
! 84: bpos++;
! 85: sprintf(&buff[bpos], "%.2x", (int)(unsigned char)c);
! 86: buff[bpos + 2] = ' ';
! 87: if (no_ascii)
! 88: buff[cpos++] = ' ';
! 89: else {
! 90: if ((c < ' ') || (c >= 0x7f))
! 91: c='.';
! 92: buff[cpos++] = c;
! 93: }
! 94: if (cpos > (cpstart+15))
! 95: {
! 96: pout("%s\n", buff);
! 97: bpos = bpstart;
! 98: cpos = cpstart;
! 99: a += 16;
! 100: memset(buff,' ',80);
! 101: k = sprintf(buff + 1, "%.2x", a);
! 102: buff[k + 1] = ' ';
! 103: }
! 104: }
! 105: if (cpos > cpstart)
! 106: {
! 107: pout("%s\n", buff);
! 108: }
! 109: }
! 110:
! 111: struct scsi_opcode_name {
! 112: UINT8 opcode;
! 113: const char * name;
! 114: };
! 115:
! 116: static struct scsi_opcode_name opcode_name_arr[] = {
! 117: /* in ascending opcode order */
! 118: {TEST_UNIT_READY, "test unit ready"}, /* 0x00 */
! 119: {REQUEST_SENSE, "request sense"}, /* 0x03 */
! 120: {INQUIRY, "inquiry"}, /* 0x12 */
! 121: {MODE_SELECT, "mode select(6)"}, /* 0x15 */
! 122: {MODE_SENSE, "mode sense(6)"}, /* 0x1a */
! 123: {START_STOP_UNIT, "start stop unit"}, /* 0x1b */
! 124: {RECEIVE_DIAGNOSTIC, "receive diagnostic"}, /* 0x1c */
! 125: {SEND_DIAGNOSTIC, "send diagnostic"}, /* 0x1d */
! 126: {READ_CAPACITY_10, "read capacity(10)"}, /* 0x25 */
! 127: {READ_DEFECT_10, "read defect list(10)"}, /* 0x37 */
! 128: {LOG_SELECT, "log select"}, /* 0x4c */
! 129: {LOG_SENSE, "log sense"}, /* 0x4d */
! 130: {MODE_SELECT_10, "mode select(10)"}, /* 0x55 */
! 131: {MODE_SENSE_10, "mode sense(10)"}, /* 0x5a */
! 132: {SAT_ATA_PASSTHROUGH_16, "ata pass-through(16)"}, /* 0x85 */
! 133: {READ_CAPACITY_16, "read capacity(16)"}, /* 0x9e,0x10 */
! 134: {REPORT_LUNS, "report luns"}, /* 0xa0 */
! 135: {SAT_ATA_PASSTHROUGH_12, "ata pass-through(12)"}, /* 0xa1 */
! 136: };
! 137:
! 138: static const char * vendor_specific = "<vendor specific>";
! 139:
! 140: /* Need to expand to take service action into account. For commands
! 141: * of interest the service action is in the 2nd command byte */
! 142: const char * scsi_get_opcode_name(UINT8 opcode)
! 143: {
! 144: int k;
! 145: int len = sizeof(opcode_name_arr) / sizeof(opcode_name_arr[0]);
! 146: struct scsi_opcode_name * onp;
! 147:
! 148: if (opcode >= 0xc0)
! 149: return vendor_specific;
! 150: for (k = 0; k < len; ++k) {
! 151: onp = &opcode_name_arr[k];
! 152: if (opcode == onp->opcode)
! 153: return onp->name;
! 154: else if (opcode < onp->opcode)
! 155: return NULL;
! 156: }
! 157: return NULL;
! 158: }
! 159:
! 160:
! 161: void scsi_do_sense_disect(const struct scsi_cmnd_io * io_buf,
! 162: struct scsi_sense_disect * out)
! 163: {
! 164: int resp_code;
! 165:
! 166: memset(out, 0, sizeof(struct scsi_sense_disect));
! 167: if (SCSI_STATUS_CHECK_CONDITION == io_buf->scsi_status) {
! 168: resp_code = (io_buf->sensep[0] & 0x7f);
! 169: out->error_code = resp_code;
! 170: if (resp_code >= 0x72) {
! 171: out->sense_key = (io_buf->sensep[1] & 0xf);
! 172: out->asc = io_buf->sensep[2];
! 173: out->ascq = io_buf->sensep[3];
! 174: } else if (resp_code >= 0x70) {
! 175: out->sense_key = (io_buf->sensep[2] & 0xf);
! 176: if (io_buf->resp_sense_len > 13) {
! 177: out->asc = io_buf->sensep[12];
! 178: out->ascq = io_buf->sensep[13];
! 179: }
! 180: }
! 181: }
! 182: }
! 183:
! 184: int scsiSimpleSenseFilter(const struct scsi_sense_disect * sinfo)
! 185: {
! 186: switch (sinfo->sense_key) {
! 187: case SCSI_SK_NO_SENSE:
! 188: case SCSI_SK_RECOVERED_ERR:
! 189: return SIMPLE_NO_ERROR;
! 190: case SCSI_SK_NOT_READY:
! 191: if (SCSI_ASC_NO_MEDIUM == sinfo->asc)
! 192: return SIMPLE_ERR_NO_MEDIUM;
! 193: else if (SCSI_ASC_NOT_READY == sinfo->asc) {
! 194: if (0x1 == sinfo->ascq)
! 195: return SIMPLE_ERR_BECOMING_READY;
! 196: else
! 197: return SIMPLE_ERR_NOT_READY;
! 198: } else
! 199: return SIMPLE_ERR_NOT_READY;
! 200: case SCSI_SK_MEDIUM_ERROR:
! 201: case SCSI_SK_HARDWARE_ERROR:
! 202: return SIMPLE_ERR_MEDIUM_HARDWARE;
! 203: case SCSI_SK_ILLEGAL_REQUEST:
! 204: if (SCSI_ASC_UNKNOWN_OPCODE == sinfo->asc)
! 205: return SIMPLE_ERR_BAD_OPCODE;
! 206: else if (SCSI_ASC_UNKNOWN_FIELD == sinfo->asc)
! 207: return SIMPLE_ERR_BAD_FIELD;
! 208: else if (SCSI_ASC_UNKNOWN_PARAM == sinfo->asc)
! 209: return SIMPLE_ERR_BAD_PARAM;
! 210: else
! 211: return SIMPLE_ERR_BAD_PARAM; /* all other illegal request */
! 212: case SCSI_SK_UNIT_ATTENTION:
! 213: return SIMPLE_ERR_TRY_AGAIN;
! 214: case SCSI_SK_ABORTED_COMMAND:
! 215: return SIMPLE_ERR_ABORTED_COMMAND;
! 216: default:
! 217: return SIMPLE_ERR_UNKNOWN;
! 218: }
! 219: }
! 220:
! 221: const char * scsiErrString(int scsiErr)
! 222: {
! 223: if (scsiErr < 0)
! 224: return strerror(-scsiErr);
! 225: switch (scsiErr) {
! 226: case SIMPLE_NO_ERROR:
! 227: return "no error";
! 228: case SIMPLE_ERR_NOT_READY:
! 229: return "device not ready";
! 230: case SIMPLE_ERR_BAD_OPCODE:
! 231: return "unsupported scsi opcode";
! 232: case SIMPLE_ERR_BAD_FIELD:
! 233: return "unsupported field in scsi command";
! 234: case SIMPLE_ERR_BAD_PARAM:
! 235: return "badly formed scsi parameters";
! 236: case SIMPLE_ERR_BAD_RESP:
! 237: return "scsi response fails sanity test";
! 238: case SIMPLE_ERR_NO_MEDIUM:
! 239: return "no medium present";
! 240: case SIMPLE_ERR_BECOMING_READY:
! 241: return "device will be ready soon";
! 242: case SIMPLE_ERR_TRY_AGAIN:
! 243: return "unit attention reported, try again";
! 244: case SIMPLE_ERR_MEDIUM_HARDWARE:
! 245: return "medium or hardware error (serious)";
! 246: case SIMPLE_ERR_UNKNOWN:
! 247: return "unknown error (unexpected sense key)";
! 248: case SIMPLE_ERR_ABORTED_COMMAND:
! 249: return "aborted command";
! 250: default:
! 251: return "unknown error";
! 252: }
! 253: }
! 254:
! 255: /* Iterates to next designation descriptor in the device identification
! 256: * VPD page. The 'initial_desig_desc' should point to start of first
! 257: * descriptor with 'page_len' being the number of valid bytes in that
! 258: * and following descriptors. To start, 'off' should point to a negative
! 259: * value, thereafter it should point to the value yielded by the previous
! 260: * call. If 0 returned then 'initial_desig_desc + *off' should be a valid
! 261: * descriptor; returns -1 if normal end condition and -2 for an abnormal
! 262: * termination. Matches association, designator_type and/or code_set when
! 263: * any of those values are greater than or equal to zero. */
! 264: int scsi_vpd_dev_id_iter(const unsigned char * initial_desig_desc,
! 265: int page_len, int * off, int m_assoc,
! 266: int m_desig_type, int m_code_set)
! 267: {
! 268: const unsigned char * ucp;
! 269: int k, c_set, assoc, desig_type;
! 270:
! 271: for (k = *off, ucp = initial_desig_desc ; (k + 3) < page_len; ) {
! 272: k = (k < 0) ? 0 : (k + ucp[k + 3] + 4);
! 273: if ((k + 4) > page_len)
! 274: break;
! 275: c_set = (ucp[k] & 0xf);
! 276: if ((m_code_set >= 0) && (m_code_set != c_set))
! 277: continue;
! 278: assoc = ((ucp[k + 1] >> 4) & 0x3);
! 279: if ((m_assoc >= 0) && (m_assoc != assoc))
! 280: continue;
! 281: desig_type = (ucp[k + 1] & 0xf);
! 282: if ((m_desig_type >= 0) && (m_desig_type != desig_type))
! 283: continue;
! 284: *off = k;
! 285: return 0;
! 286: }
! 287: return (k == page_len) ? -1 : -2;
! 288: }
! 289:
! 290: /* Decode VPD page 0x83 logical unit designator into a string. If both
! 291: * numeric address and SCSI name string present, prefer the former.
! 292: * Returns 0 on success, -1 on error with error string in s. */
! 293: int scsi_decode_lu_dev_id(const unsigned char * b, int blen, char * s,
! 294: int slen, int * transport)
! 295: {
! 296: int m, c_set, assoc, desig_type, i_len, naa, off, u, have_scsi_ns;
! 297: const unsigned char * ucp;
! 298: const unsigned char * ip;
! 299: char * orig_s = s;
! 300:
! 301: if (transport)
! 302: *transport = -1;
! 303: if (slen < 32) {
! 304: if (slen > 0)
! 305: s[0] = '\0';
! 306: return -1;
! 307: }
! 308: have_scsi_ns = 0;
! 309: s[0] = '\0';
! 310: off = -1;
! 311: while ((u = scsi_vpd_dev_id_iter(b, blen, &off, -1, -1, -1)) == 0) {
! 312: ucp = b + off;
! 313: i_len = ucp[3];
! 314: if ((off + i_len + 4) > blen) {
! 315: s += sprintf(s, "error: designator length");
! 316: return -1;
! 317: }
! 318: assoc = ((ucp[1] >> 4) & 0x3);
! 319: if (transport && assoc && (ucp[1] & 0x80) && (*transport < 0))
! 320: *transport = (ucp[0] >> 4) & 0xf;
! 321: if (0 != assoc)
! 322: continue;
! 323: ip = ucp + 4;
! 324: c_set = (ucp[0] & 0xf);
! 325: desig_type = (ucp[1] & 0xf);
! 326:
! 327: switch (desig_type) {
! 328: case 0: /* vendor specific */
! 329: case 1: /* T10 vendor identification */
! 330: break;
! 331: case 2: /* EUI-64 based */
! 332: if ((8 != i_len) && (12 != i_len) && (16 != i_len)) {
! 333: s += sprintf(s, "error: EUI-64 length");
! 334: return -1;
! 335: }
! 336: if (have_scsi_ns)
! 337: s = orig_s;
! 338: s += sprintf(s, "0x");
! 339: for (m = 0; m < i_len; ++m)
! 340: s += sprintf(s, "%02x", (unsigned int)ip[m]);
! 341: break;
! 342: case 3: /* NAA */
! 343: if (1 != c_set) {
! 344: s += sprintf(s, "error: NAA bad code_set");
! 345: return -1;
! 346: }
! 347: naa = (ip[0] >> 4) & 0xff;
! 348: if ((naa < 2) || (naa > 6) || (4 == naa)) {
! 349: s += sprintf(s, "error: unexpected NAA");
! 350: return -1;
! 351: }
! 352: if (have_scsi_ns)
! 353: s = orig_s;
! 354: if (2 == naa) { /* NAA IEEE Extended */
! 355: if (8 != i_len) {
! 356: s += sprintf(s, "error: NAA 2 length");
! 357: return -1;
! 358: }
! 359: s += sprintf(s, "0x");
! 360: for (m = 0; m < 8; ++m)
! 361: s += sprintf(s, "%02x", (unsigned int)ip[m]);
! 362: } else if ((3 == naa ) || (5 == naa)) {
! 363: /* NAA=3 Locally assigned; NAA=5 IEEE Registered */
! 364: if (8 != i_len) {
! 365: s += sprintf(s, "error: NAA 3 or 5 length");
! 366: return -1;
! 367: }
! 368: s += sprintf(s, "0x");
! 369: for (m = 0; m < 8; ++m)
! 370: s += sprintf(s, "%02x", (unsigned int)ip[m]);
! 371: } else if (6 == naa) { /* NAA IEEE Registered extended */
! 372: if (16 != i_len) {
! 373: s += sprintf(s, "error: NAA 6 length");
! 374: return -1;
! 375: }
! 376: s += sprintf(s, "0x");
! 377: for (m = 0; m < 16; ++m)
! 378: s += sprintf(s, "%02x", (unsigned int)ip[m]);
! 379: }
! 380: break;
! 381: case 4: /* Relative target port */
! 382: case 5: /* (primary) Target port group */
! 383: case 6: /* Logical unit group */
! 384: case 7: /* MD5 logical unit identifier */
! 385: break;
! 386: case 8: /* SCSI name string */
! 387: if (3 != c_set) {
! 388: s += sprintf(s, "error: SCSI name string");
! 389: return -1;
! 390: }
! 391: /* does %s print out UTF-8 ok?? */
! 392: if (orig_s == s) {
! 393: s += sprintf(s, "%s", (const char *)ip);
! 394: ++have_scsi_ns;
! 395: }
! 396: break;
! 397: default: /* reserved */
! 398: break;
! 399: }
! 400: }
! 401: if (-2 == u) {
! 402: s += sprintf(s, "error: bad structure");
! 403: return -1;
! 404: }
! 405: return 0;
! 406: }
! 407:
! 408: /* Sends LOG SENSE command. Returns 0 if ok, 1 if device NOT READY, 2 if
! 409: command not supported, 3 if field (within command) not supported or
! 410: returns negated errno. SPC-3 sections 6.6 and 7.2 (rec 22a).
! 411: N.B. Sets PC==1 to fetch "current cumulative" log pages.
! 412: If known_resp_len > 0 then a single fetch is done for this response
! 413: length. If known_resp_len == 0 then twin fetches are performed, the
! 414: first to deduce the response length, then send the same command again
! 415: requesting the deduced response length. This protects certain fragile
! 416: HBAs. The twin fetch technique should not be used with the TapeAlert
! 417: log page since it clears its state flags after each fetch. */
! 418: int scsiLogSense(scsi_device * device, int pagenum, int subpagenum, UINT8 *pBuf,
! 419: int bufLen, int known_resp_len)
! 420: {
! 421: struct scsi_cmnd_io io_hdr;
! 422: struct scsi_sense_disect sinfo;
! 423: UINT8 cdb[10];
! 424: UINT8 sense[32];
! 425: int pageLen;
! 426: int status, res;
! 427:
! 428: if (known_resp_len > bufLen)
! 429: return -EIO;
! 430: if (known_resp_len > 0)
! 431: pageLen = known_resp_len;
! 432: else {
! 433: /* Starting twin fetch strategy: first fetch to find respone length */
! 434: pageLen = 4;
! 435: if (pageLen > bufLen)
! 436: return -EIO;
! 437: else
! 438: memset(pBuf, 0, pageLen);
! 439:
! 440: memset(&io_hdr, 0, sizeof(io_hdr));
! 441: memset(cdb, 0, sizeof(cdb));
! 442: io_hdr.dxfer_dir = DXFER_FROM_DEVICE;
! 443: io_hdr.dxfer_len = pageLen;
! 444: io_hdr.dxferp = pBuf;
! 445: cdb[0] = LOG_SENSE;
! 446: cdb[2] = 0x40 | (pagenum & 0x3f); /* Page control (PC)==1 */
! 447: cdb[3] = subpagenum;
! 448: cdb[7] = (pageLen >> 8) & 0xff;
! 449: cdb[8] = pageLen & 0xff;
! 450: io_hdr.cmnd = cdb;
! 451: io_hdr.cmnd_len = sizeof(cdb);
! 452: io_hdr.sensep = sense;
! 453: io_hdr.max_sense_len = sizeof(sense);
! 454: io_hdr.timeout = SCSI_TIMEOUT_DEFAULT;
! 455:
! 456: if (!device->scsi_pass_through(&io_hdr))
! 457: return -device->get_errno();
! 458: scsi_do_sense_disect(&io_hdr, &sinfo);
! 459: if ((res = scsiSimpleSenseFilter(&sinfo)))
! 460: return res;
! 461: /* sanity check on response */
! 462: if ((SUPPORTED_LPAGES != pagenum) && ((pBuf[0] & 0x3f) != pagenum))
! 463: return SIMPLE_ERR_BAD_RESP;
! 464: if (0 == ((pBuf[2] << 8) + pBuf[3]))
! 465: return SIMPLE_ERR_BAD_RESP;
! 466: pageLen = (pBuf[2] << 8) + pBuf[3] + 4;
! 467: if (4 == pageLen) /* why define a lpage with no payload? */
! 468: pageLen = 252; /* some IBM tape drives don't like double fetch */
! 469: /* some SCSI HBA don't like "odd" length transfers */
! 470: if (pageLen % 2)
! 471: pageLen += 1;
! 472: if (pageLen > bufLen)
! 473: pageLen = bufLen;
! 474: }
! 475: memset(pBuf, 0, 4);
! 476: memset(&io_hdr, 0, sizeof(io_hdr));
! 477: memset(cdb, 0, sizeof(cdb));
! 478: io_hdr.dxfer_dir = DXFER_FROM_DEVICE;
! 479: io_hdr.dxfer_len = pageLen;
! 480: io_hdr.dxferp = pBuf;
! 481: cdb[0] = LOG_SENSE;
! 482: cdb[2] = 0x40 | (pagenum & 0x3f); /* Page control (PC)==1 */
! 483: cdb[7] = (pageLen >> 8) & 0xff;
! 484: cdb[8] = pageLen & 0xff;
! 485: io_hdr.cmnd = cdb;
! 486: io_hdr.cmnd_len = sizeof(cdb);
! 487: io_hdr.sensep = sense;
! 488: io_hdr.max_sense_len = sizeof(sense);
! 489: io_hdr.timeout = SCSI_TIMEOUT_DEFAULT;
! 490:
! 491: if (!device->scsi_pass_through(&io_hdr))
! 492: return -device->get_errno();
! 493: scsi_do_sense_disect(&io_hdr, &sinfo);
! 494: status = scsiSimpleSenseFilter(&sinfo);
! 495: if (0 != status)
! 496: return status;
! 497: /* sanity check on response */
! 498: if ((SUPPORTED_LPAGES != pagenum) && ((pBuf[0] & 0x3f) != pagenum))
! 499: return SIMPLE_ERR_BAD_RESP;
! 500: if (0 == ((pBuf[2] << 8) + pBuf[3]))
! 501: return SIMPLE_ERR_BAD_RESP;
! 502: return 0;
! 503: }
! 504:
! 505: /* Sends a LOG SELECT command. Can be used to set log page values
! 506: * or reset one log page (or all of them) to its defaults (typically zero).
! 507: * Returns 0 if ok, 1 if NOT READY, 2 if command not supported, * 3 if
! 508: * field in command not supported, * 4 if bad parameter to command or
! 509: * returns negated errno. SPC-4 sections 6.5 and 7.2 (rev 20) */
! 510: int scsiLogSelect(scsi_device * device, int pcr, int sp, int pc, int pagenum,
! 511: int subpagenum, UINT8 *pBuf, int bufLen)
! 512: {
! 513: struct scsi_cmnd_io io_hdr;
! 514: struct scsi_sense_disect sinfo;
! 515: UINT8 cdb[10];
! 516: UINT8 sense[32];
! 517:
! 518: memset(&io_hdr, 0, sizeof(io_hdr));
! 519: memset(cdb, 0, sizeof(cdb));
! 520: io_hdr.dxfer_dir = DXFER_TO_DEVICE;
! 521: io_hdr.dxfer_len = bufLen;
! 522: io_hdr.dxferp = pBuf;
! 523: cdb[0] = LOG_SELECT;
! 524: cdb[1] = (pcr ? 2 : 0) | (sp ? 1 : 0);
! 525: cdb[2] = ((pc << 6) & 0xc0) | (pagenum & 0x3f);
! 526: cdb[3] = (subpagenum & 0xff);
! 527: cdb[7] = ((bufLen >> 8) & 0xff);
! 528: cdb[8] = (bufLen & 0xff);
! 529: io_hdr.cmnd = cdb;
! 530: io_hdr.cmnd_len = sizeof(cdb);
! 531: io_hdr.sensep = sense;
! 532: io_hdr.max_sense_len = sizeof(sense);
! 533: io_hdr.timeout = SCSI_TIMEOUT_DEFAULT;
! 534:
! 535: if (!device->scsi_pass_through(&io_hdr))
! 536: return -device->get_errno();
! 537: scsi_do_sense_disect(&io_hdr, &sinfo);
! 538: return scsiSimpleSenseFilter(&sinfo);
! 539: }
! 540:
! 541: /* Send MODE SENSE (6 byte) command. Returns 0 if ok, 1 if NOT READY,
! 542: * 2 if command not supported (then MODE SENSE(10) should be supported),
! 543: * 3 if field in command not supported or returns negated errno.
! 544: * SPC-3 sections 6.9 and 7.4 (rev 22a) [mode subpage==0] */
! 545: int scsiModeSense(scsi_device * device, int pagenum, int subpagenum, int pc,
! 546: UINT8 *pBuf, int bufLen)
! 547: {
! 548: struct scsi_cmnd_io io_hdr;
! 549: struct scsi_sense_disect sinfo;
! 550: UINT8 cdb[6];
! 551: UINT8 sense[32];
! 552: int status;
! 553:
! 554: if ((bufLen < 0) || (bufLen > 255))
! 555: return -EINVAL;
! 556: memset(&io_hdr, 0, sizeof(io_hdr));
! 557: memset(cdb, 0, sizeof(cdb));
! 558: io_hdr.dxfer_dir = DXFER_FROM_DEVICE;
! 559: io_hdr.dxfer_len = bufLen;
! 560: io_hdr.dxferp = pBuf;
! 561: cdb[0] = MODE_SENSE;
! 562: cdb[2] = (pc << 6) | (pagenum & 0x3f);
! 563: cdb[3] = subpagenum;
! 564: cdb[4] = bufLen;
! 565: io_hdr.cmnd = cdb;
! 566: io_hdr.cmnd_len = sizeof(cdb);
! 567: io_hdr.sensep = sense;
! 568: io_hdr.max_sense_len = sizeof(sense);
! 569: io_hdr.timeout = SCSI_TIMEOUT_DEFAULT;
! 570:
! 571: if (!device->scsi_pass_through(&io_hdr))
! 572: return -device->get_errno();
! 573: scsi_do_sense_disect(&io_hdr, &sinfo);
! 574: status = scsiSimpleSenseFilter(&sinfo);
! 575: if (SIMPLE_ERR_TRY_AGAIN == status) {
! 576: if (!device->scsi_pass_through(&io_hdr))
! 577: return -device->get_errno();
! 578: scsi_do_sense_disect(&io_hdr, &sinfo);
! 579: status = scsiSimpleSenseFilter(&sinfo);
! 580: }
! 581: if ((0 == status) && (ALL_MODE_PAGES != pagenum)) {
! 582: int offset;
! 583:
! 584: offset = scsiModePageOffset(pBuf, bufLen, 0);
! 585: if (offset < 0)
! 586: return SIMPLE_ERR_BAD_RESP;
! 587: else if (pagenum != (pBuf[offset] & 0x3f))
! 588: return SIMPLE_ERR_BAD_RESP;
! 589: }
! 590: return status;
! 591: }
! 592:
! 593: /* Sends a 6 byte MODE SELECT command. Assumes given pBuf is the response
! 594: * from a corresponding 6 byte MODE SENSE command. Such a response should
! 595: * have a 4 byte header followed by 0 or more 8 byte block descriptors
! 596: * (normally 1) and then 1 mode page. Returns 0 if ok, 1 if NOT READY,
! 597: * 2 if command not supported (then MODE SELECT(10) may be supported),
! 598: * 3 if field in command not supported, 4 if bad parameter to command
! 599: * or returns negated errno. SPC-3 sections 6.7 and 7.4 (rev 22a) */
! 600: int scsiModeSelect(scsi_device * device, int sp, UINT8 *pBuf, int bufLen)
! 601: {
! 602: struct scsi_cmnd_io io_hdr;
! 603: struct scsi_sense_disect sinfo;
! 604: UINT8 cdb[6];
! 605: UINT8 sense[32];
! 606: int pg_offset, pg_len, hdr_plus_1_pg;
! 607:
! 608: pg_offset = 4 + pBuf[3];
! 609: if (pg_offset + 2 >= bufLen)
! 610: return -EINVAL;
! 611: pg_len = pBuf[pg_offset + 1] + 2;
! 612: hdr_plus_1_pg = pg_offset + pg_len;
! 613: if (hdr_plus_1_pg > bufLen)
! 614: return -EINVAL;
! 615: pBuf[0] = 0; /* Length of returned mode sense data reserved for SELECT */
! 616: pBuf[pg_offset] &= 0x7f; /* Mask out PS bit from byte 0 of page data */
! 617: memset(&io_hdr, 0, sizeof(io_hdr));
! 618: memset(cdb, 0, sizeof(cdb));
! 619: io_hdr.dxfer_dir = DXFER_TO_DEVICE;
! 620: io_hdr.dxfer_len = hdr_plus_1_pg;
! 621: io_hdr.dxferp = pBuf;
! 622: cdb[0] = MODE_SELECT;
! 623: cdb[1] = 0x10 | (sp & 1); /* set PF (page format) bit always */
! 624: cdb[4] = hdr_plus_1_pg; /* make sure only one page sent */
! 625: io_hdr.cmnd = cdb;
! 626: io_hdr.cmnd_len = sizeof(cdb);
! 627: io_hdr.sensep = sense;
! 628: io_hdr.max_sense_len = sizeof(sense);
! 629: io_hdr.timeout = SCSI_TIMEOUT_DEFAULT;
! 630:
! 631: if (!device->scsi_pass_through(&io_hdr))
! 632: return -device->get_errno();
! 633: scsi_do_sense_disect(&io_hdr, &sinfo);
! 634: return scsiSimpleSenseFilter(&sinfo);
! 635: }
! 636:
! 637: /* MODE SENSE (10 byte). Returns 0 if ok, 1 if NOT READY, 2 if command
! 638: * not supported (then MODE SENSE(6) might be supported), 3 if field in
! 639: * command not supported or returns negated errno.
! 640: * SPC-3 sections 6.10 and 7.4 (rev 22a) [mode subpage==0] */
! 641: int scsiModeSense10(scsi_device * device, int pagenum, int subpagenum, int pc,
! 642: UINT8 *pBuf, int bufLen)
! 643: {
! 644: struct scsi_cmnd_io io_hdr;
! 645: struct scsi_sense_disect sinfo;
! 646: UINT8 cdb[10];
! 647: UINT8 sense[32];
! 648: int status;
! 649:
! 650: memset(&io_hdr, 0, sizeof(io_hdr));
! 651: memset(cdb, 0, sizeof(cdb));
! 652: io_hdr.dxfer_dir = DXFER_FROM_DEVICE;
! 653: io_hdr.dxfer_len = bufLen;
! 654: io_hdr.dxferp = pBuf;
! 655: cdb[0] = MODE_SENSE_10;
! 656: cdb[2] = (pc << 6) | (pagenum & 0x3f);
! 657: cdb[3] = subpagenum;
! 658: cdb[7] = (bufLen >> 8) & 0xff;
! 659: cdb[8] = bufLen & 0xff;
! 660: io_hdr.cmnd = cdb;
! 661: io_hdr.cmnd_len = sizeof(cdb);
! 662: io_hdr.sensep = sense;
! 663: io_hdr.max_sense_len = sizeof(sense);
! 664: io_hdr.timeout = SCSI_TIMEOUT_DEFAULT;
! 665:
! 666: if (!device->scsi_pass_through(&io_hdr))
! 667: return -device->get_errno();
! 668: scsi_do_sense_disect(&io_hdr, &sinfo);
! 669: status = scsiSimpleSenseFilter(&sinfo);
! 670: if (SIMPLE_ERR_TRY_AGAIN == status) {
! 671: if (!device->scsi_pass_through(&io_hdr))
! 672: return -device->get_errno();
! 673: scsi_do_sense_disect(&io_hdr, &sinfo);
! 674: status = scsiSimpleSenseFilter(&sinfo);
! 675: }
! 676: if ((0 == status) && (ALL_MODE_PAGES != pagenum)) {
! 677: int offset;
! 678:
! 679: offset = scsiModePageOffset(pBuf, bufLen, 1);
! 680: if (offset < 0)
! 681: return SIMPLE_ERR_BAD_RESP;
! 682: else if (pagenum != (pBuf[offset] & 0x3f))
! 683: return SIMPLE_ERR_BAD_RESP;
! 684: }
! 685: return status;
! 686: }
! 687:
! 688: /* Sends a 10 byte MODE SELECT command. Assumes given pBuf is the response
! 689: * from a corresponding 10 byte MODE SENSE command. Such a response should
! 690: * have a 8 byte header followed by 0 or more 8 byte block descriptors
! 691: * (normally 1) and then 1 mode page. Returns 0 if ok, 1 NOT REAFY, 2 if
! 692: * command not supported (then MODE SELECT(6) may be supported), 3 if field
! 693: * in command not supported, 4 if bad parameter to command or returns
! 694: * negated errno. SPC-3 sections 6.8 and 7.4 (rev 22a) */
! 695: int scsiModeSelect10(scsi_device * device, int sp, UINT8 *pBuf, int bufLen)
! 696: {
! 697: struct scsi_cmnd_io io_hdr;
! 698: struct scsi_sense_disect sinfo;
! 699: UINT8 cdb[10];
! 700: UINT8 sense[32];
! 701: int pg_offset, pg_len, hdr_plus_1_pg;
! 702:
! 703: pg_offset = 8 + (pBuf[6] << 8) + pBuf[7];
! 704: if (pg_offset + 2 >= bufLen)
! 705: return -EINVAL;
! 706: pg_len = pBuf[pg_offset + 1] + 2;
! 707: hdr_plus_1_pg = pg_offset + pg_len;
! 708: if (hdr_plus_1_pg > bufLen)
! 709: return -EINVAL;
! 710: pBuf[0] = 0;
! 711: pBuf[1] = 0; /* Length of returned mode sense data reserved for SELECT */
! 712: pBuf[pg_offset] &= 0x7f; /* Mask out PS bit from byte 0 of page data */
! 713: memset(&io_hdr, 0, sizeof(io_hdr));
! 714: memset(cdb, 0, sizeof(cdb));
! 715: io_hdr.dxfer_dir = DXFER_TO_DEVICE;
! 716: io_hdr.dxfer_len = hdr_plus_1_pg;
! 717: io_hdr.dxferp = pBuf;
! 718: cdb[0] = MODE_SELECT_10;
! 719: cdb[1] = 0x10 | (sp & 1); /* set PF (page format) bit always */
! 720: cdb[8] = hdr_plus_1_pg; /* make sure only one page sent */
! 721: io_hdr.cmnd = cdb;
! 722: io_hdr.cmnd_len = sizeof(cdb);
! 723: io_hdr.sensep = sense;
! 724: io_hdr.max_sense_len = sizeof(sense);
! 725: io_hdr.timeout = SCSI_TIMEOUT_DEFAULT;
! 726:
! 727: if (!device->scsi_pass_through(&io_hdr))
! 728: return -device->get_errno();
! 729: scsi_do_sense_disect(&io_hdr, &sinfo);
! 730: return scsiSimpleSenseFilter(&sinfo);
! 731: }
! 732:
! 733: /* Standard INQUIRY returns 0 for ok, anything else is a major problem.
! 734: * bufLen should be 36 for unsafe devices (like USB mass storage stuff)
! 735: * otherwise they can lock up! SPC-3 sections 6.4 and 7.6 (rev 22a) */
! 736: int scsiStdInquiry(scsi_device * device, UINT8 *pBuf, int bufLen)
! 737: {
! 738: struct scsi_sense_disect sinfo;
! 739: struct scsi_cmnd_io io_hdr;
! 740: UINT8 cdb[6];
! 741: UINT8 sense[32];
! 742:
! 743: if ((bufLen < 0) || (bufLen > 255))
! 744: return -EINVAL;
! 745: memset(&io_hdr, 0, sizeof(io_hdr));
! 746: memset(cdb, 0, sizeof(cdb));
! 747: io_hdr.dxfer_dir = DXFER_FROM_DEVICE;
! 748: io_hdr.dxfer_len = bufLen;
! 749: io_hdr.dxferp = pBuf;
! 750: cdb[0] = INQUIRY;
! 751: cdb[4] = bufLen;
! 752: io_hdr.cmnd = cdb;
! 753: io_hdr.cmnd_len = sizeof(cdb);
! 754: io_hdr.sensep = sense;
! 755: io_hdr.max_sense_len = sizeof(sense);
! 756: io_hdr.timeout = SCSI_TIMEOUT_DEFAULT;
! 757:
! 758: if (!device->scsi_pass_through(&io_hdr))
! 759: return -device->get_errno();
! 760: scsi_do_sense_disect(&io_hdr, &sinfo);
! 761: return scsiSimpleSenseFilter(&sinfo);
! 762: }
! 763:
! 764: /* INQUIRY to fetch Vital Page Data. Returns 0 if ok, 1 if NOT READY
! 765: * (unlikely), 2 if command not supported, 3 if field in command not
! 766: * supported, 5 if response indicates that EVPD bit ignored or returns
! 767: * negated errno. SPC-3 section 6.4 and 7.6 (rev 22a) */
! 768: int scsiInquiryVpd(scsi_device * device, int vpd_page, UINT8 *pBuf, int bufLen)
! 769: {
! 770: struct scsi_cmnd_io io_hdr;
! 771: struct scsi_sense_disect sinfo;
! 772: UINT8 cdb[6];
! 773: UINT8 sense[32];
! 774: int res;
! 775:
! 776: if ((bufLen < 0) || (bufLen > 255))
! 777: return -EINVAL;
! 778: memset(&io_hdr, 0, sizeof(io_hdr));
! 779: memset(cdb, 0, sizeof(cdb));
! 780: if (bufLen > 1)
! 781: pBuf[1] = 0x0;
! 782: io_hdr.dxfer_dir = DXFER_FROM_DEVICE;
! 783: io_hdr.dxfer_len = bufLen;
! 784: io_hdr.dxferp = pBuf;
! 785: cdb[0] = INQUIRY;
! 786: cdb[1] = 0x1; /* set EVPD bit (enable Vital Product Data) */
! 787: cdb[2] = vpd_page;
! 788: cdb[4] = bufLen;
! 789: io_hdr.cmnd = cdb;
! 790: io_hdr.cmnd_len = sizeof(cdb);
! 791: io_hdr.sensep = sense;
! 792: io_hdr.max_sense_len = sizeof(sense);
! 793: io_hdr.timeout = SCSI_TIMEOUT_DEFAULT;
! 794:
! 795: if (!device->scsi_pass_through(&io_hdr))
! 796: return -device->get_errno();
! 797: scsi_do_sense_disect(&io_hdr, &sinfo);
! 798: if ((res = scsiSimpleSenseFilter(&sinfo)))
! 799: return res;
! 800: /* Guard against devices that ignore EVPD bit and do standard INQUIRY */
! 801: if (bufLen > 1) {
! 802: if (vpd_page == pBuf[1]) {
! 803: if ((0x80 == vpd_page) && (bufLen > 2) && (0x0 != pBuf[2]))
! 804: return SIMPLE_ERR_BAD_RESP;
! 805: } else
! 806: return SIMPLE_ERR_BAD_RESP;
! 807: }
! 808: return 0;
! 809: }
! 810:
! 811: /* REQUEST SENSE command. Returns 0 if ok, anything else major problem.
! 812: * SPC-3 section 6.27 (rev 22a) */
! 813: int scsiRequestSense(scsi_device * device, struct scsi_sense_disect * sense_info)
! 814: {
! 815: struct scsi_cmnd_io io_hdr;
! 816: UINT8 cdb[6];
! 817: UINT8 sense[32];
! 818: UINT8 buff[18];
! 819: int len;
! 820: UINT8 ecode;
! 821:
! 822: memset(&io_hdr, 0, sizeof(io_hdr));
! 823: memset(cdb, 0, sizeof(cdb));
! 824: io_hdr.dxfer_dir = DXFER_FROM_DEVICE;
! 825: io_hdr.dxfer_len = sizeof(buff);
! 826: io_hdr.dxferp = buff;
! 827: cdb[0] = REQUEST_SENSE;
! 828: cdb[4] = sizeof(buff);
! 829: io_hdr.cmnd = cdb;
! 830: io_hdr.cmnd_len = sizeof(cdb);
! 831: io_hdr.sensep = sense;
! 832: io_hdr.max_sense_len = sizeof(sense);
! 833: io_hdr.timeout = SCSI_TIMEOUT_DEFAULT;
! 834:
! 835: if (!device->scsi_pass_through(&io_hdr))
! 836: return -device->get_errno();
! 837: if (sense_info) {
! 838: ecode = buff[0] & 0x7f;
! 839: sense_info->error_code = ecode;
! 840: sense_info->sense_key = buff[2] & 0xf;
! 841: sense_info->asc = 0;
! 842: sense_info->ascq = 0;
! 843: if ((0x70 == ecode) || (0x71 == ecode)) {
! 844: len = buff[7] + 8;
! 845: if (len > 13) {
! 846: sense_info->asc = buff[12];
! 847: sense_info->ascq = buff[13];
! 848: }
! 849: }
! 850: }
! 851: return 0;
! 852: }
! 853:
! 854: /* SEND DIAGNOSTIC command. Returns 0 if ok, 1 if NOT READY, 2 if command
! 855: * not supported, 3 if field in command not supported or returns negated
! 856: * errno. SPC-3 section 6.28 (rev 22a) */
! 857: int scsiSendDiagnostic(scsi_device * device, int functioncode, UINT8 *pBuf, int bufLen)
! 858: {
! 859: struct scsi_cmnd_io io_hdr;
! 860: struct scsi_sense_disect sinfo;
! 861: UINT8 cdb[6];
! 862: UINT8 sense[32];
! 863:
! 864: memset(&io_hdr, 0, sizeof(io_hdr));
! 865: memset(cdb, 0, sizeof(cdb));
! 866: io_hdr.dxfer_dir = bufLen ? DXFER_TO_DEVICE: DXFER_NONE;
! 867: io_hdr.dxfer_len = bufLen;
! 868: io_hdr.dxferp = pBuf;
! 869: cdb[0] = SEND_DIAGNOSTIC;
! 870: if (SCSI_DIAG_DEF_SELF_TEST == functioncode)
! 871: cdb[1] = 0x4; /* SelfTest bit */
! 872: else if (SCSI_DIAG_NO_SELF_TEST != functioncode)
! 873: cdb[1] = (functioncode & 0x7) << 5; /* SelfTest _code_ */
! 874: else /* SCSI_DIAG_NO_SELF_TEST == functioncode */
! 875: cdb[1] = 0x10; /* PF bit */
! 876: cdb[3] = (bufLen >> 8) & 0xff;
! 877: cdb[4] = bufLen & 0xff;
! 878: io_hdr.cmnd = cdb;
! 879: io_hdr.cmnd_len = sizeof(cdb);
! 880: io_hdr.sensep = sense;
! 881: io_hdr.max_sense_len = sizeof(sense);
! 882: /* worst case is an extended foreground self test on a big disk */
! 883: io_hdr.timeout = SCSI_TIMEOUT_SELF_TEST;
! 884:
! 885: if (!device->scsi_pass_through(&io_hdr))
! 886: return -device->get_errno();
! 887: scsi_do_sense_disect(&io_hdr, &sinfo);
! 888: return scsiSimpleSenseFilter(&sinfo);
! 889: }
! 890:
! 891: /* RECEIVE DIAGNOSTIC command. Returns 0 if ok, 1 if NOT READY, 2 if
! 892: * command not supported, 3 if field in command not supported or returns
! 893: * negated errno. SPC-3 section 6.18 (rev 22a) */
! 894: int scsiReceiveDiagnostic(scsi_device * device, int pcv, int pagenum, UINT8 *pBuf,
! 895: int bufLen)
! 896: {
! 897: struct scsi_cmnd_io io_hdr;
! 898: struct scsi_sense_disect sinfo;
! 899: UINT8 cdb[6];
! 900: UINT8 sense[32];
! 901:
! 902: memset(&io_hdr, 0, sizeof(io_hdr));
! 903: memset(cdb, 0, sizeof(cdb));
! 904: io_hdr.dxfer_dir = DXFER_FROM_DEVICE;
! 905: io_hdr.dxfer_len = bufLen;
! 906: io_hdr.dxferp = pBuf;
! 907: cdb[0] = RECEIVE_DIAGNOSTIC;
! 908: cdb[1] = pcv;
! 909: cdb[2] = pagenum;
! 910: cdb[3] = (bufLen >> 8) & 0xff;
! 911: cdb[4] = bufLen & 0xff;
! 912: io_hdr.cmnd = cdb;
! 913: io_hdr.cmnd_len = sizeof(cdb);
! 914: io_hdr.sensep = sense;
! 915: io_hdr.max_sense_len = sizeof(sense);
! 916: io_hdr.timeout = SCSI_TIMEOUT_DEFAULT;
! 917:
! 918: if (!device->scsi_pass_through(&io_hdr))
! 919: return -device->get_errno();
! 920: scsi_do_sense_disect(&io_hdr, &sinfo);
! 921: return scsiSimpleSenseFilter(&sinfo);
! 922: }
! 923:
! 924: /* TEST UNIT READY command. SPC-3 section 6.33 (rev 22a) */
! 925: static int _testunitready(scsi_device * device, struct scsi_sense_disect * sinfo)
! 926: {
! 927: struct scsi_cmnd_io io_hdr;
! 928: UINT8 cdb[6];
! 929: UINT8 sense[32];
! 930:
! 931: memset(&io_hdr, 0, sizeof(io_hdr));
! 932: memset(cdb, 0, sizeof(cdb));
! 933: io_hdr.dxfer_dir = DXFER_NONE;
! 934: io_hdr.dxfer_len = 0;
! 935: io_hdr.dxferp = NULL;
! 936: cdb[0] = TEST_UNIT_READY;
! 937: io_hdr.cmnd = cdb;
! 938: io_hdr.cmnd_len = sizeof(cdb);
! 939: io_hdr.sensep = sense;
! 940: io_hdr.max_sense_len = sizeof(sense);
! 941: io_hdr.timeout = SCSI_TIMEOUT_DEFAULT;
! 942:
! 943: if (!device->scsi_pass_through(&io_hdr))
! 944: return -device->get_errno();
! 945: scsi_do_sense_disect(&io_hdr, sinfo);
! 946: return 0;
! 947: }
! 948:
! 949: /* Returns 0 for device responds and media ready, 1 for device responds and
! 950: media not ready, or returns a negated errno value */
! 951: int scsiTestUnitReady(scsi_device * device)
! 952: {
! 953: struct scsi_sense_disect sinfo;
! 954: int status;
! 955:
! 956: status = _testunitready(device, &sinfo);
! 957: if (0 != status)
! 958: return status;
! 959: status = scsiSimpleSenseFilter(&sinfo);
! 960: if (SIMPLE_ERR_TRY_AGAIN == status) {
! 961: /* power on reset, media changed, ok ... try again */
! 962: status = _testunitready(device, &sinfo);
! 963: if (0 != status)
! 964: return status;
! 965: status = scsiSimpleSenseFilter(&sinfo);
! 966: }
! 967: return status;
! 968: }
! 969:
! 970: /* READ DEFECT (10) command. Returns 0 if ok, 1 if NOT READY, 2 if
! 971: * command not supported, 3 if field in command not supported or returns
! 972: * negated errno. SBC-2 section 5.12 (rev 16) */
! 973: int scsiReadDefect10(scsi_device * device, int req_plist, int req_glist, int dl_format,
! 974: UINT8 *pBuf, int bufLen)
! 975: {
! 976: struct scsi_cmnd_io io_hdr;
! 977: struct scsi_sense_disect sinfo;
! 978: UINT8 cdb[10];
! 979: UINT8 sense[32];
! 980:
! 981: memset(&io_hdr, 0, sizeof(io_hdr));
! 982: memset(cdb, 0, sizeof(cdb));
! 983: io_hdr.dxfer_dir = DXFER_FROM_DEVICE;
! 984: io_hdr.dxfer_len = bufLen;
! 985: io_hdr.dxferp = pBuf;
! 986: cdb[0] = READ_DEFECT_10;
! 987: cdb[2] = (unsigned char)(((req_plist << 4) & 0x10) |
! 988: ((req_glist << 3) & 0x8) | (dl_format & 0x7));
! 989: cdb[7] = (bufLen >> 8) & 0xff;
! 990: cdb[8] = bufLen & 0xff;
! 991: io_hdr.cmnd = cdb;
! 992: io_hdr.cmnd_len = sizeof(cdb);
! 993: io_hdr.sensep = sense;
! 994: io_hdr.max_sense_len = sizeof(sense);
! 995: io_hdr.timeout = SCSI_TIMEOUT_DEFAULT;
! 996:
! 997: if (!device->scsi_pass_through(&io_hdr))
! 998: return -device->get_errno();
! 999: scsi_do_sense_disect(&io_hdr, &sinfo);
! 1000: return scsiSimpleSenseFilter(&sinfo);
! 1001: }
! 1002:
! 1003: /* READ CAPACITY (10) command. Returns 0 if ok, 1 if NOT READY, 2 if
! 1004: * command not supported, 3 if field in command not supported or returns
! 1005: * negated errno. SBC-3 section 5.15 (rev 26) */
! 1006: int scsiReadCapacity10(scsi_device * device, unsigned int * last_lbap,
! 1007: unsigned int * lb_sizep)
! 1008: {
! 1009: int res;
! 1010: struct scsi_cmnd_io io_hdr;
! 1011: struct scsi_sense_disect sinfo;
! 1012: UINT8 cdb[10];
! 1013: UINT8 sense[32];
! 1014: UINT8 resp[8];
! 1015:
! 1016: memset(&io_hdr, 0, sizeof(io_hdr));
! 1017: memset(cdb, 0, sizeof(cdb));
! 1018: memset(resp, 0, sizeof(resp));
! 1019: io_hdr.dxfer_dir = DXFER_FROM_DEVICE;
! 1020: io_hdr.dxfer_len = sizeof(resp);
! 1021: io_hdr.dxferp = resp;
! 1022: cdb[0] = READ_CAPACITY_10;
! 1023: io_hdr.cmnd = cdb;
! 1024: io_hdr.cmnd_len = sizeof(cdb);
! 1025: io_hdr.sensep = sense;
! 1026: io_hdr.max_sense_len = sizeof(sense);
! 1027: io_hdr.timeout = SCSI_TIMEOUT_DEFAULT;
! 1028:
! 1029: if (!device->scsi_pass_through(&io_hdr))
! 1030: return -device->get_errno();
! 1031: scsi_do_sense_disect(&io_hdr, &sinfo);
! 1032: res = scsiSimpleSenseFilter(&sinfo);
! 1033: if (res)
! 1034: return res;
! 1035: if (last_lbap)
! 1036: *last_lbap = (resp[0] << 24) | (resp[1] << 16) | (resp[2] << 8) |
! 1037: resp[3];
! 1038: if (lb_sizep)
! 1039: *lb_sizep = (resp[4] << 24) | (resp[5] << 16) | (resp[6] << 8) |
! 1040: resp[7];
! 1041: return 0;
! 1042: }
! 1043:
! 1044: /* READ CAPACITY (16) command. The bufLen argument should be 32. Returns 0
! 1045: * if ok, 1 if NOT READY, 2 if command not supported, 3 if field in command
! 1046: * not supported or returns negated errno. SBC-3 section 5.16 (rev 26) */
! 1047: int scsiReadCapacity16(scsi_device * device, UINT8 *pBuf, int bufLen)
! 1048: {
! 1049: struct scsi_cmnd_io io_hdr;
! 1050: struct scsi_sense_disect sinfo;
! 1051: UINT8 cdb[16];
! 1052: UINT8 sense[32];
! 1053:
! 1054: memset(&io_hdr, 0, sizeof(io_hdr));
! 1055: memset(cdb, 0, sizeof(cdb));
! 1056: io_hdr.dxfer_dir = DXFER_FROM_DEVICE;
! 1057: io_hdr.dxfer_len = bufLen;
! 1058: io_hdr.dxferp = pBuf;
! 1059: cdb[0] = READ_CAPACITY_16;
! 1060: cdb[1] = SAI_READ_CAPACITY_16;
! 1061: cdb[10] = (bufLen >> 24) & 0xff;
! 1062: cdb[11] = (bufLen >> 16) & 0xff;
! 1063: cdb[12] = (bufLen >> 8) & 0xff;
! 1064: cdb[13] = bufLen & 0xff;
! 1065: io_hdr.cmnd = cdb;
! 1066: io_hdr.cmnd_len = sizeof(cdb);
! 1067: io_hdr.sensep = sense;
! 1068: io_hdr.max_sense_len = sizeof(sense);
! 1069: io_hdr.timeout = SCSI_TIMEOUT_DEFAULT;
! 1070:
! 1071: if (!device->scsi_pass_through(&io_hdr))
! 1072: return -device->get_errno();
! 1073: scsi_do_sense_disect(&io_hdr, &sinfo);
! 1074: return scsiSimpleSenseFilter(&sinfo);
! 1075: }
! 1076:
! 1077: /* Return number of bytes of storage in 'device' or 0 if error. If
! 1078: * successful and lb_sizep is not NULL then the logical block size
! 1079: * in bytes is written to the location pointed to by lb_sizep. */
! 1080: uint64_t scsiGetSize(scsi_device * device, unsigned int * lb_sizep)
! 1081: {
! 1082: unsigned int last_lba, lb_size;
! 1083: int k, res;
! 1084: uint64_t ret_val = 0;
! 1085: UINT8 rc16resp[32];
! 1086:
! 1087: res = scsiReadCapacity10(device, &last_lba, &lb_size);
! 1088: if (res) {
! 1089: if (scsi_debugmode)
! 1090: pout("scsiGetSize: READ CAPACITY(10) failed, res=%d\n", res);
! 1091: return ret_val;
! 1092: }
! 1093: if (0xffffffff == last_lba) {
! 1094: res = scsiReadCapacity16(device, rc16resp, sizeof(rc16resp));
! 1095: if (res) {
! 1096: if (scsi_debugmode)
! 1097: pout("scsiGetSize: READ CAPACITY(16) failed, res=%d\n", res);
! 1098: return ret_val;
! 1099: }
! 1100: for (k = 0; k < 8; ++k) {
! 1101: if (k > 0)
! 1102: ret_val <<= 8;
! 1103: ret_val |= rc16resp[k + 0];
! 1104: }
! 1105: } else
! 1106: ret_val = last_lba;
! 1107: if (lb_sizep)
! 1108: *lb_sizep = lb_size;
! 1109: ++ret_val; /* last_lba is origin 0 so need to bump to get number of */
! 1110: return ret_val * lb_size;
! 1111: }
! 1112:
! 1113:
! 1114: /* Offset into mode sense (6 or 10 byte) response that actual mode page
! 1115: * starts at (relative to resp[0]). Returns -1 if problem */
! 1116: int scsiModePageOffset(const UINT8 * resp, int len, int modese_len)
! 1117: {
! 1118: int resp_len, bd_len;
! 1119: int offset = -1;
! 1120:
! 1121: if (resp) {
! 1122: if (10 == modese_len) {
! 1123: resp_len = (resp[0] << 8) + resp[1] + 2;
! 1124: bd_len = (resp[6] << 8) + resp[7];
! 1125: offset = bd_len + 8;
! 1126: } else {
! 1127: resp_len = resp[0] + 1;
! 1128: bd_len = resp[3];
! 1129: offset = bd_len + 4;
! 1130: }
! 1131: if ((offset + 2) > len) {
! 1132: pout("scsiModePageOffset: raw_curr too small, offset=%d "
! 1133: "resp_len=%d bd_len=%d\n", offset, resp_len, bd_len);
! 1134: offset = -1;
! 1135: } else if ((offset + 2) > resp_len) {
! 1136: if ((resp_len > 2) || scsi_debugmode)
! 1137: pout("scsiModePageOffset: response length too short, "
! 1138: "resp_len=%d offset=%d bd_len=%d\n", resp_len,
! 1139: offset, bd_len);
! 1140: offset = -1;
! 1141: }
! 1142: }
! 1143: return offset;
! 1144: }
! 1145:
! 1146: /* IEC mode page byte 2 bit masks */
! 1147: #define DEXCPT_ENABLE 0x08
! 1148: #define EWASC_ENABLE 0x10
! 1149: #define DEXCPT_DISABLE 0xf7
! 1150: #define EWASC_DISABLE 0xef
! 1151: #define TEST_DISABLE 0xfb
! 1152:
! 1153: /* Fetches the Informational Exceptions Control mode page. First tries
! 1154: * the 6 byte MODE SENSE command and if that fails with an illegal opcode
! 1155: * tries a 10 byte MODE SENSE command. Returns 0 if successful, a positive
! 1156: * number if a known error (see SIMPLE_ERR_ ...) or a negative errno
! 1157: * value. */
! 1158: int scsiFetchIECmpage(scsi_device * device, struct scsi_iec_mode_page *iecp, int modese_len)
! 1159: {
! 1160: int err = 0;
! 1161:
! 1162: memset(iecp, 0, sizeof(*iecp));
! 1163: iecp->modese_len = modese_len;
! 1164: iecp->requestedCurrent = 1;
! 1165: if (iecp->modese_len <= 6) {
! 1166: if ((err = scsiModeSense(device, INFORMATIONAL_EXCEPTIONS_CONTROL_PAGE,
! 1167: 0, MPAGE_CONTROL_CURRENT,
! 1168: iecp->raw_curr, sizeof(iecp->raw_curr)))) {
! 1169: if (SIMPLE_ERR_BAD_OPCODE == err)
! 1170: iecp->modese_len = 10;
! 1171: else {
! 1172: iecp->modese_len = 0;
! 1173: return err;
! 1174: }
! 1175: } else if (0 == iecp->modese_len)
! 1176: iecp->modese_len = 6;
! 1177: }
! 1178: if (10 == iecp->modese_len) {
! 1179: err = scsiModeSense10(device, INFORMATIONAL_EXCEPTIONS_CONTROL_PAGE,
! 1180: 0, MPAGE_CONTROL_CURRENT,
! 1181: iecp->raw_curr, sizeof(iecp->raw_curr));
! 1182: if (err) {
! 1183: iecp->modese_len = 0;
! 1184: return err;
! 1185: }
! 1186: }
! 1187: iecp->gotCurrent = 1;
! 1188: iecp->requestedChangeable = 1;
! 1189: if (10 == iecp->modese_len)
! 1190: err = scsiModeSense10(device, INFORMATIONAL_EXCEPTIONS_CONTROL_PAGE,
! 1191: 0, MPAGE_CONTROL_CHANGEABLE,
! 1192: iecp->raw_chg, sizeof(iecp->raw_chg));
! 1193: else if (6 == iecp->modese_len)
! 1194: err = scsiModeSense(device, INFORMATIONAL_EXCEPTIONS_CONTROL_PAGE,
! 1195: 0, MPAGE_CONTROL_CHANGEABLE,
! 1196: iecp->raw_chg, sizeof(iecp->raw_chg));
! 1197: if (err)
! 1198: return err;
! 1199: iecp->gotChangeable = 1;
! 1200: return 0;
! 1201: }
! 1202:
! 1203: int scsi_IsExceptionControlEnabled(const struct scsi_iec_mode_page *iecp)
! 1204: {
! 1205: int offset;
! 1206:
! 1207: if (iecp && iecp->gotCurrent) {
! 1208: offset = scsiModePageOffset(iecp->raw_curr, sizeof(iecp->raw_curr),
! 1209: iecp->modese_len);
! 1210: if (offset >= 0)
! 1211: return (iecp->raw_curr[offset + 2] & DEXCPT_ENABLE) ? 0 : 1;
! 1212: else
! 1213: return 0;
! 1214: } else
! 1215: return 0;
! 1216: }
! 1217:
! 1218: int scsi_IsWarningEnabled(const struct scsi_iec_mode_page *iecp)
! 1219: {
! 1220: int offset;
! 1221:
! 1222: if (iecp && iecp->gotCurrent) {
! 1223: offset = scsiModePageOffset(iecp->raw_curr, sizeof(iecp->raw_curr),
! 1224: iecp->modese_len);
! 1225: if (offset >= 0)
! 1226: return (iecp->raw_curr[offset + 2] & EWASC_ENABLE) ? 1 : 0;
! 1227: else
! 1228: return 0;
! 1229: } else
! 1230: return 0;
! 1231: }
! 1232:
! 1233: /* set EWASC and clear PERF, EBF, DEXCPT TEST and LOGERR */
! 1234: #define SCSI_IEC_MP_BYTE2_ENABLED 0x10
! 1235: #define SCSI_IEC_MP_BYTE2_TEST_MASK 0x4
! 1236: /* exception/warning via an unrequested REQUEST SENSE command */
! 1237: #define SCSI_IEC_MP_MRIE 6
! 1238: #define SCSI_IEC_MP_INTERVAL_T 0
! 1239: #define SCSI_IEC_MP_REPORT_COUNT 1
! 1240:
! 1241: /* Try to set (or clear) both Exception Control and Warning in the IE
! 1242: * mode page subject to the "changeable" mask. The object pointed to
! 1243: * by iecp is (possibly) inaccurate after this call, therefore
! 1244: * scsiFetchIECmpage() should be called again if the IEC mode page
! 1245: * is to be re-examined.
! 1246: * When -r ioctl is invoked 3 or more time on 'smartctl -s on ...'
! 1247: * then set the TEST bit (causes asc,ascq pair of 0x5d,0xff). */
! 1248: int scsiSetExceptionControlAndWarning(scsi_device * device, int enabled,
! 1249: const struct scsi_iec_mode_page *iecp)
! 1250: {
! 1251: int k, offset, resp_len;
! 1252: int err = 0;
! 1253: UINT8 rout[SCSI_IECMP_RAW_LEN];
! 1254: int sp, eCEnabled, wEnabled;
! 1255:
! 1256: if ((! iecp) || (! iecp->gotCurrent))
! 1257: return -EINVAL;
! 1258: offset = scsiModePageOffset(iecp->raw_curr, sizeof(iecp->raw_curr),
! 1259: iecp->modese_len);
! 1260: if (offset < 0)
! 1261: return -EINVAL;
! 1262: memcpy(rout, iecp->raw_curr, SCSI_IECMP_RAW_LEN);
! 1263: if (10 == iecp->modese_len) {
! 1264: resp_len = (rout[0] << 8) + rout[1] + 2;
! 1265: rout[3] &= 0xef; /* for disks mask out DPOFUA bit */
! 1266: } else {
! 1267: resp_len = rout[0] + 1;
! 1268: rout[2] &= 0xef; /* for disks mask out DPOFUA bit */
! 1269: }
! 1270: sp = (rout[offset] & 0x80) ? 1 : 0; /* PS bit becomes 'SELECT's SP bit */
! 1271: if (enabled) {
! 1272: rout[offset + 2] = SCSI_IEC_MP_BYTE2_ENABLED;
! 1273: if (scsi_debugmode > 2)
! 1274: rout[offset + 2] |= SCSI_IEC_MP_BYTE2_TEST_MASK;
! 1275: rout[offset + 3] = SCSI_IEC_MP_MRIE;
! 1276: rout[offset + 4] = (SCSI_IEC_MP_INTERVAL_T >> 24) & 0xff;
! 1277: rout[offset + 5] = (SCSI_IEC_MP_INTERVAL_T >> 16) & 0xff;
! 1278: rout[offset + 6] = (SCSI_IEC_MP_INTERVAL_T >> 8) & 0xff;
! 1279: rout[offset + 7] = SCSI_IEC_MP_INTERVAL_T & 0xff;
! 1280: rout[offset + 8] = (SCSI_IEC_MP_REPORT_COUNT >> 24) & 0xff;
! 1281: rout[offset + 9] = (SCSI_IEC_MP_REPORT_COUNT >> 16) & 0xff;
! 1282: rout[offset + 10] = (SCSI_IEC_MP_REPORT_COUNT >> 8) & 0xff;
! 1283: rout[offset + 11] = SCSI_IEC_MP_REPORT_COUNT & 0xff;
! 1284: if (iecp->gotChangeable) {
! 1285: UINT8 chg2 = iecp->raw_chg[offset + 2];
! 1286:
! 1287: rout[offset + 2] = chg2 ? (rout[offset + 2] & chg2) :
! 1288: iecp->raw_curr[offset + 2];
! 1289: for (k = 3; k < 12; ++k) {
! 1290: if (0 == iecp->raw_chg[offset + k])
! 1291: rout[offset + k] = iecp->raw_curr[offset + k];
! 1292: }
! 1293: }
! 1294: if (0 == memcmp(&rout[offset + 2], &iecp->raw_chg[offset + 2], 10)) {
! 1295: if (scsi_debugmode > 0)
! 1296: pout("scsiSetExceptionControlAndWarning: already enabled\n");
! 1297: return 0;
! 1298: }
! 1299: } else { /* disabling Exception Control and (temperature) Warnings */
! 1300: eCEnabled = (rout[offset + 2] & DEXCPT_ENABLE) ? 0 : 1;
! 1301: wEnabled = (rout[offset + 2] & EWASC_ENABLE) ? 1 : 0;
! 1302: if ((! eCEnabled) && (! wEnabled)) {
! 1303: if (scsi_debugmode > 0)
! 1304: pout("scsiSetExceptionControlAndWarning: already disabled\n");
! 1305: return 0; /* nothing to do, leave other setting alone */
! 1306: }
! 1307: if (wEnabled)
! 1308: rout[offset + 2] &= EWASC_DISABLE;
! 1309: if (eCEnabled) {
! 1310: if (iecp->gotChangeable &&
! 1311: (iecp->raw_chg[offset + 2] & DEXCPT_ENABLE))
! 1312: rout[offset + 2] |= DEXCPT_ENABLE;
! 1313: rout[offset + 2] &= TEST_DISABLE;/* clear TEST bit for spec */
! 1314: }
! 1315: }
! 1316: if (10 == iecp->modese_len)
! 1317: err = scsiModeSelect10(device, sp, rout, resp_len);
! 1318: else if (6 == iecp->modese_len)
! 1319: err = scsiModeSelect(device, sp, rout, resp_len);
! 1320: return err;
! 1321: }
! 1322:
! 1323: int scsiGetTemp(scsi_device * device, UINT8 *currenttemp, UINT8 *triptemp)
! 1324: {
! 1325: UINT8 tBuf[252];
! 1326: int err;
! 1327:
! 1328: memset(tBuf, 0, sizeof(tBuf));
! 1329: if ((err = scsiLogSense(device, TEMPERATURE_LPAGE, 0, tBuf,
! 1330: sizeof(tBuf), 0))) {
! 1331: *currenttemp = 0;
! 1332: *triptemp = 0;
! 1333: pout("Log Sense for temperature failed [%s]\n", scsiErrString(err));
! 1334: return err;
! 1335: }
! 1336: *currenttemp = tBuf[9];
! 1337: *triptemp = tBuf[15];
! 1338: return 0;
! 1339: }
! 1340:
! 1341: /* Read informational exception log page or Request Sense response.
! 1342: * Fetching asc/ascq code potentially flagging an exception or warning.
! 1343: * Returns 0 if ok, else error number. A current temperature of 255
! 1344: * (Celsius) implies that the temperature not available. */
! 1345: int scsiCheckIE(scsi_device * device, int hasIELogPage, int hasTempLogPage,
! 1346: UINT8 *asc, UINT8 *ascq, UINT8 *currenttemp,
! 1347: UINT8 *triptemp)
! 1348: {
! 1349: UINT8 tBuf[252];
! 1350: struct scsi_sense_disect sense_info;
! 1351: int err;
! 1352: int temperatureSet = 0;
! 1353: unsigned short pagesize;
! 1354: UINT8 currTemp, trTemp;
! 1355:
! 1356: *asc = 0;
! 1357: *ascq = 0;
! 1358: *currenttemp = 0;
! 1359: *triptemp = 0;
! 1360: memset(tBuf,0,sizeof(tBuf)); // need to clear stack space of junk
! 1361: memset(&sense_info, 0, sizeof(sense_info));
! 1362: if (hasIELogPage) {
! 1363: if ((err = scsiLogSense(device, IE_LPAGE, 0, tBuf,
! 1364: sizeof(tBuf), 0))) {
! 1365: pout("Log Sense failed, IE page [%s]\n", scsiErrString(err));
! 1366: return err;
! 1367: }
! 1368: // pull out page size from response, don't forget to add 4
! 1369: pagesize = (unsigned short) ((tBuf[2] << 8) | tBuf[3]) + 4;
! 1370: if ((pagesize < 4) || tBuf[4] || tBuf[5]) {
! 1371: pout("Log Sense failed, IE page, bad parameter code or length\n");
! 1372: return SIMPLE_ERR_BAD_PARAM;
! 1373: }
! 1374: if (tBuf[7] > 1) {
! 1375: sense_info.asc = tBuf[8];
! 1376: sense_info.ascq = tBuf[9];
! 1377: if (! hasTempLogPage) {
! 1378: if (tBuf[7] > 2)
! 1379: *currenttemp = tBuf[10];
! 1380: if (tBuf[7] > 3) /* IBM extension in SMART (IE) lpage */
! 1381: *triptemp = tBuf[11];
! 1382: }
! 1383: }
! 1384: }
! 1385: if (0 == sense_info.asc) {
! 1386: /* ties in with MRIE field of 6 in IEC mode page (0x1c) */
! 1387: if ((err = scsiRequestSense(device, &sense_info))) {
! 1388: pout("Request Sense failed, [%s]\n", scsiErrString(err));
! 1389: return err;
! 1390: }
! 1391: }
! 1392: *asc = sense_info.asc;
! 1393: *ascq = sense_info.ascq;
! 1394: if ((! temperatureSet) && hasTempLogPage) {
! 1395: if (0 == scsiGetTemp(device, &currTemp, &trTemp)) {
! 1396: *currenttemp = currTemp;
! 1397: *triptemp = trTemp;
! 1398: }
! 1399: }
! 1400: return 0;
! 1401: }
! 1402:
! 1403: // The first character (W, C, I) tells the severity
! 1404: static const char * TapeAlertsMessageTable[]= {
! 1405: " ",
! 1406: /* 0x01 */
! 1407: "W: The tape drive is having problems reading data. No data has been lost,\n"
! 1408: " but there has been a reduction in the performance of the tape.",
! 1409: /* 0x02 */
! 1410: "W: The tape drive is having problems writing data. No data has been lost,\n"
! 1411: " but there has been a reduction in the capacity of the tape.",
! 1412: /* 0x03 */
! 1413: "W: The operation has stopped because an error has occurred while reading\n"
! 1414: " or writing data that the drive cannot correct.",
! 1415: /* 0x04 */
! 1416: "C: Your data is at risk:\n"
! 1417: " 1. Copy any data you require from this tape. \n"
! 1418: " 2. Do not use this tape again.\n"
! 1419: " 3. Restart the operation with a different tape.",
! 1420: /* 0x05 */
! 1421: "C: The tape is damaged or the drive is faulty. Call the tape drive\n"
! 1422: " supplier helpline.",
! 1423: /* 0x06 */
! 1424: "C: The tape is from a faulty batch or the tape drive is faulty:\n"
! 1425: " 1. Use a good tape to test the drive.\n"
! 1426: " 2. If problem persists, call the tape drive supplier helpline.",
! 1427: /* 0x07 */
! 1428: "W: The tape cartridge has reached the end of its calculated useful life:\n"
! 1429: " 1. Copy data you need to another tape.\n"
! 1430: " 2. Discard the old tape.",
! 1431: /* 0x08 */
! 1432: "W: The tape cartridge is not data-grade. Any data you back up to the tape\n"
! 1433: " is at risk. Replace the cartridge with a data-grade tape.",
! 1434: /* 0x09 */
! 1435: "C: You are trying to write to a write-protected cartridge. Remove the\n"
! 1436: " write-protection or use another tape.",
! 1437: /* 0x0a */
! 1438: "I: You cannot eject the cartridge because the tape drive is in use. Wait\n"
! 1439: " until the operation is complete before ejecting the cartridge.",
! 1440: /* 0x0b */
! 1441: "I: The tape in the drive is a cleaning cartridge.",
! 1442: /* 0x0c */
! 1443: "I: You have tried to load a cartridge of a type which is not supported\n"
! 1444: " by this drive.",
! 1445: /* 0x0d */
! 1446: "C: The operation has failed because the tape in the drive has experienced\n"
! 1447: " a mechanical failure:\n"
! 1448: " 1. Discard the old tape.\n"
! 1449: " 2. Restart the operation with a different tape.",
! 1450: /* 0x0e */
! 1451: "C: The operation has failed because the tape in the drive has experienced\n"
! 1452: " a mechanical failure:\n"
! 1453: " 1. Do not attempt to extract the tape cartridge\n"
! 1454: " 2. Call the tape drive supplier helpline.",
! 1455: /* 0x0f */
! 1456: "W: The memory in the tape cartridge has failed, which reduces\n"
! 1457: " performance. Do not use the cartridge for further write operations.",
! 1458: /* 0x10 */
! 1459: "C: The operation has failed because the tape cartridge was manually\n"
! 1460: " de-mounted while the tape drive was actively writing or reading.",
! 1461: /* 0x11 */
! 1462: "W: You have loaded a cartridge of a type that is read-only in this drive.\n"
! 1463: " The cartridge will appear as write-protected.",
! 1464: /* 0x12 */
! 1465: "W: The tape directory on the tape cartridge has been corrupted. File\n"
! 1466: " search performance will be degraded. The tape directory can be rebuilt\n"
! 1467: " by reading all the data on the cartridge.",
! 1468: /* 0x13 */
! 1469: "I: The tape cartridge is nearing the end of its calculated life. It is\n"
! 1470: " recommended that you:\n"
! 1471: " 1. Use another tape cartridge for your next backup.\n"
! 1472: " 2. Store this tape in a safe place in case you need to restore "
! 1473: " data from it.",
! 1474: /* 0x14 */
! 1475: "C: The tape drive needs cleaning:\n"
! 1476: " 1. If the operation has stopped, eject the tape and clean the drive.\n"
! 1477: " 2. If the operation has not stopped, wait for it to finish and then\n"
! 1478: " clean the drive.\n"
! 1479: " Check the tape drive users manual for device specific cleaning instructions.",
! 1480: /* 0x15 */
! 1481: "W: The tape drive is due for routine cleaning:\n"
! 1482: " 1. Wait for the current operation to finish.\n"
! 1483: " 2. The use a cleaning cartridge.\n"
! 1484: " Check the tape drive users manual for device specific cleaning instructions.",
! 1485: /* 0x16 */
! 1486: "C: The last cleaning cartridge used in the tape drive has worn out:\n"
! 1487: " 1. Discard the worn out cleaning cartridge.\n"
! 1488: " 2. Wait for the current operation to finish.\n"
! 1489: " 3. Then use a new cleaning cartridge.",
! 1490: /* 0x17 */
! 1491: "C: The last cleaning cartridge used in the tape drive was an invalid\n"
! 1492: " type:\n"
! 1493: " 1. Do not use this cleaning cartridge in this drive.\n"
! 1494: " 2. Wait for the current operation to finish.\n"
! 1495: " 3. Then use a new cleaning cartridge.",
! 1496: /* 0x18 */
! 1497: "W: The tape drive has requested a retention operation",
! 1498: /* 0x19 */
! 1499: "W: A redundant interface port on the tape drive has failed",
! 1500: /* 0x1a */
! 1501: "W: A tape drive cooling fan has failed",
! 1502: /* 0x1b */
! 1503: "W: A redundant power supply has failed inside the tape drive enclosure.\n"
! 1504: " Check the enclosure users manual for instructions on replacing the\n"
! 1505: " failed power supply.",
! 1506: /* 0x1c */
! 1507: "W: The tape drive power consumption is outside the specified range.",
! 1508: /* 0x1d */
! 1509: "W: Preventive maintenance of the tape drive is required. Check the tape\n"
! 1510: " drive users manual for device specific preventive maintenance\n"
! 1511: " tasks or call the tape drive supplier helpline.",
! 1512: /* 0x1e */
! 1513: "C: The tape drive has a hardware fault:\n"
! 1514: " 1. Eject the tape or magazine.\n"
! 1515: " 2. Reset the drive.\n"
! 1516: " 3. Restart the operation.",
! 1517: /* 0x1f */
! 1518: "C: The tape drive has a hardware fault:\n"
! 1519: " 1. Turn the tape drive off and then on again.\n"
! 1520: " 2. Restart the operation.\n"
! 1521: " 3. If the problem persists, call the tape drive supplier helpline.",
! 1522: /* 0x20 */
! 1523: "W: The tape drive has a problem with the application client interface:\n"
! 1524: " 1. Check the cables and cable connections.\n"
! 1525: " 2. Restart the operation.",
! 1526: /* 0x21 */
! 1527: "C: The operation has failed:\n"
! 1528: " 1. Eject the tape or magazine.\n"
! 1529: " 2. Insert the tape or magazine again.\n"
! 1530: " 3. Restart the operation.",
! 1531: /* 0x22 */
! 1532: "W: The firmware download has failed because you have tried to use the\n"
! 1533: " incorrect firmware for this tape drive. Obtain the correct\n"
! 1534: " firmware and try again.",
! 1535: /* 0x23 */
! 1536: "W: Environmental conditions inside the tape drive are outside the\n"
! 1537: " specified humidity range.",
! 1538: /* 0x24 */
! 1539: "W: Environmental conditions inside the tape drive are outside the\n"
! 1540: " specified temperature range.",
! 1541: /* 0x25 */
! 1542: "W: The voltage supply to the tape drive is outside the specified range.",
! 1543: /* 0x26 */
! 1544: "C: A hardware failure of the tape drive is predicted. Call the tape\n"
! 1545: " drive supplier helpline.",
! 1546: /* 0x27 */
! 1547: "W: The tape drive may have a hardware fault. Run extended diagnostics to\n"
! 1548: " verify and diagnose the problem. Check the tape drive users manual for\n"
! 1549: " device specific instructions on running extended diagnostic tests.",
! 1550: /* 0x28 */
! 1551: "C: The changer mechanism is having difficulty communicating with the tape\n"
! 1552: " drive:\n"
! 1553: " 1. Turn the autoloader off then on.\n"
! 1554: " 2. Restart the operation.\n"
! 1555: " 3. If problem persists, call the tape drive supplier helpline.",
! 1556: /* 0x29 */
! 1557: "C: A tape has been left in the autoloader by a previous hardware fault:\n"
! 1558: " 1. Insert an empty magazine to clear the fault.\n"
! 1559: " 2. If the fault does not clear, turn the autoloader off and then\n"
! 1560: " on again.\n"
! 1561: " 3. If the problem persists, call the tape drive supplier helpline.",
! 1562: /* 0x2a */
! 1563: "W: There is a problem with the autoloader mechanism.",
! 1564: /* 0x2b */
! 1565: "C: The operation has failed because the autoloader door is open:\n"
! 1566: " 1. Clear any obstructions from the autoloader door.\n"
! 1567: " 2. Eject the magazine and then insert it again.\n"
! 1568: " 3. If the fault does not clear, turn the autoloader off and then\n"
! 1569: " on again.\n"
! 1570: " 4. If the problem persists, call the tape drive supplier helpline.",
! 1571: /* 0x2c */
! 1572: "C: The autoloader has a hardware fault:\n"
! 1573: " 1. Turn the autoloader off and then on again.\n"
! 1574: " 2. Restart the operation.\n"
! 1575: " 3. If the problem persists, call the tape drive supplier helpline.\n"
! 1576: " Check the autoloader users manual for device specific instructions\n"
! 1577: " on turning the device power on and off.",
! 1578: /* 0x2d */
! 1579: "C: The autoloader cannot operate without the magazine,\n"
! 1580: " 1. Insert the magazine into the autoloader.\n"
! 1581: " 2. Restart the operation.",
! 1582: /* 0x2e */
! 1583: "W: A hardware failure of the changer mechanism is predicted. Call the\n"
! 1584: " tape drive supplier helpline.",
! 1585: /* 0x2f */
! 1586: "I: Reserved.",
! 1587: /* 0x30 */
! 1588: "I: Reserved.",
! 1589: /* 0x31 */
! 1590: "I: Reserved.",
! 1591: /* 0x32 */
! 1592: "W: Media statistics have been lost at some time in the past",
! 1593: /* 0x33 */
! 1594: "W: The tape directory on the tape cartridge just unloaded has been\n"
! 1595: " corrupted. File search performance will be degraded. The tape\n"
! 1596: " directory can be rebuilt by reading all the data.",
! 1597: /* 0x34 */
! 1598: "C: The tape just unloaded could not write its system area successfully:\n"
! 1599: " 1. Copy data to another tape cartridge.\n"
! 1600: " 2. Discard the old cartridge.",
! 1601: /* 0x35 */
! 1602: "C: The tape system are could not be read successfully at load time:\n"
! 1603: " 1. Copy data to another tape cartridge.\n",
! 1604: /* 0x36 */
! 1605: "C: The start or data could not be found on the tape:\n"
! 1606: " 1. Check you are using the correct format tape.\n"
! 1607: " 2. Discard the tape or return the tape to your supplier",
! 1608: /* 0x37 */
! 1609: "C: The operation has failed because the media cannot be loaded\n"
! 1610: " and threaded.\n"
! 1611: " 1. Remove the cartridge, inspect it as specified in the product\n"
! 1612: " manual, and retry the operation.\n"
! 1613: " 2. If the problem persists, call the tape drive supplier help line.",
! 1614: /* 0x38 */
! 1615: "C: The operation has failed because the medium cannot be unloaded:\n"
! 1616: " 1. Do not attempt to extract the tape cartridge.\n"
! 1617: " 2. Call the tape driver supplier help line.",
! 1618: /* 0x39 */
! 1619: "C: The tape drive has a problem with the automation interface:\n"
! 1620: " 1. Check the power to the automation system.\n"
! 1621: " 2. Check the cables and cable connections.\n"
! 1622: " 3. Call the supplier help line if problem persists.",
! 1623: /* 0x3a */
! 1624: "W: The tape drive has reset itself due to a detected firmware\n"
! 1625: " fault. If problem persists, call the supplier help line.",
! 1626: };
! 1627:
! 1628: const char * scsiTapeAlertsTapeDevice(unsigned short code)
! 1629: {
! 1630: const int num = sizeof(TapeAlertsMessageTable) /
! 1631: sizeof(TapeAlertsMessageTable[0]);
! 1632:
! 1633: return (code < num) ? TapeAlertsMessageTable[code] : "Unknown Alert";
! 1634: }
! 1635:
! 1636: // The first character (W, C, I) tells the severity
! 1637: static const char * ChangerTapeAlertsMessageTable[]= {
! 1638: " ",
! 1639: /* 0x01 */
! 1640: "C: The library mechanism is having difficulty communicating with the\n"
! 1641: " drive:\n"
! 1642: " 1. Turn the library off then on.\n"
! 1643: " 2. Restart the operation.\n"
! 1644: " 3. If the problem persists, call the library supplier help line.",
! 1645: /* 0x02 */
! 1646: "W: There is a problem with the library mechanism. If problem persists,\n"
! 1647: " call the library supplier help line.",
! 1648: /* 0x03 */
! 1649: "C: The library has a hardware fault:\n"
! 1650: " 1. Reset the library.\n"
! 1651: " 2. Restart the operation.\n"
! 1652: " Check the library users manual for device specific instructions on resetting\n"
! 1653: " the device.",
! 1654: /* 0x04 */
! 1655: "C: The library has a hardware fault:\n"
! 1656: " 1. Turn the library off then on again.\n"
! 1657: " 2. Restart the operation.\n"
! 1658: " 3. If the problem persists, call the library supplier help line.\n"
! 1659: " Check the library users manual for device specific instructions on turning the\n"
! 1660: " device power on and off.",
! 1661: /* 0x05 */
! 1662: "W: The library mechanism may have a hardware fault.\n"
! 1663: " Run extended diagnostics to verify and diagnose the problem. Check the library\n"
! 1664: " users manual for device specific instructions on running extended diagnostic\n"
! 1665: " tests.",
! 1666: /* 0x06 */
! 1667: "C: The library has a problem with the host interface:\n"
! 1668: " 1. Check the cables and connections.\n"
! 1669: " 2. Restart the operation.",
! 1670: /* 0x07 */
! 1671: "W: A hardware failure of the library is predicted. Call the library\n"
! 1672: " supplier help line.",
! 1673: /* 0x08 */
! 1674: "W: Preventive maintenance of the library is required.\n"
! 1675: " Check the library users manual for device specific preventative maintenance\n"
! 1676: " tasks, or call your library supplier help line.",
! 1677: /* 0x09 */
! 1678: "C: General environmental conditions inside the library are outside the\n"
! 1679: " specified humidity range.",
! 1680: /* 0x0a */
! 1681: "C: General environmental conditions inside the library are outside the\n"
! 1682: " specified temperature range.",
! 1683: /* 0x0b */
! 1684: "C: The voltage supply to the library is outside the specified range.\n"
! 1685: " There is a potential problem with the power supply or failure of\n"
! 1686: " a redundant power supply.",
! 1687: /* 0x0c */
! 1688: "C: A cartridge has been left inside the library by a previous hardware\n"
! 1689: " fault:\n"
! 1690: " 1. Insert an empty magazine to clear the fault.\n"
! 1691: " 2. If the fault does not clear, turn the library off and then on again.\n"
! 1692: " 3. If the problem persists, call the library supplier help line.",
! 1693: /* 0x0d */
! 1694: "W: There is a potential problem with the drive ejecting cartridges or\n"
! 1695: " with the library mechanism picking a cartridge from a slot.\n"
! 1696: " 1. No action needs to be taken at this time.\n"
! 1697: " 2. If the problem persists, call the library supplier help line.",
! 1698: /* 0x0e */
! 1699: "W: There is a potential problem with the library mechanism placing a\n"
! 1700: " cartridge into a slot.\n"
! 1701: " 1. No action needs to be taken at this time.\n"
! 1702: " 2. If the problem persists, call the library supplier help line.",
! 1703: /* 0x0f */
! 1704: "W: There is a potential problem with the drive or the library mechanism\n"
! 1705: " loading cartridges, or an incompatible cartridge.",
! 1706: /* 0x10 */
! 1707: "C: The library has failed because the door is open:\n"
! 1708: " 1. Clear any obstructions from the library door.\n"
! 1709: " 2. Close the library door.\n"
! 1710: " 3. If the problem persists, call the library supplier help line.",
! 1711: /* 0x11 */
! 1712: "C: There is a mechanical problem with the library media import/export\n"
! 1713: " mailslot.",
! 1714: /* 0x12 */
! 1715: "C: The library cannot operate without the magazine.\n"
! 1716: " 1. Insert the magazine into the library.\n"
! 1717: " 2. Restart the operation.",
! 1718: /* 0x13 */
! 1719: "W: Library security has been compromised.",
! 1720: /* 0x14 */
! 1721: "I: The library security mode has been changed.\n"
! 1722: " The library has either been put into secure mode, or the library has exited\n"
! 1723: " the secure mode.\n"
! 1724: " This is for information purposes only. No action is required.",
! 1725: /* 0x15 */
! 1726: "I: The library has been manually turned offline and is unavailable for use.",
! 1727: /* 0x16 */
! 1728: "I: A drive inside the library has been taken offline.\n"
! 1729: " This is for information purposes only. No action is required.",
! 1730: /* 0x17 */
! 1731: "W: There is a potential problem with the bar code label or the scanner\n"
! 1732: " hardware in the library mechanism.\n"
! 1733: " 1. No action needs to be taken at this time.\n"
! 1734: " 2. If the problem persists, call the library supplier help line.",
! 1735: /* 0x18 */
! 1736: "C: The library has detected an inconsistency in its inventory.\n"
! 1737: " 1. Redo the library inventory to correct inconsistency.\n"
! 1738: " 2. Restart the operation.\n"
! 1739: " Check the applications users manual or the hardware users manual for\n"
! 1740: " specific instructions on redoing the library inventory.",
! 1741: /* 0x19 */
! 1742: "W: A library operation has been attempted that is invalid at this time.",
! 1743: /* 0x1a */
! 1744: "W: A redundant interface port on the library has failed.",
! 1745: /* 0x1b */
! 1746: "W: A library cooling fan has failed.",
! 1747: /* 0x1c */
! 1748: "W: A redundant power supply has failed inside the library. Check the\n"
! 1749: " library users manual for instructions on replacing the failed power supply.",
! 1750: /* 0x1d */
! 1751: "W: The library power consumption is outside the specified range.",
! 1752: /* 0x1e */
! 1753: "C: A failure has occurred in the cartridge pass-through mechanism between\n"
! 1754: " two library modules.",
! 1755: /* 0x1f */
! 1756: "C: A cartridge has been left in the pass-through mechanism from a\n"
! 1757: " previous hardware fault. Check the library users guide for instructions on\n"
! 1758: " clearing this fault.",
! 1759: /* 0x20 */
! 1760: "I: The library was unable to read the bar code on a cartridge.",
! 1761: };
! 1762:
! 1763: const char * scsiTapeAlertsChangerDevice(unsigned short code)
! 1764: {
! 1765: const int num = sizeof(ChangerTapeAlertsMessageTable) /
! 1766: sizeof(ChangerTapeAlertsMessageTable[0]);
! 1767:
! 1768: return (code < num) ? ChangerTapeAlertsMessageTable[code] : "Unknown Alert";
! 1769: }
! 1770:
! 1771:
! 1772: /* this is a subset of the SCSI additional sense code strings indexed
! 1773: * by "ascq" for the case when asc==SCSI_ASC_IMPENDING_FAILURE (0x5d)
! 1774: */
! 1775: static const char * strs_for_asc_5d[] = {
! 1776: /* 0x00 */ "FAILURE PREDICTION THRESHOLD EXCEEDED",
! 1777: "MEDIA FAILURE PREDICTION THRESHOLD EXCEEDED",
! 1778: "LOGICAL UNIT FAILURE PREDICTION THRESHOLD EXCEEDED",
! 1779: "SPARE AREA EXHAUSTION PREDICTION THRESHOLD EXCEEDED",
! 1780: "",
! 1781: "",
! 1782: "",
! 1783: "",
! 1784: "",
! 1785: "",
! 1786: "",
! 1787: "",
! 1788: "",
! 1789: "",
! 1790: "",
! 1791: "",
! 1792: /* 0x10 */ "HARDWARE IMPENDING FAILURE GENERAL HARD DRIVE FAILURE",
! 1793: "HARDWARE IMPENDING FAILURE DRIVE ERROR RATE TOO HIGH",
! 1794: "HARDWARE IMPENDING FAILURE DATA ERROR RATE TOO HIGH",
! 1795: "HARDWARE IMPENDING FAILURE SEEK ERROR RATE TOO HIGH",
! 1796: "HARDWARE IMPENDING FAILURE TOO MANY BLOCK REASSIGNS",
! 1797: "HARDWARE IMPENDING FAILURE ACCESS TIMES TOO HIGH",
! 1798: "HARDWARE IMPENDING FAILURE START UNIT TIMES TOO HIGH",
! 1799: "HARDWARE IMPENDING FAILURE CHANNEL PARAMETRICS",
! 1800: "HARDWARE IMPENDING FAILURE CONTROLLER DETECTED",
! 1801: "HARDWARE IMPENDING FAILURE THROUGHPUT PERFORMANCE",
! 1802: "HARDWARE IMPENDING FAILURE SEEK TIME PERFORMANCE",
! 1803: "HARDWARE IMPENDING FAILURE SPIN-UP RETRY COUNT",
! 1804: "HARDWARE IMPENDING FAILURE DRIVE CALIBRATION RETRY COUNT",
! 1805: "",
! 1806: "",
! 1807: "",
! 1808: /* 0x20 */ "CONTROLLER IMPENDING FAILURE GENERAL HARD DRIVE FAILURE",
! 1809: "CONTROLLER IMPENDING FAILURE DRIVE ERROR RATE TOO HIGH",
! 1810: "CONTROLLER IMPENDING FAILURE DATA ERROR RATE TOO HIGH",
! 1811: "CONTROLLER IMPENDING FAILURE SEEK ERROR RATE TOO HIGH",
! 1812: "CONTROLLER IMPENDING FAILURE TOO MANY BLOCK REASSIGNS",
! 1813: "CONTROLLER IMPENDING FAILURE ACCESS TIMES TOO HIGH",
! 1814: "CONTROLLER IMPENDING FAILURE START UNIT TIMES TOO HIGH",
! 1815: "CONTROLLER IMPENDING FAILURE CHANNEL PARAMETRICS",
! 1816: "CONTROLLER IMPENDING FAILURE CONTROLLER DETECTED",
! 1817: "CONTROLLER IMPENDING FAILURE THROUGHPUT PERFORMANCE",
! 1818: "CONTROLLER IMPENDING FAILURE SEEK TIME PERFORMANCE",
! 1819: "CONTROLLER IMPENDING FAILURE SPIN-UP RETRY COUNT",
! 1820: "CONTROLLER IMPENDING FAILURE DRIVE CALIBRATION RETRY COUNT",
! 1821: "",
! 1822: "",
! 1823: "",
! 1824: /* 0x30 */ "DATA CHANNEL IMPENDING FAILURE GENERAL HARD DRIVE FAILURE",
! 1825: "DATA CHANNEL IMPENDING FAILURE DRIVE ERROR RATE TOO HIGH",
! 1826: "DATA CHANNEL IMPENDING FAILURE DATA ERROR RATE TOO HIGH",
! 1827: "DATA CHANNEL IMPENDING FAILURE SEEK ERROR RATE TOO HIGH",
! 1828: "DATA CHANNEL IMPENDING FAILURE TOO MANY BLOCK REASSIGNS",
! 1829: "DATA CHANNEL IMPENDING FAILURE ACCESS TIMES TOO HIGH",
! 1830: "DATA CHANNEL IMPENDING FAILURE START UNIT TIMES TOO HIGH",
! 1831: "DATA CHANNEL IMPENDING FAILURE CHANNEL PARAMETRICS",
! 1832: "DATA CHANNEL IMPENDING FAILURE CONTROLLER DETECTED",
! 1833: "DATA CHANNEL IMPENDING FAILURE THROUGHPUT PERFORMANCE",
! 1834: "DATA CHANNEL IMPENDING FAILURE SEEK TIME PERFORMANCE",
! 1835: "DATA CHANNEL IMPENDING FAILURE SPIN-UP RETRY COUNT",
! 1836: "DATA CHANNEL IMPENDING FAILURE DRIVE CALIBRATION RETRY COUNT",
! 1837: "",
! 1838: "",
! 1839: "",
! 1840: /* 0x40 */ "SERVO IMPENDING FAILURE GENERAL HARD DRIVE FAILURE",
! 1841: "SERVO IMPENDING FAILURE DRIVE ERROR RATE TOO HIGH",
! 1842: "SERVO IMPENDING FAILURE DATA ERROR RATE TOO HIGH",
! 1843: "SERVO IMPENDING FAILURE SEEK ERROR RATE TOO HIGH",
! 1844: "SERVO IMPENDING FAILURE TOO MANY BLOCK REASSIGNS",
! 1845: "SERVO IMPENDING FAILURE ACCESS TIMES TOO HIGH",
! 1846: "SERVO IMPENDING FAILURE START UNIT TIMES TOO HIGH",
! 1847: "SERVO IMPENDING FAILURE CHANNEL PARAMETRICS",
! 1848: "SERVO IMPENDING FAILURE CONTROLLER DETECTED",
! 1849: "SERVO IMPENDING FAILURE THROUGHPUT PERFORMANCE",
! 1850: "SERVO IMPENDING FAILURE SEEK TIME PERFORMANCE",
! 1851: "SERVO IMPENDING FAILURE SPIN-UP RETRY COUNT",
! 1852: "SERVO IMPENDING FAILURE DRIVE CALIBRATION RETRY COUNT",
! 1853: "",
! 1854: "",
! 1855: "",
! 1856: /* 0x50 */ "SPINDLE IMPENDING FAILURE GENERAL HARD DRIVE FAILURE",
! 1857: "SPINDLE IMPENDING FAILURE DRIVE ERROR RATE TOO HIGH",
! 1858: "SPINDLE IMPENDING FAILURE DATA ERROR RATE TOO HIGH",
! 1859: "SPINDLE IMPENDING FAILURE SEEK ERROR RATE TOO HIGH",
! 1860: "SPINDLE IMPENDING FAILURE TOO MANY BLOCK REASSIGNS",
! 1861: "SPINDLE IMPENDING FAILURE ACCESS TIMES TOO HIGH",
! 1862: "SPINDLE IMPENDING FAILURE START UNIT TIMES TOO HIGH",
! 1863: "SPINDLE IMPENDING FAILURE CHANNEL PARAMETRICS",
! 1864: "SPINDLE IMPENDING FAILURE CONTROLLER DETECTED",
! 1865: "SPINDLE IMPENDING FAILURE THROUGHPUT PERFORMANCE",
! 1866: "SPINDLE IMPENDING FAILURE SEEK TIME PERFORMANCE",
! 1867: "SPINDLE IMPENDING FAILURE SPIN-UP RETRY COUNT",
! 1868: "SPINDLE IMPENDING FAILURE DRIVE CALIBRATION RETRY COUNT",
! 1869: "",
! 1870: "",
! 1871: "",
! 1872: /* 0x60 */ "FIRMWARE IMPENDING FAILURE GENERAL HARD DRIVE FAILURE",
! 1873: "FIRMWARE IMPENDING FAILURE DRIVE ERROR RATE TOO HIGH",
! 1874: "FIRMWARE IMPENDING FAILURE DATA ERROR RATE TOO HIGH",
! 1875: "FIRMWARE IMPENDING FAILURE SEEK ERROR RATE TOO HIGH",
! 1876: "FIRMWARE IMPENDING FAILURE TOO MANY BLOCK REASSIGNS",
! 1877: "FIRMWARE IMPENDING FAILURE ACCESS TIMES TOO HIGH",
! 1878: "FIRMWARE IMPENDING FAILURE START UNIT TIMES TOO HIGH",
! 1879: "FIRMWARE IMPENDING FAILURE CHANNEL PARAMETRICS",
! 1880: "FIRMWARE IMPENDING FAILURE CONTROLLER DETECTED",
! 1881: "FIRMWARE IMPENDING FAILURE THROUGHPUT PERFORMANCE",
! 1882: "FIRMWARE IMPENDING FAILURE SEEK TIME PERFORMANCE",
! 1883: "FIRMWARE IMPENDING FAILURE SPIN-UP RETRY COUNT",
! 1884: /* 0x6c */ "FIRMWARE IMPENDING FAILURE DRIVE CALIBRATION RETRY COUNT"};
! 1885:
! 1886:
! 1887: /* this is a subset of the SCSI additional sense code strings indexed
! 1888: * * by "ascq" for the case when asc==SCSI_ASC_WARNING (0xb)
! 1889: * */
! 1890: static const char * strs_for_asc_b[] = {
! 1891: /* 0x00 */ "WARNING",
! 1892: "WARNING - SPECIFIED TEMPERATURE EXCEEDED",
! 1893: "WARNING - ENCLOSURE DEGRADED"};
! 1894:
! 1895: static char spare_buff[128];
! 1896:
! 1897: const char * scsiGetIEString(UINT8 asc, UINT8 ascq)
! 1898: {
! 1899: const char * rp;
! 1900:
! 1901: if (SCSI_ASC_IMPENDING_FAILURE == asc) {
! 1902: if (ascq == 0xff)
! 1903: return "FAILURE PREDICTION THRESHOLD EXCEEDED (FALSE)";
! 1904: else if (ascq <
! 1905: (sizeof(strs_for_asc_5d) / sizeof(strs_for_asc_5d[0]))) {
! 1906: rp = strs_for_asc_5d[ascq];
! 1907: if (strlen(rp) > 0)
! 1908: return rp;
! 1909: }
! 1910: snprintf(spare_buff, sizeof(spare_buff),
! 1911: "FAILURE PREDICTION THRESHOLD EXCEEDED: ascq=0x%x", ascq);
! 1912: return spare_buff;
! 1913: } else if (SCSI_ASC_WARNING == asc) {
! 1914: if (ascq < (sizeof(strs_for_asc_b) / sizeof(strs_for_asc_b[0]))) {
! 1915: rp = strs_for_asc_b[ascq];
! 1916: if (strlen(rp) > 0)
! 1917: return rp;
! 1918: }
! 1919: snprintf(spare_buff, sizeof(spare_buff), "WARNING: ascq=0x%x", ascq);
! 1920: return spare_buff;
! 1921: }
! 1922: return NULL; /* not a IE additional sense code */
! 1923: }
! 1924:
! 1925:
! 1926: /* This is not documented in t10.org, page 0x80 is vendor specific */
! 1927: /* Some IBM disks do an offline read-scan when they get this command. */
! 1928: int scsiSmartIBMOfflineTest(scsi_device * device)
! 1929: {
! 1930: UINT8 tBuf[256];
! 1931: int res;
! 1932:
! 1933: memset(tBuf, 0, sizeof(tBuf));
! 1934: /* Build SMART Off-line Immediate Diag Header */
! 1935: tBuf[0] = 0x80; /* Page Code */
! 1936: tBuf[1] = 0x00; /* Reserved */
! 1937: tBuf[2] = 0x00; /* Page Length MSB */
! 1938: tBuf[3] = 0x04; /* Page Length LSB */
! 1939: tBuf[4] = 0x03; /* SMART Revision */
! 1940: tBuf[5] = 0x00; /* Reserved */
! 1941: tBuf[6] = 0x00; /* Off-line Immediate Time MSB */
! 1942: tBuf[7] = 0x00; /* Off-line Immediate Time LSB */
! 1943: res = scsiSendDiagnostic(device, SCSI_DIAG_NO_SELF_TEST, tBuf, 8);
! 1944: if (res)
! 1945: pout("IBM offline test failed [%s]\n", scsiErrString(res));
! 1946: return res;
! 1947: }
! 1948:
! 1949: int scsiSmartDefaultSelfTest(scsi_device * device)
! 1950: {
! 1951: int res;
! 1952:
! 1953: res = scsiSendDiagnostic(device, SCSI_DIAG_DEF_SELF_TEST, NULL, 0);
! 1954: if (res)
! 1955: pout("Default self test failed [%s]\n", scsiErrString(res));
! 1956: return res;
! 1957: }
! 1958:
! 1959: int scsiSmartShortSelfTest(scsi_device * device)
! 1960: {
! 1961: int res;
! 1962:
! 1963: res = scsiSendDiagnostic(device, SCSI_DIAG_BG_SHORT_SELF_TEST, NULL, 0);
! 1964: if (res)
! 1965: pout("Short offline self test failed [%s]\n", scsiErrString(res));
! 1966: return res;
! 1967: }
! 1968:
! 1969: int scsiSmartExtendSelfTest(scsi_device * device)
! 1970: {
! 1971: int res;
! 1972:
! 1973: res = scsiSendDiagnostic(device, SCSI_DIAG_BG_EXTENDED_SELF_TEST, NULL, 0);
! 1974: if (res)
! 1975: pout("Long (extended) offline self test failed [%s]\n",
! 1976: scsiErrString(res));
! 1977: return res;
! 1978: }
! 1979:
! 1980: int scsiSmartShortCapSelfTest(scsi_device * device)
! 1981: {
! 1982: int res;
! 1983:
! 1984: res = scsiSendDiagnostic(device, SCSI_DIAG_FG_SHORT_SELF_TEST, NULL, 0);
! 1985: if (res)
! 1986: pout("Short foreground self test failed [%s]\n", scsiErrString(res));
! 1987: return res;
! 1988: }
! 1989:
! 1990: int scsiSmartExtendCapSelfTest(scsi_device * device)
! 1991: {
! 1992: int res;
! 1993:
! 1994: res = scsiSendDiagnostic(device, SCSI_DIAG_FG_EXTENDED_SELF_TEST, NULL, 0);
! 1995: if (res)
! 1996: pout("Long (extended) foreground self test failed [%s]\n",
! 1997: scsiErrString(res));
! 1998: return res;
! 1999: }
! 2000:
! 2001: int scsiSmartSelfTestAbort(scsi_device * device)
! 2002: {
! 2003: int res;
! 2004:
! 2005: res = scsiSendDiagnostic(device, SCSI_DIAG_ABORT_SELF_TEST, NULL, 0);
! 2006: if (res)
! 2007: pout("Abort self test failed [%s]\n", scsiErrString(res));
! 2008: return res;
! 2009: }
! 2010:
! 2011: /* Returns 0 and the expected duration of an extended self test (in seconds)
! 2012: if successful; any other return value indicates a failure. */
! 2013: int scsiFetchExtendedSelfTestTime(scsi_device * device, int * durationSec, int modese_len)
! 2014: {
! 2015: int err, offset, res;
! 2016: UINT8 buff[64];
! 2017:
! 2018: memset(buff, 0, sizeof(buff));
! 2019: if (modese_len <= 6) {
! 2020: if ((err = scsiModeSense(device, CONTROL_MODE_PAGE, 0,
! 2021: MPAGE_CONTROL_CURRENT,
! 2022: buff, sizeof(buff)))) {
! 2023: if (SIMPLE_ERR_BAD_OPCODE == err)
! 2024: modese_len = 10;
! 2025: else
! 2026: return err;
! 2027: } else if (0 == modese_len)
! 2028: modese_len = 6;
! 2029: }
! 2030: if (10 == modese_len) {
! 2031: err = scsiModeSense10(device, CONTROL_MODE_PAGE, 0,
! 2032: MPAGE_CONTROL_CURRENT,
! 2033: buff, sizeof(buff));
! 2034: if (err)
! 2035: return err;
! 2036: }
! 2037: offset = scsiModePageOffset(buff, sizeof(buff), modese_len);
! 2038: if (offset < 0)
! 2039: return -EINVAL;
! 2040: if (buff[offset + 1] >= 0xa) {
! 2041: res = (buff[offset + 10] << 8) | buff[offset + 11];
! 2042: *durationSec = res;
! 2043: return 0;
! 2044: }
! 2045: else
! 2046: return -EINVAL;
! 2047: }
! 2048:
! 2049: void scsiDecodeErrCounterPage(unsigned char * resp,
! 2050: struct scsiErrorCounter *ecp)
! 2051: {
! 2052: int k, j, num, pl, pc;
! 2053: unsigned char * ucp;
! 2054: unsigned char * xp;
! 2055: uint64_t * ullp;
! 2056:
! 2057: memset(ecp, 0, sizeof(*ecp));
! 2058: num = (resp[2] << 8) | resp[3];
! 2059: ucp = &resp[0] + 4;
! 2060: while (num > 3) {
! 2061: pc = (ucp[0] << 8) | ucp[1];
! 2062: pl = ucp[3] + 4;
! 2063: switch (pc) {
! 2064: case 0:
! 2065: case 1:
! 2066: case 2:
! 2067: case 3:
! 2068: case 4:
! 2069: case 5:
! 2070: case 6:
! 2071: ecp->gotPC[pc] = 1;
! 2072: ullp = &ecp->counter[pc];
! 2073: break;
! 2074: default:
! 2075: ecp->gotExtraPC = 1;
! 2076: ullp = &ecp->counter[7];
! 2077: break;
! 2078: }
! 2079: k = pl - 4;
! 2080: xp = ucp + 4;
! 2081: if (k > (int)sizeof(*ullp)) {
! 2082: xp += (k - sizeof(*ullp));
! 2083: k = sizeof(*ullp);
! 2084: }
! 2085: *ullp = 0;
! 2086: for (j = 0; j < k; ++j) {
! 2087: if (j > 0)
! 2088: *ullp <<= 8;
! 2089: *ullp |= xp[j];
! 2090: }
! 2091: num -= pl;
! 2092: ucp += pl;
! 2093: }
! 2094: }
! 2095:
! 2096: void scsiDecodeNonMediumErrPage(unsigned char *resp,
! 2097: struct scsiNonMediumError *nmep)
! 2098: {
! 2099: int k, j, num, pl, pc, szof;
! 2100: unsigned char * ucp;
! 2101: unsigned char * xp;
! 2102:
! 2103: memset(nmep, 0, sizeof(*nmep));
! 2104: num = (resp[2] << 8) | resp[3];
! 2105: ucp = &resp[0] + 4;
! 2106: szof = sizeof(nmep->counterPC0);
! 2107: while (num > 3) {
! 2108: pc = (ucp[0] << 8) | ucp[1];
! 2109: pl = ucp[3] + 4;
! 2110: switch (pc) {
! 2111: case 0:
! 2112: nmep->gotPC0 = 1;
! 2113: k = pl - 4;
! 2114: xp = ucp + 4;
! 2115: if (k > szof) {
! 2116: xp += (k - szof);
! 2117: k = szof;
! 2118: }
! 2119: nmep->counterPC0 = 0;
! 2120: for (j = 0; j < k; ++j) {
! 2121: if (j > 0)
! 2122: nmep->counterPC0 <<= 8;
! 2123: nmep->counterPC0 |= xp[j];
! 2124: }
! 2125: break;
! 2126: case 0x8009:
! 2127: nmep->gotTFE_H = 1;
! 2128: k = pl - 4;
! 2129: xp = ucp + 4;
! 2130: if (k > szof) {
! 2131: xp += (k - szof);
! 2132: k = szof;
! 2133: }
! 2134: nmep->counterTFE_H = 0;
! 2135: for (j = 0; j < k; ++j) {
! 2136: if (j > 0)
! 2137: nmep->counterTFE_H <<= 8;
! 2138: nmep->counterTFE_H |= xp[j];
! 2139: }
! 2140: break;
! 2141: case 0x8015:
! 2142: nmep->gotPE_H = 1;
! 2143: k = pl - 4;
! 2144: xp = ucp + 4;
! 2145: if (k > szof) {
! 2146: xp += (k - szof);
! 2147: k = szof;
! 2148: }
! 2149: nmep->counterPE_H = 0;
! 2150: for (j = 0; j < k; ++j) {
! 2151: if (j > 0)
! 2152: nmep->counterPE_H <<= 8;
! 2153: nmep->counterPE_H |= xp[j];
! 2154: }
! 2155: break;
! 2156: default:
! 2157: nmep->gotExtraPC = 1;
! 2158: break;
! 2159: }
! 2160: num -= pl;
! 2161: ucp += pl;
! 2162: }
! 2163: }
! 2164:
! 2165: /* Counts number of failed self-tests. Also encodes the poweron_hour
! 2166: of the most recent failed self-test. Return value is negative if
! 2167: this function has a problem (typically -1), otherwise the bottom 8
! 2168: bits are the number of failed self tests and the 16 bits above that
! 2169: are the poweron hour of the most recent failure. Note: aborted self
! 2170: tests (typically by the user) and self tests in progress are not
! 2171: considered failures. See Working Draft SCSI Primary Commands - 3
! 2172: (SPC-3) section 7.2.10 T10/1416-D (rev 22a) */
! 2173: int scsiCountFailedSelfTests(scsi_device * fd, int noisy)
! 2174: {
! 2175: int num, k, n, err, res, fails, fail_hour;
! 2176: UINT8 * ucp;
! 2177: unsigned char resp[LOG_RESP_SELF_TEST_LEN];
! 2178:
! 2179: if ((err = scsiLogSense(fd, SELFTEST_RESULTS_LPAGE, 0, resp,
! 2180: LOG_RESP_SELF_TEST_LEN, 0))) {
! 2181: if (noisy)
! 2182: pout("scsiCountSelfTests Failed [%s]\n", scsiErrString(err));
! 2183: return -1;
! 2184: }
! 2185: if ((resp[0] & 0x3f) != SELFTEST_RESULTS_LPAGE) {
! 2186: if (noisy)
! 2187: pout("Self-test Log Sense Failed, page mismatch\n");
! 2188: return -1;
! 2189: }
! 2190: // compute page length
! 2191: num = (resp[2] << 8) + resp[3];
! 2192: // Log sense page length 0x190 bytes
! 2193: if (num != 0x190) {
! 2194: if (noisy)
! 2195: pout("Self-test Log Sense length is 0x%x not 0x190 bytes\n", num);
! 2196: return -1;
! 2197: }
! 2198: fails = 0;
! 2199: fail_hour = 0;
! 2200: // loop through the twenty possible entries
! 2201: for (k = 0, ucp = resp + 4; k < 20; ++k, ucp += 20 ) {
! 2202:
! 2203: // timestamp in power-on hours (or zero if test in progress)
! 2204: n = (ucp[6] << 8) | ucp[7];
! 2205:
! 2206: // The spec says "all 20 bytes will be zero if no test" but
! 2207: // DG has found otherwise. So this is a heuristic.
! 2208: if ((0 == n) && (0 == ucp[4]))
! 2209: break;
! 2210: res = ucp[4] & 0xf;
! 2211: if ((res > 2) && (res < 8)) {
! 2212: fails++;
! 2213: if (1 == fails)
! 2214: fail_hour = (ucp[6] << 8) + ucp[7];
! 2215: }
! 2216: }
! 2217: return (fail_hour << 8) + fails;
! 2218: }
! 2219:
! 2220: /* Returns 0 if able to read self test log page; then outputs 1 into
! 2221: *inProgress if self test still in progress, else outputs 0. */
! 2222: int scsiSelfTestInProgress(scsi_device * fd, int * inProgress)
! 2223: {
! 2224: int num;
! 2225: UINT8 * ucp;
! 2226: unsigned char resp[LOG_RESP_SELF_TEST_LEN];
! 2227:
! 2228: if (scsiLogSense(fd, SELFTEST_RESULTS_LPAGE, 0, resp,
! 2229: LOG_RESP_SELF_TEST_LEN, 0))
! 2230: return -1;
! 2231: if (resp[0] != SELFTEST_RESULTS_LPAGE)
! 2232: return -1;
! 2233: // compute page length
! 2234: num = (resp[2] << 8) + resp[3];
! 2235: // Log sense page length 0x190 bytes
! 2236: if (num != 0x190) {
! 2237: return -1;
! 2238: }
! 2239: ucp = resp + 4;
! 2240: if (inProgress)
! 2241: *inProgress = (0xf == (ucp[4] & 0xf)) ? 1 : 0;
! 2242: return 0;
! 2243: }
! 2244:
! 2245: /* Returns a negative value if failed to fetch Contol mode page or it was
! 2246: malformed. Returns 0 if GLTSD bit is zero and returns 1 if the GLTSD
! 2247: bit is set. Examines default mode page when current==0 else examines
! 2248: current mode page. */
! 2249: int scsiFetchControlGLTSD(scsi_device * device, int modese_len, int current)
! 2250: {
! 2251: int err, offset;
! 2252: UINT8 buff[64];
! 2253: int pc = current ? MPAGE_CONTROL_CURRENT : MPAGE_CONTROL_DEFAULT;
! 2254:
! 2255: memset(buff, 0, sizeof(buff));
! 2256: if (modese_len <= 6) {
! 2257: if ((err = scsiModeSense(device, CONTROL_MODE_PAGE, 0, pc,
! 2258: buff, sizeof(buff)))) {
! 2259: if (SIMPLE_ERR_BAD_OPCODE == err)
! 2260: modese_len = 10;
! 2261: else
! 2262: return -EINVAL;
! 2263: } else if (0 == modese_len)
! 2264: modese_len = 6;
! 2265: }
! 2266: if (10 == modese_len) {
! 2267: err = scsiModeSense10(device, CONTROL_MODE_PAGE, 0, pc,
! 2268: buff, sizeof(buff));
! 2269: if (err)
! 2270: return -EINVAL;
! 2271: }
! 2272: offset = scsiModePageOffset(buff, sizeof(buff), modese_len);
! 2273: if ((offset >= 0) && (buff[offset + 1] >= 0xa))
! 2274: return (buff[offset + 2] & 2) ? 1 : 0;
! 2275: return -EINVAL;
! 2276: }
! 2277:
! 2278: /* Attempts to set or clear GLTSD bit in Control mode page. If enabled is
! 2279: 0 attempts to clear GLTSD otherwise it attempts to set it. Returns 0 if
! 2280: successful, negative if low level error, > 0 if higher level error (e.g.
! 2281: SIMPLE_ERR_BAD_PARAM if GLTSD bit is not changeable). */
! 2282: int scsiSetControlGLTSD(scsi_device * device, int enabled, int modese_len)
! 2283: {
! 2284: int err, offset, resp_len, sp;
! 2285: UINT8 buff[64];
! 2286: UINT8 ch_buff[64];
! 2287:
! 2288: memset(buff, 0, sizeof(buff));
! 2289: if (modese_len <= 6) {
! 2290: if ((err = scsiModeSense(device, CONTROL_MODE_PAGE, 0,
! 2291: MPAGE_CONTROL_CURRENT,
! 2292: buff, sizeof(buff)))) {
! 2293: if (SIMPLE_ERR_BAD_OPCODE == err)
! 2294: modese_len = 10;
! 2295: else
! 2296: return err;
! 2297: } else if (0 == modese_len)
! 2298: modese_len = 6;
! 2299: }
! 2300: if (10 == modese_len) {
! 2301: err = scsiModeSense10(device, CONTROL_MODE_PAGE, 0,
! 2302: MPAGE_CONTROL_CURRENT,
! 2303: buff, sizeof(buff));
! 2304: if (err)
! 2305: return err;
! 2306: }
! 2307: offset = scsiModePageOffset(buff, sizeof(buff), modese_len);
! 2308: if ((offset < 0) || (buff[offset + 1] < 0xa))
! 2309: return SIMPLE_ERR_BAD_RESP;
! 2310:
! 2311: if (enabled)
! 2312: enabled = 2;
! 2313: if (enabled == (buff[offset + 2] & 2))
! 2314: return 0; /* GLTSD already in wanted state so nothing to do */
! 2315:
! 2316: if (modese_len == 6)
! 2317: err = scsiModeSense(device, CONTROL_MODE_PAGE, 0,
! 2318: MPAGE_CONTROL_CHANGEABLE,
! 2319: ch_buff, sizeof(ch_buff));
! 2320: else
! 2321: err = scsiModeSense10(device, CONTROL_MODE_PAGE, 0,
! 2322: MPAGE_CONTROL_CHANGEABLE,
! 2323: ch_buff, sizeof(ch_buff));
! 2324: if (err)
! 2325: return err;
! 2326: if (0 == (ch_buff[offset + 2] & 2))
! 2327: return SIMPLE_ERR_BAD_PARAM; /* GLTSD bit not chageable */
! 2328:
! 2329: if (10 == modese_len) {
! 2330: resp_len = (buff[0] << 8) + buff[1] + 2;
! 2331: buff[3] &= 0xef; /* for disks mask out DPOFUA bit */
! 2332: } else {
! 2333: resp_len = buff[0] + 1;
! 2334: buff[2] &= 0xef; /* for disks mask out DPOFUA bit */
! 2335: }
! 2336: sp = (buff[offset] & 0x80) ? 1 : 0; /* PS bit becomes 'SELECT's SP bit */
! 2337: if (enabled)
! 2338: buff[offset + 2] |= 0x2; /* set GLTSD bit */
! 2339: else
! 2340: buff[offset + 2] &= 0xfd; /* clear GLTSD bit */
! 2341: if (10 == modese_len)
! 2342: err = scsiModeSelect10(device, sp, buff, resp_len);
! 2343: else if (6 == modese_len)
! 2344: err = scsiModeSelect(device, sp, buff, resp_len);
! 2345: return err;
! 2346: }
! 2347:
! 2348: /* Returns a negative value if failed to fetch Protocol specific port mode
! 2349: page or it was malformed. Returns transport protocol identifier when
! 2350: value >= 0 . */
! 2351: int scsiFetchTransportProtocol(scsi_device * device, int modese_len)
! 2352: {
! 2353: int err, offset;
! 2354: UINT8 buff[64];
! 2355:
! 2356: memset(buff, 0, sizeof(buff));
! 2357: if (modese_len <= 6) {
! 2358: if ((err = scsiModeSense(device, PROTOCOL_SPECIFIC_PORT_PAGE, 0,
! 2359: MPAGE_CONTROL_CURRENT,
! 2360: buff, sizeof(buff)))) {
! 2361: if (SIMPLE_ERR_BAD_OPCODE == err)
! 2362: modese_len = 10;
! 2363: else
! 2364: return -EINVAL;
! 2365: } else if (0 == modese_len)
! 2366: modese_len = 6;
! 2367: }
! 2368: if (10 == modese_len) {
! 2369: err = scsiModeSense10(device, PROTOCOL_SPECIFIC_PORT_PAGE, 0,
! 2370: MPAGE_CONTROL_CURRENT,
! 2371: buff, sizeof(buff));
! 2372: if (err)
! 2373: return -EINVAL;
! 2374: }
! 2375: offset = scsiModePageOffset(buff, sizeof(buff), modese_len);
! 2376: if ((offset >= 0) && (buff[offset + 1] > 1)) {
! 2377: if ((0 == (buff[offset] & 0x40)) && /* SPF==0 */
! 2378: (PROTOCOL_SPECIFIC_PORT_PAGE == (buff[offset] & 0x3f)))
! 2379: return (buff[offset + 2] & 0xf);
! 2380: }
! 2381: return -EINVAL;
! 2382: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to scsicmds.cpp CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / smartmontools