scsi_all.c revision 288692
1/*- 2 * Implementation of Utility functions for all SCSI device types. 3 * 4 * Copyright (c) 1997, 1998, 1999 Justin T. Gibbs. 5 * Copyright (c) 1997, 1998, 2003 Kenneth D. Merry. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions, and the following disclaimer, 13 * without modification, immediately at the beginning of the file. 14 * 2. The name of the author may not be used to endorse or promote products 15 * derived from this software without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 21 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30#include <sys/cdefs.h> 31__FBSDID("$FreeBSD: stable/10/sys/cam/scsi/scsi_all.c 288692 2015-10-05 06:55:26Z mav $"); 32 33#include <sys/param.h> 34#include <sys/types.h> 35#include <sys/stdint.h> 36 37#ifdef _KERNEL 38#include <opt_scsi.h> 39 40#include <sys/systm.h> 41#include <sys/libkern.h> 42#include <sys/kernel.h> 43#include <sys/lock.h> 44#include <sys/malloc.h> 45#include <sys/mutex.h> 46#include <sys/sysctl.h> 47#include <sys/ctype.h> 48#else 49#include <errno.h> 50#include <stdio.h> 51#include <stdlib.h> 52#include <string.h> 53#include <ctype.h> 54#endif 55 56#include <cam/cam.h> 57#include <cam/cam_ccb.h> 58#include <cam/cam_queue.h> 59#include <cam/cam_xpt.h> 60#include <cam/scsi/scsi_all.h> 61#include <sys/ata.h> 62#include <sys/sbuf.h> 63 64#ifdef _KERNEL 65#include <cam/cam_periph.h> 66#include <cam/cam_xpt_sim.h> 67#include <cam/cam_xpt_periph.h> 68#include <cam/cam_xpt_internal.h> 69#else 70#include <camlib.h> 71#include <stddef.h> 72 73#ifndef FALSE 74#define FALSE 0 75#endif /* FALSE */ 76#ifndef TRUE 77#define TRUE 1 78#endif /* TRUE */ 79#define ERESTART -1 /* restart syscall */ 80#define EJUSTRETURN -2 /* don't modify regs, just return */ 81#endif /* !_KERNEL */ 82 83/* 84 * This is the default number of milliseconds we wait for devices to settle 85 * after a SCSI bus reset. 86 */ 87#ifndef SCSI_DELAY 88#define SCSI_DELAY 2000 89#endif 90/* 91 * All devices need _some_ sort of bus settle delay, so we'll set it to 92 * a minimum value of 100ms. Note that this is pertinent only for SPI- 93 * not transport like Fibre Channel or iSCSI where 'delay' is completely 94 * meaningless. 95 */ 96#ifndef SCSI_MIN_DELAY 97#define SCSI_MIN_DELAY 100 98#endif 99/* 100 * Make sure the user isn't using seconds instead of milliseconds. 101 */ 102#if (SCSI_DELAY < SCSI_MIN_DELAY && SCSI_DELAY != 0) 103#error "SCSI_DELAY is in milliseconds, not seconds! Please use a larger value" 104#endif 105 106int scsi_delay; 107 108static int ascentrycomp(const void *key, const void *member); 109static int senseentrycomp(const void *key, const void *member); 110static void fetchtableentries(int sense_key, int asc, int ascq, 111 struct scsi_inquiry_data *, 112 const struct sense_key_table_entry **, 113 const struct asc_table_entry **); 114#ifdef _KERNEL 115static void init_scsi_delay(void); 116static int sysctl_scsi_delay(SYSCTL_HANDLER_ARGS); 117static int set_scsi_delay(int delay); 118#endif 119 120#if !defined(SCSI_NO_OP_STRINGS) 121 122#define D (1 << T_DIRECT) 123#define T (1 << T_SEQUENTIAL) 124#define L (1 << T_PRINTER) 125#define P (1 << T_PROCESSOR) 126#define W (1 << T_WORM) 127#define R (1 << T_CDROM) 128#define O (1 << T_OPTICAL) 129#define M (1 << T_CHANGER) 130#define A (1 << T_STORARRAY) 131#define E (1 << T_ENCLOSURE) 132#define B (1 << T_RBC) 133#define K (1 << T_OCRW) 134#define V (1 << T_ADC) 135#define F (1 << T_OSD) 136#define S (1 << T_SCANNER) 137#define C (1 << T_COMM) 138 139#define ALL (D | T | L | P | W | R | O | M | A | E | B | K | V | F | S | C) 140 141static struct op_table_entry plextor_cd_ops[] = { 142 { 0xD8, R, "CD-DA READ" } 143}; 144 145static struct scsi_op_quirk_entry scsi_op_quirk_table[] = { 146 { 147 /* 148 * I believe that 0xD8 is the Plextor proprietary command 149 * to read CD-DA data. I'm not sure which Plextor CDROM 150 * models support the command, though. I know for sure 151 * that the 4X, 8X, and 12X models do, and presumably the 152 * 12-20X does. I don't know about any earlier models, 153 * though. If anyone has any more complete information, 154 * feel free to change this quirk entry. 155 */ 156 {T_CDROM, SIP_MEDIA_REMOVABLE, "PLEXTOR", "CD-ROM PX*", "*"}, 157 sizeof(plextor_cd_ops)/sizeof(struct op_table_entry), 158 plextor_cd_ops 159 } 160}; 161 162static struct op_table_entry scsi_op_codes[] = { 163 /* 164 * From: http://www.t10.org/lists/op-num.txt 165 * Modifications by Kenneth Merry (ken@FreeBSD.ORG) 166 * and Jung-uk Kim (jkim@FreeBSD.org) 167 * 168 * Note: order is important in this table, scsi_op_desc() currently 169 * depends on the opcodes in the table being in order to save 170 * search time. 171 * Note: scanner and comm. devices are carried over from the previous 172 * version because they were removed in the latest spec. 173 */ 174 /* File: OP-NUM.TXT 175 * 176 * SCSI Operation Codes 177 * Numeric Sorted Listing 178 * as of 3/11/08 179 * 180 * D - DIRECT ACCESS DEVICE (SBC-2) device column key 181 * .T - SEQUENTIAL ACCESS DEVICE (SSC-2) ----------------- 182 * . L - PRINTER DEVICE (SSC) M = Mandatory 183 * . P - PROCESSOR DEVICE (SPC) O = Optional 184 * . .W - WRITE ONCE READ MULTIPLE DEVICE (SBC-2) V = Vendor spec. 185 * . . R - CD/DVE DEVICE (MMC-3) Z = Obsolete 186 * . . O - OPTICAL MEMORY DEVICE (SBC-2) 187 * . . .M - MEDIA CHANGER DEVICE (SMC-2) 188 * . . . A - STORAGE ARRAY DEVICE (SCC-2) 189 * . . . .E - ENCLOSURE SERVICES DEVICE (SES) 190 * . . . .B - SIMPLIFIED DIRECT-ACCESS DEVICE (RBC) 191 * . . . . K - OPTICAL CARD READER/WRITER DEVICE (OCRW) 192 * . . . . V - AUTOMATION/DRIVE INTERFACE (ADC) 193 * . . . . .F - OBJECT-BASED STORAGE (OSD) 194 * OP DTLPWROMAEBKVF Description 195 * -- -------------- ---------------------------------------------- */ 196 /* 00 MMMMMMMMMMMMMM TEST UNIT READY */ 197 { 0x00, ALL, "TEST UNIT READY" }, 198 /* 01 M REWIND */ 199 { 0x01, T, "REWIND" }, 200 /* 01 Z V ZZZZ REZERO UNIT */ 201 { 0x01, D | W | R | O | M, "REZERO UNIT" }, 202 /* 02 VVVVVV V */ 203 /* 03 MMMMMMMMMMOMMM REQUEST SENSE */ 204 { 0x03, ALL, "REQUEST SENSE" }, 205 /* 04 M OO FORMAT UNIT */ 206 { 0x04, D | R | O, "FORMAT UNIT" }, 207 /* 04 O FORMAT MEDIUM */ 208 { 0x04, T, "FORMAT MEDIUM" }, 209 /* 04 O FORMAT */ 210 { 0x04, L, "FORMAT" }, 211 /* 05 VMVVVV V READ BLOCK LIMITS */ 212 { 0x05, T, "READ BLOCK LIMITS" }, 213 /* 06 VVVVVV V */ 214 /* 07 OVV O OV REASSIGN BLOCKS */ 215 { 0x07, D | W | O, "REASSIGN BLOCKS" }, 216 /* 07 O INITIALIZE ELEMENT STATUS */ 217 { 0x07, M, "INITIALIZE ELEMENT STATUS" }, 218 /* 08 MOV O OV READ(6) */ 219 { 0x08, D | T | W | O, "READ(6)" }, 220 /* 08 O RECEIVE */ 221 { 0x08, P, "RECEIVE" }, 222 /* 08 GET MESSAGE(6) */ 223 { 0x08, C, "GET MESSAGE(6)" }, 224 /* 09 VVVVVV V */ 225 /* 0A OO O OV WRITE(6) */ 226 { 0x0A, D | T | W | O, "WRITE(6)" }, 227 /* 0A M SEND(6) */ 228 { 0x0A, P, "SEND(6)" }, 229 /* 0A SEND MESSAGE(6) */ 230 { 0x0A, C, "SEND MESSAGE(6)" }, 231 /* 0A M PRINT */ 232 { 0x0A, L, "PRINT" }, 233 /* 0B Z ZOZV SEEK(6) */ 234 { 0x0B, D | W | R | O, "SEEK(6)" }, 235 /* 0B O SET CAPACITY */ 236 { 0x0B, T, "SET CAPACITY" }, 237 /* 0B O SLEW AND PRINT */ 238 { 0x0B, L, "SLEW AND PRINT" }, 239 /* 0C VVVVVV V */ 240 /* 0D VVVVVV V */ 241 /* 0E VVVVVV V */ 242 /* 0F VOVVVV V READ REVERSE(6) */ 243 { 0x0F, T, "READ REVERSE(6)" }, 244 /* 10 VM VVV WRITE FILEMARKS(6) */ 245 { 0x10, T, "WRITE FILEMARKS(6)" }, 246 /* 10 O SYNCHRONIZE BUFFER */ 247 { 0x10, L, "SYNCHRONIZE BUFFER" }, 248 /* 11 VMVVVV SPACE(6) */ 249 { 0x11, T, "SPACE(6)" }, 250 /* 12 MMMMMMMMMMMMMM INQUIRY */ 251 { 0x12, ALL, "INQUIRY" }, 252 /* 13 V VVVV */ 253 /* 13 O VERIFY(6) */ 254 { 0x13, T, "VERIFY(6)" }, 255 /* 14 VOOVVV RECOVER BUFFERED DATA */ 256 { 0x14, T | L, "RECOVER BUFFERED DATA" }, 257 /* 15 OMO O OOOO OO MODE SELECT(6) */ 258 { 0x15, ALL & ~(P | R | B | F), "MODE SELECT(6)" }, 259 /* 16 ZZMZO OOOZ O RESERVE(6) */ 260 { 0x16, ALL & ~(R | B | V | F | C), "RESERVE(6)" }, 261 /* 16 Z RESERVE ELEMENT(6) */ 262 { 0x16, M, "RESERVE ELEMENT(6)" }, 263 /* 17 ZZMZO OOOZ O RELEASE(6) */ 264 { 0x17, ALL & ~(R | B | V | F | C), "RELEASE(6)" }, 265 /* 17 Z RELEASE ELEMENT(6) */ 266 { 0x17, M, "RELEASE ELEMENT(6)" }, 267 /* 18 ZZZZOZO Z COPY */ 268 { 0x18, D | T | L | P | W | R | O | K | S, "COPY" }, 269 /* 19 VMVVVV ERASE(6) */ 270 { 0x19, T, "ERASE(6)" }, 271 /* 1A OMO O OOOO OO MODE SENSE(6) */ 272 { 0x1A, ALL & ~(P | R | B | F), "MODE SENSE(6)" }, 273 /* 1B O OOO O MO O START STOP UNIT */ 274 { 0x1B, D | W | R | O | A | B | K | F, "START STOP UNIT" }, 275 /* 1B O M LOAD UNLOAD */ 276 { 0x1B, T | V, "LOAD UNLOAD" }, 277 /* 1B SCAN */ 278 { 0x1B, S, "SCAN" }, 279 /* 1B O STOP PRINT */ 280 { 0x1B, L, "STOP PRINT" }, 281 /* 1B O OPEN/CLOSE IMPORT/EXPORT ELEMENT */ 282 { 0x1B, M, "OPEN/CLOSE IMPORT/EXPORT ELEMENT" }, 283 /* 1C OOOOO OOOM OOO RECEIVE DIAGNOSTIC RESULTS */ 284 { 0x1C, ALL & ~(R | B), "RECEIVE DIAGNOSTIC RESULTS" }, 285 /* 1D MMMMM MMOM MMM SEND DIAGNOSTIC */ 286 { 0x1D, ALL & ~(R | B), "SEND DIAGNOSTIC" }, 287 /* 1E OO OOOO O O PREVENT ALLOW MEDIUM REMOVAL */ 288 { 0x1E, D | T | W | R | O | M | K | F, "PREVENT ALLOW MEDIUM REMOVAL" }, 289 /* 1F */ 290 /* 20 V VVV V */ 291 /* 21 V VVV V */ 292 /* 22 V VVV V */ 293 /* 23 V V V V */ 294 /* 23 O READ FORMAT CAPACITIES */ 295 { 0x23, R, "READ FORMAT CAPACITIES" }, 296 /* 24 V VV SET WINDOW */ 297 { 0x24, S, "SET WINDOW" }, 298 /* 25 M M M M READ CAPACITY(10) */ 299 { 0x25, D | W | O | B, "READ CAPACITY(10)" }, 300 /* 25 O READ CAPACITY */ 301 { 0x25, R, "READ CAPACITY" }, 302 /* 25 M READ CARD CAPACITY */ 303 { 0x25, K, "READ CARD CAPACITY" }, 304 /* 25 GET WINDOW */ 305 { 0x25, S, "GET WINDOW" }, 306 /* 26 V VV */ 307 /* 27 V VV */ 308 /* 28 M MOM MM READ(10) */ 309 { 0x28, D | W | R | O | B | K | S, "READ(10)" }, 310 /* 28 GET MESSAGE(10) */ 311 { 0x28, C, "GET MESSAGE(10)" }, 312 /* 29 V VVO READ GENERATION */ 313 { 0x29, O, "READ GENERATION" }, 314 /* 2A O MOM MO WRITE(10) */ 315 { 0x2A, D | W | R | O | B | K, "WRITE(10)" }, 316 /* 2A SEND(10) */ 317 { 0x2A, S, "SEND(10)" }, 318 /* 2A SEND MESSAGE(10) */ 319 { 0x2A, C, "SEND MESSAGE(10)" }, 320 /* 2B Z OOO O SEEK(10) */ 321 { 0x2B, D | W | R | O | K, "SEEK(10)" }, 322 /* 2B O LOCATE(10) */ 323 { 0x2B, T, "LOCATE(10)" }, 324 /* 2B O POSITION TO ELEMENT */ 325 { 0x2B, M, "POSITION TO ELEMENT" }, 326 /* 2C V OO ERASE(10) */ 327 { 0x2C, R | O, "ERASE(10)" }, 328 /* 2D O READ UPDATED BLOCK */ 329 { 0x2D, O, "READ UPDATED BLOCK" }, 330 /* 2D V */ 331 /* 2E O OOO MO WRITE AND VERIFY(10) */ 332 { 0x2E, D | W | R | O | B | K, "WRITE AND VERIFY(10)" }, 333 /* 2F O OOO VERIFY(10) */ 334 { 0x2F, D | W | R | O, "VERIFY(10)" }, 335 /* 30 Z ZZZ SEARCH DATA HIGH(10) */ 336 { 0x30, D | W | R | O, "SEARCH DATA HIGH(10)" }, 337 /* 31 Z ZZZ SEARCH DATA EQUAL(10) */ 338 { 0x31, D | W | R | O, "SEARCH DATA EQUAL(10)" }, 339 /* 31 OBJECT POSITION */ 340 { 0x31, S, "OBJECT POSITION" }, 341 /* 32 Z ZZZ SEARCH DATA LOW(10) */ 342 { 0x32, D | W | R | O, "SEARCH DATA LOW(10)" }, 343 /* 33 Z OZO SET LIMITS(10) */ 344 { 0x33, D | W | R | O, "SET LIMITS(10)" }, 345 /* 34 O O O O PRE-FETCH(10) */ 346 { 0x34, D | W | O | K, "PRE-FETCH(10)" }, 347 /* 34 M READ POSITION */ 348 { 0x34, T, "READ POSITION" }, 349 /* 34 GET DATA BUFFER STATUS */ 350 { 0x34, S, "GET DATA BUFFER STATUS" }, 351 /* 35 O OOO MO SYNCHRONIZE CACHE(10) */ 352 { 0x35, D | W | R | O | B | K, "SYNCHRONIZE CACHE(10)" }, 353 /* 36 Z O O O LOCK UNLOCK CACHE(10) */ 354 { 0x36, D | W | O | K, "LOCK UNLOCK CACHE(10)" }, 355 /* 37 O O READ DEFECT DATA(10) */ 356 { 0x37, D | O, "READ DEFECT DATA(10)" }, 357 /* 37 O INITIALIZE ELEMENT STATUS WITH RANGE */ 358 { 0x37, M, "INITIALIZE ELEMENT STATUS WITH RANGE" }, 359 /* 38 O O O MEDIUM SCAN */ 360 { 0x38, W | O | K, "MEDIUM SCAN" }, 361 /* 39 ZZZZOZO Z COMPARE */ 362 { 0x39, D | T | L | P | W | R | O | K | S, "COMPARE" }, 363 /* 3A ZZZZOZO Z COPY AND VERIFY */ 364 { 0x3A, D | T | L | P | W | R | O | K | S, "COPY AND VERIFY" }, 365 /* 3B OOOOOOOOOOMOOO WRITE BUFFER */ 366 { 0x3B, ALL, "WRITE BUFFER" }, 367 /* 3C OOOOOOOOOO OOO READ BUFFER */ 368 { 0x3C, ALL & ~(B), "READ BUFFER" }, 369 /* 3D O UPDATE BLOCK */ 370 { 0x3D, O, "UPDATE BLOCK" }, 371 /* 3E O O O READ LONG(10) */ 372 { 0x3E, D | W | O, "READ LONG(10)" }, 373 /* 3F O O O WRITE LONG(10) */ 374 { 0x3F, D | W | O, "WRITE LONG(10)" }, 375 /* 40 ZZZZOZOZ CHANGE DEFINITION */ 376 { 0x40, D | T | L | P | W | R | O | M | S | C, "CHANGE DEFINITION" }, 377 /* 41 O WRITE SAME(10) */ 378 { 0x41, D, "WRITE SAME(10)" }, 379 /* 42 O UNMAP */ 380 { 0x42, D, "UNMAP" }, 381 /* 42 O READ SUB-CHANNEL */ 382 { 0x42, R, "READ SUB-CHANNEL" }, 383 /* 43 O READ TOC/PMA/ATIP */ 384 { 0x43, R, "READ TOC/PMA/ATIP" }, 385 /* 44 M M REPORT DENSITY SUPPORT */ 386 { 0x44, T | V, "REPORT DENSITY SUPPORT" }, 387 /* 44 READ HEADER */ 388 /* 45 O PLAY AUDIO(10) */ 389 { 0x45, R, "PLAY AUDIO(10)" }, 390 /* 46 M GET CONFIGURATION */ 391 { 0x46, R, "GET CONFIGURATION" }, 392 /* 47 O PLAY AUDIO MSF */ 393 { 0x47, R, "PLAY AUDIO MSF" }, 394 /* 48 */ 395 /* 49 */ 396 /* 4A M GET EVENT STATUS NOTIFICATION */ 397 { 0x4A, R, "GET EVENT STATUS NOTIFICATION" }, 398 /* 4B O PAUSE/RESUME */ 399 { 0x4B, R, "PAUSE/RESUME" }, 400 /* 4C OOOOO OOOO OOO LOG SELECT */ 401 { 0x4C, ALL & ~(R | B), "LOG SELECT" }, 402 /* 4D OOOOO OOOO OMO LOG SENSE */ 403 { 0x4D, ALL & ~(R | B), "LOG SENSE" }, 404 /* 4E O STOP PLAY/SCAN */ 405 { 0x4E, R, "STOP PLAY/SCAN" }, 406 /* 4F */ 407 /* 50 O XDWRITE(10) */ 408 { 0x50, D, "XDWRITE(10)" }, 409 /* 51 O XPWRITE(10) */ 410 { 0x51, D, "XPWRITE(10)" }, 411 /* 51 O READ DISC INFORMATION */ 412 { 0x51, R, "READ DISC INFORMATION" }, 413 /* 52 O XDREAD(10) */ 414 { 0x52, D, "XDREAD(10)" }, 415 /* 52 O READ TRACK INFORMATION */ 416 { 0x52, R, "READ TRACK INFORMATION" }, 417 /* 53 O RESERVE TRACK */ 418 { 0x53, R, "RESERVE TRACK" }, 419 /* 54 O SEND OPC INFORMATION */ 420 { 0x54, R, "SEND OPC INFORMATION" }, 421 /* 55 OOO OMOOOOMOMO MODE SELECT(10) */ 422 { 0x55, ALL & ~(P), "MODE SELECT(10)" }, 423 /* 56 ZZMZO OOOZ RESERVE(10) */ 424 { 0x56, ALL & ~(R | B | K | V | F | C), "RESERVE(10)" }, 425 /* 56 Z RESERVE ELEMENT(10) */ 426 { 0x56, M, "RESERVE ELEMENT(10)" }, 427 /* 57 ZZMZO OOOZ RELEASE(10) */ 428 { 0x57, ALL & ~(R | B | K | V | F | C), "RELEASE(10)" }, 429 /* 57 Z RELEASE ELEMENT(10) */ 430 { 0x57, M, "RELEASE ELEMENT(10)" }, 431 /* 58 O REPAIR TRACK */ 432 { 0x58, R, "REPAIR TRACK" }, 433 /* 59 */ 434 /* 5A OOO OMOOOOMOMO MODE SENSE(10) */ 435 { 0x5A, ALL & ~(P), "MODE SENSE(10)" }, 436 /* 5B O CLOSE TRACK/SESSION */ 437 { 0x5B, R, "CLOSE TRACK/SESSION" }, 438 /* 5C O READ BUFFER CAPACITY */ 439 { 0x5C, R, "READ BUFFER CAPACITY" }, 440 /* 5D O SEND CUE SHEET */ 441 { 0x5D, R, "SEND CUE SHEET" }, 442 /* 5E OOOOO OOOO M PERSISTENT RESERVE IN */ 443 { 0x5E, ALL & ~(R | B | K | V | C), "PERSISTENT RESERVE IN" }, 444 /* 5F OOOOO OOOO M PERSISTENT RESERVE OUT */ 445 { 0x5F, ALL & ~(R | B | K | V | C), "PERSISTENT RESERVE OUT" }, 446 /* 7E OO O OOOO O extended CDB */ 447 { 0x7E, D | T | R | M | A | E | B | V, "extended CDB" }, 448 /* 7F O M variable length CDB (more than 16 bytes) */ 449 { 0x7F, D | F, "variable length CDB (more than 16 bytes)" }, 450 /* 80 Z XDWRITE EXTENDED(16) */ 451 { 0x80, D, "XDWRITE EXTENDED(16)" }, 452 /* 80 M WRITE FILEMARKS(16) */ 453 { 0x80, T, "WRITE FILEMARKS(16)" }, 454 /* 81 Z REBUILD(16) */ 455 { 0x81, D, "REBUILD(16)" }, 456 /* 81 O READ REVERSE(16) */ 457 { 0x81, T, "READ REVERSE(16)" }, 458 /* 82 Z REGENERATE(16) */ 459 { 0x82, D, "REGENERATE(16)" }, 460 /* 83 OOOOO O OO EXTENDED COPY */ 461 { 0x83, D | T | L | P | W | O | K | V, "EXTENDED COPY" }, 462 /* 84 OOOOO O OO RECEIVE COPY RESULTS */ 463 { 0x84, D | T | L | P | W | O | K | V, "RECEIVE COPY RESULTS" }, 464 /* 85 O O O ATA COMMAND PASS THROUGH(16) */ 465 { 0x85, D | R | B, "ATA COMMAND PASS THROUGH(16)" }, 466 /* 86 OO OO OOOOOOO ACCESS CONTROL IN */ 467 { 0x86, ALL & ~(L | R | F), "ACCESS CONTROL IN" }, 468 /* 87 OO OO OOOOOOO ACCESS CONTROL OUT */ 469 { 0x87, ALL & ~(L | R | F), "ACCESS CONTROL OUT" }, 470 /* 471 * XXX READ(16)/WRITE(16) were not listed for CD/DVE in op-num.txt 472 * but we had it since r1.40. Do we really want them? 473 */ 474 /* 88 MM O O O READ(16) */ 475 { 0x88, D | T | W | O | B, "READ(16)" }, 476 /* 89 O COMPARE AND WRITE*/ 477 { 0x89, D, "COMPARE AND WRITE" }, 478 /* 8A OM O O O WRITE(16) */ 479 { 0x8A, D | T | W | O | B, "WRITE(16)" }, 480 /* 8B O ORWRITE */ 481 { 0x8B, D, "ORWRITE" }, 482 /* 8C OO O OO O M READ ATTRIBUTE */ 483 { 0x8C, D | T | W | O | M | B | V, "READ ATTRIBUTE" }, 484 /* 8D OO O OO O O WRITE ATTRIBUTE */ 485 { 0x8D, D | T | W | O | M | B | V, "WRITE ATTRIBUTE" }, 486 /* 8E O O O O WRITE AND VERIFY(16) */ 487 { 0x8E, D | W | O | B, "WRITE AND VERIFY(16)" }, 488 /* 8F OO O O O VERIFY(16) */ 489 { 0x8F, D | T | W | O | B, "VERIFY(16)" }, 490 /* 90 O O O O PRE-FETCH(16) */ 491 { 0x90, D | W | O | B, "PRE-FETCH(16)" }, 492 /* 91 O O O O SYNCHRONIZE CACHE(16) */ 493 { 0x91, D | W | O | B, "SYNCHRONIZE CACHE(16)" }, 494 /* 91 O SPACE(16) */ 495 { 0x91, T, "SPACE(16)" }, 496 /* 92 Z O O LOCK UNLOCK CACHE(16) */ 497 { 0x92, D | W | O, "LOCK UNLOCK CACHE(16)" }, 498 /* 92 O LOCATE(16) */ 499 { 0x92, T, "LOCATE(16)" }, 500 /* 93 O WRITE SAME(16) */ 501 { 0x93, D, "WRITE SAME(16)" }, 502 /* 93 M ERASE(16) */ 503 { 0x93, T, "ERASE(16)" }, 504 /* 94 [usage proposed by SCSI Socket Services project] */ 505 /* 95 [usage proposed by SCSI Socket Services project] */ 506 /* 96 [usage proposed by SCSI Socket Services project] */ 507 /* 97 [usage proposed by SCSI Socket Services project] */ 508 /* 98 */ 509 /* 99 */ 510 /* 9A */ 511 /* 9B */ 512 /* 9C */ 513 /* 9D */ 514 /* XXX KDM ALL for this? op-num.txt defines it for none.. */ 515 /* 9E SERVICE ACTION IN(16) */ 516 { 0x9E, ALL, "SERVICE ACTION IN(16)" }, 517 /* XXX KDM ALL for this? op-num.txt defines it for ADC.. */ 518 /* 9F M SERVICE ACTION OUT(16) */ 519 { 0x9F, ALL, "SERVICE ACTION OUT(16)" }, 520 /* A0 MMOOO OMMM OMO REPORT LUNS */ 521 { 0xA0, ALL & ~(R | B), "REPORT LUNS" }, 522 /* A1 O BLANK */ 523 { 0xA1, R, "BLANK" }, 524 /* A1 O O ATA COMMAND PASS THROUGH(12) */ 525 { 0xA1, D | B, "ATA COMMAND PASS THROUGH(12)" }, 526 /* A2 OO O O SECURITY PROTOCOL IN */ 527 { 0xA2, D | T | R | V, "SECURITY PROTOCOL IN" }, 528 /* A3 OOO O OOMOOOM MAINTENANCE (IN) */ 529 { 0xA3, ALL & ~(P | R | F), "MAINTENANCE (IN)" }, 530 /* A3 O SEND KEY */ 531 { 0xA3, R, "SEND KEY" }, 532 /* A4 OOO O OOOOOOO MAINTENANCE (OUT) */ 533 { 0xA4, ALL & ~(P | R | F), "MAINTENANCE (OUT)" }, 534 /* A4 O REPORT KEY */ 535 { 0xA4, R, "REPORT KEY" }, 536 /* A5 O O OM MOVE MEDIUM */ 537 { 0xA5, T | W | O | M, "MOVE MEDIUM" }, 538 /* A5 O PLAY AUDIO(12) */ 539 { 0xA5, R, "PLAY AUDIO(12)" }, 540 /* A6 O EXCHANGE MEDIUM */ 541 { 0xA6, M, "EXCHANGE MEDIUM" }, 542 /* A6 O LOAD/UNLOAD C/DVD */ 543 { 0xA6, R, "LOAD/UNLOAD C/DVD" }, 544 /* A7 ZZ O O MOVE MEDIUM ATTACHED */ 545 { 0xA7, D | T | W | O, "MOVE MEDIUM ATTACHED" }, 546 /* A7 O SET READ AHEAD */ 547 { 0xA7, R, "SET READ AHEAD" }, 548 /* A8 O OOO READ(12) */ 549 { 0xA8, D | W | R | O, "READ(12)" }, 550 /* A8 GET MESSAGE(12) */ 551 { 0xA8, C, "GET MESSAGE(12)" }, 552 /* A9 O SERVICE ACTION OUT(12) */ 553 { 0xA9, V, "SERVICE ACTION OUT(12)" }, 554 /* AA O OOO WRITE(12) */ 555 { 0xAA, D | W | R | O, "WRITE(12)" }, 556 /* AA SEND MESSAGE(12) */ 557 { 0xAA, C, "SEND MESSAGE(12)" }, 558 /* AB O O SERVICE ACTION IN(12) */ 559 { 0xAB, R | V, "SERVICE ACTION IN(12)" }, 560 /* AC O ERASE(12) */ 561 { 0xAC, O, "ERASE(12)" }, 562 /* AC O GET PERFORMANCE */ 563 { 0xAC, R, "GET PERFORMANCE" }, 564 /* AD O READ DVD STRUCTURE */ 565 { 0xAD, R, "READ DVD STRUCTURE" }, 566 /* AE O O O WRITE AND VERIFY(12) */ 567 { 0xAE, D | W | O, "WRITE AND VERIFY(12)" }, 568 /* AF O OZO VERIFY(12) */ 569 { 0xAF, D | W | R | O, "VERIFY(12)" }, 570 /* B0 ZZZ SEARCH DATA HIGH(12) */ 571 { 0xB0, W | R | O, "SEARCH DATA HIGH(12)" }, 572 /* B1 ZZZ SEARCH DATA EQUAL(12) */ 573 { 0xB1, W | R | O, "SEARCH DATA EQUAL(12)" }, 574 /* B2 ZZZ SEARCH DATA LOW(12) */ 575 { 0xB2, W | R | O, "SEARCH DATA LOW(12)" }, 576 /* B3 Z OZO SET LIMITS(12) */ 577 { 0xB3, D | W | R | O, "SET LIMITS(12)" }, 578 /* B4 ZZ OZO READ ELEMENT STATUS ATTACHED */ 579 { 0xB4, D | T | W | R | O, "READ ELEMENT STATUS ATTACHED" }, 580 /* B5 OO O O SECURITY PROTOCOL OUT */ 581 { 0xB5, D | T | R | V, "SECURITY PROTOCOL OUT" }, 582 /* B5 O REQUEST VOLUME ELEMENT ADDRESS */ 583 { 0xB5, M, "REQUEST VOLUME ELEMENT ADDRESS" }, 584 /* B6 O SEND VOLUME TAG */ 585 { 0xB6, M, "SEND VOLUME TAG" }, 586 /* B6 O SET STREAMING */ 587 { 0xB6, R, "SET STREAMING" }, 588 /* B7 O O READ DEFECT DATA(12) */ 589 { 0xB7, D | O, "READ DEFECT DATA(12)" }, 590 /* B8 O OZOM READ ELEMENT STATUS */ 591 { 0xB8, T | W | R | O | M, "READ ELEMENT STATUS" }, 592 /* B9 O READ CD MSF */ 593 { 0xB9, R, "READ CD MSF" }, 594 /* BA O O OOMO REDUNDANCY GROUP (IN) */ 595 { 0xBA, D | W | O | M | A | E, "REDUNDANCY GROUP (IN)" }, 596 /* BA O SCAN */ 597 { 0xBA, R, "SCAN" }, 598 /* BB O O OOOO REDUNDANCY GROUP (OUT) */ 599 { 0xBB, D | W | O | M | A | E, "REDUNDANCY GROUP (OUT)" }, 600 /* BB O SET CD SPEED */ 601 { 0xBB, R, "SET CD SPEED" }, 602 /* BC O O OOMO SPARE (IN) */ 603 { 0xBC, D | W | O | M | A | E, "SPARE (IN)" }, 604 /* BD O O OOOO SPARE (OUT) */ 605 { 0xBD, D | W | O | M | A | E, "SPARE (OUT)" }, 606 /* BD O MECHANISM STATUS */ 607 { 0xBD, R, "MECHANISM STATUS" }, 608 /* BE O O OOMO VOLUME SET (IN) */ 609 { 0xBE, D | W | O | M | A | E, "VOLUME SET (IN)" }, 610 /* BE O READ CD */ 611 { 0xBE, R, "READ CD" }, 612 /* BF O O OOOO VOLUME SET (OUT) */ 613 { 0xBF, D | W | O | M | A | E, "VOLUME SET (OUT)" }, 614 /* BF O SEND DVD STRUCTURE */ 615 { 0xBF, R, "SEND DVD STRUCTURE" } 616}; 617 618const char * 619scsi_op_desc(u_int16_t opcode, struct scsi_inquiry_data *inq_data) 620{ 621 caddr_t match; 622 int i, j; 623 u_int32_t opmask; 624 u_int16_t pd_type; 625 int num_ops[2]; 626 struct op_table_entry *table[2]; 627 int num_tables; 628 629 /* 630 * If we've got inquiry data, use it to determine what type of 631 * device we're dealing with here. Otherwise, assume direct 632 * access. 633 */ 634 if (inq_data == NULL) { 635 pd_type = T_DIRECT; 636 match = NULL; 637 } else { 638 pd_type = SID_TYPE(inq_data); 639 640 match = cam_quirkmatch((caddr_t)inq_data, 641 (caddr_t)scsi_op_quirk_table, 642 sizeof(scsi_op_quirk_table)/ 643 sizeof(*scsi_op_quirk_table), 644 sizeof(*scsi_op_quirk_table), 645 scsi_inquiry_match); 646 } 647 648 if (match != NULL) { 649 table[0] = ((struct scsi_op_quirk_entry *)match)->op_table; 650 num_ops[0] = ((struct scsi_op_quirk_entry *)match)->num_ops; 651 table[1] = scsi_op_codes; 652 num_ops[1] = sizeof(scsi_op_codes)/sizeof(scsi_op_codes[0]); 653 num_tables = 2; 654 } else { 655 /* 656 * If this is true, we have a vendor specific opcode that 657 * wasn't covered in the quirk table. 658 */ 659 if ((opcode > 0xBF) || ((opcode > 0x5F) && (opcode < 0x80))) 660 return("Vendor Specific Command"); 661 662 table[0] = scsi_op_codes; 663 num_ops[0] = sizeof(scsi_op_codes)/sizeof(scsi_op_codes[0]); 664 num_tables = 1; 665 } 666 667 /* RBC is 'Simplified' Direct Access Device */ 668 if (pd_type == T_RBC) 669 pd_type = T_DIRECT; 670 671 /* Map NODEVICE to Direct Access Device to handle REPORT LUNS, etc. */ 672 if (pd_type == T_NODEVICE) 673 pd_type = T_DIRECT; 674 675 opmask = 1 << pd_type; 676 677 for (j = 0; j < num_tables; j++) { 678 for (i = 0;i < num_ops[j] && table[j][i].opcode <= opcode; i++){ 679 if ((table[j][i].opcode == opcode) 680 && ((table[j][i].opmask & opmask) != 0)) 681 return(table[j][i].desc); 682 } 683 } 684 685 /* 686 * If we can't find a match for the command in the table, we just 687 * assume it's a vendor specifc command. 688 */ 689 return("Vendor Specific Command"); 690 691} 692 693#else /* SCSI_NO_OP_STRINGS */ 694 695const char * 696scsi_op_desc(u_int16_t opcode, struct scsi_inquiry_data *inq_data) 697{ 698 return(""); 699} 700 701#endif 702 703 704#if !defined(SCSI_NO_SENSE_STRINGS) 705#define SST(asc, ascq, action, desc) \ 706 asc, ascq, action, desc 707#else 708const char empty_string[] = ""; 709 710#define SST(asc, ascq, action, desc) \ 711 asc, ascq, action, empty_string 712#endif 713 714const struct sense_key_table_entry sense_key_table[] = 715{ 716 { SSD_KEY_NO_SENSE, SS_NOP, "NO SENSE" }, 717 { SSD_KEY_RECOVERED_ERROR, SS_NOP|SSQ_PRINT_SENSE, "RECOVERED ERROR" }, 718 { SSD_KEY_NOT_READY, SS_RDEF, "NOT READY" }, 719 { SSD_KEY_MEDIUM_ERROR, SS_RDEF, "MEDIUM ERROR" }, 720 { SSD_KEY_HARDWARE_ERROR, SS_RDEF, "HARDWARE FAILURE" }, 721 { SSD_KEY_ILLEGAL_REQUEST, SS_FATAL|EINVAL, "ILLEGAL REQUEST" }, 722 { SSD_KEY_UNIT_ATTENTION, SS_FATAL|ENXIO, "UNIT ATTENTION" }, 723 { SSD_KEY_DATA_PROTECT, SS_FATAL|EACCES, "DATA PROTECT" }, 724 { SSD_KEY_BLANK_CHECK, SS_FATAL|ENOSPC, "BLANK CHECK" }, 725 { SSD_KEY_Vendor_Specific, SS_FATAL|EIO, "Vendor Specific" }, 726 { SSD_KEY_COPY_ABORTED, SS_FATAL|EIO, "COPY ABORTED" }, 727 { SSD_KEY_ABORTED_COMMAND, SS_RDEF, "ABORTED COMMAND" }, 728 { SSD_KEY_EQUAL, SS_NOP, "EQUAL" }, 729 { SSD_KEY_VOLUME_OVERFLOW, SS_FATAL|EIO, "VOLUME OVERFLOW" }, 730 { SSD_KEY_MISCOMPARE, SS_NOP, "MISCOMPARE" }, 731 { SSD_KEY_COMPLETED, SS_NOP, "COMPLETED" } 732}; 733 734const int sense_key_table_size = 735 sizeof(sense_key_table)/sizeof(sense_key_table[0]); 736 737static struct asc_table_entry quantum_fireball_entries[] = { 738 { SST(0x04, 0x0b, SS_START | SSQ_DECREMENT_COUNT | ENXIO, 739 "Logical unit not ready, initializing cmd. required") } 740}; 741 742static struct asc_table_entry sony_mo_entries[] = { 743 { SST(0x04, 0x00, SS_START | SSQ_DECREMENT_COUNT | ENXIO, 744 "Logical unit not ready, cause not reportable") } 745}; 746 747static struct asc_table_entry hgst_entries[] = { 748 { SST(0x04, 0xF0, SS_RDEF, 749 "Vendor Unique - Logical Unit Not Ready") }, 750 { SST(0x0A, 0x01, SS_RDEF, 751 "Unrecovered Super Certification Log Write Error") }, 752 { SST(0x0A, 0x02, SS_RDEF, 753 "Unrecovered Super Certification Log Read Error") }, 754 { SST(0x15, 0x03, SS_RDEF, 755 "Unrecovered Sector Error") }, 756 { SST(0x3E, 0x04, SS_RDEF, 757 "Unrecovered Self-Test Hard-Cache Test Fail") }, 758 { SST(0x3E, 0x05, SS_RDEF, 759 "Unrecovered Self-Test OTF-Cache Fail") }, 760 { SST(0x40, 0x00, SS_RDEF, 761 "Unrecovered SAT No Buffer Overflow Error") }, 762 { SST(0x40, 0x01, SS_RDEF, 763 "Unrecovered SAT Buffer Overflow Error") }, 764 { SST(0x40, 0x02, SS_RDEF, 765 "Unrecovered SAT No Buffer Overflow With ECS Fault") }, 766 { SST(0x40, 0x03, SS_RDEF, 767 "Unrecovered SAT Buffer Overflow With ECS Fault") }, 768 { SST(0x40, 0x81, SS_RDEF, 769 "DRAM Failure") }, 770 { SST(0x44, 0x0B, SS_RDEF, 771 "Vendor Unique - Internal Target Failure") }, 772 { SST(0x44, 0xF2, SS_RDEF, 773 "Vendor Unique - Internal Target Failure") }, 774 { SST(0x44, 0xF6, SS_RDEF, 775 "Vendor Unique - Internal Target Failure") }, 776 { SST(0x44, 0xF9, SS_RDEF, 777 "Vendor Unique - Internal Target Failure") }, 778 { SST(0x44, 0xFA, SS_RDEF, 779 "Vendor Unique - Internal Target Failure") }, 780 { SST(0x5D, 0x22, SS_RDEF, 781 "Extreme Over-Temperature Warning") }, 782 { SST(0x5D, 0x50, SS_RDEF, 783 "Load/Unload cycle Count Warning") }, 784 { SST(0x81, 0x00, SS_RDEF, 785 "Vendor Unique - Internal Logic Error") }, 786 { SST(0x85, 0x00, SS_RDEF, 787 "Vendor Unique - Internal Key Seed Error") }, 788}; 789 790static struct asc_table_entry seagate_entries[] = { 791 { SST(0x04, 0xF0, SS_RDEF, 792 "Logical Unit Not Ready, super certify in Progress") }, 793 { SST(0x08, 0x86, SS_RDEF, 794 "Write Fault Data Corruption") }, 795 { SST(0x09, 0x0D, SS_RDEF, 796 "Tracking Failure") }, 797 { SST(0x09, 0x0E, SS_RDEF, 798 "ETF Failure") }, 799 { SST(0x0B, 0x5D, SS_RDEF, 800 "Pre-SMART Warning") }, 801 { SST(0x0B, 0x85, SS_RDEF, 802 "5V Voltage Warning") }, 803 { SST(0x0B, 0x8C, SS_RDEF, 804 "12V Voltage Warning") }, 805 { SST(0x0C, 0xFF, SS_RDEF, 806 "Write Error - Too many error recovery revs") }, 807 { SST(0x11, 0xFF, SS_RDEF, 808 "Unrecovered Read Error - Too many error recovery revs") }, 809 { SST(0x19, 0x0E, SS_RDEF, 810 "Fewer than 1/2 defect list copies") }, 811 { SST(0x20, 0xF3, SS_RDEF, 812 "Illegal CDB linked to skip mask cmd") }, 813 { SST(0x24, 0xF0, SS_RDEF, 814 "Illegal byte in CDB, LBA not matching") }, 815 { SST(0x24, 0xF1, SS_RDEF, 816 "Illegal byte in CDB, LEN not matching") }, 817 { SST(0x24, 0xF2, SS_RDEF, 818 "Mask not matching transfer length") }, 819 { SST(0x24, 0xF3, SS_RDEF, 820 "Drive formatted without plist") }, 821 { SST(0x26, 0x95, SS_RDEF, 822 "Invalid Field Parameter - CAP File") }, 823 { SST(0x26, 0x96, SS_RDEF, 824 "Invalid Field Parameter - RAP File") }, 825 { SST(0x26, 0x97, SS_RDEF, 826 "Invalid Field Parameter - TMS Firmware Tag") }, 827 { SST(0x26, 0x98, SS_RDEF, 828 "Invalid Field Parameter - Check Sum") }, 829 { SST(0x26, 0x99, SS_RDEF, 830 "Invalid Field Parameter - Firmware Tag") }, 831 { SST(0x29, 0x08, SS_RDEF, 832 "Write Log Dump data") }, 833 { SST(0x29, 0x09, SS_RDEF, 834 "Write Log Dump data") }, 835 { SST(0x29, 0x0A, SS_RDEF, 836 "Reserved disk space") }, 837 { SST(0x29, 0x0B, SS_RDEF, 838 "SDBP") }, 839 { SST(0x29, 0x0C, SS_RDEF, 840 "SDBP") }, 841 { SST(0x31, 0x91, SS_RDEF, 842 "Format Corrupted World Wide Name (WWN) is Invalid") }, 843 { SST(0x32, 0x03, SS_RDEF, 844 "Defect List - Length exceeds Command Allocated Length") }, 845 { SST(0x33, 0x00, SS_RDEF, 846 "Flash not ready for access") }, 847 { SST(0x3F, 0x70, SS_RDEF, 848 "Invalid RAP block") }, 849 { SST(0x3F, 0x71, SS_RDEF, 850 "RAP/ETF mismatch") }, 851 { SST(0x3F, 0x90, SS_RDEF, 852 "Invalid CAP block") }, 853 { SST(0x3F, 0x91, SS_RDEF, 854 "World Wide Name (WWN) Mismatch") }, 855 { SST(0x40, 0x01, SS_RDEF, 856 "DRAM Parity Error") }, 857 { SST(0x40, 0x02, SS_RDEF, 858 "DRAM Parity Error") }, 859 { SST(0x42, 0x0A, SS_RDEF, 860 "Loopback Test") }, 861 { SST(0x42, 0x0B, SS_RDEF, 862 "Loopback Test") }, 863 { SST(0x44, 0xF2, SS_RDEF, 864 "Compare error during data integrity check") }, 865 { SST(0x44, 0xF6, SS_RDEF, 866 "Unrecoverable error during data integrity check") }, 867 { SST(0x47, 0x80, SS_RDEF, 868 "Fibre Channel Sequence Error") }, 869 { SST(0x4E, 0x01, SS_RDEF, 870 "Information Unit Too Short") }, 871 { SST(0x80, 0x00, SS_RDEF, 872 "General Firmware Error / Command Timeout") }, 873 { SST(0x80, 0x01, SS_RDEF, 874 "Command Timeout") }, 875 { SST(0x80, 0x02, SS_RDEF, 876 "Command Timeout") }, 877 { SST(0x80, 0x80, SS_RDEF, 878 "FC FIFO Error During Read Transfer") }, 879 { SST(0x80, 0x81, SS_RDEF, 880 "FC FIFO Error During Write Transfer") }, 881 { SST(0x80, 0x82, SS_RDEF, 882 "DISC FIFO Error During Read Transfer") }, 883 { SST(0x80, 0x83, SS_RDEF, 884 "DISC FIFO Error During Write Transfer") }, 885 { SST(0x80, 0x84, SS_RDEF, 886 "LBA Seeded LRC Error on Read") }, 887 { SST(0x80, 0x85, SS_RDEF, 888 "LBA Seeded LRC Error on Write") }, 889 { SST(0x80, 0x86, SS_RDEF, 890 "IOEDC Error on Read") }, 891 { SST(0x80, 0x87, SS_RDEF, 892 "IOEDC Error on Write") }, 893 { SST(0x80, 0x88, SS_RDEF, 894 "Host Parity Check Failed") }, 895 { SST(0x80, 0x89, SS_RDEF, 896 "IOEDC error on read detected by formatter") }, 897 { SST(0x80, 0x8A, SS_RDEF, 898 "Host Parity Errors / Host FIFO Initialization Failed") }, 899 { SST(0x80, 0x8B, SS_RDEF, 900 "Host Parity Errors") }, 901 { SST(0x80, 0x8C, SS_RDEF, 902 "Host Parity Errors") }, 903 { SST(0x80, 0x8D, SS_RDEF, 904 "Host Parity Errors") }, 905 { SST(0x81, 0x00, SS_RDEF, 906 "LA Check Failed") }, 907 { SST(0x82, 0x00, SS_RDEF, 908 "Internal client detected insufficient buffer") }, 909 { SST(0x84, 0x00, SS_RDEF, 910 "Scheduled Diagnostic And Repair") }, 911}; 912 913static struct scsi_sense_quirk_entry sense_quirk_table[] = { 914 { 915 /* 916 * XXX The Quantum Fireball ST and SE like to return 0x04 0x0b 917 * when they really should return 0x04 0x02. 918 */ 919 {T_DIRECT, SIP_MEDIA_FIXED, "QUANTUM", "FIREBALL S*", "*"}, 920 /*num_sense_keys*/0, 921 sizeof(quantum_fireball_entries)/sizeof(struct asc_table_entry), 922 /*sense key entries*/NULL, 923 quantum_fireball_entries 924 }, 925 { 926 /* 927 * This Sony MO drive likes to return 0x04, 0x00 when it 928 * isn't spun up. 929 */ 930 {T_DIRECT, SIP_MEDIA_REMOVABLE, "SONY", "SMO-*", "*"}, 931 /*num_sense_keys*/0, 932 sizeof(sony_mo_entries)/sizeof(struct asc_table_entry), 933 /*sense key entries*/NULL, 934 sony_mo_entries 935 }, 936 { 937 /* 938 * HGST vendor-specific error codes 939 */ 940 {T_DIRECT, SIP_MEDIA_FIXED, "HGST", "*", "*"}, 941 /*num_sense_keys*/0, 942 sizeof(hgst_entries)/sizeof(struct asc_table_entry), 943 /*sense key entries*/NULL, 944 hgst_entries 945 }, 946 { 947 /* 948 * SEAGATE vendor-specific error codes 949 */ 950 {T_DIRECT, SIP_MEDIA_FIXED, "SEAGATE", "*", "*"}, 951 /*num_sense_keys*/0, 952 sizeof(seagate_entries)/sizeof(struct asc_table_entry), 953 /*sense key entries*/NULL, 954 seagate_entries 955 } 956}; 957 958const int sense_quirk_table_size = 959 sizeof(sense_quirk_table)/sizeof(sense_quirk_table[0]); 960 961static struct asc_table_entry asc_table[] = { 962 /* 963 * From: http://www.t10.org/lists/asc-num.txt 964 * Modifications by Jung-uk Kim (jkim@FreeBSD.org) 965 */ 966 /* 967 * File: ASC-NUM.TXT 968 * 969 * SCSI ASC/ASCQ Assignments 970 * Numeric Sorted Listing 971 * as of 5/20/12 972 * 973 * D - DIRECT ACCESS DEVICE (SBC-2) device column key 974 * .T - SEQUENTIAL ACCESS DEVICE (SSC) ------------------- 975 * . L - PRINTER DEVICE (SSC) blank = reserved 976 * . P - PROCESSOR DEVICE (SPC) not blank = allowed 977 * . .W - WRITE ONCE READ MULTIPLE DEVICE (SBC-2) 978 * . . R - CD DEVICE (MMC) 979 * . . O - OPTICAL MEMORY DEVICE (SBC-2) 980 * . . .M - MEDIA CHANGER DEVICE (SMC) 981 * . . . A - STORAGE ARRAY DEVICE (SCC) 982 * . . . E - ENCLOSURE SERVICES DEVICE (SES) 983 * . . . .B - SIMPLIFIED DIRECT-ACCESS DEVICE (RBC) 984 * . . . . K - OPTICAL CARD READER/WRITER DEVICE (OCRW) 985 * . . . . V - AUTOMATION/DRIVE INTERFACE (ADC) 986 * . . . . .F - OBJECT-BASED STORAGE (OSD) 987 * DTLPWROMAEBKVF 988 * ASC ASCQ Action 989 * Description 990 */ 991 /* DTLPWROMAEBKVF */ 992 { SST(0x00, 0x00, SS_NOP, 993 "No additional sense information") }, 994 /* T */ 995 { SST(0x00, 0x01, SS_RDEF, 996 "Filemark detected") }, 997 /* T */ 998 { SST(0x00, 0x02, SS_RDEF, 999 "End-of-partition/medium detected") }, 1000 /* T */ 1001 { SST(0x00, 0x03, SS_RDEF, 1002 "Setmark detected") }, 1003 /* T */ 1004 { SST(0x00, 0x04, SS_RDEF, 1005 "Beginning-of-partition/medium detected") }, 1006 /* TL */ 1007 { SST(0x00, 0x05, SS_RDEF, 1008 "End-of-data detected") }, 1009 /* DTLPWROMAEBKVF */ 1010 { SST(0x00, 0x06, SS_RDEF, 1011 "I/O process terminated") }, 1012 /* T */ 1013 { SST(0x00, 0x07, SS_RDEF, /* XXX TBD */ 1014 "Programmable early warning detected") }, 1015 /* R */ 1016 { SST(0x00, 0x11, SS_FATAL | EBUSY, 1017 "Audio play operation in progress") }, 1018 /* R */ 1019 { SST(0x00, 0x12, SS_NOP, 1020 "Audio play operation paused") }, 1021 /* R */ 1022 { SST(0x00, 0x13, SS_NOP, 1023 "Audio play operation successfully completed") }, 1024 /* R */ 1025 { SST(0x00, 0x14, SS_RDEF, 1026 "Audio play operation stopped due to error") }, 1027 /* R */ 1028 { SST(0x00, 0x15, SS_NOP, 1029 "No current audio status to return") }, 1030 /* DTLPWROMAEBKVF */ 1031 { SST(0x00, 0x16, SS_FATAL | EBUSY, 1032 "Operation in progress") }, 1033 /* DTL WROMAEBKVF */ 1034 { SST(0x00, 0x17, SS_RDEF, 1035 "Cleaning requested") }, 1036 /* T */ 1037 { SST(0x00, 0x18, SS_RDEF, /* XXX TBD */ 1038 "Erase operation in progress") }, 1039 /* T */ 1040 { SST(0x00, 0x19, SS_RDEF, /* XXX TBD */ 1041 "Locate operation in progress") }, 1042 /* T */ 1043 { SST(0x00, 0x1A, SS_RDEF, /* XXX TBD */ 1044 "Rewind operation in progress") }, 1045 /* T */ 1046 { SST(0x00, 0x1B, SS_RDEF, /* XXX TBD */ 1047 "Set capacity operation in progress") }, 1048 /* T */ 1049 { SST(0x00, 0x1C, SS_RDEF, /* XXX TBD */ 1050 "Verify operation in progress") }, 1051 /* DT B */ 1052 { SST(0x00, 0x1D, SS_RDEF, /* XXX TBD */ 1053 "ATA pass through information available") }, 1054 /* DT R MAEBKV */ 1055 { SST(0x00, 0x1E, SS_RDEF, /* XXX TBD */ 1056 "Conflicting SA creation request") }, 1057 /* DT B */ 1058 { SST(0x00, 0x1F, SS_RDEF, /* XXX TBD */ 1059 "Logical unit transitioning to another power condition") }, 1060 /* DT P B */ 1061 { SST(0x00, 0x20, SS_RDEF, /* XXX TBD */ 1062 "Extended copy information available") }, 1063 /* D W O BK */ 1064 { SST(0x01, 0x00, SS_RDEF, 1065 "No index/sector signal") }, 1066 /* D WRO BK */ 1067 { SST(0x02, 0x00, SS_RDEF, 1068 "No seek complete") }, 1069 /* DTL W O BK */ 1070 { SST(0x03, 0x00, SS_RDEF, 1071 "Peripheral device write fault") }, 1072 /* T */ 1073 { SST(0x03, 0x01, SS_RDEF, 1074 "No write current") }, 1075 /* T */ 1076 { SST(0x03, 0x02, SS_RDEF, 1077 "Excessive write errors") }, 1078 /* DTLPWROMAEBKVF */ 1079 { SST(0x04, 0x00, SS_RDEF, 1080 "Logical unit not ready, cause not reportable") }, 1081 /* DTLPWROMAEBKVF */ 1082 { SST(0x04, 0x01, SS_WAIT | EBUSY, 1083 "Logical unit is in process of becoming ready") }, 1084 /* DTLPWROMAEBKVF */ 1085 { SST(0x04, 0x02, SS_START | SSQ_DECREMENT_COUNT | ENXIO, 1086 "Logical unit not ready, initializing command required") }, 1087 /* DTLPWROMAEBKVF */ 1088 { SST(0x04, 0x03, SS_FATAL | ENXIO, 1089 "Logical unit not ready, manual intervention required") }, 1090 /* DTL RO B */ 1091 { SST(0x04, 0x04, SS_FATAL | EBUSY, 1092 "Logical unit not ready, format in progress") }, 1093 /* DT W O A BK F */ 1094 { SST(0x04, 0x05, SS_FATAL | EBUSY, 1095 "Logical unit not ready, rebuild in progress") }, 1096 /* DT W O A BK */ 1097 { SST(0x04, 0x06, SS_FATAL | EBUSY, 1098 "Logical unit not ready, recalculation in progress") }, 1099 /* DTLPWROMAEBKVF */ 1100 { SST(0x04, 0x07, SS_FATAL | EBUSY, 1101 "Logical unit not ready, operation in progress") }, 1102 /* R */ 1103 { SST(0x04, 0x08, SS_FATAL | EBUSY, 1104 "Logical unit not ready, long write in progress") }, 1105 /* DTLPWROMAEBKVF */ 1106 { SST(0x04, 0x09, SS_RDEF, /* XXX TBD */ 1107 "Logical unit not ready, self-test in progress") }, 1108 /* DTLPWROMAEBKVF */ 1109 { SST(0x04, 0x0A, SS_WAIT | ENXIO, 1110 "Logical unit not accessible, asymmetric access state transition")}, 1111 /* DTLPWROMAEBKVF */ 1112 { SST(0x04, 0x0B, SS_FATAL | ENXIO, 1113 "Logical unit not accessible, target port in standby state") }, 1114 /* DTLPWROMAEBKVF */ 1115 { SST(0x04, 0x0C, SS_FATAL | ENXIO, 1116 "Logical unit not accessible, target port in unavailable state") }, 1117 /* F */ 1118 { SST(0x04, 0x0D, SS_RDEF, /* XXX TBD */ 1119 "Logical unit not ready, structure check required") }, 1120 /* DT WROM B */ 1121 { SST(0x04, 0x10, SS_RDEF, /* XXX TBD */ 1122 "Logical unit not ready, auxiliary memory not accessible") }, 1123 /* DT WRO AEB VF */ 1124 { SST(0x04, 0x11, SS_WAIT | EBUSY, 1125 "Logical unit not ready, notify (enable spinup) required") }, 1126 /* M V */ 1127 { SST(0x04, 0x12, SS_RDEF, /* XXX TBD */ 1128 "Logical unit not ready, offline") }, 1129 /* DT R MAEBKV */ 1130 { SST(0x04, 0x13, SS_RDEF, /* XXX TBD */ 1131 "Logical unit not ready, SA creation in progress") }, 1132 /* D B */ 1133 { SST(0x04, 0x14, SS_RDEF, /* XXX TBD */ 1134 "Logical unit not ready, space allocation in progress") }, 1135 /* M */ 1136 { SST(0x04, 0x15, SS_RDEF, /* XXX TBD */ 1137 "Logical unit not ready, robotics disabled") }, 1138 /* M */ 1139 { SST(0x04, 0x16, SS_RDEF, /* XXX TBD */ 1140 "Logical unit not ready, configuration required") }, 1141 /* M */ 1142 { SST(0x04, 0x17, SS_RDEF, /* XXX TBD */ 1143 "Logical unit not ready, calibration required") }, 1144 /* M */ 1145 { SST(0x04, 0x18, SS_RDEF, /* XXX TBD */ 1146 "Logical unit not ready, a door is open") }, 1147 /* M */ 1148 { SST(0x04, 0x19, SS_RDEF, /* XXX TBD */ 1149 "Logical unit not ready, operating in sequential mode") }, 1150 /* DT B */ 1151 { SST(0x04, 0x1A, SS_RDEF, /* XXX TBD */ 1152 "Logical unit not ready, START/STOP UNIT command in progress") }, 1153 /* D B */ 1154 { SST(0x04, 0x1B, SS_RDEF, /* XXX TBD */ 1155 "Logical unit not ready, sanitize in progress") }, 1156 /* DT MAEB */ 1157 { SST(0x04, 0x1C, SS_RDEF, /* XXX TBD */ 1158 "Logical unit not ready, additional power use not yet granted") }, 1159 /* DTL WROMAEBKVF */ 1160 { SST(0x05, 0x00, SS_RDEF, 1161 "Logical unit does not respond to selection") }, 1162 /* D WROM BK */ 1163 { SST(0x06, 0x00, SS_RDEF, 1164 "No reference position found") }, 1165 /* DTL WROM BK */ 1166 { SST(0x07, 0x00, SS_RDEF, 1167 "Multiple peripheral devices selected") }, 1168 /* DTL WROMAEBKVF */ 1169 { SST(0x08, 0x00, SS_RDEF, 1170 "Logical unit communication failure") }, 1171 /* DTL WROMAEBKVF */ 1172 { SST(0x08, 0x01, SS_RDEF, 1173 "Logical unit communication time-out") }, 1174 /* DTL WROMAEBKVF */ 1175 { SST(0x08, 0x02, SS_RDEF, 1176 "Logical unit communication parity error") }, 1177 /* DT ROM BK */ 1178 { SST(0x08, 0x03, SS_RDEF, 1179 "Logical unit communication CRC error (Ultra-DMA/32)") }, 1180 /* DTLPWRO K */ 1181 { SST(0x08, 0x04, SS_RDEF, /* XXX TBD */ 1182 "Unreachable copy target") }, 1183 /* DT WRO B */ 1184 { SST(0x09, 0x00, SS_RDEF, 1185 "Track following error") }, 1186 /* WRO K */ 1187 { SST(0x09, 0x01, SS_RDEF, 1188 "Tracking servo failure") }, 1189 /* WRO K */ 1190 { SST(0x09, 0x02, SS_RDEF, 1191 "Focus servo failure") }, 1192 /* WRO */ 1193 { SST(0x09, 0x03, SS_RDEF, 1194 "Spindle servo failure") }, 1195 /* DT WRO B */ 1196 { SST(0x09, 0x04, SS_RDEF, 1197 "Head select fault") }, 1198 /* DTLPWROMAEBKVF */ 1199 { SST(0x0A, 0x00, SS_FATAL | ENOSPC, 1200 "Error log overflow") }, 1201 /* DTLPWROMAEBKVF */ 1202 { SST(0x0B, 0x00, SS_RDEF, 1203 "Warning") }, 1204 /* DTLPWROMAEBKVF */ 1205 { SST(0x0B, 0x01, SS_RDEF, 1206 "Warning - specified temperature exceeded") }, 1207 /* DTLPWROMAEBKVF */ 1208 { SST(0x0B, 0x02, SS_RDEF, 1209 "Warning - enclosure degraded") }, 1210 /* DTLPWROMAEBKVF */ 1211 { SST(0x0B, 0x03, SS_RDEF, /* XXX TBD */ 1212 "Warning - background self-test failed") }, 1213 /* DTLPWRO AEBKVF */ 1214 { SST(0x0B, 0x04, SS_RDEF, /* XXX TBD */ 1215 "Warning - background pre-scan detected medium error") }, 1216 /* DTLPWRO AEBKVF */ 1217 { SST(0x0B, 0x05, SS_RDEF, /* XXX TBD */ 1218 "Warning - background medium scan detected medium error") }, 1219 /* DTLPWROMAEBKVF */ 1220 { SST(0x0B, 0x06, SS_RDEF, /* XXX TBD */ 1221 "Warning - non-volatile cache now volatile") }, 1222 /* DTLPWROMAEBKVF */ 1223 { SST(0x0B, 0x07, SS_RDEF, /* XXX TBD */ 1224 "Warning - degraded power to non-volatile cache") }, 1225 /* DTLPWROMAEBKVF */ 1226 { SST(0x0B, 0x08, SS_RDEF, /* XXX TBD */ 1227 "Warning - power loss expected") }, 1228 /* D */ 1229 { SST(0x0B, 0x09, SS_RDEF, /* XXX TBD */ 1230 "Warning - device statistics notification available") }, 1231 /* T R */ 1232 { SST(0x0C, 0x00, SS_RDEF, 1233 "Write error") }, 1234 /* K */ 1235 { SST(0x0C, 0x01, SS_NOP | SSQ_PRINT_SENSE, 1236 "Write error - recovered with auto reallocation") }, 1237 /* D W O BK */ 1238 { SST(0x0C, 0x02, SS_RDEF, 1239 "Write error - auto reallocation failed") }, 1240 /* D W O BK */ 1241 { SST(0x0C, 0x03, SS_RDEF, 1242 "Write error - recommend reassignment") }, 1243 /* DT W O B */ 1244 { SST(0x0C, 0x04, SS_RDEF, 1245 "Compression check miscompare error") }, 1246 /* DT W O B */ 1247 { SST(0x0C, 0x05, SS_RDEF, 1248 "Data expansion occurred during compression") }, 1249 /* DT W O B */ 1250 { SST(0x0C, 0x06, SS_RDEF, 1251 "Block not compressible") }, 1252 /* R */ 1253 { SST(0x0C, 0x07, SS_RDEF, 1254 "Write error - recovery needed") }, 1255 /* R */ 1256 { SST(0x0C, 0x08, SS_RDEF, 1257 "Write error - recovery failed") }, 1258 /* R */ 1259 { SST(0x0C, 0x09, SS_RDEF, 1260 "Write error - loss of streaming") }, 1261 /* R */ 1262 { SST(0x0C, 0x0A, SS_RDEF, 1263 "Write error - padding blocks added") }, 1264 /* DT WROM B */ 1265 { SST(0x0C, 0x0B, SS_RDEF, /* XXX TBD */ 1266 "Auxiliary memory write error") }, 1267 /* DTLPWRO AEBKVF */ 1268 { SST(0x0C, 0x0C, SS_RDEF, /* XXX TBD */ 1269 "Write error - unexpected unsolicited data") }, 1270 /* DTLPWRO AEBKVF */ 1271 { SST(0x0C, 0x0D, SS_RDEF, /* XXX TBD */ 1272 "Write error - not enough unsolicited data") }, 1273 /* DT W O BK */ 1274 { SST(0x0C, 0x0E, SS_RDEF, /* XXX TBD */ 1275 "Multiple write errors") }, 1276 /* R */ 1277 { SST(0x0C, 0x0F, SS_RDEF, /* XXX TBD */ 1278 "Defects in error window") }, 1279 /* DTLPWRO A K */ 1280 { SST(0x0D, 0x00, SS_RDEF, /* XXX TBD */ 1281 "Error detected by third party temporary initiator") }, 1282 /* DTLPWRO A K */ 1283 { SST(0x0D, 0x01, SS_RDEF, /* XXX TBD */ 1284 "Third party device failure") }, 1285 /* DTLPWRO A K */ 1286 { SST(0x0D, 0x02, SS_RDEF, /* XXX TBD */ 1287 "Copy target device not reachable") }, 1288 /* DTLPWRO A K */ 1289 { SST(0x0D, 0x03, SS_RDEF, /* XXX TBD */ 1290 "Incorrect copy target device type") }, 1291 /* DTLPWRO A K */ 1292 { SST(0x0D, 0x04, SS_RDEF, /* XXX TBD */ 1293 "Copy target device data underrun") }, 1294 /* DTLPWRO A K */ 1295 { SST(0x0D, 0x05, SS_RDEF, /* XXX TBD */ 1296 "Copy target device data overrun") }, 1297 /* DT PWROMAEBK F */ 1298 { SST(0x0E, 0x00, SS_RDEF, /* XXX TBD */ 1299 "Invalid information unit") }, 1300 /* DT PWROMAEBK F */ 1301 { SST(0x0E, 0x01, SS_RDEF, /* XXX TBD */ 1302 "Information unit too short") }, 1303 /* DT PWROMAEBK F */ 1304 { SST(0x0E, 0x02, SS_RDEF, /* XXX TBD */ 1305 "Information unit too long") }, 1306 /* DT P R MAEBK F */ 1307 { SST(0x0E, 0x03, SS_RDEF, /* XXX TBD */ 1308 "Invalid field in command information unit") }, 1309 /* D W O BK */ 1310 { SST(0x10, 0x00, SS_RDEF, 1311 "ID CRC or ECC error") }, 1312 /* DT W O */ 1313 { SST(0x10, 0x01, SS_RDEF, /* XXX TBD */ 1314 "Logical block guard check failed") }, 1315 /* DT W O */ 1316 { SST(0x10, 0x02, SS_RDEF, /* XXX TBD */ 1317 "Logical block application tag check failed") }, 1318 /* DT W O */ 1319 { SST(0x10, 0x03, SS_RDEF, /* XXX TBD */ 1320 "Logical block reference tag check failed") }, 1321 /* T */ 1322 { SST(0x10, 0x04, SS_RDEF, /* XXX TBD */ 1323 "Logical block protection error on recovered buffer data") }, 1324 /* T */ 1325 { SST(0x10, 0x05, SS_RDEF, /* XXX TBD */ 1326 "Logical block protection method error") }, 1327 /* DT WRO BK */ 1328 { SST(0x11, 0x00, SS_FATAL|EIO, 1329 "Unrecovered read error") }, 1330 /* DT WRO BK */ 1331 { SST(0x11, 0x01, SS_FATAL|EIO, 1332 "Read retries exhausted") }, 1333 /* DT WRO BK */ 1334 { SST(0x11, 0x02, SS_FATAL|EIO, 1335 "Error too long to correct") }, 1336 /* DT W O BK */ 1337 { SST(0x11, 0x03, SS_FATAL|EIO, 1338 "Multiple read errors") }, 1339 /* D W O BK */ 1340 { SST(0x11, 0x04, SS_FATAL|EIO, 1341 "Unrecovered read error - auto reallocate failed") }, 1342 /* WRO B */ 1343 { SST(0x11, 0x05, SS_FATAL|EIO, 1344 "L-EC uncorrectable error") }, 1345 /* WRO B */ 1346 { SST(0x11, 0x06, SS_FATAL|EIO, 1347 "CIRC unrecovered error") }, 1348 /* W O B */ 1349 { SST(0x11, 0x07, SS_RDEF, 1350 "Data re-synchronization error") }, 1351 /* T */ 1352 { SST(0x11, 0x08, SS_RDEF, 1353 "Incomplete block read") }, 1354 /* T */ 1355 { SST(0x11, 0x09, SS_RDEF, 1356 "No gap found") }, 1357 /* DT O BK */ 1358 { SST(0x11, 0x0A, SS_RDEF, 1359 "Miscorrected error") }, 1360 /* D W O BK */ 1361 { SST(0x11, 0x0B, SS_FATAL|EIO, 1362 "Unrecovered read error - recommend reassignment") }, 1363 /* D W O BK */ 1364 { SST(0x11, 0x0C, SS_FATAL|EIO, 1365 "Unrecovered read error - recommend rewrite the data") }, 1366 /* DT WRO B */ 1367 { SST(0x11, 0x0D, SS_RDEF, 1368 "De-compression CRC error") }, 1369 /* DT WRO B */ 1370 { SST(0x11, 0x0E, SS_RDEF, 1371 "Cannot decompress using declared algorithm") }, 1372 /* R */ 1373 { SST(0x11, 0x0F, SS_RDEF, 1374 "Error reading UPC/EAN number") }, 1375 /* R */ 1376 { SST(0x11, 0x10, SS_RDEF, 1377 "Error reading ISRC number") }, 1378 /* R */ 1379 { SST(0x11, 0x11, SS_RDEF, 1380 "Read error - loss of streaming") }, 1381 /* DT WROM B */ 1382 { SST(0x11, 0x12, SS_RDEF, /* XXX TBD */ 1383 "Auxiliary memory read error") }, 1384 /* DTLPWRO AEBKVF */ 1385 { SST(0x11, 0x13, SS_RDEF, /* XXX TBD */ 1386 "Read error - failed retransmission request") }, 1387 /* D */ 1388 { SST(0x11, 0x14, SS_RDEF, /* XXX TBD */ 1389 "Read error - LBA marked bad by application client") }, 1390 /* D W O BK */ 1391 { SST(0x12, 0x00, SS_RDEF, 1392 "Address mark not found for ID field") }, 1393 /* D W O BK */ 1394 { SST(0x13, 0x00, SS_RDEF, 1395 "Address mark not found for data field") }, 1396 /* DTL WRO BK */ 1397 { SST(0x14, 0x00, SS_RDEF, 1398 "Recorded entity not found") }, 1399 /* DT WRO BK */ 1400 { SST(0x14, 0x01, SS_RDEF, 1401 "Record not found") }, 1402 /* T */ 1403 { SST(0x14, 0x02, SS_RDEF, 1404 "Filemark or setmark not found") }, 1405 /* T */ 1406 { SST(0x14, 0x03, SS_RDEF, 1407 "End-of-data not found") }, 1408 /* T */ 1409 { SST(0x14, 0x04, SS_RDEF, 1410 "Block sequence error") }, 1411 /* DT W O BK */ 1412 { SST(0x14, 0x05, SS_RDEF, 1413 "Record not found - recommend reassignment") }, 1414 /* DT W O BK */ 1415 { SST(0x14, 0x06, SS_RDEF, 1416 "Record not found - data auto-reallocated") }, 1417 /* T */ 1418 { SST(0x14, 0x07, SS_RDEF, /* XXX TBD */ 1419 "Locate operation failure") }, 1420 /* DTL WROM BK */ 1421 { SST(0x15, 0x00, SS_RDEF, 1422 "Random positioning error") }, 1423 /* DTL WROM BK */ 1424 { SST(0x15, 0x01, SS_RDEF, 1425 "Mechanical positioning error") }, 1426 /* DT WRO BK */ 1427 { SST(0x15, 0x02, SS_RDEF, 1428 "Positioning error detected by read of medium") }, 1429 /* D W O BK */ 1430 { SST(0x16, 0x00, SS_RDEF, 1431 "Data synchronization mark error") }, 1432 /* D W O BK */ 1433 { SST(0x16, 0x01, SS_RDEF, 1434 "Data sync error - data rewritten") }, 1435 /* D W O BK */ 1436 { SST(0x16, 0x02, SS_RDEF, 1437 "Data sync error - recommend rewrite") }, 1438 /* D W O BK */ 1439 { SST(0x16, 0x03, SS_NOP | SSQ_PRINT_SENSE, 1440 "Data sync error - data auto-reallocated") }, 1441 /* D W O BK */ 1442 { SST(0x16, 0x04, SS_RDEF, 1443 "Data sync error - recommend reassignment") }, 1444 /* DT WRO BK */ 1445 { SST(0x17, 0x00, SS_NOP | SSQ_PRINT_SENSE, 1446 "Recovered data with no error correction applied") }, 1447 /* DT WRO BK */ 1448 { SST(0x17, 0x01, SS_NOP | SSQ_PRINT_SENSE, 1449 "Recovered data with retries") }, 1450 /* DT WRO BK */ 1451 { SST(0x17, 0x02, SS_NOP | SSQ_PRINT_SENSE, 1452 "Recovered data with positive head offset") }, 1453 /* DT WRO BK */ 1454 { SST(0x17, 0x03, SS_NOP | SSQ_PRINT_SENSE, 1455 "Recovered data with negative head offset") }, 1456 /* WRO B */ 1457 { SST(0x17, 0x04, SS_NOP | SSQ_PRINT_SENSE, 1458 "Recovered data with retries and/or CIRC applied") }, 1459 /* D WRO BK */ 1460 { SST(0x17, 0x05, SS_NOP | SSQ_PRINT_SENSE, 1461 "Recovered data using previous sector ID") }, 1462 /* D W O BK */ 1463 { SST(0x17, 0x06, SS_NOP | SSQ_PRINT_SENSE, 1464 "Recovered data without ECC - data auto-reallocated") }, 1465 /* D WRO BK */ 1466 { SST(0x17, 0x07, SS_NOP | SSQ_PRINT_SENSE, 1467 "Recovered data without ECC - recommend reassignment") }, 1468 /* D WRO BK */ 1469 { SST(0x17, 0x08, SS_NOP | SSQ_PRINT_SENSE, 1470 "Recovered data without ECC - recommend rewrite") }, 1471 /* D WRO BK */ 1472 { SST(0x17, 0x09, SS_NOP | SSQ_PRINT_SENSE, 1473 "Recovered data without ECC - data rewritten") }, 1474 /* DT WRO BK */ 1475 { SST(0x18, 0x00, SS_NOP | SSQ_PRINT_SENSE, 1476 "Recovered data with error correction applied") }, 1477 /* D WRO BK */ 1478 { SST(0x18, 0x01, SS_NOP | SSQ_PRINT_SENSE, 1479 "Recovered data with error corr. & retries applied") }, 1480 /* D WRO BK */ 1481 { SST(0x18, 0x02, SS_NOP | SSQ_PRINT_SENSE, 1482 "Recovered data - data auto-reallocated") }, 1483 /* R */ 1484 { SST(0x18, 0x03, SS_NOP | SSQ_PRINT_SENSE, 1485 "Recovered data with CIRC") }, 1486 /* R */ 1487 { SST(0x18, 0x04, SS_NOP | SSQ_PRINT_SENSE, 1488 "Recovered data with L-EC") }, 1489 /* D WRO BK */ 1490 { SST(0x18, 0x05, SS_NOP | SSQ_PRINT_SENSE, 1491 "Recovered data - recommend reassignment") }, 1492 /* D WRO BK */ 1493 { SST(0x18, 0x06, SS_NOP | SSQ_PRINT_SENSE, 1494 "Recovered data - recommend rewrite") }, 1495 /* D W O BK */ 1496 { SST(0x18, 0x07, SS_NOP | SSQ_PRINT_SENSE, 1497 "Recovered data with ECC - data rewritten") }, 1498 /* R */ 1499 { SST(0x18, 0x08, SS_RDEF, /* XXX TBD */ 1500 "Recovered data with linking") }, 1501 /* D O K */ 1502 { SST(0x19, 0x00, SS_RDEF, 1503 "Defect list error") }, 1504 /* D O K */ 1505 { SST(0x19, 0x01, SS_RDEF, 1506 "Defect list not available") }, 1507 /* D O K */ 1508 { SST(0x19, 0x02, SS_RDEF, 1509 "Defect list error in primary list") }, 1510 /* D O K */ 1511 { SST(0x19, 0x03, SS_RDEF, 1512 "Defect list error in grown list") }, 1513 /* DTLPWROMAEBKVF */ 1514 { SST(0x1A, 0x00, SS_RDEF, 1515 "Parameter list length error") }, 1516 /* DTLPWROMAEBKVF */ 1517 { SST(0x1B, 0x00, SS_RDEF, 1518 "Synchronous data transfer error") }, 1519 /* D O BK */ 1520 { SST(0x1C, 0x00, SS_RDEF, 1521 "Defect list not found") }, 1522 /* D O BK */ 1523 { SST(0x1C, 0x01, SS_RDEF, 1524 "Primary defect list not found") }, 1525 /* D O BK */ 1526 { SST(0x1C, 0x02, SS_RDEF, 1527 "Grown defect list not found") }, 1528 /* DT WRO BK */ 1529 { SST(0x1D, 0x00, SS_FATAL, 1530 "Miscompare during verify operation") }, 1531 /* D B */ 1532 { SST(0x1D, 0x01, SS_RDEF, /* XXX TBD */ 1533 "Miscomparable verify of unmapped LBA") }, 1534 /* D W O BK */ 1535 { SST(0x1E, 0x00, SS_NOP | SSQ_PRINT_SENSE, 1536 "Recovered ID with ECC correction") }, 1537 /* D O K */ 1538 { SST(0x1F, 0x00, SS_RDEF, 1539 "Partial defect list transfer") }, 1540 /* DTLPWROMAEBKVF */ 1541 { SST(0x20, 0x00, SS_FATAL | EINVAL, 1542 "Invalid command operation code") }, 1543 /* DT PWROMAEBK */ 1544 { SST(0x20, 0x01, SS_RDEF, /* XXX TBD */ 1545 "Access denied - initiator pending-enrolled") }, 1546 /* DT PWROMAEBK */ 1547 { SST(0x20, 0x02, SS_RDEF, /* XXX TBD */ 1548 "Access denied - no access rights") }, 1549 /* DT PWROMAEBK */ 1550 { SST(0x20, 0x03, SS_RDEF, /* XXX TBD */ 1551 "Access denied - invalid mgmt ID key") }, 1552 /* T */ 1553 { SST(0x20, 0x04, SS_RDEF, /* XXX TBD */ 1554 "Illegal command while in write capable state") }, 1555 /* T */ 1556 { SST(0x20, 0x05, SS_RDEF, /* XXX TBD */ 1557 "Obsolete") }, 1558 /* T */ 1559 { SST(0x20, 0x06, SS_RDEF, /* XXX TBD */ 1560 "Illegal command while in explicit address mode") }, 1561 /* T */ 1562 { SST(0x20, 0x07, SS_RDEF, /* XXX TBD */ 1563 "Illegal command while in implicit address mode") }, 1564 /* DT PWROMAEBK */ 1565 { SST(0x20, 0x08, SS_RDEF, /* XXX TBD */ 1566 "Access denied - enrollment conflict") }, 1567 /* DT PWROMAEBK */ 1568 { SST(0x20, 0x09, SS_RDEF, /* XXX TBD */ 1569 "Access denied - invalid LU identifier") }, 1570 /* DT PWROMAEBK */ 1571 { SST(0x20, 0x0A, SS_RDEF, /* XXX TBD */ 1572 "Access denied - invalid proxy token") }, 1573 /* DT PWROMAEBK */ 1574 { SST(0x20, 0x0B, SS_RDEF, /* XXX TBD */ 1575 "Access denied - ACL LUN conflict") }, 1576 /* T */ 1577 { SST(0x20, 0x0C, SS_FATAL | EINVAL, 1578 "Illegal command when not in append-only mode") }, 1579 /* DT WRO BK */ 1580 { SST(0x21, 0x00, SS_FATAL | EINVAL, 1581 "Logical block address out of range") }, 1582 /* DT WROM BK */ 1583 { SST(0x21, 0x01, SS_FATAL | EINVAL, 1584 "Invalid element address") }, 1585 /* R */ 1586 { SST(0x21, 0x02, SS_RDEF, /* XXX TBD */ 1587 "Invalid address for write") }, 1588 /* R */ 1589 { SST(0x21, 0x03, SS_RDEF, /* XXX TBD */ 1590 "Invalid write crossing layer jump") }, 1591 /* D */ 1592 { SST(0x22, 0x00, SS_FATAL | EINVAL, 1593 "Illegal function (use 20 00, 24 00, or 26 00)") }, 1594 /* DT P B */ 1595 { SST(0x23, 0x00, SS_FATAL | EINVAL, 1596 "Invalid token operation, cause not reportable") }, 1597 /* DT P B */ 1598 { SST(0x23, 0x01, SS_FATAL | EINVAL, 1599 "Invalid token operation, unsupported token type") }, 1600 /* DT P B */ 1601 { SST(0x23, 0x02, SS_FATAL | EINVAL, 1602 "Invalid token operation, remote token usage not supported") }, 1603 /* DT P B */ 1604 { SST(0x23, 0x03, SS_FATAL | EINVAL, 1605 "Invalid token operation, remote ROD token creation not supported") }, 1606 /* DT P B */ 1607 { SST(0x23, 0x04, SS_FATAL | EINVAL, 1608 "Invalid token operation, token unknown") }, 1609 /* DT P B */ 1610 { SST(0x23, 0x05, SS_FATAL | EINVAL, 1611 "Invalid token operation, token corrupt") }, 1612 /* DT P B */ 1613 { SST(0x23, 0x06, SS_FATAL | EINVAL, 1614 "Invalid token operation, token revoked") }, 1615 /* DT P B */ 1616 { SST(0x23, 0x07, SS_FATAL | EINVAL, 1617 "Invalid token operation, token expired") }, 1618 /* DT P B */ 1619 { SST(0x23, 0x08, SS_FATAL | EINVAL, 1620 "Invalid token operation, token cancelled") }, 1621 /* DT P B */ 1622 { SST(0x23, 0x09, SS_FATAL | EINVAL, 1623 "Invalid token operation, token deleted") }, 1624 /* DT P B */ 1625 { SST(0x23, 0x0A, SS_FATAL | EINVAL, 1626 "Invalid token operation, invalid token length") }, 1627 /* DTLPWROMAEBKVF */ 1628 { SST(0x24, 0x00, SS_FATAL | EINVAL, 1629 "Invalid field in CDB") }, 1630 /* DTLPWRO AEBKVF */ 1631 { SST(0x24, 0x01, SS_RDEF, /* XXX TBD */ 1632 "CDB decryption error") }, 1633 /* T */ 1634 { SST(0x24, 0x02, SS_RDEF, /* XXX TBD */ 1635 "Obsolete") }, 1636 /* T */ 1637 { SST(0x24, 0x03, SS_RDEF, /* XXX TBD */ 1638 "Obsolete") }, 1639 /* F */ 1640 { SST(0x24, 0x04, SS_RDEF, /* XXX TBD */ 1641 "Security audit value frozen") }, 1642 /* F */ 1643 { SST(0x24, 0x05, SS_RDEF, /* XXX TBD */ 1644 "Security working key frozen") }, 1645 /* F */ 1646 { SST(0x24, 0x06, SS_RDEF, /* XXX TBD */ 1647 "NONCE not unique") }, 1648 /* F */ 1649 { SST(0x24, 0x07, SS_RDEF, /* XXX TBD */ 1650 "NONCE timestamp out of range") }, 1651 /* DT R MAEBKV */ 1652 { SST(0x24, 0x08, SS_RDEF, /* XXX TBD */ 1653 "Invalid XCDB") }, 1654 /* DTLPWROMAEBKVF */ 1655 { SST(0x25, 0x00, SS_FATAL | ENXIO | SSQ_LOST, 1656 "Logical unit not supported") }, 1657 /* DTLPWROMAEBKVF */ 1658 { SST(0x26, 0x00, SS_FATAL | EINVAL, 1659 "Invalid field in parameter list") }, 1660 /* DTLPWROMAEBKVF */ 1661 { SST(0x26, 0x01, SS_FATAL | EINVAL, 1662 "Parameter not supported") }, 1663 /* DTLPWROMAEBKVF */ 1664 { SST(0x26, 0x02, SS_FATAL | EINVAL, 1665 "Parameter value invalid") }, 1666 /* DTLPWROMAE K */ 1667 { SST(0x26, 0x03, SS_FATAL | EINVAL, 1668 "Threshold parameters not supported") }, 1669 /* DTLPWROMAEBKVF */ 1670 { SST(0x26, 0x04, SS_FATAL | EINVAL, 1671 "Invalid release of persistent reservation") }, 1672 /* DTLPWRO A BK */ 1673 { SST(0x26, 0x05, SS_RDEF, /* XXX TBD */ 1674 "Data decryption error") }, 1675 /* DTLPWRO K */ 1676 { SST(0x26, 0x06, SS_FATAL | EINVAL, 1677 "Too many target descriptors") }, 1678 /* DTLPWRO K */ 1679 { SST(0x26, 0x07, SS_FATAL | EINVAL, 1680 "Unsupported target descriptor type code") }, 1681 /* DTLPWRO K */ 1682 { SST(0x26, 0x08, SS_FATAL | EINVAL, 1683 "Too many segment descriptors") }, 1684 /* DTLPWRO K */ 1685 { SST(0x26, 0x09, SS_FATAL | EINVAL, 1686 "Unsupported segment descriptor type code") }, 1687 /* DTLPWRO K */ 1688 { SST(0x26, 0x0A, SS_FATAL | EINVAL, 1689 "Unexpected inexact segment") }, 1690 /* DTLPWRO K */ 1691 { SST(0x26, 0x0B, SS_FATAL | EINVAL, 1692 "Inline data length exceeded") }, 1693 /* DTLPWRO K */ 1694 { SST(0x26, 0x0C, SS_FATAL | EINVAL, 1695 "Invalid operation for copy source or destination") }, 1696 /* DTLPWRO K */ 1697 { SST(0x26, 0x0D, SS_FATAL | EINVAL, 1698 "Copy segment granularity violation") }, 1699 /* DT PWROMAEBK */ 1700 { SST(0x26, 0x0E, SS_RDEF, /* XXX TBD */ 1701 "Invalid parameter while port is enabled") }, 1702 /* F */ 1703 { SST(0x26, 0x0F, SS_RDEF, /* XXX TBD */ 1704 "Invalid data-out buffer integrity check value") }, 1705 /* T */ 1706 { SST(0x26, 0x10, SS_RDEF, /* XXX TBD */ 1707 "Data decryption key fail limit reached") }, 1708 /* T */ 1709 { SST(0x26, 0x11, SS_RDEF, /* XXX TBD */ 1710 "Incomplete key-associated data set") }, 1711 /* T */ 1712 { SST(0x26, 0x12, SS_RDEF, /* XXX TBD */ 1713 "Vendor specific key reference not found") }, 1714 /* DT WRO BK */ 1715 { SST(0x27, 0x00, SS_FATAL | EACCES, 1716 "Write protected") }, 1717 /* DT WRO BK */ 1718 { SST(0x27, 0x01, SS_FATAL | EACCES, 1719 "Hardware write protected") }, 1720 /* DT WRO BK */ 1721 { SST(0x27, 0x02, SS_FATAL | EACCES, 1722 "Logical unit software write protected") }, 1723 /* T R */ 1724 { SST(0x27, 0x03, SS_FATAL | EACCES, 1725 "Associated write protect") }, 1726 /* T R */ 1727 { SST(0x27, 0x04, SS_FATAL | EACCES, 1728 "Persistent write protect") }, 1729 /* T R */ 1730 { SST(0x27, 0x05, SS_FATAL | EACCES, 1731 "Permanent write protect") }, 1732 /* R F */ 1733 { SST(0x27, 0x06, SS_RDEF, /* XXX TBD */ 1734 "Conditional write protect") }, 1735 /* D B */ 1736 { SST(0x27, 0x07, SS_FATAL | ENOSPC, 1737 "Space allocation failed write protect") }, 1738 /* DTLPWROMAEBKVF */ 1739 { SST(0x28, 0x00, SS_FATAL | ENXIO, 1740 "Not ready to ready change, medium may have changed") }, 1741 /* DT WROM B */ 1742 { SST(0x28, 0x01, SS_FATAL | ENXIO, 1743 "Import or export element accessed") }, 1744 /* R */ 1745 { SST(0x28, 0x02, SS_RDEF, /* XXX TBD */ 1746 "Format-layer may have changed") }, 1747 /* M */ 1748 { SST(0x28, 0x03, SS_RDEF, /* XXX TBD */ 1749 "Import/export element accessed, medium changed") }, 1750 /* 1751 * XXX JGibbs - All of these should use the same errno, but I don't 1752 * think ENXIO is the correct choice. Should we borrow from 1753 * the networking errnos? ECONNRESET anyone? 1754 */ 1755 /* DTLPWROMAEBKVF */ 1756 { SST(0x29, 0x00, SS_FATAL | ENXIO, 1757 "Power on, reset, or bus device reset occurred") }, 1758 /* DTLPWROMAEBKVF */ 1759 { SST(0x29, 0x01, SS_RDEF, 1760 "Power on occurred") }, 1761 /* DTLPWROMAEBKVF */ 1762 { SST(0x29, 0x02, SS_RDEF, 1763 "SCSI bus reset occurred") }, 1764 /* DTLPWROMAEBKVF */ 1765 { SST(0x29, 0x03, SS_RDEF, 1766 "Bus device reset function occurred") }, 1767 /* DTLPWROMAEBKVF */ 1768 { SST(0x29, 0x04, SS_RDEF, 1769 "Device internal reset") }, 1770 /* DTLPWROMAEBKVF */ 1771 { SST(0x29, 0x05, SS_RDEF, 1772 "Transceiver mode changed to single-ended") }, 1773 /* DTLPWROMAEBKVF */ 1774 { SST(0x29, 0x06, SS_RDEF, 1775 "Transceiver mode changed to LVD") }, 1776 /* DTLPWROMAEBKVF */ 1777 { SST(0x29, 0x07, SS_RDEF, /* XXX TBD */ 1778 "I_T nexus loss occurred") }, 1779 /* DTL WROMAEBKVF */ 1780 { SST(0x2A, 0x00, SS_RDEF, 1781 "Parameters changed") }, 1782 /* DTL WROMAEBKVF */ 1783 { SST(0x2A, 0x01, SS_RDEF, 1784 "Mode parameters changed") }, 1785 /* DTL WROMAE K */ 1786 { SST(0x2A, 0x02, SS_RDEF, 1787 "Log parameters changed") }, 1788 /* DTLPWROMAE K */ 1789 { SST(0x2A, 0x03, SS_RDEF, 1790 "Reservations preempted") }, 1791 /* DTLPWROMAE */ 1792 { SST(0x2A, 0x04, SS_RDEF, /* XXX TBD */ 1793 "Reservations released") }, 1794 /* DTLPWROMAE */ 1795 { SST(0x2A, 0x05, SS_RDEF, /* XXX TBD */ 1796 "Registrations preempted") }, 1797 /* DTLPWROMAEBKVF */ 1798 { SST(0x2A, 0x06, SS_RDEF, /* XXX TBD */ 1799 "Asymmetric access state changed") }, 1800 /* DTLPWROMAEBKVF */ 1801 { SST(0x2A, 0x07, SS_RDEF, /* XXX TBD */ 1802 "Implicit asymmetric access state transition failed") }, 1803 /* DT WROMAEBKVF */ 1804 { SST(0x2A, 0x08, SS_RDEF, /* XXX TBD */ 1805 "Priority changed") }, 1806 /* D */ 1807 { SST(0x2A, 0x09, SS_RDEF, /* XXX TBD */ 1808 "Capacity data has changed") }, 1809 /* DT */ 1810 { SST(0x2A, 0x0A, SS_RDEF, /* XXX TBD */ 1811 "Error history I_T nexus cleared") }, 1812 /* DT */ 1813 { SST(0x2A, 0x0B, SS_RDEF, /* XXX TBD */ 1814 "Error history snapshot released") }, 1815 /* F */ 1816 { SST(0x2A, 0x0C, SS_RDEF, /* XXX TBD */ 1817 "Error recovery attributes have changed") }, 1818 /* T */ 1819 { SST(0x2A, 0x0D, SS_RDEF, /* XXX TBD */ 1820 "Data encryption capabilities changed") }, 1821 /* DT M E V */ 1822 { SST(0x2A, 0x10, SS_RDEF, /* XXX TBD */ 1823 "Timestamp changed") }, 1824 /* T */ 1825 { SST(0x2A, 0x11, SS_RDEF, /* XXX TBD */ 1826 "Data encryption parameters changed by another I_T nexus") }, 1827 /* T */ 1828 { SST(0x2A, 0x12, SS_RDEF, /* XXX TBD */ 1829 "Data encryption parameters changed by vendor specific event") }, 1830 /* T */ 1831 { SST(0x2A, 0x13, SS_RDEF, /* XXX TBD */ 1832 "Data encryption key instance counter has changed") }, 1833 /* DT R MAEBKV */ 1834 { SST(0x2A, 0x14, SS_RDEF, /* XXX TBD */ 1835 "SA creation capabilities data has changed") }, 1836 /* T M V */ 1837 { SST(0x2A, 0x15, SS_RDEF, /* XXX TBD */ 1838 "Medium removal prevention preempted") }, 1839 /* DTLPWRO K */ 1840 { SST(0x2B, 0x00, SS_RDEF, 1841 "Copy cannot execute since host cannot disconnect") }, 1842 /* DTLPWROMAEBKVF */ 1843 { SST(0x2C, 0x00, SS_RDEF, 1844 "Command sequence error") }, 1845 /* */ 1846 { SST(0x2C, 0x01, SS_RDEF, 1847 "Too many windows specified") }, 1848 /* */ 1849 { SST(0x2C, 0x02, SS_RDEF, 1850 "Invalid combination of windows specified") }, 1851 /* R */ 1852 { SST(0x2C, 0x03, SS_RDEF, 1853 "Current program area is not empty") }, 1854 /* R */ 1855 { SST(0x2C, 0x04, SS_RDEF, 1856 "Current program area is empty") }, 1857 /* B */ 1858 { SST(0x2C, 0x05, SS_RDEF, /* XXX TBD */ 1859 "Illegal power condition request") }, 1860 /* R */ 1861 { SST(0x2C, 0x06, SS_RDEF, /* XXX TBD */ 1862 "Persistent prevent conflict") }, 1863 /* DTLPWROMAEBKVF */ 1864 { SST(0x2C, 0x07, SS_RDEF, /* XXX TBD */ 1865 "Previous busy status") }, 1866 /* DTLPWROMAEBKVF */ 1867 { SST(0x2C, 0x08, SS_RDEF, /* XXX TBD */ 1868 "Previous task set full status") }, 1869 /* DTLPWROM EBKVF */ 1870 { SST(0x2C, 0x09, SS_RDEF, /* XXX TBD */ 1871 "Previous reservation conflict status") }, 1872 /* F */ 1873 { SST(0x2C, 0x0A, SS_RDEF, /* XXX TBD */ 1874 "Partition or collection contains user objects") }, 1875 /* T */ 1876 { SST(0x2C, 0x0B, SS_RDEF, /* XXX TBD */ 1877 "Not reserved") }, 1878 /* D */ 1879 { SST(0x2C, 0x0C, SS_RDEF, /* XXX TBD */ 1880 "ORWRITE generation does not match") }, 1881 /* T */ 1882 { SST(0x2D, 0x00, SS_RDEF, 1883 "Overwrite error on update in place") }, 1884 /* R */ 1885 { SST(0x2E, 0x00, SS_RDEF, /* XXX TBD */ 1886 "Insufficient time for operation") }, 1887 /* DTLPWROMAEBKVF */ 1888 { SST(0x2F, 0x00, SS_RDEF, 1889 "Commands cleared by another initiator") }, 1890 /* D */ 1891 { SST(0x2F, 0x01, SS_RDEF, /* XXX TBD */ 1892 "Commands cleared by power loss notification") }, 1893 /* DTLPWROMAEBKVF */ 1894 { SST(0x2F, 0x02, SS_RDEF, /* XXX TBD */ 1895 "Commands cleared by device server") }, 1896 /* DT WROM BK */ 1897 { SST(0x30, 0x00, SS_RDEF, 1898 "Incompatible medium installed") }, 1899 /* DT WRO BK */ 1900 { SST(0x30, 0x01, SS_RDEF, 1901 "Cannot read medium - unknown format") }, 1902 /* DT WRO BK */ 1903 { SST(0x30, 0x02, SS_RDEF, 1904 "Cannot read medium - incompatible format") }, 1905 /* DT R K */ 1906 { SST(0x30, 0x03, SS_RDEF, 1907 "Cleaning cartridge installed") }, 1908 /* DT WRO BK */ 1909 { SST(0x30, 0x04, SS_RDEF, 1910 "Cannot write medium - unknown format") }, 1911 /* DT WRO BK */ 1912 { SST(0x30, 0x05, SS_RDEF, 1913 "Cannot write medium - incompatible format") }, 1914 /* DT WRO B */ 1915 { SST(0x30, 0x06, SS_RDEF, 1916 "Cannot format medium - incompatible medium") }, 1917 /* DTL WROMAEBKVF */ 1918 { SST(0x30, 0x07, SS_RDEF, 1919 "Cleaning failure") }, 1920 /* R */ 1921 { SST(0x30, 0x08, SS_RDEF, 1922 "Cannot write - application code mismatch") }, 1923 /* R */ 1924 { SST(0x30, 0x09, SS_RDEF, 1925 "Current session not fixated for append") }, 1926 /* DT WRO AEBK */ 1927 { SST(0x30, 0x0A, SS_RDEF, /* XXX TBD */ 1928 "Cleaning request rejected") }, 1929 /* T */ 1930 { SST(0x30, 0x0C, SS_RDEF, /* XXX TBD */ 1931 "WORM medium - overwrite attempted") }, 1932 /* T */ 1933 { SST(0x30, 0x0D, SS_RDEF, /* XXX TBD */ 1934 "WORM medium - integrity check") }, 1935 /* R */ 1936 { SST(0x30, 0x10, SS_RDEF, /* XXX TBD */ 1937 "Medium not formatted") }, 1938 /* M */ 1939 { SST(0x30, 0x11, SS_RDEF, /* XXX TBD */ 1940 "Incompatible volume type") }, 1941 /* M */ 1942 { SST(0x30, 0x12, SS_RDEF, /* XXX TBD */ 1943 "Incompatible volume qualifier") }, 1944 /* M */ 1945 { SST(0x30, 0x13, SS_RDEF, /* XXX TBD */ 1946 "Cleaning volume expired") }, 1947 /* DT WRO BK */ 1948 { SST(0x31, 0x00, SS_RDEF, 1949 "Medium format corrupted") }, 1950 /* D L RO B */ 1951 { SST(0x31, 0x01, SS_RDEF, 1952 "Format command failed") }, 1953 /* R */ 1954 { SST(0x31, 0x02, SS_RDEF, /* XXX TBD */ 1955 "Zoned formatting failed due to spare linking") }, 1956 /* D B */ 1957 { SST(0x31, 0x03, SS_RDEF, /* XXX TBD */ 1958 "SANITIZE command failed") }, 1959 /* D W O BK */ 1960 { SST(0x32, 0x00, SS_RDEF, 1961 "No defect spare location available") }, 1962 /* D W O BK */ 1963 { SST(0x32, 0x01, SS_RDEF, 1964 "Defect list update failure") }, 1965 /* T */ 1966 { SST(0x33, 0x00, SS_RDEF, 1967 "Tape length error") }, 1968 /* DTLPWROMAEBKVF */ 1969 { SST(0x34, 0x00, SS_RDEF, 1970 "Enclosure failure") }, 1971 /* DTLPWROMAEBKVF */ 1972 { SST(0x35, 0x00, SS_RDEF, 1973 "Enclosure services failure") }, 1974 /* DTLPWROMAEBKVF */ 1975 { SST(0x35, 0x01, SS_RDEF, 1976 "Unsupported enclosure function") }, 1977 /* DTLPWROMAEBKVF */ 1978 { SST(0x35, 0x02, SS_RDEF, 1979 "Enclosure services unavailable") }, 1980 /* DTLPWROMAEBKVF */ 1981 { SST(0x35, 0x03, SS_RDEF, 1982 "Enclosure services transfer failure") }, 1983 /* DTLPWROMAEBKVF */ 1984 { SST(0x35, 0x04, SS_RDEF, 1985 "Enclosure services transfer refused") }, 1986 /* DTL WROMAEBKVF */ 1987 { SST(0x35, 0x05, SS_RDEF, /* XXX TBD */ 1988 "Enclosure services checksum error") }, 1989 /* L */ 1990 { SST(0x36, 0x00, SS_RDEF, 1991 "Ribbon, ink, or toner failure") }, 1992 /* DTL WROMAEBKVF */ 1993 { SST(0x37, 0x00, SS_RDEF, 1994 "Rounded parameter") }, 1995 /* B */ 1996 { SST(0x38, 0x00, SS_RDEF, /* XXX TBD */ 1997 "Event status notification") }, 1998 /* B */ 1999 { SST(0x38, 0x02, SS_RDEF, /* XXX TBD */ 2000 "ESN - power management class event") }, 2001 /* B */ 2002 { SST(0x38, 0x04, SS_RDEF, /* XXX TBD */ 2003 "ESN - media class event") }, 2004 /* B */ 2005 { SST(0x38, 0x06, SS_RDEF, /* XXX TBD */ 2006 "ESN - device busy class event") }, 2007 /* D */ 2008 { SST(0x38, 0x07, SS_RDEF, /* XXX TBD */ 2009 "Thin provisioning soft threshold reached") }, 2010 /* DTL WROMAE K */ 2011 { SST(0x39, 0x00, SS_RDEF, 2012 "Saving parameters not supported") }, 2013 /* DTL WROM BK */ 2014 { SST(0x3A, 0x00, SS_FATAL | ENXIO, 2015 "Medium not present") }, 2016 /* DT WROM BK */ 2017 { SST(0x3A, 0x01, SS_FATAL | ENXIO, 2018 "Medium not present - tray closed") }, 2019 /* DT WROM BK */ 2020 { SST(0x3A, 0x02, SS_FATAL | ENXIO, 2021 "Medium not present - tray open") }, 2022 /* DT WROM B */ 2023 { SST(0x3A, 0x03, SS_RDEF, /* XXX TBD */ 2024 "Medium not present - loadable") }, 2025 /* DT WRO B */ 2026 { SST(0x3A, 0x04, SS_RDEF, /* XXX TBD */ 2027 "Medium not present - medium auxiliary memory accessible") }, 2028 /* TL */ 2029 { SST(0x3B, 0x00, SS_RDEF, 2030 "Sequential positioning error") }, 2031 /* T */ 2032 { SST(0x3B, 0x01, SS_RDEF, 2033 "Tape position error at beginning-of-medium") }, 2034 /* T */ 2035 { SST(0x3B, 0x02, SS_RDEF, 2036 "Tape position error at end-of-medium") }, 2037 /* L */ 2038 { SST(0x3B, 0x03, SS_RDEF, 2039 "Tape or electronic vertical forms unit not ready") }, 2040 /* L */ 2041 { SST(0x3B, 0x04, SS_RDEF, 2042 "Slew failure") }, 2043 /* L */ 2044 { SST(0x3B, 0x05, SS_RDEF, 2045 "Paper jam") }, 2046 /* L */ 2047 { SST(0x3B, 0x06, SS_RDEF, 2048 "Failed to sense top-of-form") }, 2049 /* L */ 2050 { SST(0x3B, 0x07, SS_RDEF, 2051 "Failed to sense bottom-of-form") }, 2052 /* T */ 2053 { SST(0x3B, 0x08, SS_RDEF, 2054 "Reposition error") }, 2055 /* */ 2056 { SST(0x3B, 0x09, SS_RDEF, 2057 "Read past end of medium") }, 2058 /* */ 2059 { SST(0x3B, 0x0A, SS_RDEF, 2060 "Read past beginning of medium") }, 2061 /* */ 2062 { SST(0x3B, 0x0B, SS_RDEF, 2063 "Position past end of medium") }, 2064 /* T */ 2065 { SST(0x3B, 0x0C, SS_RDEF, 2066 "Position past beginning of medium") }, 2067 /* DT WROM BK */ 2068 { SST(0x3B, 0x0D, SS_FATAL | ENOSPC, 2069 "Medium destination element full") }, 2070 /* DT WROM BK */ 2071 { SST(0x3B, 0x0E, SS_RDEF, 2072 "Medium source element empty") }, 2073 /* R */ 2074 { SST(0x3B, 0x0F, SS_RDEF, 2075 "End of medium reached") }, 2076 /* DT WROM BK */ 2077 { SST(0x3B, 0x11, SS_RDEF, 2078 "Medium magazine not accessible") }, 2079 /* DT WROM BK */ 2080 { SST(0x3B, 0x12, SS_RDEF, 2081 "Medium magazine removed") }, 2082 /* DT WROM BK */ 2083 { SST(0x3B, 0x13, SS_RDEF, 2084 "Medium magazine inserted") }, 2085 /* DT WROM BK */ 2086 { SST(0x3B, 0x14, SS_RDEF, 2087 "Medium magazine locked") }, 2088 /* DT WROM BK */ 2089 { SST(0x3B, 0x15, SS_RDEF, 2090 "Medium magazine unlocked") }, 2091 /* R */ 2092 { SST(0x3B, 0x16, SS_RDEF, /* XXX TBD */ 2093 "Mechanical positioning or changer error") }, 2094 /* F */ 2095 { SST(0x3B, 0x17, SS_RDEF, /* XXX TBD */ 2096 "Read past end of user object") }, 2097 /* M */ 2098 { SST(0x3B, 0x18, SS_RDEF, /* XXX TBD */ 2099 "Element disabled") }, 2100 /* M */ 2101 { SST(0x3B, 0x19, SS_RDEF, /* XXX TBD */ 2102 "Element enabled") }, 2103 /* M */ 2104 { SST(0x3B, 0x1A, SS_RDEF, /* XXX TBD */ 2105 "Data transfer device removed") }, 2106 /* M */ 2107 { SST(0x3B, 0x1B, SS_RDEF, /* XXX TBD */ 2108 "Data transfer device inserted") }, 2109 /* T */ 2110 { SST(0x3B, 0x1C, SS_RDEF, /* XXX TBD */ 2111 "Too many logical objects on partition to support operation") }, 2112 /* DTLPWROMAE K */ 2113 { SST(0x3D, 0x00, SS_RDEF, 2114 "Invalid bits in IDENTIFY message") }, 2115 /* DTLPWROMAEBKVF */ 2116 { SST(0x3E, 0x00, SS_RDEF, 2117 "Logical unit has not self-configured yet") }, 2118 /* DTLPWROMAEBKVF */ 2119 { SST(0x3E, 0x01, SS_RDEF, 2120 "Logical unit failure") }, 2121 /* DTLPWROMAEBKVF */ 2122 { SST(0x3E, 0x02, SS_RDEF, 2123 "Timeout on logical unit") }, 2124 /* DTLPWROMAEBKVF */ 2125 { SST(0x3E, 0x03, SS_RDEF, /* XXX TBD */ 2126 "Logical unit failed self-test") }, 2127 /* DTLPWROMAEBKVF */ 2128 { SST(0x3E, 0x04, SS_RDEF, /* XXX TBD */ 2129 "Logical unit unable to update self-test log") }, 2130 /* DTLPWROMAEBKVF */ 2131 { SST(0x3F, 0x00, SS_RDEF, 2132 "Target operating conditions have changed") }, 2133 /* DTLPWROMAEBKVF */ 2134 { SST(0x3F, 0x01, SS_RDEF, 2135 "Microcode has been changed") }, 2136 /* DTLPWROM BK */ 2137 { SST(0x3F, 0x02, SS_RDEF, 2138 "Changed operating definition") }, 2139 /* DTLPWROMAEBKVF */ 2140 { SST(0x3F, 0x03, SS_RDEF, 2141 "INQUIRY data has changed") }, 2142 /* DT WROMAEBK */ 2143 { SST(0x3F, 0x04, SS_RDEF, 2144 "Component device attached") }, 2145 /* DT WROMAEBK */ 2146 { SST(0x3F, 0x05, SS_RDEF, 2147 "Device identifier changed") }, 2148 /* DT WROMAEB */ 2149 { SST(0x3F, 0x06, SS_RDEF, 2150 "Redundancy group created or modified") }, 2151 /* DT WROMAEB */ 2152 { SST(0x3F, 0x07, SS_RDEF, 2153 "Redundancy group deleted") }, 2154 /* DT WROMAEB */ 2155 { SST(0x3F, 0x08, SS_RDEF, 2156 "Spare created or modified") }, 2157 /* DT WROMAEB */ 2158 { SST(0x3F, 0x09, SS_RDEF, 2159 "Spare deleted") }, 2160 /* DT WROMAEBK */ 2161 { SST(0x3F, 0x0A, SS_RDEF, 2162 "Volume set created or modified") }, 2163 /* DT WROMAEBK */ 2164 { SST(0x3F, 0x0B, SS_RDEF, 2165 "Volume set deleted") }, 2166 /* DT WROMAEBK */ 2167 { SST(0x3F, 0x0C, SS_RDEF, 2168 "Volume set deassigned") }, 2169 /* DT WROMAEBK */ 2170 { SST(0x3F, 0x0D, SS_RDEF, 2171 "Volume set reassigned") }, 2172 /* DTLPWROMAE */ 2173 { SST(0x3F, 0x0E, SS_RDEF | SSQ_RESCAN , 2174 "Reported LUNs data has changed") }, 2175 /* DTLPWROMAEBKVF */ 2176 { SST(0x3F, 0x0F, SS_RDEF, /* XXX TBD */ 2177 "Echo buffer overwritten") }, 2178 /* DT WROM B */ 2179 { SST(0x3F, 0x10, SS_RDEF, /* XXX TBD */ 2180 "Medium loadable") }, 2181 /* DT WROM B */ 2182 { SST(0x3F, 0x11, SS_RDEF, /* XXX TBD */ 2183 "Medium auxiliary memory accessible") }, 2184 /* DTLPWR MAEBK F */ 2185 { SST(0x3F, 0x12, SS_RDEF, /* XXX TBD */ 2186 "iSCSI IP address added") }, 2187 /* DTLPWR MAEBK F */ 2188 { SST(0x3F, 0x13, SS_RDEF, /* XXX TBD */ 2189 "iSCSI IP address removed") }, 2190 /* DTLPWR MAEBK F */ 2191 { SST(0x3F, 0x14, SS_RDEF, /* XXX TBD */ 2192 "iSCSI IP address changed") }, 2193 /* D */ 2194 { SST(0x40, 0x00, SS_RDEF, 2195 "RAM failure") }, /* deprecated - use 40 NN instead */ 2196 /* DTLPWROMAEBKVF */ 2197 { SST(0x40, 0x80, SS_RDEF, 2198 "Diagnostic failure: ASCQ = Component ID") }, 2199 /* DTLPWROMAEBKVF */ 2200 { SST(0x40, 0xFF, SS_RDEF | SSQ_RANGE, 2201 NULL) }, /* Range 0x80->0xFF */ 2202 /* D */ 2203 { SST(0x41, 0x00, SS_RDEF, 2204 "Data path failure") }, /* deprecated - use 40 NN instead */ 2205 /* D */ 2206 { SST(0x42, 0x00, SS_RDEF, 2207 "Power-on or self-test failure") }, 2208 /* deprecated - use 40 NN instead */ 2209 /* DTLPWROMAEBKVF */ 2210 { SST(0x43, 0x00, SS_RDEF, 2211 "Message error") }, 2212 /* DTLPWROMAEBKVF */ 2213 { SST(0x44, 0x00, SS_RDEF, 2214 "Internal target failure") }, 2215 /* DT P MAEBKVF */ 2216 { SST(0x44, 0x01, SS_RDEF, /* XXX TBD */ 2217 "Persistent reservation information lost") }, 2218 /* DT B */ 2219 { SST(0x44, 0x71, SS_RDEF, /* XXX TBD */ 2220 "ATA device failed set features") }, 2221 /* DTLPWROMAEBKVF */ 2222 { SST(0x45, 0x00, SS_RDEF, 2223 "Select or reselect failure") }, 2224 /* DTLPWROM BK */ 2225 { SST(0x46, 0x00, SS_RDEF, 2226 "Unsuccessful soft reset") }, 2227 /* DTLPWROMAEBKVF */ 2228 { SST(0x47, 0x00, SS_RDEF, 2229 "SCSI parity error") }, 2230 /* DTLPWROMAEBKVF */ 2231 { SST(0x47, 0x01, SS_RDEF, /* XXX TBD */ 2232 "Data phase CRC error detected") }, 2233 /* DTLPWROMAEBKVF */ 2234 { SST(0x47, 0x02, SS_RDEF, /* XXX TBD */ 2235 "SCSI parity error detected during ST data phase") }, 2236 /* DTLPWROMAEBKVF */ 2237 { SST(0x47, 0x03, SS_RDEF, /* XXX TBD */ 2238 "Information unit iuCRC error detected") }, 2239 /* DTLPWROMAEBKVF */ 2240 { SST(0x47, 0x04, SS_RDEF, /* XXX TBD */ 2241 "Asynchronous information protection error detected") }, 2242 /* DTLPWROMAEBKVF */ 2243 { SST(0x47, 0x05, SS_RDEF, /* XXX TBD */ 2244 "Protocol service CRC error") }, 2245 /* DT MAEBKVF */ 2246 { SST(0x47, 0x06, SS_RDEF, /* XXX TBD */ 2247 "PHY test function in progress") }, 2248 /* DT PWROMAEBK */ 2249 { SST(0x47, 0x7F, SS_RDEF, /* XXX TBD */ 2250 "Some commands cleared by iSCSI protocol event") }, 2251 /* DTLPWROMAEBKVF */ 2252 { SST(0x48, 0x00, SS_RDEF, 2253 "Initiator detected error message received") }, 2254 /* DTLPWROMAEBKVF */ 2255 { SST(0x49, 0x00, SS_RDEF, 2256 "Invalid message error") }, 2257 /* DTLPWROMAEBKVF */ 2258 { SST(0x4A, 0x00, SS_RDEF, 2259 "Command phase error") }, 2260 /* DTLPWROMAEBKVF */ 2261 { SST(0x4B, 0x00, SS_RDEF, 2262 "Data phase error") }, 2263 /* DT PWROMAEBK */ 2264 { SST(0x4B, 0x01, SS_RDEF, /* XXX TBD */ 2265 "Invalid target port transfer tag received") }, 2266 /* DT PWROMAEBK */ 2267 { SST(0x4B, 0x02, SS_RDEF, /* XXX TBD */ 2268 "Too much write data") }, 2269 /* DT PWROMAEBK */ 2270 { SST(0x4B, 0x03, SS_RDEF, /* XXX TBD */ 2271 "ACK/NAK timeout") }, 2272 /* DT PWROMAEBK */ 2273 { SST(0x4B, 0x04, SS_RDEF, /* XXX TBD */ 2274 "NAK received") }, 2275 /* DT PWROMAEBK */ 2276 { SST(0x4B, 0x05, SS_RDEF, /* XXX TBD */ 2277 "Data offset error") }, 2278 /* DT PWROMAEBK */ 2279 { SST(0x4B, 0x06, SS_RDEF, /* XXX TBD */ 2280 "Initiator response timeout") }, 2281 /* DT PWROMAEBK F */ 2282 { SST(0x4B, 0x07, SS_RDEF, /* XXX TBD */ 2283 "Connection lost") }, 2284 /* DT PWROMAEBK F */ 2285 { SST(0x4B, 0x08, SS_RDEF, /* XXX TBD */ 2286 "Data-in buffer overflow - data buffer size") }, 2287 /* DT PWROMAEBK F */ 2288 { SST(0x4B, 0x09, SS_RDEF, /* XXX TBD */ 2289 "Data-in buffer overflow - data buffer descriptor area") }, 2290 /* DT PWROMAEBK F */ 2291 { SST(0x4B, 0x0A, SS_RDEF, /* XXX TBD */ 2292 "Data-in buffer error") }, 2293 /* DT PWROMAEBK F */ 2294 { SST(0x4B, 0x0B, SS_RDEF, /* XXX TBD */ 2295 "Data-out buffer overflow - data buffer size") }, 2296 /* DT PWROMAEBK F */ 2297 { SST(0x4B, 0x0C, SS_RDEF, /* XXX TBD */ 2298 "Data-out buffer overflow - data buffer descriptor area") }, 2299 /* DT PWROMAEBK F */ 2300 { SST(0x4B, 0x0D, SS_RDEF, /* XXX TBD */ 2301 "Data-out buffer error") }, 2302 /* DTLPWROMAEBKVF */ 2303 { SST(0x4C, 0x00, SS_RDEF, 2304 "Logical unit failed self-configuration") }, 2305 /* DTLPWROMAEBKVF */ 2306 { SST(0x4D, 0x00, SS_RDEF, 2307 "Tagged overlapped commands: ASCQ = Queue tag ID") }, 2308 /* DTLPWROMAEBKVF */ 2309 { SST(0x4D, 0xFF, SS_RDEF | SSQ_RANGE, 2310 NULL) }, /* Range 0x00->0xFF */ 2311 /* DTLPWROMAEBKVF */ 2312 { SST(0x4E, 0x00, SS_RDEF, 2313 "Overlapped commands attempted") }, 2314 /* T */ 2315 { SST(0x50, 0x00, SS_RDEF, 2316 "Write append error") }, 2317 /* T */ 2318 { SST(0x50, 0x01, SS_RDEF, 2319 "Write append position error") }, 2320 /* T */ 2321 { SST(0x50, 0x02, SS_RDEF, 2322 "Position error related to timing") }, 2323 /* T RO */ 2324 { SST(0x51, 0x00, SS_RDEF, 2325 "Erase failure") }, 2326 /* R */ 2327 { SST(0x51, 0x01, SS_RDEF, /* XXX TBD */ 2328 "Erase failure - incomplete erase operation detected") }, 2329 /* T */ 2330 { SST(0x52, 0x00, SS_RDEF, 2331 "Cartridge fault") }, 2332 /* DTL WROM BK */ 2333 { SST(0x53, 0x00, SS_RDEF, 2334 "Media load or eject failed") }, 2335 /* T */ 2336 { SST(0x53, 0x01, SS_RDEF, 2337 "Unload tape failure") }, 2338 /* DT WROM BK */ 2339 { SST(0x53, 0x02, SS_RDEF, 2340 "Medium removal prevented") }, 2341 /* M */ 2342 { SST(0x53, 0x03, SS_RDEF, /* XXX TBD */ 2343 "Medium removal prevented by data transfer element") }, 2344 /* T */ 2345 { SST(0x53, 0x04, SS_RDEF, /* XXX TBD */ 2346 "Medium thread or unthread failure") }, 2347 /* M */ 2348 { SST(0x53, 0x05, SS_RDEF, /* XXX TBD */ 2349 "Volume identifier invalid") }, 2350 /* T */ 2351 { SST(0x53, 0x06, SS_RDEF, /* XXX TBD */ 2352 "Volume identifier missing") }, 2353 /* M */ 2354 { SST(0x53, 0x07, SS_RDEF, /* XXX TBD */ 2355 "Duplicate volume identifier") }, 2356 /* M */ 2357 { SST(0x53, 0x08, SS_RDEF, /* XXX TBD */ 2358 "Element status unknown") }, 2359 /* P */ 2360 { SST(0x54, 0x00, SS_RDEF, 2361 "SCSI to host system interface failure") }, 2362 /* P */ 2363 { SST(0x55, 0x00, SS_RDEF, 2364 "System resource failure") }, 2365 /* D O BK */ 2366 { SST(0x55, 0x01, SS_FATAL | ENOSPC, 2367 "System buffer full") }, 2368 /* DTLPWROMAE K */ 2369 { SST(0x55, 0x02, SS_RDEF, /* XXX TBD */ 2370 "Insufficient reservation resources") }, 2371 /* DTLPWROMAE K */ 2372 { SST(0x55, 0x03, SS_RDEF, /* XXX TBD */ 2373 "Insufficient resources") }, 2374 /* DTLPWROMAE K */ 2375 { SST(0x55, 0x04, SS_RDEF, /* XXX TBD */ 2376 "Insufficient registration resources") }, 2377 /* DT PWROMAEBK */ 2378 { SST(0x55, 0x05, SS_RDEF, /* XXX TBD */ 2379 "Insufficient access control resources") }, 2380 /* DT WROM B */ 2381 { SST(0x55, 0x06, SS_RDEF, /* XXX TBD */ 2382 "Auxiliary memory out of space") }, 2383 /* F */ 2384 { SST(0x55, 0x07, SS_RDEF, /* XXX TBD */ 2385 "Quota error") }, 2386 /* T */ 2387 { SST(0x55, 0x08, SS_RDEF, /* XXX TBD */ 2388 "Maximum number of supplemental decryption keys exceeded") }, 2389 /* M */ 2390 { SST(0x55, 0x09, SS_RDEF, /* XXX TBD */ 2391 "Medium auxiliary memory not accessible") }, 2392 /* M */ 2393 { SST(0x55, 0x0A, SS_RDEF, /* XXX TBD */ 2394 "Data currently unavailable") }, 2395 /* DTLPWROMAEBKVF */ 2396 { SST(0x55, 0x0B, SS_RDEF, /* XXX TBD */ 2397 "Insufficient power for operation") }, 2398 /* DT P B */ 2399 { SST(0x55, 0x0C, SS_RDEF, /* XXX TBD */ 2400 "Insufficient resources to create ROD") }, 2401 /* DT P B */ 2402 { SST(0x55, 0x0D, SS_RDEF, /* XXX TBD */ 2403 "Insufficient resources to create ROD token") }, 2404 /* R */ 2405 { SST(0x57, 0x00, SS_RDEF, 2406 "Unable to recover table-of-contents") }, 2407 /* O */ 2408 { SST(0x58, 0x00, SS_RDEF, 2409 "Generation does not exist") }, 2410 /* O */ 2411 { SST(0x59, 0x00, SS_RDEF, 2412 "Updated block read") }, 2413 /* DTLPWRO BK */ 2414 { SST(0x5A, 0x00, SS_RDEF, 2415 "Operator request or state change input") }, 2416 /* DT WROM BK */ 2417 { SST(0x5A, 0x01, SS_RDEF, 2418 "Operator medium removal request") }, 2419 /* DT WRO A BK */ 2420 { SST(0x5A, 0x02, SS_RDEF, 2421 "Operator selected write protect") }, 2422 /* DT WRO A BK */ 2423 { SST(0x5A, 0x03, SS_RDEF, 2424 "Operator selected write permit") }, 2425 /* DTLPWROM K */ 2426 { SST(0x5B, 0x00, SS_RDEF, 2427 "Log exception") }, 2428 /* DTLPWROM K */ 2429 { SST(0x5B, 0x01, SS_RDEF, 2430 "Threshold condition met") }, 2431 /* DTLPWROM K */ 2432 { SST(0x5B, 0x02, SS_RDEF, 2433 "Log counter at maximum") }, 2434 /* DTLPWROM K */ 2435 { SST(0x5B, 0x03, SS_RDEF, 2436 "Log list codes exhausted") }, 2437 /* D O */ 2438 { SST(0x5C, 0x00, SS_RDEF, 2439 "RPL status change") }, 2440 /* D O */ 2441 { SST(0x5C, 0x01, SS_NOP | SSQ_PRINT_SENSE, 2442 "Spindles synchronized") }, 2443 /* D O */ 2444 { SST(0x5C, 0x02, SS_RDEF, 2445 "Spindles not synchronized") }, 2446 /* DTLPWROMAEBKVF */ 2447 { SST(0x5D, 0x00, SS_RDEF, 2448 "Failure prediction threshold exceeded") }, 2449 /* R B */ 2450 { SST(0x5D, 0x01, SS_RDEF, /* XXX TBD */ 2451 "Media failure prediction threshold exceeded") }, 2452 /* R */ 2453 { SST(0x5D, 0x02, SS_RDEF, /* XXX TBD */ 2454 "Logical unit failure prediction threshold exceeded") }, 2455 /* R */ 2456 { SST(0x5D, 0x03, SS_RDEF, /* XXX TBD */ 2457 "Spare area exhaustion prediction threshold exceeded") }, 2458 /* D B */ 2459 { SST(0x5D, 0x10, SS_RDEF, /* XXX TBD */ 2460 "Hardware impending failure general hard drive failure") }, 2461 /* D B */ 2462 { SST(0x5D, 0x11, SS_RDEF, /* XXX TBD */ 2463 "Hardware impending failure drive error rate too high") }, 2464 /* D B */ 2465 { SST(0x5D, 0x12, SS_RDEF, /* XXX TBD */ 2466 "Hardware impending failure data error rate too high") }, 2467 /* D B */ 2468 { SST(0x5D, 0x13, SS_RDEF, /* XXX TBD */ 2469 "Hardware impending failure seek error rate too high") }, 2470 /* D B */ 2471 { SST(0x5D, 0x14, SS_RDEF, /* XXX TBD */ 2472 "Hardware impending failure too many block reassigns") }, 2473 /* D B */ 2474 { SST(0x5D, 0x15, SS_RDEF, /* XXX TBD */ 2475 "Hardware impending failure access times too high") }, 2476 /* D B */ 2477 { SST(0x5D, 0x16, SS_RDEF, /* XXX TBD */ 2478 "Hardware impending failure start unit times too high") }, 2479 /* D B */ 2480 { SST(0x5D, 0x17, SS_RDEF, /* XXX TBD */ 2481 "Hardware impending failure channel parametrics") }, 2482 /* D B */ 2483 { SST(0x5D, 0x18, SS_RDEF, /* XXX TBD */ 2484 "Hardware impending failure controller detected") }, 2485 /* D B */ 2486 { SST(0x5D, 0x19, SS_RDEF, /* XXX TBD */ 2487 "Hardware impending failure throughput performance") }, 2488 /* D B */ 2489 { SST(0x5D, 0x1A, SS_RDEF, /* XXX TBD */ 2490 "Hardware impending failure seek time performance") }, 2491 /* D B */ 2492 { SST(0x5D, 0x1B, SS_RDEF, /* XXX TBD */ 2493 "Hardware impending failure spin-up retry count") }, 2494 /* D B */ 2495 { SST(0x5D, 0x1C, SS_RDEF, /* XXX TBD */ 2496 "Hardware impending failure drive calibration retry count") }, 2497 /* D B */ 2498 { SST(0x5D, 0x20, SS_RDEF, /* XXX TBD */ 2499 "Controller impending failure general hard drive failure") }, 2500 /* D B */ 2501 { SST(0x5D, 0x21, SS_RDEF, /* XXX TBD */ 2502 "Controller impending failure drive error rate too high") }, 2503 /* D B */ 2504 { SST(0x5D, 0x22, SS_RDEF, /* XXX TBD */ 2505 "Controller impending failure data error rate too high") }, 2506 /* D B */ 2507 { SST(0x5D, 0x23, SS_RDEF, /* XXX TBD */ 2508 "Controller impending failure seek error rate too high") }, 2509 /* D B */ 2510 { SST(0x5D, 0x24, SS_RDEF, /* XXX TBD */ 2511 "Controller impending failure too many block reassigns") }, 2512 /* D B */ 2513 { SST(0x5D, 0x25, SS_RDEF, /* XXX TBD */ 2514 "Controller impending failure access times too high") }, 2515 /* D B */ 2516 { SST(0x5D, 0x26, SS_RDEF, /* XXX TBD */ 2517 "Controller impending failure start unit times too high") }, 2518 /* D B */ 2519 { SST(0x5D, 0x27, SS_RDEF, /* XXX TBD */ 2520 "Controller impending failure channel parametrics") }, 2521 /* D B */ 2522 { SST(0x5D, 0x28, SS_RDEF, /* XXX TBD */ 2523 "Controller impending failure controller detected") }, 2524 /* D B */ 2525 { SST(0x5D, 0x29, SS_RDEF, /* XXX TBD */ 2526 "Controller impending failure throughput performance") }, 2527 /* D B */ 2528 { SST(0x5D, 0x2A, SS_RDEF, /* XXX TBD */ 2529 "Controller impending failure seek time performance") }, 2530 /* D B */ 2531 { SST(0x5D, 0x2B, SS_RDEF, /* XXX TBD */ 2532 "Controller impending failure spin-up retry count") }, 2533 /* D B */ 2534 { SST(0x5D, 0x2C, SS_RDEF, /* XXX TBD */ 2535 "Controller impending failure drive calibration retry count") }, 2536 /* D B */ 2537 { SST(0x5D, 0x30, SS_RDEF, /* XXX TBD */ 2538 "Data channel impending failure general hard drive failure") }, 2539 /* D B */ 2540 { SST(0x5D, 0x31, SS_RDEF, /* XXX TBD */ 2541 "Data channel impending failure drive error rate too high") }, 2542 /* D B */ 2543 { SST(0x5D, 0x32, SS_RDEF, /* XXX TBD */ 2544 "Data channel impending failure data error rate too high") }, 2545 /* D B */ 2546 { SST(0x5D, 0x33, SS_RDEF, /* XXX TBD */ 2547 "Data channel impending failure seek error rate too high") }, 2548 /* D B */ 2549 { SST(0x5D, 0x34, SS_RDEF, /* XXX TBD */ 2550 "Data channel impending failure too many block reassigns") }, 2551 /* D B */ 2552 { SST(0x5D, 0x35, SS_RDEF, /* XXX TBD */ 2553 "Data channel impending failure access times too high") }, 2554 /* D B */ 2555 { SST(0x5D, 0x36, SS_RDEF, /* XXX TBD */ 2556 "Data channel impending failure start unit times too high") }, 2557 /* D B */ 2558 { SST(0x5D, 0x37, SS_RDEF, /* XXX TBD */ 2559 "Data channel impending failure channel parametrics") }, 2560 /* D B */ 2561 { SST(0x5D, 0x38, SS_RDEF, /* XXX TBD */ 2562 "Data channel impending failure controller detected") }, 2563 /* D B */ 2564 { SST(0x5D, 0x39, SS_RDEF, /* XXX TBD */ 2565 "Data channel impending failure throughput performance") }, 2566 /* D B */ 2567 { SST(0x5D, 0x3A, SS_RDEF, /* XXX TBD */ 2568 "Data channel impending failure seek time performance") }, 2569 /* D B */ 2570 { SST(0x5D, 0x3B, SS_RDEF, /* XXX TBD */ 2571 "Data channel impending failure spin-up retry count") }, 2572 /* D B */ 2573 { SST(0x5D, 0x3C, SS_RDEF, /* XXX TBD */ 2574 "Data channel impending failure drive calibration retry count") }, 2575 /* D B */ 2576 { SST(0x5D, 0x40, SS_RDEF, /* XXX TBD */ 2577 "Servo impending failure general hard drive failure") }, 2578 /* D B */ 2579 { SST(0x5D, 0x41, SS_RDEF, /* XXX TBD */ 2580 "Servo impending failure drive error rate too high") }, 2581 /* D B */ 2582 { SST(0x5D, 0x42, SS_RDEF, /* XXX TBD */ 2583 "Servo impending failure data error rate too high") }, 2584 /* D B */ 2585 { SST(0x5D, 0x43, SS_RDEF, /* XXX TBD */ 2586 "Servo impending failure seek error rate too high") }, 2587 /* D B */ 2588 { SST(0x5D, 0x44, SS_RDEF, /* XXX TBD */ 2589 "Servo impending failure too many block reassigns") }, 2590 /* D B */ 2591 { SST(0x5D, 0x45, SS_RDEF, /* XXX TBD */ 2592 "Servo impending failure access times too high") }, 2593 /* D B */ 2594 { SST(0x5D, 0x46, SS_RDEF, /* XXX TBD */ 2595 "Servo impending failure start unit times too high") }, 2596 /* D B */ 2597 { SST(0x5D, 0x47, SS_RDEF, /* XXX TBD */ 2598 "Servo impending failure channel parametrics") }, 2599 /* D B */ 2600 { SST(0x5D, 0x48, SS_RDEF, /* XXX TBD */ 2601 "Servo impending failure controller detected") }, 2602 /* D B */ 2603 { SST(0x5D, 0x49, SS_RDEF, /* XXX TBD */ 2604 "Servo impending failure throughput performance") }, 2605 /* D B */ 2606 { SST(0x5D, 0x4A, SS_RDEF, /* XXX TBD */ 2607 "Servo impending failure seek time performance") }, 2608 /* D B */ 2609 { SST(0x5D, 0x4B, SS_RDEF, /* XXX TBD */ 2610 "Servo impending failure spin-up retry count") }, 2611 /* D B */ 2612 { SST(0x5D, 0x4C, SS_RDEF, /* XXX TBD */ 2613 "Servo impending failure drive calibration retry count") }, 2614 /* D B */ 2615 { SST(0x5D, 0x50, SS_RDEF, /* XXX TBD */ 2616 "Spindle impending failure general hard drive failure") }, 2617 /* D B */ 2618 { SST(0x5D, 0x51, SS_RDEF, /* XXX TBD */ 2619 "Spindle impending failure drive error rate too high") }, 2620 /* D B */ 2621 { SST(0x5D, 0x52, SS_RDEF, /* XXX TBD */ 2622 "Spindle impending failure data error rate too high") }, 2623 /* D B */ 2624 { SST(0x5D, 0x53, SS_RDEF, /* XXX TBD */ 2625 "Spindle impending failure seek error rate too high") }, 2626 /* D B */ 2627 { SST(0x5D, 0x54, SS_RDEF, /* XXX TBD */ 2628 "Spindle impending failure too many block reassigns") }, 2629 /* D B */ 2630 { SST(0x5D, 0x55, SS_RDEF, /* XXX TBD */ 2631 "Spindle impending failure access times too high") }, 2632 /* D B */ 2633 { SST(0x5D, 0x56, SS_RDEF, /* XXX TBD */ 2634 "Spindle impending failure start unit times too high") }, 2635 /* D B */ 2636 { SST(0x5D, 0x57, SS_RDEF, /* XXX TBD */ 2637 "Spindle impending failure channel parametrics") }, 2638 /* D B */ 2639 { SST(0x5D, 0x58, SS_RDEF, /* XXX TBD */ 2640 "Spindle impending failure controller detected") }, 2641 /* D B */ 2642 { SST(0x5D, 0x59, SS_RDEF, /* XXX TBD */ 2643 "Spindle impending failure throughput performance") }, 2644 /* D B */ 2645 { SST(0x5D, 0x5A, SS_RDEF, /* XXX TBD */ 2646 "Spindle impending failure seek time performance") }, 2647 /* D B */ 2648 { SST(0x5D, 0x5B, SS_RDEF, /* XXX TBD */ 2649 "Spindle impending failure spin-up retry count") }, 2650 /* D B */ 2651 { SST(0x5D, 0x5C, SS_RDEF, /* XXX TBD */ 2652 "Spindle impending failure drive calibration retry count") }, 2653 /* D B */ 2654 { SST(0x5D, 0x60, SS_RDEF, /* XXX TBD */ 2655 "Firmware impending failure general hard drive failure") }, 2656 /* D B */ 2657 { SST(0x5D, 0x61, SS_RDEF, /* XXX TBD */ 2658 "Firmware impending failure drive error rate too high") }, 2659 /* D B */ 2660 { SST(0x5D, 0x62, SS_RDEF, /* XXX TBD */ 2661 "Firmware impending failure data error rate too high") }, 2662 /* D B */ 2663 { SST(0x5D, 0x63, SS_RDEF, /* XXX TBD */ 2664 "Firmware impending failure seek error rate too high") }, 2665 /* D B */ 2666 { SST(0x5D, 0x64, SS_RDEF, /* XXX TBD */ 2667 "Firmware impending failure too many block reassigns") }, 2668 /* D B */ 2669 { SST(0x5D, 0x65, SS_RDEF, /* XXX TBD */ 2670 "Firmware impending failure access times too high") }, 2671 /* D B */ 2672 { SST(0x5D, 0x66, SS_RDEF, /* XXX TBD */ 2673 "Firmware impending failure start unit times too high") }, 2674 /* D B */ 2675 { SST(0x5D, 0x67, SS_RDEF, /* XXX TBD */ 2676 "Firmware impending failure channel parametrics") }, 2677 /* D B */ 2678 { SST(0x5D, 0x68, SS_RDEF, /* XXX TBD */ 2679 "Firmware impending failure controller detected") }, 2680 /* D B */ 2681 { SST(0x5D, 0x69, SS_RDEF, /* XXX TBD */ 2682 "Firmware impending failure throughput performance") }, 2683 /* D B */ 2684 { SST(0x5D, 0x6A, SS_RDEF, /* XXX TBD */ 2685 "Firmware impending failure seek time performance") }, 2686 /* D B */ 2687 { SST(0x5D, 0x6B, SS_RDEF, /* XXX TBD */ 2688 "Firmware impending failure spin-up retry count") }, 2689 /* D B */ 2690 { SST(0x5D, 0x6C, SS_RDEF, /* XXX TBD */ 2691 "Firmware impending failure drive calibration retry count") }, 2692 /* DTLPWROMAEBKVF */ 2693 { SST(0x5D, 0xFF, SS_RDEF, 2694 "Failure prediction threshold exceeded (false)") }, 2695 /* DTLPWRO A K */ 2696 { SST(0x5E, 0x00, SS_RDEF, 2697 "Low power condition on") }, 2698 /* DTLPWRO A K */ 2699 { SST(0x5E, 0x01, SS_RDEF, 2700 "Idle condition activated by timer") }, 2701 /* DTLPWRO A K */ 2702 { SST(0x5E, 0x02, SS_RDEF, 2703 "Standby condition activated by timer") }, 2704 /* DTLPWRO A K */ 2705 { SST(0x5E, 0x03, SS_RDEF, 2706 "Idle condition activated by command") }, 2707 /* DTLPWRO A K */ 2708 { SST(0x5E, 0x04, SS_RDEF, 2709 "Standby condition activated by command") }, 2710 /* DTLPWRO A K */ 2711 { SST(0x5E, 0x05, SS_RDEF, 2712 "Idle-B condition activated by timer") }, 2713 /* DTLPWRO A K */ 2714 { SST(0x5E, 0x06, SS_RDEF, 2715 "Idle-B condition activated by command") }, 2716 /* DTLPWRO A K */ 2717 { SST(0x5E, 0x07, SS_RDEF, 2718 "Idle-C condition activated by timer") }, 2719 /* DTLPWRO A K */ 2720 { SST(0x5E, 0x08, SS_RDEF, 2721 "Idle-C condition activated by command") }, 2722 /* DTLPWRO A K */ 2723 { SST(0x5E, 0x09, SS_RDEF, 2724 "Standby-Y condition activated by timer") }, 2725 /* DTLPWRO A K */ 2726 { SST(0x5E, 0x0A, SS_RDEF, 2727 "Standby-Y condition activated by command") }, 2728 /* B */ 2729 { SST(0x5E, 0x41, SS_RDEF, /* XXX TBD */ 2730 "Power state change to active") }, 2731 /* B */ 2732 { SST(0x5E, 0x42, SS_RDEF, /* XXX TBD */ 2733 "Power state change to idle") }, 2734 /* B */ 2735 { SST(0x5E, 0x43, SS_RDEF, /* XXX TBD */ 2736 "Power state change to standby") }, 2737 /* B */ 2738 { SST(0x5E, 0x45, SS_RDEF, /* XXX TBD */ 2739 "Power state change to sleep") }, 2740 /* BK */ 2741 { SST(0x5E, 0x47, SS_RDEF, /* XXX TBD */ 2742 "Power state change to device control") }, 2743 /* */ 2744 { SST(0x60, 0x00, SS_RDEF, 2745 "Lamp failure") }, 2746 /* */ 2747 { SST(0x61, 0x00, SS_RDEF, 2748 "Video acquisition error") }, 2749 /* */ 2750 { SST(0x61, 0x01, SS_RDEF, 2751 "Unable to acquire video") }, 2752 /* */ 2753 { SST(0x61, 0x02, SS_RDEF, 2754 "Out of focus") }, 2755 /* */ 2756 { SST(0x62, 0x00, SS_RDEF, 2757 "Scan head positioning error") }, 2758 /* R */ 2759 { SST(0x63, 0x00, SS_RDEF, 2760 "End of user area encountered on this track") }, 2761 /* R */ 2762 { SST(0x63, 0x01, SS_FATAL | ENOSPC, 2763 "Packet does not fit in available space") }, 2764 /* R */ 2765 { SST(0x64, 0x00, SS_FATAL | ENXIO, 2766 "Illegal mode for this track") }, 2767 /* R */ 2768 { SST(0x64, 0x01, SS_RDEF, 2769 "Invalid packet size") }, 2770 /* DTLPWROMAEBKVF */ 2771 { SST(0x65, 0x00, SS_RDEF, 2772 "Voltage fault") }, 2773 /* */ 2774 { SST(0x66, 0x00, SS_RDEF, 2775 "Automatic document feeder cover up") }, 2776 /* */ 2777 { SST(0x66, 0x01, SS_RDEF, 2778 "Automatic document feeder lift up") }, 2779 /* */ 2780 { SST(0x66, 0x02, SS_RDEF, 2781 "Document jam in automatic document feeder") }, 2782 /* */ 2783 { SST(0x66, 0x03, SS_RDEF, 2784 "Document miss feed automatic in document feeder") }, 2785 /* A */ 2786 { SST(0x67, 0x00, SS_RDEF, 2787 "Configuration failure") }, 2788 /* A */ 2789 { SST(0x67, 0x01, SS_RDEF, 2790 "Configuration of incapable logical units failed") }, 2791 /* A */ 2792 { SST(0x67, 0x02, SS_RDEF, 2793 "Add logical unit failed") }, 2794 /* A */ 2795 { SST(0x67, 0x03, SS_RDEF, 2796 "Modification of logical unit failed") }, 2797 /* A */ 2798 { SST(0x67, 0x04, SS_RDEF, 2799 "Exchange of logical unit failed") }, 2800 /* A */ 2801 { SST(0x67, 0x05, SS_RDEF, 2802 "Remove of logical unit failed") }, 2803 /* A */ 2804 { SST(0x67, 0x06, SS_RDEF, 2805 "Attachment of logical unit failed") }, 2806 /* A */ 2807 { SST(0x67, 0x07, SS_RDEF, 2808 "Creation of logical unit failed") }, 2809 /* A */ 2810 { SST(0x67, 0x08, SS_RDEF, /* XXX TBD */ 2811 "Assign failure occurred") }, 2812 /* A */ 2813 { SST(0x67, 0x09, SS_RDEF, /* XXX TBD */ 2814 "Multiply assigned logical unit") }, 2815 /* DTLPWROMAEBKVF */ 2816 { SST(0x67, 0x0A, SS_RDEF, /* XXX TBD */ 2817 "Set target port groups command failed") }, 2818 /* DT B */ 2819 { SST(0x67, 0x0B, SS_RDEF, /* XXX TBD */ 2820 "ATA device feature not enabled") }, 2821 /* A */ 2822 { SST(0x68, 0x00, SS_RDEF, 2823 "Logical unit not configured") }, 2824 /* A */ 2825 { SST(0x69, 0x00, SS_RDEF, 2826 "Data loss on logical unit") }, 2827 /* A */ 2828 { SST(0x69, 0x01, SS_RDEF, 2829 "Multiple logical unit failures") }, 2830 /* A */ 2831 { SST(0x69, 0x02, SS_RDEF, 2832 "Parity/data mismatch") }, 2833 /* A */ 2834 { SST(0x6A, 0x00, SS_RDEF, 2835 "Informational, refer to log") }, 2836 /* A */ 2837 { SST(0x6B, 0x00, SS_RDEF, 2838 "State change has occurred") }, 2839 /* A */ 2840 { SST(0x6B, 0x01, SS_RDEF, 2841 "Redundancy level got better") }, 2842 /* A */ 2843 { SST(0x6B, 0x02, SS_RDEF, 2844 "Redundancy level got worse") }, 2845 /* A */ 2846 { SST(0x6C, 0x00, SS_RDEF, 2847 "Rebuild failure occurred") }, 2848 /* A */ 2849 { SST(0x6D, 0x00, SS_RDEF, 2850 "Recalculate failure occurred") }, 2851 /* A */ 2852 { SST(0x6E, 0x00, SS_RDEF, 2853 "Command to logical unit failed") }, 2854 /* R */ 2855 { SST(0x6F, 0x00, SS_RDEF, /* XXX TBD */ 2856 "Copy protection key exchange failure - authentication failure") }, 2857 /* R */ 2858 { SST(0x6F, 0x01, SS_RDEF, /* XXX TBD */ 2859 "Copy protection key exchange failure - key not present") }, 2860 /* R */ 2861 { SST(0x6F, 0x02, SS_RDEF, /* XXX TBD */ 2862 "Copy protection key exchange failure - key not established") }, 2863 /* R */ 2864 { SST(0x6F, 0x03, SS_RDEF, /* XXX TBD */ 2865 "Read of scrambled sector without authentication") }, 2866 /* R */ 2867 { SST(0x6F, 0x04, SS_RDEF, /* XXX TBD */ 2868 "Media region code is mismatched to logical unit region") }, 2869 /* R */ 2870 { SST(0x6F, 0x05, SS_RDEF, /* XXX TBD */ 2871 "Drive region must be permanent/region reset count error") }, 2872 /* R */ 2873 { SST(0x6F, 0x06, SS_RDEF, /* XXX TBD */ 2874 "Insufficient block count for binding NONCE recording") }, 2875 /* R */ 2876 { SST(0x6F, 0x07, SS_RDEF, /* XXX TBD */ 2877 "Conflict in binding NONCE recording") }, 2878 /* T */ 2879 { SST(0x70, 0x00, SS_RDEF, 2880 "Decompression exception short: ASCQ = Algorithm ID") }, 2881 /* T */ 2882 { SST(0x70, 0xFF, SS_RDEF | SSQ_RANGE, 2883 NULL) }, /* Range 0x00 -> 0xFF */ 2884 /* T */ 2885 { SST(0x71, 0x00, SS_RDEF, 2886 "Decompression exception long: ASCQ = Algorithm ID") }, 2887 /* T */ 2888 { SST(0x71, 0xFF, SS_RDEF | SSQ_RANGE, 2889 NULL) }, /* Range 0x00 -> 0xFF */ 2890 /* R */ 2891 { SST(0x72, 0x00, SS_RDEF, 2892 "Session fixation error") }, 2893 /* R */ 2894 { SST(0x72, 0x01, SS_RDEF, 2895 "Session fixation error writing lead-in") }, 2896 /* R */ 2897 { SST(0x72, 0x02, SS_RDEF, 2898 "Session fixation error writing lead-out") }, 2899 /* R */ 2900 { SST(0x72, 0x03, SS_RDEF, 2901 "Session fixation error - incomplete track in session") }, 2902 /* R */ 2903 { SST(0x72, 0x04, SS_RDEF, 2904 "Empty or partially written reserved track") }, 2905 /* R */ 2906 { SST(0x72, 0x05, SS_RDEF, /* XXX TBD */ 2907 "No more track reservations allowed") }, 2908 /* R */ 2909 { SST(0x72, 0x06, SS_RDEF, /* XXX TBD */ 2910 "RMZ extension is not allowed") }, 2911 /* R */ 2912 { SST(0x72, 0x07, SS_RDEF, /* XXX TBD */ 2913 "No more test zone extensions are allowed") }, 2914 /* R */ 2915 { SST(0x73, 0x00, SS_RDEF, 2916 "CD control error") }, 2917 /* R */ 2918 { SST(0x73, 0x01, SS_RDEF, 2919 "Power calibration area almost full") }, 2920 /* R */ 2921 { SST(0x73, 0x02, SS_FATAL | ENOSPC, 2922 "Power calibration area is full") }, 2923 /* R */ 2924 { SST(0x73, 0x03, SS_RDEF, 2925 "Power calibration area error") }, 2926 /* R */ 2927 { SST(0x73, 0x04, SS_RDEF, 2928 "Program memory area update failure") }, 2929 /* R */ 2930 { SST(0x73, 0x05, SS_RDEF, 2931 "Program memory area is full") }, 2932 /* R */ 2933 { SST(0x73, 0x06, SS_RDEF, /* XXX TBD */ 2934 "RMA/PMA is almost full") }, 2935 /* R */ 2936 { SST(0x73, 0x10, SS_RDEF, /* XXX TBD */ 2937 "Current power calibration area almost full") }, 2938 /* R */ 2939 { SST(0x73, 0x11, SS_RDEF, /* XXX TBD */ 2940 "Current power calibration area is full") }, 2941 /* R */ 2942 { SST(0x73, 0x17, SS_RDEF, /* XXX TBD */ 2943 "RDZ is full") }, 2944 /* T */ 2945 { SST(0x74, 0x00, SS_RDEF, /* XXX TBD */ 2946 "Security error") }, 2947 /* T */ 2948 { SST(0x74, 0x01, SS_RDEF, /* XXX TBD */ 2949 "Unable to decrypt data") }, 2950 /* T */ 2951 { SST(0x74, 0x02, SS_RDEF, /* XXX TBD */ 2952 "Unencrypted data encountered while decrypting") }, 2953 /* T */ 2954 { SST(0x74, 0x03, SS_RDEF, /* XXX TBD */ 2955 "Incorrect data encryption key") }, 2956 /* T */ 2957 { SST(0x74, 0x04, SS_RDEF, /* XXX TBD */ 2958 "Cryptographic integrity validation failed") }, 2959 /* T */ 2960 { SST(0x74, 0x05, SS_RDEF, /* XXX TBD */ 2961 "Error decrypting data") }, 2962 /* T */ 2963 { SST(0x74, 0x06, SS_RDEF, /* XXX TBD */ 2964 "Unknown signature verification key") }, 2965 /* T */ 2966 { SST(0x74, 0x07, SS_RDEF, /* XXX TBD */ 2967 "Encryption parameters not useable") }, 2968 /* DT R M E VF */ 2969 { SST(0x74, 0x08, SS_RDEF, /* XXX TBD */ 2970 "Digital signature validation failure") }, 2971 /* T */ 2972 { SST(0x74, 0x09, SS_RDEF, /* XXX TBD */ 2973 "Encryption mode mismatch on read") }, 2974 /* T */ 2975 { SST(0x74, 0x0A, SS_RDEF, /* XXX TBD */ 2976 "Encrypted block not raw read enabled") }, 2977 /* T */ 2978 { SST(0x74, 0x0B, SS_RDEF, /* XXX TBD */ 2979 "Incorrect encryption parameters") }, 2980 /* DT R MAEBKV */ 2981 { SST(0x74, 0x0C, SS_RDEF, /* XXX TBD */ 2982 "Unable to decrypt parameter list") }, 2983 /* T */ 2984 { SST(0x74, 0x0D, SS_RDEF, /* XXX TBD */ 2985 "Encryption algorithm disabled") }, 2986 /* DT R MAEBKV */ 2987 { SST(0x74, 0x10, SS_RDEF, /* XXX TBD */ 2988 "SA creation parameter value invalid") }, 2989 /* DT R MAEBKV */ 2990 { SST(0x74, 0x11, SS_RDEF, /* XXX TBD */ 2991 "SA creation parameter value rejected") }, 2992 /* DT R MAEBKV */ 2993 { SST(0x74, 0x12, SS_RDEF, /* XXX TBD */ 2994 "Invalid SA usage") }, 2995 /* T */ 2996 { SST(0x74, 0x21, SS_RDEF, /* XXX TBD */ 2997 "Data encryption configuration prevented") }, 2998 /* DT R MAEBKV */ 2999 { SST(0x74, 0x30, SS_RDEF, /* XXX TBD */ 3000 "SA creation parameter not supported") }, 3001 /* DT R MAEBKV */ 3002 { SST(0x74, 0x40, SS_RDEF, /* XXX TBD */ 3003 "Authentication failed") }, 3004 /* V */ 3005 { SST(0x74, 0x61, SS_RDEF, /* XXX TBD */ 3006 "External data encryption key manager access error") }, 3007 /* V */ 3008 { SST(0x74, 0x62, SS_RDEF, /* XXX TBD */ 3009 "External data encryption key manager error") }, 3010 /* V */ 3011 { SST(0x74, 0x63, SS_RDEF, /* XXX TBD */ 3012 "External data encryption key not found") }, 3013 /* V */ 3014 { SST(0x74, 0x64, SS_RDEF, /* XXX TBD */ 3015 "External data encryption request not authorized") }, 3016 /* T */ 3017 { SST(0x74, 0x6E, SS_RDEF, /* XXX TBD */ 3018 "External data encryption control timeout") }, 3019 /* T */ 3020 { SST(0x74, 0x6F, SS_RDEF, /* XXX TBD */ 3021 "External data encryption control error") }, 3022 /* DT R M E V */ 3023 { SST(0x74, 0x71, SS_RDEF, /* XXX TBD */ 3024 "Logical unit access not authorized") }, 3025 /* D */ 3026 { SST(0x74, 0x79, SS_RDEF, /* XXX TBD */ 3027 "Security conflict in translated device") } 3028}; 3029 3030const int asc_table_size = sizeof(asc_table)/sizeof(asc_table[0]); 3031 3032struct asc_key 3033{ 3034 int asc; 3035 int ascq; 3036}; 3037 3038static int 3039ascentrycomp(const void *key, const void *member) 3040{ 3041 int asc; 3042 int ascq; 3043 const struct asc_table_entry *table_entry; 3044 3045 asc = ((const struct asc_key *)key)->asc; 3046 ascq = ((const struct asc_key *)key)->ascq; 3047 table_entry = (const struct asc_table_entry *)member; 3048 3049 if (asc >= table_entry->asc) { 3050 3051 if (asc > table_entry->asc) 3052 return (1); 3053 3054 if (ascq <= table_entry->ascq) { 3055 /* Check for ranges */ 3056 if (ascq == table_entry->ascq 3057 || ((table_entry->action & SSQ_RANGE) != 0 3058 && ascq >= (table_entry - 1)->ascq)) 3059 return (0); 3060 return (-1); 3061 } 3062 return (1); 3063 } 3064 return (-1); 3065} 3066 3067static int 3068senseentrycomp(const void *key, const void *member) 3069{ 3070 int sense_key; 3071 const struct sense_key_table_entry *table_entry; 3072 3073 sense_key = *((const int *)key); 3074 table_entry = (const struct sense_key_table_entry *)member; 3075 3076 if (sense_key >= table_entry->sense_key) { 3077 if (sense_key == table_entry->sense_key) 3078 return (0); 3079 return (1); 3080 } 3081 return (-1); 3082} 3083 3084static void 3085fetchtableentries(int sense_key, int asc, int ascq, 3086 struct scsi_inquiry_data *inq_data, 3087 const struct sense_key_table_entry **sense_entry, 3088 const struct asc_table_entry **asc_entry) 3089{ 3090 caddr_t match; 3091 const struct asc_table_entry *asc_tables[2]; 3092 const struct sense_key_table_entry *sense_tables[2]; 3093 struct asc_key asc_ascq; 3094 size_t asc_tables_size[2]; 3095 size_t sense_tables_size[2]; 3096 int num_asc_tables; 3097 int num_sense_tables; 3098 int i; 3099 3100 /* Default to failure */ 3101 *sense_entry = NULL; 3102 *asc_entry = NULL; 3103 match = NULL; 3104 if (inq_data != NULL) 3105 match = cam_quirkmatch((caddr_t)inq_data, 3106 (caddr_t)sense_quirk_table, 3107 sense_quirk_table_size, 3108 sizeof(*sense_quirk_table), 3109 scsi_inquiry_match); 3110 3111 if (match != NULL) { 3112 struct scsi_sense_quirk_entry *quirk; 3113 3114 quirk = (struct scsi_sense_quirk_entry *)match; 3115 asc_tables[0] = quirk->asc_info; 3116 asc_tables_size[0] = quirk->num_ascs; 3117 asc_tables[1] = asc_table; 3118 asc_tables_size[1] = asc_table_size; 3119 num_asc_tables = 2; 3120 sense_tables[0] = quirk->sense_key_info; 3121 sense_tables_size[0] = quirk->num_sense_keys; 3122 sense_tables[1] = sense_key_table; 3123 sense_tables_size[1] = sense_key_table_size; 3124 num_sense_tables = 2; 3125 } else { 3126 asc_tables[0] = asc_table; 3127 asc_tables_size[0] = asc_table_size; 3128 num_asc_tables = 1; 3129 sense_tables[0] = sense_key_table; 3130 sense_tables_size[0] = sense_key_table_size; 3131 num_sense_tables = 1; 3132 } 3133 3134 asc_ascq.asc = asc; 3135 asc_ascq.ascq = ascq; 3136 for (i = 0; i < num_asc_tables; i++) { 3137 void *found_entry; 3138 3139 found_entry = bsearch(&asc_ascq, asc_tables[i], 3140 asc_tables_size[i], 3141 sizeof(**asc_tables), 3142 ascentrycomp); 3143 3144 if (found_entry) { 3145 *asc_entry = (struct asc_table_entry *)found_entry; 3146 break; 3147 } 3148 } 3149 3150 for (i = 0; i < num_sense_tables; i++) { 3151 void *found_entry; 3152 3153 found_entry = bsearch(&sense_key, sense_tables[i], 3154 sense_tables_size[i], 3155 sizeof(**sense_tables), 3156 senseentrycomp); 3157 3158 if (found_entry) { 3159 *sense_entry = 3160 (struct sense_key_table_entry *)found_entry; 3161 break; 3162 } 3163 } 3164} 3165 3166void 3167scsi_sense_desc(int sense_key, int asc, int ascq, 3168 struct scsi_inquiry_data *inq_data, 3169 const char **sense_key_desc, const char **asc_desc) 3170{ 3171 const struct asc_table_entry *asc_entry; 3172 const struct sense_key_table_entry *sense_entry; 3173 3174 fetchtableentries(sense_key, asc, ascq, 3175 inq_data, 3176 &sense_entry, 3177 &asc_entry); 3178 3179 if (sense_entry != NULL) 3180 *sense_key_desc = sense_entry->desc; 3181 else 3182 *sense_key_desc = "Invalid Sense Key"; 3183 3184 if (asc_entry != NULL) 3185 *asc_desc = asc_entry->desc; 3186 else if (asc >= 0x80 && asc <= 0xff) 3187 *asc_desc = "Vendor Specific ASC"; 3188 else if (ascq >= 0x80 && ascq <= 0xff) 3189 *asc_desc = "Vendor Specific ASCQ"; 3190 else 3191 *asc_desc = "Reserved ASC/ASCQ pair"; 3192} 3193 3194/* 3195 * Given sense and device type information, return the appropriate action. 3196 * If we do not understand the specific error as identified by the ASC/ASCQ 3197 * pair, fall back on the more generic actions derived from the sense key. 3198 */ 3199scsi_sense_action 3200scsi_error_action(struct ccb_scsiio *csio, struct scsi_inquiry_data *inq_data, 3201 u_int32_t sense_flags) 3202{ 3203 const struct asc_table_entry *asc_entry; 3204 const struct sense_key_table_entry *sense_entry; 3205 int error_code, sense_key, asc, ascq; 3206 scsi_sense_action action; 3207 3208 if (!scsi_extract_sense_ccb((union ccb *)csio, 3209 &error_code, &sense_key, &asc, &ascq)) { 3210 action = SS_RETRY | SSQ_DECREMENT_COUNT | SSQ_PRINT_SENSE | EIO; 3211 } else if ((error_code == SSD_DEFERRED_ERROR) 3212 || (error_code == SSD_DESC_DEFERRED_ERROR)) { 3213 /* 3214 * XXX dufault@FreeBSD.org 3215 * This error doesn't relate to the command associated 3216 * with this request sense. A deferred error is an error 3217 * for a command that has already returned GOOD status 3218 * (see SCSI2 8.2.14.2). 3219 * 3220 * By my reading of that section, it looks like the current 3221 * command has been cancelled, we should now clean things up 3222 * (hopefully recovering any lost data) and then retry the 3223 * current command. There are two easy choices, both wrong: 3224 * 3225 * 1. Drop through (like we had been doing), thus treating 3226 * this as if the error were for the current command and 3227 * return and stop the current command. 3228 * 3229 * 2. Issue a retry (like I made it do) thus hopefully 3230 * recovering the current transfer, and ignoring the 3231 * fact that we've dropped a command. 3232 * 3233 * These should probably be handled in a device specific 3234 * sense handler or punted back up to a user mode daemon 3235 */ 3236 action = SS_RETRY|SSQ_DECREMENT_COUNT|SSQ_PRINT_SENSE; 3237 } else { 3238 fetchtableentries(sense_key, asc, ascq, 3239 inq_data, 3240 &sense_entry, 3241 &asc_entry); 3242 3243 /* 3244 * Override the 'No additional Sense' entry (0,0) 3245 * with the error action of the sense key. 3246 */ 3247 if (asc_entry != NULL 3248 && (asc != 0 || ascq != 0)) 3249 action = asc_entry->action; 3250 else if (sense_entry != NULL) 3251 action = sense_entry->action; 3252 else 3253 action = SS_RETRY|SSQ_DECREMENT_COUNT|SSQ_PRINT_SENSE; 3254 3255 if (sense_key == SSD_KEY_RECOVERED_ERROR) { 3256 /* 3257 * The action succeeded but the device wants 3258 * the user to know that some recovery action 3259 * was required. 3260 */ 3261 action &= ~(SS_MASK|SSQ_MASK|SS_ERRMASK); 3262 action |= SS_NOP|SSQ_PRINT_SENSE; 3263 } else if (sense_key == SSD_KEY_ILLEGAL_REQUEST) { 3264 if ((sense_flags & SF_QUIET_IR) != 0) 3265 action &= ~SSQ_PRINT_SENSE; 3266 } else if (sense_key == SSD_KEY_UNIT_ATTENTION) { 3267 if ((sense_flags & SF_RETRY_UA) != 0 3268 && (action & SS_MASK) == SS_FAIL) { 3269 action &= ~(SS_MASK|SSQ_MASK); 3270 action |= SS_RETRY|SSQ_DECREMENT_COUNT| 3271 SSQ_PRINT_SENSE; 3272 } 3273 action |= SSQ_UA; 3274 } 3275 } 3276 if ((action & SS_MASK) >= SS_START && 3277 (sense_flags & SF_NO_RECOVERY)) { 3278 action &= ~SS_MASK; 3279 action |= SS_FAIL; 3280 } else if ((action & SS_MASK) == SS_RETRY && 3281 (sense_flags & SF_NO_RETRY)) { 3282 action &= ~SS_MASK; 3283 action |= SS_FAIL; 3284 } 3285 if ((sense_flags & SF_PRINT_ALWAYS) != 0) 3286 action |= SSQ_PRINT_SENSE; 3287 else if ((sense_flags & SF_NO_PRINT) != 0) 3288 action &= ~SSQ_PRINT_SENSE; 3289 3290 return (action); 3291} 3292 3293char * 3294scsi_cdb_string(u_int8_t *cdb_ptr, char *cdb_string, size_t len) 3295{ 3296 u_int8_t cdb_len; 3297 int i; 3298 3299 if (cdb_ptr == NULL) 3300 return(""); 3301 3302 /* Silence warnings */ 3303 cdb_len = 0; 3304 3305 /* 3306 * This is taken from the SCSI-3 draft spec. 3307 * (T10/1157D revision 0.3) 3308 * The top 3 bits of an opcode are the group code. The next 5 bits 3309 * are the command code. 3310 * Group 0: six byte commands 3311 * Group 1: ten byte commands 3312 * Group 2: ten byte commands 3313 * Group 3: reserved 3314 * Group 4: sixteen byte commands 3315 * Group 5: twelve byte commands 3316 * Group 6: vendor specific 3317 * Group 7: vendor specific 3318 */ 3319 switch((*cdb_ptr >> 5) & 0x7) { 3320 case 0: 3321 cdb_len = 6; 3322 break; 3323 case 1: 3324 case 2: 3325 cdb_len = 10; 3326 break; 3327 case 3: 3328 case 6: 3329 case 7: 3330 /* in this case, just print out the opcode */ 3331 cdb_len = 1; 3332 break; 3333 case 4: 3334 cdb_len = 16; 3335 break; 3336 case 5: 3337 cdb_len = 12; 3338 break; 3339 } 3340 *cdb_string = '\0'; 3341 for (i = 0; i < cdb_len; i++) 3342 snprintf(cdb_string + strlen(cdb_string), 3343 len - strlen(cdb_string), "%02hhx ", cdb_ptr[i]); 3344 3345 return(cdb_string); 3346} 3347 3348const char * 3349scsi_status_string(struct ccb_scsiio *csio) 3350{ 3351 switch(csio->scsi_status) { 3352 case SCSI_STATUS_OK: 3353 return("OK"); 3354 case SCSI_STATUS_CHECK_COND: 3355 return("Check Condition"); 3356 case SCSI_STATUS_BUSY: 3357 return("Busy"); 3358 case SCSI_STATUS_INTERMED: 3359 return("Intermediate"); 3360 case SCSI_STATUS_INTERMED_COND_MET: 3361 return("Intermediate-Condition Met"); 3362 case SCSI_STATUS_RESERV_CONFLICT: 3363 return("Reservation Conflict"); 3364 case SCSI_STATUS_CMD_TERMINATED: 3365 return("Command Terminated"); 3366 case SCSI_STATUS_QUEUE_FULL: 3367 return("Queue Full"); 3368 case SCSI_STATUS_ACA_ACTIVE: 3369 return("ACA Active"); 3370 case SCSI_STATUS_TASK_ABORTED: 3371 return("Task Aborted"); 3372 default: { 3373 static char unkstr[64]; 3374 snprintf(unkstr, sizeof(unkstr), "Unknown %#x", 3375 csio->scsi_status); 3376 return(unkstr); 3377 } 3378 } 3379} 3380 3381/* 3382 * scsi_command_string() returns 0 for success and -1 for failure. 3383 */ 3384#ifdef _KERNEL 3385int 3386scsi_command_string(struct ccb_scsiio *csio, struct sbuf *sb) 3387#else /* !_KERNEL */ 3388int 3389scsi_command_string(struct cam_device *device, struct ccb_scsiio *csio, 3390 struct sbuf *sb) 3391#endif /* _KERNEL/!_KERNEL */ 3392{ 3393 struct scsi_inquiry_data *inq_data; 3394 char cdb_str[(SCSI_MAX_CDBLEN * 3) + 1]; 3395#ifdef _KERNEL 3396 struct ccb_getdev *cgd; 3397#endif /* _KERNEL */ 3398 3399#ifdef _KERNEL 3400 if ((cgd = (struct ccb_getdev*)xpt_alloc_ccb_nowait()) == NULL) 3401 return(-1); 3402 /* 3403 * Get the device information. 3404 */ 3405 xpt_setup_ccb(&cgd->ccb_h, 3406 csio->ccb_h.path, 3407 CAM_PRIORITY_NORMAL); 3408 cgd->ccb_h.func_code = XPT_GDEV_TYPE; 3409 xpt_action((union ccb *)cgd); 3410 3411 /* 3412 * If the device is unconfigured, just pretend that it is a hard 3413 * drive. scsi_op_desc() needs this. 3414 */ 3415 if (cgd->ccb_h.status == CAM_DEV_NOT_THERE) 3416 cgd->inq_data.device = T_DIRECT; 3417 3418 inq_data = &cgd->inq_data; 3419 3420#else /* !_KERNEL */ 3421 3422 inq_data = &device->inq_data; 3423 3424#endif /* _KERNEL/!_KERNEL */ 3425 3426 if ((csio->ccb_h.flags & CAM_CDB_POINTER) != 0) { 3427 sbuf_printf(sb, "%s. CDB: %s", 3428 scsi_op_desc(csio->cdb_io.cdb_ptr[0], inq_data), 3429 scsi_cdb_string(csio->cdb_io.cdb_ptr, cdb_str, 3430 sizeof(cdb_str))); 3431 } else { 3432 sbuf_printf(sb, "%s. CDB: %s", 3433 scsi_op_desc(csio->cdb_io.cdb_bytes[0], inq_data), 3434 scsi_cdb_string(csio->cdb_io.cdb_bytes, cdb_str, 3435 sizeof(cdb_str))); 3436 } 3437 3438#ifdef _KERNEL 3439 xpt_free_ccb((union ccb *)cgd); 3440#endif 3441 3442 return(0); 3443} 3444 3445/* 3446 * Iterate over sense descriptors. Each descriptor is passed into iter_func(). 3447 * If iter_func() returns 0, list traversal continues. If iter_func() 3448 * returns non-zero, list traversal is stopped. 3449 */ 3450void 3451scsi_desc_iterate(struct scsi_sense_data_desc *sense, u_int sense_len, 3452 int (*iter_func)(struct scsi_sense_data_desc *sense, 3453 u_int, struct scsi_sense_desc_header *, 3454 void *), void *arg) 3455{ 3456 int cur_pos; 3457 int desc_len; 3458 3459 /* 3460 * First make sure the extra length field is present. 3461 */ 3462 if (SSD_DESC_IS_PRESENT(sense, sense_len, extra_len) == 0) 3463 return; 3464 3465 /* 3466 * The length of data actually returned may be different than the 3467 * extra_len recorded in the sturcture. 3468 */ 3469 desc_len = sense_len -offsetof(struct scsi_sense_data_desc, sense_desc); 3470 3471 /* 3472 * Limit this further by the extra length reported, and the maximum 3473 * allowed extra length. 3474 */ 3475 desc_len = MIN(desc_len, MIN(sense->extra_len, SSD_EXTRA_MAX)); 3476 3477 /* 3478 * Subtract the size of the header from the descriptor length. 3479 * This is to ensure that we have at least the header left, so we 3480 * don't have to check that inside the loop. This can wind up 3481 * being a negative value. 3482 */ 3483 desc_len -= sizeof(struct scsi_sense_desc_header); 3484 3485 for (cur_pos = 0; cur_pos < desc_len;) { 3486 struct scsi_sense_desc_header *header; 3487 3488 header = (struct scsi_sense_desc_header *) 3489 &sense->sense_desc[cur_pos]; 3490 3491 /* 3492 * Check to make sure we have the entire descriptor. We 3493 * don't call iter_func() unless we do. 3494 * 3495 * Note that although cur_pos is at the beginning of the 3496 * descriptor, desc_len already has the header length 3497 * subtracted. So the comparison of the length in the 3498 * header (which does not include the header itself) to 3499 * desc_len - cur_pos is correct. 3500 */ 3501 if (header->length > (desc_len - cur_pos)) 3502 break; 3503 3504 if (iter_func(sense, sense_len, header, arg) != 0) 3505 break; 3506 3507 cur_pos += sizeof(*header) + header->length; 3508 } 3509} 3510 3511struct scsi_find_desc_info { 3512 uint8_t desc_type; 3513 struct scsi_sense_desc_header *header; 3514}; 3515 3516static int 3517scsi_find_desc_func(struct scsi_sense_data_desc *sense, u_int sense_len, 3518 struct scsi_sense_desc_header *header, void *arg) 3519{ 3520 struct scsi_find_desc_info *desc_info; 3521 3522 desc_info = (struct scsi_find_desc_info *)arg; 3523 3524 if (header->desc_type == desc_info->desc_type) { 3525 desc_info->header = header; 3526 3527 /* We found the descriptor, tell the iterator to stop. */ 3528 return (1); 3529 } else 3530 return (0); 3531} 3532 3533/* 3534 * Given a descriptor type, return a pointer to it if it is in the sense 3535 * data and not truncated. Avoiding truncating sense data will simplify 3536 * things significantly for the caller. 3537 */ 3538uint8_t * 3539scsi_find_desc(struct scsi_sense_data_desc *sense, u_int sense_len, 3540 uint8_t desc_type) 3541{ 3542 struct scsi_find_desc_info desc_info; 3543 3544 desc_info.desc_type = desc_type; 3545 desc_info.header = NULL; 3546 3547 scsi_desc_iterate(sense, sense_len, scsi_find_desc_func, &desc_info); 3548 3549 return ((uint8_t *)desc_info.header); 3550} 3551 3552/* 3553 * Fill in SCSI sense data with the specified parameters. This routine can 3554 * fill in either fixed or descriptor type sense data. 3555 */ 3556void 3557scsi_set_sense_data_va(struct scsi_sense_data *sense_data, 3558 scsi_sense_data_type sense_format, int current_error, 3559 int sense_key, int asc, int ascq, va_list ap) 3560{ 3561 int descriptor_sense; 3562 scsi_sense_elem_type elem_type; 3563 3564 /* 3565 * Determine whether to return fixed or descriptor format sense 3566 * data. If the user specifies SSD_TYPE_NONE for some reason, 3567 * they'll just get fixed sense data. 3568 */ 3569 if (sense_format == SSD_TYPE_DESC) 3570 descriptor_sense = 1; 3571 else 3572 descriptor_sense = 0; 3573 3574 /* 3575 * Zero the sense data, so that we don't pass back any garbage data 3576 * to the user. 3577 */ 3578 memset(sense_data, 0, sizeof(*sense_data)); 3579 3580 if (descriptor_sense != 0) { 3581 struct scsi_sense_data_desc *sense; 3582 3583 sense = (struct scsi_sense_data_desc *)sense_data; 3584 /* 3585 * The descriptor sense format eliminates the use of the 3586 * valid bit. 3587 */ 3588 if (current_error != 0) 3589 sense->error_code = SSD_DESC_CURRENT_ERROR; 3590 else 3591 sense->error_code = SSD_DESC_DEFERRED_ERROR; 3592 sense->sense_key = sense_key; 3593 sense->add_sense_code = asc; 3594 sense->add_sense_code_qual = ascq; 3595 /* 3596 * Start off with no extra length, since the above data 3597 * fits in the standard descriptor sense information. 3598 */ 3599 sense->extra_len = 0; 3600 while ((elem_type = (scsi_sense_elem_type)va_arg(ap, 3601 scsi_sense_elem_type)) != SSD_ELEM_NONE) { 3602 int sense_len, len_to_copy; 3603 uint8_t *data; 3604 3605 if (elem_type >= SSD_ELEM_MAX) { 3606 printf("%s: invalid sense type %d\n", __func__, 3607 elem_type); 3608 break; 3609 } 3610 3611 sense_len = (int)va_arg(ap, int); 3612 len_to_copy = MIN(sense_len, SSD_EXTRA_MAX - 3613 sense->extra_len); 3614 data = (uint8_t *)va_arg(ap, uint8_t *); 3615 3616 /* 3617 * We've already consumed the arguments for this one. 3618 */ 3619 if (elem_type == SSD_ELEM_SKIP) 3620 continue; 3621 3622 switch (elem_type) { 3623 case SSD_ELEM_DESC: { 3624 3625 /* 3626 * This is a straight descriptor. All we 3627 * need to do is copy the data in. 3628 */ 3629 bcopy(data, &sense->sense_desc[ 3630 sense->extra_len], len_to_copy); 3631 sense->extra_len += len_to_copy; 3632 break; 3633 } 3634 case SSD_ELEM_SKS: { 3635 struct scsi_sense_sks sks; 3636 3637 bzero(&sks, sizeof(sks)); 3638 3639 /* 3640 * This is already-formatted sense key 3641 * specific data. We just need to fill out 3642 * the header and copy everything in. 3643 */ 3644 bcopy(data, &sks.sense_key_spec, 3645 MIN(len_to_copy, 3646 sizeof(sks.sense_key_spec))); 3647 3648 sks.desc_type = SSD_DESC_SKS; 3649 sks.length = sizeof(sks) - 3650 offsetof(struct scsi_sense_sks, reserved1); 3651 bcopy(&sks,&sense->sense_desc[sense->extra_len], 3652 sizeof(sks)); 3653 sense->extra_len += sizeof(sks); 3654 break; 3655 } 3656 case SSD_ELEM_INFO: 3657 case SSD_ELEM_COMMAND: { 3658 struct scsi_sense_command cmd; 3659 struct scsi_sense_info info; 3660 uint8_t *data_dest; 3661 uint8_t *descriptor; 3662 int descriptor_size, i, copy_len; 3663 3664 bzero(&cmd, sizeof(cmd)); 3665 bzero(&info, sizeof(info)); 3666 3667 /* 3668 * Command or information data. The 3669 * operate in pretty much the same way. 3670 */ 3671 if (elem_type == SSD_ELEM_COMMAND) { 3672 len_to_copy = MIN(len_to_copy, 3673 sizeof(cmd.command_info)); 3674 descriptor = (uint8_t *)&cmd; 3675 descriptor_size = sizeof(cmd); 3676 data_dest =(uint8_t *)&cmd.command_info; 3677 cmd.desc_type = SSD_DESC_COMMAND; 3678 cmd.length = sizeof(cmd) - 3679 offsetof(struct scsi_sense_command, 3680 reserved); 3681 } else { 3682 len_to_copy = MIN(len_to_copy, 3683 sizeof(info.info)); 3684 descriptor = (uint8_t *)&info; 3685 descriptor_size = sizeof(cmd); 3686 data_dest = (uint8_t *)&info.info; 3687 info.desc_type = SSD_DESC_INFO; 3688 info.byte2 = SSD_INFO_VALID; 3689 info.length = sizeof(info) - 3690 offsetof(struct scsi_sense_info, 3691 byte2); 3692 } 3693 3694 /* 3695 * Copy this in reverse because the spec 3696 * (SPC-4) says that when 4 byte quantities 3697 * are stored in this 8 byte field, the 3698 * first four bytes shall be 0. 3699 * 3700 * So we fill the bytes in from the end, and 3701 * if we have less than 8 bytes to copy, 3702 * the initial, most significant bytes will 3703 * be 0. 3704 */ 3705 for (i = sense_len - 1; i >= 0 && 3706 len_to_copy > 0; i--, len_to_copy--) 3707 data_dest[len_to_copy - 1] = data[i]; 3708 3709 /* 3710 * This calculation looks much like the 3711 * initial len_to_copy calculation, but 3712 * we have to do it again here, because 3713 * we're looking at a larger amount that 3714 * may or may not fit. It's not only the 3715 * data the user passed in, but also the 3716 * rest of the descriptor. 3717 */ 3718 copy_len = MIN(descriptor_size, 3719 SSD_EXTRA_MAX - sense->extra_len); 3720 bcopy(descriptor, &sense->sense_desc[ 3721 sense->extra_len], copy_len); 3722 sense->extra_len += copy_len; 3723 break; 3724 } 3725 case SSD_ELEM_FRU: { 3726 struct scsi_sense_fru fru; 3727 int copy_len; 3728 3729 bzero(&fru, sizeof(fru)); 3730 3731 fru.desc_type = SSD_DESC_FRU; 3732 fru.length = sizeof(fru) - 3733 offsetof(struct scsi_sense_fru, reserved); 3734 fru.fru = *data; 3735 3736 copy_len = MIN(sizeof(fru), SSD_EXTRA_MAX - 3737 sense->extra_len); 3738 bcopy(&fru, &sense->sense_desc[ 3739 sense->extra_len], copy_len); 3740 sense->extra_len += copy_len; 3741 break; 3742 } 3743 case SSD_ELEM_STREAM: { 3744 struct scsi_sense_stream stream_sense; 3745 int copy_len; 3746 3747 bzero(&stream_sense, sizeof(stream_sense)); 3748 stream_sense.desc_type = SSD_DESC_STREAM; 3749 stream_sense.length = sizeof(stream_sense) - 3750 offsetof(struct scsi_sense_stream, reserved); 3751 stream_sense.byte3 = *data; 3752 3753 copy_len = MIN(sizeof(stream_sense), 3754 SSD_EXTRA_MAX - sense->extra_len); 3755 bcopy(&stream_sense, &sense->sense_desc[ 3756 sense->extra_len], copy_len); 3757 sense->extra_len += copy_len; 3758 break; 3759 } 3760 default: 3761 /* 3762 * We shouldn't get here, but if we do, do 3763 * nothing. We've already consumed the 3764 * arguments above. 3765 */ 3766 break; 3767 } 3768 } 3769 } else { 3770 struct scsi_sense_data_fixed *sense; 3771 3772 sense = (struct scsi_sense_data_fixed *)sense_data; 3773 3774 if (current_error != 0) 3775 sense->error_code = SSD_CURRENT_ERROR; 3776 else 3777 sense->error_code = SSD_DEFERRED_ERROR; 3778 3779 sense->flags = sense_key; 3780 sense->add_sense_code = asc; 3781 sense->add_sense_code_qual = ascq; 3782 /* 3783 * We've set the ASC and ASCQ, so we have 6 more bytes of 3784 * valid data. If we wind up setting any of the other 3785 * fields, we'll bump this to 10 extra bytes. 3786 */ 3787 sense->extra_len = 6; 3788 3789 while ((elem_type = (scsi_sense_elem_type)va_arg(ap, 3790 scsi_sense_elem_type)) != SSD_ELEM_NONE) { 3791 int sense_len, len_to_copy; 3792 uint8_t *data; 3793 3794 if (elem_type >= SSD_ELEM_MAX) { 3795 printf("%s: invalid sense type %d\n", __func__, 3796 elem_type); 3797 break; 3798 } 3799 /* 3800 * If we get in here, just bump the extra length to 3801 * 10 bytes. That will encompass anything we're 3802 * going to set here. 3803 */ 3804 sense->extra_len = 10; 3805 sense_len = (int)va_arg(ap, int); 3806 data = (uint8_t *)va_arg(ap, uint8_t *); 3807 3808 switch (elem_type) { 3809 case SSD_ELEM_SKS: 3810 /* 3811 * The user passed in pre-formatted sense 3812 * key specific data. 3813 */ 3814 bcopy(data, &sense->sense_key_spec[0], 3815 MIN(sizeof(sense->sense_key_spec), 3816 sense_len)); 3817 break; 3818 case SSD_ELEM_INFO: 3819 case SSD_ELEM_COMMAND: { 3820 uint8_t *data_dest; 3821 int i; 3822 3823 if (elem_type == SSD_ELEM_COMMAND) { 3824 data_dest = &sense->cmd_spec_info[0]; 3825 len_to_copy = MIN(sense_len, 3826 sizeof(sense->cmd_spec_info)); 3827 } else { 3828 data_dest = &sense->info[0]; 3829 len_to_copy = MIN(sense_len, 3830 sizeof(sense->info)); 3831 /* 3832 * We're setting the info field, so 3833 * set the valid bit. 3834 */ 3835 sense->error_code |= SSD_ERRCODE_VALID; 3836 } 3837 3838 /* 3839 * Copy this in reverse so that if we have 3840 * less than 4 bytes to fill, the least 3841 * significant bytes will be at the end. 3842 * If we have more than 4 bytes, only the 3843 * least significant bytes will be included. 3844 */ 3845 for (i = sense_len - 1; i >= 0 && 3846 len_to_copy > 0; i--, len_to_copy--) 3847 data_dest[len_to_copy - 1] = data[i]; 3848 3849 break; 3850 } 3851 case SSD_ELEM_FRU: 3852 sense->fru = *data; 3853 break; 3854 case SSD_ELEM_STREAM: 3855 sense->flags |= *data; 3856 break; 3857 case SSD_ELEM_DESC: 3858 default: 3859 3860 /* 3861 * If the user passes in descriptor sense, 3862 * we can't handle that in fixed format. 3863 * So just skip it, and any unknown argument 3864 * types. 3865 */ 3866 break; 3867 } 3868 } 3869 } 3870} 3871 3872void 3873scsi_set_sense_data(struct scsi_sense_data *sense_data, 3874 scsi_sense_data_type sense_format, int current_error, 3875 int sense_key, int asc, int ascq, ...) 3876{ 3877 va_list ap; 3878 3879 va_start(ap, ascq); 3880 scsi_set_sense_data_va(sense_data, sense_format, current_error, 3881 sense_key, asc, ascq, ap); 3882 va_end(ap); 3883} 3884 3885/* 3886 * Get sense information for three similar sense data types. 3887 */ 3888int 3889scsi_get_sense_info(struct scsi_sense_data *sense_data, u_int sense_len, 3890 uint8_t info_type, uint64_t *info, int64_t *signed_info) 3891{ 3892 scsi_sense_data_type sense_type; 3893 3894 if (sense_len == 0) 3895 goto bailout; 3896 3897 sense_type = scsi_sense_type(sense_data); 3898 3899 switch (sense_type) { 3900 case SSD_TYPE_DESC: { 3901 struct scsi_sense_data_desc *sense; 3902 uint8_t *desc; 3903 3904 sense = (struct scsi_sense_data_desc *)sense_data; 3905 3906 desc = scsi_find_desc(sense, sense_len, info_type); 3907 if (desc == NULL) 3908 goto bailout; 3909 3910 switch (info_type) { 3911 case SSD_DESC_INFO: { 3912 struct scsi_sense_info *info_desc; 3913 3914 info_desc = (struct scsi_sense_info *)desc; 3915 *info = scsi_8btou64(info_desc->info); 3916 if (signed_info != NULL) 3917 *signed_info = *info; 3918 break; 3919 } 3920 case SSD_DESC_COMMAND: { 3921 struct scsi_sense_command *cmd_desc; 3922 3923 cmd_desc = (struct scsi_sense_command *)desc; 3924 3925 *info = scsi_8btou64(cmd_desc->command_info); 3926 if (signed_info != NULL) 3927 *signed_info = *info; 3928 break; 3929 } 3930 case SSD_DESC_FRU: { 3931 struct scsi_sense_fru *fru_desc; 3932 3933 fru_desc = (struct scsi_sense_fru *)desc; 3934 3935 *info = fru_desc->fru; 3936 if (signed_info != NULL) 3937 *signed_info = (int8_t)fru_desc->fru; 3938 break; 3939 } 3940 default: 3941 goto bailout; 3942 break; 3943 } 3944 break; 3945 } 3946 case SSD_TYPE_FIXED: { 3947 struct scsi_sense_data_fixed *sense; 3948 3949 sense = (struct scsi_sense_data_fixed *)sense_data; 3950 3951 switch (info_type) { 3952 case SSD_DESC_INFO: { 3953 uint32_t info_val; 3954 3955 if ((sense->error_code & SSD_ERRCODE_VALID) == 0) 3956 goto bailout; 3957 3958 if (SSD_FIXED_IS_PRESENT(sense, sense_len, info) == 0) 3959 goto bailout; 3960 3961 info_val = scsi_4btoul(sense->info); 3962 3963 *info = info_val; 3964 if (signed_info != NULL) 3965 *signed_info = (int32_t)info_val; 3966 break; 3967 } 3968 case SSD_DESC_COMMAND: { 3969 uint32_t cmd_val; 3970 3971 if ((SSD_FIXED_IS_PRESENT(sense, sense_len, 3972 cmd_spec_info) == 0) 3973 || (SSD_FIXED_IS_FILLED(sense, cmd_spec_info) == 0)) 3974 goto bailout; 3975 3976 cmd_val = scsi_4btoul(sense->cmd_spec_info); 3977 if (cmd_val == 0) 3978 goto bailout; 3979 3980 *info = cmd_val; 3981 if (signed_info != NULL) 3982 *signed_info = (int32_t)cmd_val; 3983 break; 3984 } 3985 case SSD_DESC_FRU: 3986 if ((SSD_FIXED_IS_PRESENT(sense, sense_len, fru) == 0) 3987 || (SSD_FIXED_IS_FILLED(sense, fru) == 0)) 3988 goto bailout; 3989 3990 if (sense->fru == 0) 3991 goto bailout; 3992 3993 *info = sense->fru; 3994 if (signed_info != NULL) 3995 *signed_info = (int8_t)sense->fru; 3996 break; 3997 default: 3998 goto bailout; 3999 break; 4000 } 4001 break; 4002 } 4003 default: 4004 goto bailout; 4005 break; 4006 } 4007 4008 return (0); 4009bailout: 4010 return (1); 4011} 4012 4013int 4014scsi_get_sks(struct scsi_sense_data *sense_data, u_int sense_len, uint8_t *sks) 4015{ 4016 scsi_sense_data_type sense_type; 4017 4018 if (sense_len == 0) 4019 goto bailout; 4020 4021 sense_type = scsi_sense_type(sense_data); 4022 4023 switch (sense_type) { 4024 case SSD_TYPE_DESC: { 4025 struct scsi_sense_data_desc *sense; 4026 struct scsi_sense_sks *desc; 4027 4028 sense = (struct scsi_sense_data_desc *)sense_data; 4029 4030 desc = (struct scsi_sense_sks *)scsi_find_desc(sense, sense_len, 4031 SSD_DESC_SKS); 4032 if (desc == NULL) 4033 goto bailout; 4034 4035 /* 4036 * No need to check the SKS valid bit for descriptor sense. 4037 * If the descriptor is present, it is valid. 4038 */ 4039 bcopy(desc->sense_key_spec, sks, sizeof(desc->sense_key_spec)); 4040 break; 4041 } 4042 case SSD_TYPE_FIXED: { 4043 struct scsi_sense_data_fixed *sense; 4044 4045 sense = (struct scsi_sense_data_fixed *)sense_data; 4046 4047 if ((SSD_FIXED_IS_PRESENT(sense, sense_len, sense_key_spec)== 0) 4048 || (SSD_FIXED_IS_FILLED(sense, sense_key_spec) == 0)) 4049 goto bailout; 4050 4051 if ((sense->sense_key_spec[0] & SSD_SCS_VALID) == 0) 4052 goto bailout; 4053 4054 bcopy(sense->sense_key_spec, sks,sizeof(sense->sense_key_spec)); 4055 break; 4056 } 4057 default: 4058 goto bailout; 4059 break; 4060 } 4061 return (0); 4062bailout: 4063 return (1); 4064} 4065 4066/* 4067 * Provide a common interface for fixed and descriptor sense to detect 4068 * whether we have block-specific sense information. It is clear by the 4069 * presence of the block descriptor in descriptor mode, but we have to 4070 * infer from the inquiry data and ILI bit in fixed mode. 4071 */ 4072int 4073scsi_get_block_info(struct scsi_sense_data *sense_data, u_int sense_len, 4074 struct scsi_inquiry_data *inq_data, uint8_t *block_bits) 4075{ 4076 scsi_sense_data_type sense_type; 4077 4078 if (inq_data != NULL) { 4079 switch (SID_TYPE(inq_data)) { 4080 case T_DIRECT: 4081 case T_RBC: 4082 break; 4083 default: 4084 goto bailout; 4085 break; 4086 } 4087 } 4088 4089 sense_type = scsi_sense_type(sense_data); 4090 4091 switch (sense_type) { 4092 case SSD_TYPE_DESC: { 4093 struct scsi_sense_data_desc *sense; 4094 struct scsi_sense_block *block; 4095 4096 sense = (struct scsi_sense_data_desc *)sense_data; 4097 4098 block = (struct scsi_sense_block *)scsi_find_desc(sense, 4099 sense_len, SSD_DESC_BLOCK); 4100 if (block == NULL) 4101 goto bailout; 4102 4103 *block_bits = block->byte3; 4104 break; 4105 } 4106 case SSD_TYPE_FIXED: { 4107 struct scsi_sense_data_fixed *sense; 4108 4109 sense = (struct scsi_sense_data_fixed *)sense_data; 4110 4111 if (SSD_FIXED_IS_PRESENT(sense, sense_len, flags) == 0) 4112 goto bailout; 4113 4114 if ((sense->flags & SSD_ILI) == 0) 4115 goto bailout; 4116 4117 *block_bits = sense->flags & SSD_ILI; 4118 break; 4119 } 4120 default: 4121 goto bailout; 4122 break; 4123 } 4124 return (0); 4125bailout: 4126 return (1); 4127} 4128 4129int 4130scsi_get_stream_info(struct scsi_sense_data *sense_data, u_int sense_len, 4131 struct scsi_inquiry_data *inq_data, uint8_t *stream_bits) 4132{ 4133 scsi_sense_data_type sense_type; 4134 4135 if (inq_data != NULL) { 4136 switch (SID_TYPE(inq_data)) { 4137 case T_SEQUENTIAL: 4138 break; 4139 default: 4140 goto bailout; 4141 break; 4142 } 4143 } 4144 4145 sense_type = scsi_sense_type(sense_data); 4146 4147 switch (sense_type) { 4148 case SSD_TYPE_DESC: { 4149 struct scsi_sense_data_desc *sense; 4150 struct scsi_sense_stream *stream; 4151 4152 sense = (struct scsi_sense_data_desc *)sense_data; 4153 4154 stream = (struct scsi_sense_stream *)scsi_find_desc(sense, 4155 sense_len, SSD_DESC_STREAM); 4156 if (stream == NULL) 4157 goto bailout; 4158 4159 *stream_bits = stream->byte3; 4160 break; 4161 } 4162 case SSD_TYPE_FIXED: { 4163 struct scsi_sense_data_fixed *sense; 4164 4165 sense = (struct scsi_sense_data_fixed *)sense_data; 4166 4167 if (SSD_FIXED_IS_PRESENT(sense, sense_len, flags) == 0) 4168 goto bailout; 4169 4170 if ((sense->flags & (SSD_ILI|SSD_EOM|SSD_FILEMARK)) == 0) 4171 goto bailout; 4172 4173 *stream_bits = sense->flags & (SSD_ILI|SSD_EOM|SSD_FILEMARK); 4174 break; 4175 } 4176 default: 4177 goto bailout; 4178 break; 4179 } 4180 return (0); 4181bailout: 4182 return (1); 4183} 4184 4185void 4186scsi_info_sbuf(struct sbuf *sb, uint8_t *cdb, int cdb_len, 4187 struct scsi_inquiry_data *inq_data, uint64_t info) 4188{ 4189 sbuf_printf(sb, "Info: %#jx", info); 4190} 4191 4192void 4193scsi_command_sbuf(struct sbuf *sb, uint8_t *cdb, int cdb_len, 4194 struct scsi_inquiry_data *inq_data, uint64_t csi) 4195{ 4196 sbuf_printf(sb, "Command Specific Info: %#jx", csi); 4197} 4198 4199 4200void 4201scsi_progress_sbuf(struct sbuf *sb, uint16_t progress) 4202{ 4203 sbuf_printf(sb, "Progress: %d%% (%d/%d) complete", 4204 (progress * 100) / SSD_SKS_PROGRESS_DENOM, 4205 progress, SSD_SKS_PROGRESS_DENOM); 4206} 4207 4208/* 4209 * Returns 1 for failure (i.e. SKS isn't valid) and 0 for success. 4210 */ 4211int 4212scsi_sks_sbuf(struct sbuf *sb, int sense_key, uint8_t *sks) 4213{ 4214 if ((sks[0] & SSD_SKS_VALID) == 0) 4215 return (1); 4216 4217 switch (sense_key) { 4218 case SSD_KEY_ILLEGAL_REQUEST: { 4219 struct scsi_sense_sks_field *field; 4220 int bad_command; 4221 char tmpstr[40]; 4222 4223 /*Field Pointer*/ 4224 field = (struct scsi_sense_sks_field *)sks; 4225 4226 if (field->byte0 & SSD_SKS_FIELD_CMD) 4227 bad_command = 1; 4228 else 4229 bad_command = 0; 4230 4231 tmpstr[0] = '\0'; 4232 4233 /* Bit pointer is valid */ 4234 if (field->byte0 & SSD_SKS_BPV) 4235 snprintf(tmpstr, sizeof(tmpstr), "bit %d ", 4236 field->byte0 & SSD_SKS_BIT_VALUE); 4237 4238 sbuf_printf(sb, "%s byte %d %sis invalid", 4239 bad_command ? "Command" : "Data", 4240 scsi_2btoul(field->field), tmpstr); 4241 break; 4242 } 4243 case SSD_KEY_UNIT_ATTENTION: { 4244 struct scsi_sense_sks_overflow *overflow; 4245 4246 overflow = (struct scsi_sense_sks_overflow *)sks; 4247 4248 /*UA Condition Queue Overflow*/ 4249 sbuf_printf(sb, "Unit Attention Condition Queue %s", 4250 (overflow->byte0 & SSD_SKS_OVERFLOW_SET) ? 4251 "Overflowed" : "Did Not Overflow??"); 4252 break; 4253 } 4254 case SSD_KEY_RECOVERED_ERROR: 4255 case SSD_KEY_HARDWARE_ERROR: 4256 case SSD_KEY_MEDIUM_ERROR: { 4257 struct scsi_sense_sks_retry *retry; 4258 4259 /*Actual Retry Count*/ 4260 retry = (struct scsi_sense_sks_retry *)sks; 4261 4262 sbuf_printf(sb, "Actual Retry Count: %d", 4263 scsi_2btoul(retry->actual_retry_count)); 4264 break; 4265 } 4266 case SSD_KEY_NO_SENSE: 4267 case SSD_KEY_NOT_READY: { 4268 struct scsi_sense_sks_progress *progress; 4269 int progress_val; 4270 4271 /*Progress Indication*/ 4272 progress = (struct scsi_sense_sks_progress *)sks; 4273 progress_val = scsi_2btoul(progress->progress); 4274 4275 scsi_progress_sbuf(sb, progress_val); 4276 break; 4277 } 4278 case SSD_KEY_COPY_ABORTED: { 4279 struct scsi_sense_sks_segment *segment; 4280 char tmpstr[40]; 4281 4282 /*Segment Pointer*/ 4283 segment = (struct scsi_sense_sks_segment *)sks; 4284 4285 tmpstr[0] = '\0'; 4286 4287 if (segment->byte0 & SSD_SKS_SEGMENT_BPV) 4288 snprintf(tmpstr, sizeof(tmpstr), "bit %d ", 4289 segment->byte0 & SSD_SKS_SEGMENT_BITPTR); 4290 4291 sbuf_printf(sb, "%s byte %d %sis invalid", (segment->byte0 & 4292 SSD_SKS_SEGMENT_SD) ? "Segment" : "Data", 4293 scsi_2btoul(segment->field), tmpstr); 4294 break; 4295 } 4296 default: 4297 sbuf_printf(sb, "Sense Key Specific: %#x,%#x", sks[0], 4298 scsi_2btoul(&sks[1])); 4299 break; 4300 } 4301 4302 return (0); 4303} 4304 4305void 4306scsi_fru_sbuf(struct sbuf *sb, uint64_t fru) 4307{ 4308 sbuf_printf(sb, "Field Replaceable Unit: %d", (int)fru); 4309} 4310 4311void 4312scsi_stream_sbuf(struct sbuf *sb, uint8_t stream_bits, uint64_t info) 4313{ 4314 int need_comma; 4315 4316 need_comma = 0; 4317 /* 4318 * XXX KDM this needs more descriptive decoding. 4319 */ 4320 if (stream_bits & SSD_DESC_STREAM_FM) { 4321 sbuf_printf(sb, "Filemark"); 4322 need_comma = 1; 4323 } 4324 4325 if (stream_bits & SSD_DESC_STREAM_EOM) { 4326 sbuf_printf(sb, "%sEOM", (need_comma) ? "," : ""); 4327 need_comma = 1; 4328 } 4329 4330 if (stream_bits & SSD_DESC_STREAM_ILI) 4331 sbuf_printf(sb, "%sILI", (need_comma) ? "," : ""); 4332 4333 sbuf_printf(sb, ": Info: %#jx", (uintmax_t) info); 4334} 4335 4336void 4337scsi_block_sbuf(struct sbuf *sb, uint8_t block_bits, uint64_t info) 4338{ 4339 if (block_bits & SSD_DESC_BLOCK_ILI) 4340 sbuf_printf(sb, "ILI: residue %#jx", (uintmax_t) info); 4341} 4342 4343void 4344scsi_sense_info_sbuf(struct sbuf *sb, struct scsi_sense_data *sense, 4345 u_int sense_len, uint8_t *cdb, int cdb_len, 4346 struct scsi_inquiry_data *inq_data, 4347 struct scsi_sense_desc_header *header) 4348{ 4349 struct scsi_sense_info *info; 4350 4351 info = (struct scsi_sense_info *)header; 4352 4353 scsi_info_sbuf(sb, cdb, cdb_len, inq_data, scsi_8btou64(info->info)); 4354} 4355 4356void 4357scsi_sense_command_sbuf(struct sbuf *sb, struct scsi_sense_data *sense, 4358 u_int sense_len, uint8_t *cdb, int cdb_len, 4359 struct scsi_inquiry_data *inq_data, 4360 struct scsi_sense_desc_header *header) 4361{ 4362 struct scsi_sense_command *command; 4363 4364 command = (struct scsi_sense_command *)header; 4365 4366 scsi_command_sbuf(sb, cdb, cdb_len, inq_data, 4367 scsi_8btou64(command->command_info)); 4368} 4369 4370void 4371scsi_sense_sks_sbuf(struct sbuf *sb, struct scsi_sense_data *sense, 4372 u_int sense_len, uint8_t *cdb, int cdb_len, 4373 struct scsi_inquiry_data *inq_data, 4374 struct scsi_sense_desc_header *header) 4375{ 4376 struct scsi_sense_sks *sks; 4377 int error_code, sense_key, asc, ascq; 4378 4379 sks = (struct scsi_sense_sks *)header; 4380 4381 scsi_extract_sense_len(sense, sense_len, &error_code, &sense_key, 4382 &asc, &ascq, /*show_errors*/ 1); 4383 4384 scsi_sks_sbuf(sb, sense_key, sks->sense_key_spec); 4385} 4386 4387void 4388scsi_sense_fru_sbuf(struct sbuf *sb, struct scsi_sense_data *sense, 4389 u_int sense_len, uint8_t *cdb, int cdb_len, 4390 struct scsi_inquiry_data *inq_data, 4391 struct scsi_sense_desc_header *header) 4392{ 4393 struct scsi_sense_fru *fru; 4394 4395 fru = (struct scsi_sense_fru *)header; 4396 4397 scsi_fru_sbuf(sb, (uint64_t)fru->fru); 4398} 4399 4400void 4401scsi_sense_stream_sbuf(struct sbuf *sb, struct scsi_sense_data *sense, 4402 u_int sense_len, uint8_t *cdb, int cdb_len, 4403 struct scsi_inquiry_data *inq_data, 4404 struct scsi_sense_desc_header *header) 4405{ 4406 struct scsi_sense_stream *stream; 4407 uint64_t info; 4408 4409 stream = (struct scsi_sense_stream *)header; 4410 info = 0; 4411 4412 scsi_get_sense_info(sense, sense_len, SSD_DESC_INFO, &info, NULL); 4413 4414 scsi_stream_sbuf(sb, stream->byte3, info); 4415} 4416 4417void 4418scsi_sense_block_sbuf(struct sbuf *sb, struct scsi_sense_data *sense, 4419 u_int sense_len, uint8_t *cdb, int cdb_len, 4420 struct scsi_inquiry_data *inq_data, 4421 struct scsi_sense_desc_header *header) 4422{ 4423 struct scsi_sense_block *block; 4424 uint64_t info; 4425 4426 block = (struct scsi_sense_block *)header; 4427 info = 0; 4428 4429 scsi_get_sense_info(sense, sense_len, SSD_DESC_INFO, &info, NULL); 4430 4431 scsi_block_sbuf(sb, block->byte3, info); 4432} 4433 4434void 4435scsi_sense_progress_sbuf(struct sbuf *sb, struct scsi_sense_data *sense, 4436 u_int sense_len, uint8_t *cdb, int cdb_len, 4437 struct scsi_inquiry_data *inq_data, 4438 struct scsi_sense_desc_header *header) 4439{ 4440 struct scsi_sense_progress *progress; 4441 const char *sense_key_desc; 4442 const char *asc_desc; 4443 int progress_val; 4444 4445 progress = (struct scsi_sense_progress *)header; 4446 4447 /* 4448 * Get descriptions for the sense key, ASC, and ASCQ in the 4449 * progress descriptor. These could be different than the values 4450 * in the overall sense data. 4451 */ 4452 scsi_sense_desc(progress->sense_key, progress->add_sense_code, 4453 progress->add_sense_code_qual, inq_data, 4454 &sense_key_desc, &asc_desc); 4455 4456 progress_val = scsi_2btoul(progress->progress); 4457 4458 /* 4459 * The progress indicator is for the operation described by the 4460 * sense key, ASC, and ASCQ in the descriptor. 4461 */ 4462 sbuf_cat(sb, sense_key_desc); 4463 sbuf_printf(sb, " asc:%x,%x (%s): ", progress->add_sense_code, 4464 progress->add_sense_code_qual, asc_desc); 4465 scsi_progress_sbuf(sb, progress_val); 4466} 4467 4468/* 4469 * Generic sense descriptor printing routine. This is used when we have 4470 * not yet implemented a specific printing routine for this descriptor. 4471 */ 4472void 4473scsi_sense_generic_sbuf(struct sbuf *sb, struct scsi_sense_data *sense, 4474 u_int sense_len, uint8_t *cdb, int cdb_len, 4475 struct scsi_inquiry_data *inq_data, 4476 struct scsi_sense_desc_header *header) 4477{ 4478 int i; 4479 uint8_t *buf_ptr; 4480 4481 sbuf_printf(sb, "Descriptor %#x:", header->desc_type); 4482 4483 buf_ptr = (uint8_t *)&header[1]; 4484 4485 for (i = 0; i < header->length; i++, buf_ptr++) 4486 sbuf_printf(sb, " %02x", *buf_ptr); 4487} 4488 4489/* 4490 * Keep this list in numeric order. This speeds the array traversal. 4491 */ 4492struct scsi_sense_desc_printer { 4493 uint8_t desc_type; 4494 /* 4495 * The function arguments here are the superset of what is needed 4496 * to print out various different descriptors. Command and 4497 * information descriptors need inquiry data and command type. 4498 * Sense key specific descriptors need the sense key. 4499 * 4500 * The sense, cdb, and inquiry data arguments may be NULL, but the 4501 * information printed may not be fully decoded as a result. 4502 */ 4503 void (*print_func)(struct sbuf *sb, struct scsi_sense_data *sense, 4504 u_int sense_len, uint8_t *cdb, int cdb_len, 4505 struct scsi_inquiry_data *inq_data, 4506 struct scsi_sense_desc_header *header); 4507} scsi_sense_printers[] = { 4508 {SSD_DESC_INFO, scsi_sense_info_sbuf}, 4509 {SSD_DESC_COMMAND, scsi_sense_command_sbuf}, 4510 {SSD_DESC_SKS, scsi_sense_sks_sbuf}, 4511 {SSD_DESC_FRU, scsi_sense_fru_sbuf}, 4512 {SSD_DESC_STREAM, scsi_sense_stream_sbuf}, 4513 {SSD_DESC_BLOCK, scsi_sense_block_sbuf}, 4514 {SSD_DESC_PROGRESS, scsi_sense_progress_sbuf} 4515}; 4516 4517void 4518scsi_sense_desc_sbuf(struct sbuf *sb, struct scsi_sense_data *sense, 4519 u_int sense_len, uint8_t *cdb, int cdb_len, 4520 struct scsi_inquiry_data *inq_data, 4521 struct scsi_sense_desc_header *header) 4522{ 4523 int i; 4524 4525 for (i = 0; i < (sizeof(scsi_sense_printers) / 4526 sizeof(scsi_sense_printers[0])); i++) { 4527 struct scsi_sense_desc_printer *printer; 4528 4529 printer = &scsi_sense_printers[i]; 4530 4531 /* 4532 * The list is sorted, so quit if we've passed our 4533 * descriptor number. 4534 */ 4535 if (printer->desc_type > header->desc_type) 4536 break; 4537 4538 if (printer->desc_type != header->desc_type) 4539 continue; 4540 4541 printer->print_func(sb, sense, sense_len, cdb, cdb_len, 4542 inq_data, header); 4543 4544 return; 4545 } 4546 4547 /* 4548 * No specific printing routine, so use the generic routine. 4549 */ 4550 scsi_sense_generic_sbuf(sb, sense, sense_len, cdb, cdb_len, 4551 inq_data, header); 4552} 4553 4554scsi_sense_data_type 4555scsi_sense_type(struct scsi_sense_data *sense_data) 4556{ 4557 switch (sense_data->error_code & SSD_ERRCODE) { 4558 case SSD_DESC_CURRENT_ERROR: 4559 case SSD_DESC_DEFERRED_ERROR: 4560 return (SSD_TYPE_DESC); 4561 break; 4562 case SSD_CURRENT_ERROR: 4563 case SSD_DEFERRED_ERROR: 4564 return (SSD_TYPE_FIXED); 4565 break; 4566 default: 4567 break; 4568 } 4569 4570 return (SSD_TYPE_NONE); 4571} 4572 4573struct scsi_print_sense_info { 4574 struct sbuf *sb; 4575 char *path_str; 4576 uint8_t *cdb; 4577 int cdb_len; 4578 struct scsi_inquiry_data *inq_data; 4579}; 4580 4581static int 4582scsi_print_desc_func(struct scsi_sense_data_desc *sense, u_int sense_len, 4583 struct scsi_sense_desc_header *header, void *arg) 4584{ 4585 struct scsi_print_sense_info *print_info; 4586 4587 print_info = (struct scsi_print_sense_info *)arg; 4588 4589 switch (header->desc_type) { 4590 case SSD_DESC_INFO: 4591 case SSD_DESC_FRU: 4592 case SSD_DESC_COMMAND: 4593 case SSD_DESC_SKS: 4594 case SSD_DESC_BLOCK: 4595 case SSD_DESC_STREAM: 4596 /* 4597 * We have already printed these descriptors, if they are 4598 * present. 4599 */ 4600 break; 4601 default: { 4602 sbuf_printf(print_info->sb, "%s", print_info->path_str); 4603 scsi_sense_desc_sbuf(print_info->sb, 4604 (struct scsi_sense_data *)sense, sense_len, 4605 print_info->cdb, print_info->cdb_len, 4606 print_info->inq_data, header); 4607 sbuf_printf(print_info->sb, "\n"); 4608 break; 4609 } 4610 } 4611 4612 /* 4613 * Tell the iterator that we want to see more descriptors if they 4614 * are present. 4615 */ 4616 return (0); 4617} 4618 4619void 4620scsi_sense_only_sbuf(struct scsi_sense_data *sense, u_int sense_len, 4621 struct sbuf *sb, char *path_str, 4622 struct scsi_inquiry_data *inq_data, uint8_t *cdb, 4623 int cdb_len) 4624{ 4625 int error_code, sense_key, asc, ascq; 4626 4627 sbuf_cat(sb, path_str); 4628 4629 scsi_extract_sense_len(sense, sense_len, &error_code, &sense_key, 4630 &asc, &ascq, /*show_errors*/ 1); 4631 4632 sbuf_printf(sb, "SCSI sense: "); 4633 switch (error_code) { 4634 case SSD_DEFERRED_ERROR: 4635 case SSD_DESC_DEFERRED_ERROR: 4636 sbuf_printf(sb, "Deferred error: "); 4637 4638 /* FALLTHROUGH */ 4639 case SSD_CURRENT_ERROR: 4640 case SSD_DESC_CURRENT_ERROR: 4641 { 4642 struct scsi_sense_data_desc *desc_sense; 4643 struct scsi_print_sense_info print_info; 4644 const char *sense_key_desc; 4645 const char *asc_desc; 4646 uint8_t sks[3]; 4647 uint64_t val; 4648 int info_valid; 4649 4650 /* 4651 * Get descriptions for the sense key, ASC, and ASCQ. If 4652 * these aren't present in the sense data (i.e. the sense 4653 * data isn't long enough), the -1 values that 4654 * scsi_extract_sense_len() returns will yield default 4655 * or error descriptions. 4656 */ 4657 scsi_sense_desc(sense_key, asc, ascq, inq_data, 4658 &sense_key_desc, &asc_desc); 4659 4660 /* 4661 * We first print the sense key and ASC/ASCQ. 4662 */ 4663 sbuf_cat(sb, sense_key_desc); 4664 sbuf_printf(sb, " asc:%x,%x (%s)\n", asc, ascq, asc_desc); 4665 4666 /* 4667 * Get the info field if it is valid. 4668 */ 4669 if (scsi_get_sense_info(sense, sense_len, SSD_DESC_INFO, 4670 &val, NULL) == 0) 4671 info_valid = 1; 4672 else 4673 info_valid = 0; 4674 4675 if (info_valid != 0) { 4676 uint8_t bits; 4677 4678 /* 4679 * Determine whether we have any block or stream 4680 * device-specific information. 4681 */ 4682 if (scsi_get_block_info(sense, sense_len, inq_data, 4683 &bits) == 0) { 4684 sbuf_cat(sb, path_str); 4685 scsi_block_sbuf(sb, bits, val); 4686 sbuf_printf(sb, "\n"); 4687 } else if (scsi_get_stream_info(sense, sense_len, 4688 inq_data, &bits) == 0) { 4689 sbuf_cat(sb, path_str); 4690 scsi_stream_sbuf(sb, bits, val); 4691 sbuf_printf(sb, "\n"); 4692 } else if (val != 0) { 4693 /* 4694 * The information field can be valid but 0. 4695 * If the block or stream bits aren't set, 4696 * and this is 0, it isn't terribly useful 4697 * to print it out. 4698 */ 4699 sbuf_cat(sb, path_str); 4700 scsi_info_sbuf(sb, cdb, cdb_len, inq_data, val); 4701 sbuf_printf(sb, "\n"); 4702 } 4703 } 4704 4705 /* 4706 * Print the FRU. 4707 */ 4708 if (scsi_get_sense_info(sense, sense_len, SSD_DESC_FRU, 4709 &val, NULL) == 0) { 4710 sbuf_cat(sb, path_str); 4711 scsi_fru_sbuf(sb, val); 4712 sbuf_printf(sb, "\n"); 4713 } 4714 4715 /* 4716 * Print any command-specific information. 4717 */ 4718 if (scsi_get_sense_info(sense, sense_len, SSD_DESC_COMMAND, 4719 &val, NULL) == 0) { 4720 sbuf_cat(sb, path_str); 4721 scsi_command_sbuf(sb, cdb, cdb_len, inq_data, val); 4722 sbuf_printf(sb, "\n"); 4723 } 4724 4725 /* 4726 * Print out any sense-key-specific information. 4727 */ 4728 if (scsi_get_sks(sense, sense_len, sks) == 0) { 4729 sbuf_cat(sb, path_str); 4730 scsi_sks_sbuf(sb, sense_key, sks); 4731 sbuf_printf(sb, "\n"); 4732 } 4733 4734 /* 4735 * If this is fixed sense, we're done. If we have 4736 * descriptor sense, we might have more information 4737 * available. 4738 */ 4739 if (scsi_sense_type(sense) != SSD_TYPE_DESC) 4740 break; 4741 4742 desc_sense = (struct scsi_sense_data_desc *)sense; 4743 4744 print_info.sb = sb; 4745 print_info.path_str = path_str; 4746 print_info.cdb = cdb; 4747 print_info.cdb_len = cdb_len; 4748 print_info.inq_data = inq_data; 4749 4750 /* 4751 * Print any sense descriptors that we have not already printed. 4752 */ 4753 scsi_desc_iterate(desc_sense, sense_len, scsi_print_desc_func, 4754 &print_info); 4755 break; 4756 4757 } 4758 case -1: 4759 /* 4760 * scsi_extract_sense_len() sets values to -1 if the 4761 * show_errors flag is set and they aren't present in the 4762 * sense data. This means that sense_len is 0. 4763 */ 4764 sbuf_printf(sb, "No sense data present\n"); 4765 break; 4766 default: { 4767 sbuf_printf(sb, "Error code 0x%x", error_code); 4768 if (sense->error_code & SSD_ERRCODE_VALID) { 4769 struct scsi_sense_data_fixed *fixed_sense; 4770 4771 fixed_sense = (struct scsi_sense_data_fixed *)sense; 4772 4773 if (SSD_FIXED_IS_PRESENT(fixed_sense, sense_len, info)){ 4774 uint32_t info; 4775 4776 info = scsi_4btoul(fixed_sense->info); 4777 4778 sbuf_printf(sb, " at block no. %d (decimal)", 4779 info); 4780 } 4781 } 4782 sbuf_printf(sb, "\n"); 4783 break; 4784 } 4785 } 4786} 4787 4788/* 4789 * scsi_sense_sbuf() returns 0 for success and -1 for failure. 4790 */ 4791#ifdef _KERNEL 4792int 4793scsi_sense_sbuf(struct ccb_scsiio *csio, struct sbuf *sb, 4794 scsi_sense_string_flags flags) 4795#else /* !_KERNEL */ 4796int 4797scsi_sense_sbuf(struct cam_device *device, struct ccb_scsiio *csio, 4798 struct sbuf *sb, scsi_sense_string_flags flags) 4799#endif /* _KERNEL/!_KERNEL */ 4800{ 4801 struct scsi_sense_data *sense; 4802 struct scsi_inquiry_data *inq_data; 4803#ifdef _KERNEL 4804 struct ccb_getdev *cgd; 4805#endif /* _KERNEL */ 4806 char path_str[64]; 4807 uint8_t *cdb; 4808 4809#ifndef _KERNEL 4810 if (device == NULL) 4811 return(-1); 4812#endif /* !_KERNEL */ 4813 if ((csio == NULL) || (sb == NULL)) 4814 return(-1); 4815 4816 /* 4817 * If the CDB is a physical address, we can't deal with it.. 4818 */ 4819 if ((csio->ccb_h.flags & CAM_CDB_PHYS) != 0) 4820 flags &= ~SSS_FLAG_PRINT_COMMAND; 4821 4822#ifdef _KERNEL 4823 xpt_path_string(csio->ccb_h.path, path_str, sizeof(path_str)); 4824#else /* !_KERNEL */ 4825 cam_path_string(device, path_str, sizeof(path_str)); 4826#endif /* _KERNEL/!_KERNEL */ 4827 4828#ifdef _KERNEL 4829 if ((cgd = (struct ccb_getdev*)xpt_alloc_ccb_nowait()) == NULL) 4830 return(-1); 4831 /* 4832 * Get the device information. 4833 */ 4834 xpt_setup_ccb(&cgd->ccb_h, 4835 csio->ccb_h.path, 4836 CAM_PRIORITY_NORMAL); 4837 cgd->ccb_h.func_code = XPT_GDEV_TYPE; 4838 xpt_action((union ccb *)cgd); 4839 4840 /* 4841 * If the device is unconfigured, just pretend that it is a hard 4842 * drive. scsi_op_desc() needs this. 4843 */ 4844 if (cgd->ccb_h.status == CAM_DEV_NOT_THERE) 4845 cgd->inq_data.device = T_DIRECT; 4846 4847 inq_data = &cgd->inq_data; 4848 4849#else /* !_KERNEL */ 4850 4851 inq_data = &device->inq_data; 4852 4853#endif /* _KERNEL/!_KERNEL */ 4854 4855 sense = NULL; 4856 4857 if (flags & SSS_FLAG_PRINT_COMMAND) { 4858 4859 sbuf_cat(sb, path_str); 4860 4861#ifdef _KERNEL 4862 scsi_command_string(csio, sb); 4863#else /* !_KERNEL */ 4864 scsi_command_string(device, csio, sb); 4865#endif /* _KERNEL/!_KERNEL */ 4866 sbuf_printf(sb, "\n"); 4867 } 4868 4869 /* 4870 * If the sense data is a physical pointer, forget it. 4871 */ 4872 if (csio->ccb_h.flags & CAM_SENSE_PTR) { 4873 if (csio->ccb_h.flags & CAM_SENSE_PHYS) { 4874#ifdef _KERNEL 4875 xpt_free_ccb((union ccb*)cgd); 4876#endif /* _KERNEL/!_KERNEL */ 4877 return(-1); 4878 } else { 4879 /* 4880 * bcopy the pointer to avoid unaligned access 4881 * errors on finicky architectures. We don't 4882 * ensure that the sense data is pointer aligned. 4883 */ 4884 bcopy(&csio->sense_data, &sense, 4885 sizeof(struct scsi_sense_data *)); 4886 } 4887 } else { 4888 /* 4889 * If the physical sense flag is set, but the sense pointer 4890 * is not also set, we assume that the user is an idiot and 4891 * return. (Well, okay, it could be that somehow, the 4892 * entire csio is physical, but we would have probably core 4893 * dumped on one of the bogus pointer deferences above 4894 * already.) 4895 */ 4896 if (csio->ccb_h.flags & CAM_SENSE_PHYS) { 4897#ifdef _KERNEL 4898 xpt_free_ccb((union ccb*)cgd); 4899#endif /* _KERNEL/!_KERNEL */ 4900 return(-1); 4901 } else 4902 sense = &csio->sense_data; 4903 } 4904 4905 if (csio->ccb_h.flags & CAM_CDB_POINTER) 4906 cdb = csio->cdb_io.cdb_ptr; 4907 else 4908 cdb = csio->cdb_io.cdb_bytes; 4909 4910 scsi_sense_only_sbuf(sense, csio->sense_len - csio->sense_resid, sb, 4911 path_str, inq_data, cdb, csio->cdb_len); 4912 4913#ifdef _KERNEL 4914 xpt_free_ccb((union ccb*)cgd); 4915#endif /* _KERNEL/!_KERNEL */ 4916 return(0); 4917} 4918 4919 4920 4921#ifdef _KERNEL 4922char * 4923scsi_sense_string(struct ccb_scsiio *csio, char *str, int str_len) 4924#else /* !_KERNEL */ 4925char * 4926scsi_sense_string(struct cam_device *device, struct ccb_scsiio *csio, 4927 char *str, int str_len) 4928#endif /* _KERNEL/!_KERNEL */ 4929{ 4930 struct sbuf sb; 4931 4932 sbuf_new(&sb, str, str_len, 0); 4933 4934#ifdef _KERNEL 4935 scsi_sense_sbuf(csio, &sb, SSS_FLAG_PRINT_COMMAND); 4936#else /* !_KERNEL */ 4937 scsi_sense_sbuf(device, csio, &sb, SSS_FLAG_PRINT_COMMAND); 4938#endif /* _KERNEL/!_KERNEL */ 4939 4940 sbuf_finish(&sb); 4941 4942 return(sbuf_data(&sb)); 4943} 4944 4945#ifdef _KERNEL 4946void 4947scsi_sense_print(struct ccb_scsiio *csio) 4948{ 4949 struct sbuf sb; 4950 char str[512]; 4951 4952 sbuf_new(&sb, str, sizeof(str), 0); 4953 4954 scsi_sense_sbuf(csio, &sb, SSS_FLAG_PRINT_COMMAND); 4955 4956 sbuf_finish(&sb); 4957 4958 printf("%s", sbuf_data(&sb)); 4959} 4960 4961#else /* !_KERNEL */ 4962void 4963scsi_sense_print(struct cam_device *device, struct ccb_scsiio *csio, 4964 FILE *ofile) 4965{ 4966 struct sbuf sb; 4967 char str[512]; 4968 4969 if ((device == NULL) || (csio == NULL) || (ofile == NULL)) 4970 return; 4971 4972 sbuf_new(&sb, str, sizeof(str), 0); 4973 4974 scsi_sense_sbuf(device, csio, &sb, SSS_FLAG_PRINT_COMMAND); 4975 4976 sbuf_finish(&sb); 4977 4978 fprintf(ofile, "%s", sbuf_data(&sb)); 4979} 4980 4981#endif /* _KERNEL/!_KERNEL */ 4982 4983/* 4984 * Extract basic sense information. This is backward-compatible with the 4985 * previous implementation. For new implementations, 4986 * scsi_extract_sense_len() is recommended. 4987 */ 4988void 4989scsi_extract_sense(struct scsi_sense_data *sense_data, int *error_code, 4990 int *sense_key, int *asc, int *ascq) 4991{ 4992 scsi_extract_sense_len(sense_data, sizeof(*sense_data), error_code, 4993 sense_key, asc, ascq, /*show_errors*/ 0); 4994} 4995 4996/* 4997 * Extract basic sense information from SCSI I/O CCB structure. 4998 */ 4999int 5000scsi_extract_sense_ccb(union ccb *ccb, 5001 int *error_code, int *sense_key, int *asc, int *ascq) 5002{ 5003 struct scsi_sense_data *sense_data; 5004 5005 /* Make sure there are some sense data we can access. */ 5006 if (ccb->ccb_h.func_code != XPT_SCSI_IO || 5007 (ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_SCSI_STATUS_ERROR || 5008 (ccb->csio.scsi_status != SCSI_STATUS_CHECK_COND) || 5009 (ccb->ccb_h.status & CAM_AUTOSNS_VALID) == 0 || 5010 (ccb->ccb_h.flags & CAM_SENSE_PHYS)) 5011 return (0); 5012 5013 if (ccb->ccb_h.flags & CAM_SENSE_PTR) 5014 bcopy(&ccb->csio.sense_data, &sense_data, 5015 sizeof(struct scsi_sense_data *)); 5016 else 5017 sense_data = &ccb->csio.sense_data; 5018 scsi_extract_sense_len(sense_data, 5019 ccb->csio.sense_len - ccb->csio.sense_resid, 5020 error_code, sense_key, asc, ascq, 1); 5021 if (*error_code == -1) 5022 return (0); 5023 return (1); 5024} 5025 5026/* 5027 * Extract basic sense information. If show_errors is set, sense values 5028 * will be set to -1 if they are not present. 5029 */ 5030void 5031scsi_extract_sense_len(struct scsi_sense_data *sense_data, u_int sense_len, 5032 int *error_code, int *sense_key, int *asc, int *ascq, 5033 int show_errors) 5034{ 5035 /* 5036 * If we have no length, we have no sense. 5037 */ 5038 if (sense_len == 0) { 5039 if (show_errors == 0) { 5040 *error_code = 0; 5041 *sense_key = 0; 5042 *asc = 0; 5043 *ascq = 0; 5044 } else { 5045 *error_code = -1; 5046 *sense_key = -1; 5047 *asc = -1; 5048 *ascq = -1; 5049 } 5050 return; 5051 } 5052 5053 *error_code = sense_data->error_code & SSD_ERRCODE; 5054 5055 switch (*error_code) { 5056 case SSD_DESC_CURRENT_ERROR: 5057 case SSD_DESC_DEFERRED_ERROR: { 5058 struct scsi_sense_data_desc *sense; 5059 5060 sense = (struct scsi_sense_data_desc *)sense_data; 5061 5062 if (SSD_DESC_IS_PRESENT(sense, sense_len, sense_key)) 5063 *sense_key = sense->sense_key & SSD_KEY; 5064 else 5065 *sense_key = (show_errors) ? -1 : 0; 5066 5067 if (SSD_DESC_IS_PRESENT(sense, sense_len, add_sense_code)) 5068 *asc = sense->add_sense_code; 5069 else 5070 *asc = (show_errors) ? -1 : 0; 5071 5072 if (SSD_DESC_IS_PRESENT(sense, sense_len, add_sense_code_qual)) 5073 *ascq = sense->add_sense_code_qual; 5074 else 5075 *ascq = (show_errors) ? -1 : 0; 5076 break; 5077 } 5078 case SSD_CURRENT_ERROR: 5079 case SSD_DEFERRED_ERROR: 5080 default: { 5081 struct scsi_sense_data_fixed *sense; 5082 5083 sense = (struct scsi_sense_data_fixed *)sense_data; 5084 5085 if (SSD_FIXED_IS_PRESENT(sense, sense_len, flags)) 5086 *sense_key = sense->flags & SSD_KEY; 5087 else 5088 *sense_key = (show_errors) ? -1 : 0; 5089 5090 if ((SSD_FIXED_IS_PRESENT(sense, sense_len, add_sense_code)) 5091 && (SSD_FIXED_IS_FILLED(sense, add_sense_code))) 5092 *asc = sense->add_sense_code; 5093 else 5094 *asc = (show_errors) ? -1 : 0; 5095 5096 if ((SSD_FIXED_IS_PRESENT(sense, sense_len,add_sense_code_qual)) 5097 && (SSD_FIXED_IS_FILLED(sense, add_sense_code_qual))) 5098 *ascq = sense->add_sense_code_qual; 5099 else 5100 *ascq = (show_errors) ? -1 : 0; 5101 break; 5102 } 5103 } 5104} 5105 5106int 5107scsi_get_sense_key(struct scsi_sense_data *sense_data, u_int sense_len, 5108 int show_errors) 5109{ 5110 int error_code, sense_key, asc, ascq; 5111 5112 scsi_extract_sense_len(sense_data, sense_len, &error_code, 5113 &sense_key, &asc, &ascq, show_errors); 5114 5115 return (sense_key); 5116} 5117 5118int 5119scsi_get_asc(struct scsi_sense_data *sense_data, u_int sense_len, 5120 int show_errors) 5121{ 5122 int error_code, sense_key, asc, ascq; 5123 5124 scsi_extract_sense_len(sense_data, sense_len, &error_code, 5125 &sense_key, &asc, &ascq, show_errors); 5126 5127 return (asc); 5128} 5129 5130int 5131scsi_get_ascq(struct scsi_sense_data *sense_data, u_int sense_len, 5132 int show_errors) 5133{ 5134 int error_code, sense_key, asc, ascq; 5135 5136 scsi_extract_sense_len(sense_data, sense_len, &error_code, 5137 &sense_key, &asc, &ascq, show_errors); 5138 5139 return (ascq); 5140} 5141 5142/* 5143 * This function currently requires at least 36 bytes, or 5144 * SHORT_INQUIRY_LENGTH, worth of data to function properly. If this 5145 * function needs more or less data in the future, another length should be 5146 * defined in scsi_all.h to indicate the minimum amount of data necessary 5147 * for this routine to function properly. 5148 */ 5149void 5150scsi_print_inquiry(struct scsi_inquiry_data *inq_data) 5151{ 5152 u_int8_t type; 5153 char *dtype, *qtype; 5154 char vendor[16], product[48], revision[16], rstr[12]; 5155 5156 type = SID_TYPE(inq_data); 5157 5158 /* 5159 * Figure out basic device type and qualifier. 5160 */ 5161 if (SID_QUAL_IS_VENDOR_UNIQUE(inq_data)) { 5162 qtype = " (vendor-unique qualifier)"; 5163 } else { 5164 switch (SID_QUAL(inq_data)) { 5165 case SID_QUAL_LU_CONNECTED: 5166 qtype = ""; 5167 break; 5168 5169 case SID_QUAL_LU_OFFLINE: 5170 qtype = " (offline)"; 5171 break; 5172 5173 case SID_QUAL_RSVD: 5174 qtype = " (reserved qualifier)"; 5175 break; 5176 default: 5177 case SID_QUAL_BAD_LU: 5178 qtype = " (LUN not supported)"; 5179 break; 5180 } 5181 } 5182 5183 switch (type) { 5184 case T_DIRECT: 5185 dtype = "Direct Access"; 5186 break; 5187 case T_SEQUENTIAL: 5188 dtype = "Sequential Access"; 5189 break; 5190 case T_PRINTER: 5191 dtype = "Printer"; 5192 break; 5193 case T_PROCESSOR: 5194 dtype = "Processor"; 5195 break; 5196 case T_WORM: 5197 dtype = "WORM"; 5198 break; 5199 case T_CDROM: 5200 dtype = "CD-ROM"; 5201 break; 5202 case T_SCANNER: 5203 dtype = "Scanner"; 5204 break; 5205 case T_OPTICAL: 5206 dtype = "Optical"; 5207 break; 5208 case T_CHANGER: 5209 dtype = "Changer"; 5210 break; 5211 case T_COMM: 5212 dtype = "Communication"; 5213 break; 5214 case T_STORARRAY: 5215 dtype = "Storage Array"; 5216 break; 5217 case T_ENCLOSURE: 5218 dtype = "Enclosure Services"; 5219 break; 5220 case T_RBC: 5221 dtype = "Simplified Direct Access"; 5222 break; 5223 case T_OCRW: 5224 dtype = "Optical Card Read/Write"; 5225 break; 5226 case T_OSD: 5227 dtype = "Object-Based Storage"; 5228 break; 5229 case T_ADC: 5230 dtype = "Automation/Drive Interface"; 5231 break; 5232 case T_NODEVICE: 5233 dtype = "Uninstalled"; 5234 break; 5235 default: 5236 dtype = "unknown"; 5237 break; 5238 } 5239 5240 cam_strvis(vendor, inq_data->vendor, sizeof(inq_data->vendor), 5241 sizeof(vendor)); 5242 cam_strvis(product, inq_data->product, sizeof(inq_data->product), 5243 sizeof(product)); 5244 cam_strvis(revision, inq_data->revision, sizeof(inq_data->revision), 5245 sizeof(revision)); 5246 5247 if (SID_ANSI_REV(inq_data) == SCSI_REV_0) 5248 snprintf(rstr, sizeof(rstr), "SCSI"); 5249 else if (SID_ANSI_REV(inq_data) <= SCSI_REV_SPC) { 5250 snprintf(rstr, sizeof(rstr), "SCSI-%d", 5251 SID_ANSI_REV(inq_data)); 5252 } else { 5253 snprintf(rstr, sizeof(rstr), "SPC-%d SCSI", 5254 SID_ANSI_REV(inq_data) - 2); 5255 } 5256 printf("<%s %s %s> %s %s %s device%s\n", 5257 vendor, product, revision, 5258 SID_IS_REMOVABLE(inq_data) ? "Removable" : "Fixed", 5259 dtype, rstr, qtype); 5260} 5261 5262void 5263scsi_print_inquiry_short(struct scsi_inquiry_data *inq_data) 5264{ 5265 char vendor[16], product[48], revision[16]; 5266 5267 cam_strvis(vendor, inq_data->vendor, sizeof(inq_data->vendor), 5268 sizeof(vendor)); 5269 cam_strvis(product, inq_data->product, sizeof(inq_data->product), 5270 sizeof(product)); 5271 cam_strvis(revision, inq_data->revision, sizeof(inq_data->revision), 5272 sizeof(revision)); 5273 5274 printf("<%s %s %s>", vendor, product, revision); 5275} 5276 5277/* 5278 * Table of syncrates that don't follow the "divisible by 4" 5279 * rule. This table will be expanded in future SCSI specs. 5280 */ 5281static struct { 5282 u_int period_factor; 5283 u_int period; /* in 100ths of ns */ 5284} scsi_syncrates[] = { 5285 { 0x08, 625 }, /* FAST-160 */ 5286 { 0x09, 1250 }, /* FAST-80 */ 5287 { 0x0a, 2500 }, /* FAST-40 40MHz */ 5288 { 0x0b, 3030 }, /* FAST-40 33MHz */ 5289 { 0x0c, 5000 } /* FAST-20 */ 5290}; 5291 5292/* 5293 * Return the frequency in kHz corresponding to the given 5294 * sync period factor. 5295 */ 5296u_int 5297scsi_calc_syncsrate(u_int period_factor) 5298{ 5299 int i; 5300 int num_syncrates; 5301 5302 /* 5303 * It's a bug if period is zero, but if it is anyway, don't 5304 * die with a divide fault- instead return something which 5305 * 'approximates' async 5306 */ 5307 if (period_factor == 0) { 5308 return (3300); 5309 } 5310 5311 num_syncrates = sizeof(scsi_syncrates) / sizeof(scsi_syncrates[0]); 5312 /* See if the period is in the "exception" table */ 5313 for (i = 0; i < num_syncrates; i++) { 5314 5315 if (period_factor == scsi_syncrates[i].period_factor) { 5316 /* Period in kHz */ 5317 return (100000000 / scsi_syncrates[i].period); 5318 } 5319 } 5320 5321 /* 5322 * Wasn't in the table, so use the standard 5323 * 4 times conversion. 5324 */ 5325 return (10000000 / (period_factor * 4 * 10)); 5326} 5327 5328/* 5329 * Return the SCSI sync parameter that corresponsd to 5330 * the passed in period in 10ths of ns. 5331 */ 5332u_int 5333scsi_calc_syncparam(u_int period) 5334{ 5335 int i; 5336 int num_syncrates; 5337 5338 if (period == 0) 5339 return (~0); /* Async */ 5340 5341 /* Adjust for exception table being in 100ths. */ 5342 period *= 10; 5343 num_syncrates = sizeof(scsi_syncrates) / sizeof(scsi_syncrates[0]); 5344 /* See if the period is in the "exception" table */ 5345 for (i = 0; i < num_syncrates; i++) { 5346 5347 if (period <= scsi_syncrates[i].period) { 5348 /* Period in 100ths of ns */ 5349 return (scsi_syncrates[i].period_factor); 5350 } 5351 } 5352 5353 /* 5354 * Wasn't in the table, so use the standard 5355 * 1/4 period in ns conversion. 5356 */ 5357 return (period/400); 5358} 5359 5360int 5361scsi_devid_is_naa_ieee_reg(uint8_t *bufp) 5362{ 5363 struct scsi_vpd_id_descriptor *descr; 5364 struct scsi_vpd_id_naa_basic *naa; 5365 5366 descr = (struct scsi_vpd_id_descriptor *)bufp; 5367 naa = (struct scsi_vpd_id_naa_basic *)descr->identifier; 5368 if ((descr->id_type & SVPD_ID_TYPE_MASK) != SVPD_ID_TYPE_NAA) 5369 return 0; 5370 if (descr->length < sizeof(struct scsi_vpd_id_naa_ieee_reg)) 5371 return 0; 5372 if ((naa->naa >> SVPD_ID_NAA_NAA_SHIFT) != SVPD_ID_NAA_IEEE_REG) 5373 return 0; 5374 return 1; 5375} 5376 5377int 5378scsi_devid_is_sas_target(uint8_t *bufp) 5379{ 5380 struct scsi_vpd_id_descriptor *descr; 5381 5382 descr = (struct scsi_vpd_id_descriptor *)bufp; 5383 if (!scsi_devid_is_naa_ieee_reg(bufp)) 5384 return 0; 5385 if ((descr->id_type & SVPD_ID_PIV) == 0) /* proto field reserved */ 5386 return 0; 5387 if ((descr->proto_codeset >> SVPD_ID_PROTO_SHIFT) != SCSI_PROTO_SAS) 5388 return 0; 5389 return 1; 5390} 5391 5392int 5393scsi_devid_is_lun_eui64(uint8_t *bufp) 5394{ 5395 struct scsi_vpd_id_descriptor *descr; 5396 5397 descr = (struct scsi_vpd_id_descriptor *)bufp; 5398 if ((descr->id_type & SVPD_ID_ASSOC_MASK) != SVPD_ID_ASSOC_LUN) 5399 return 0; 5400 if ((descr->id_type & SVPD_ID_TYPE_MASK) != SVPD_ID_TYPE_EUI64) 5401 return 0; 5402 return 1; 5403} 5404 5405int 5406scsi_devid_is_lun_naa(uint8_t *bufp) 5407{ 5408 struct scsi_vpd_id_descriptor *descr; 5409 5410 descr = (struct scsi_vpd_id_descriptor *)bufp; 5411 if ((descr->id_type & SVPD_ID_ASSOC_MASK) != SVPD_ID_ASSOC_LUN) 5412 return 0; 5413 if ((descr->id_type & SVPD_ID_TYPE_MASK) != SVPD_ID_TYPE_NAA) 5414 return 0; 5415 return 1; 5416} 5417 5418int 5419scsi_devid_is_lun_t10(uint8_t *bufp) 5420{ 5421 struct scsi_vpd_id_descriptor *descr; 5422 5423 descr = (struct scsi_vpd_id_descriptor *)bufp; 5424 if ((descr->id_type & SVPD_ID_ASSOC_MASK) != SVPD_ID_ASSOC_LUN) 5425 return 0; 5426 if ((descr->id_type & SVPD_ID_TYPE_MASK) != SVPD_ID_TYPE_T10) 5427 return 0; 5428 return 1; 5429} 5430 5431int 5432scsi_devid_is_lun_name(uint8_t *bufp) 5433{ 5434 struct scsi_vpd_id_descriptor *descr; 5435 5436 descr = (struct scsi_vpd_id_descriptor *)bufp; 5437 if ((descr->id_type & SVPD_ID_ASSOC_MASK) != SVPD_ID_ASSOC_LUN) 5438 return 0; 5439 if ((descr->id_type & SVPD_ID_TYPE_MASK) != SVPD_ID_TYPE_SCSI_NAME) 5440 return 0; 5441 return 1; 5442} 5443 5444struct scsi_vpd_id_descriptor * 5445scsi_get_devid_desc(struct scsi_vpd_id_descriptor *desc, uint32_t len, 5446 scsi_devid_checkfn_t ck_fn) 5447{ 5448 uint8_t *desc_buf_end; 5449 5450 desc_buf_end = (uint8_t *)desc + len; 5451 5452 for (; desc->identifier <= desc_buf_end && 5453 desc->identifier + desc->length <= desc_buf_end; 5454 desc = (struct scsi_vpd_id_descriptor *)(desc->identifier 5455 + desc->length)) { 5456 5457 if (ck_fn == NULL || ck_fn((uint8_t *)desc) != 0) 5458 return (desc); 5459 } 5460 return (NULL); 5461} 5462 5463struct scsi_vpd_id_descriptor * 5464scsi_get_devid(struct scsi_vpd_device_id *id, uint32_t page_len, 5465 scsi_devid_checkfn_t ck_fn) 5466{ 5467 uint32_t len; 5468 5469 if (page_len < sizeof(*id)) 5470 return (NULL); 5471 len = MIN(scsi_2btoul(id->length), page_len - sizeof(*id)); 5472 return (scsi_get_devid_desc((struct scsi_vpd_id_descriptor *) 5473 id->desc_list, len, ck_fn)); 5474} 5475 5476int 5477scsi_transportid_sbuf(struct sbuf *sb, struct scsi_transportid_header *hdr, 5478 uint32_t valid_len) 5479{ 5480 switch (hdr->format_protocol & SCSI_TRN_PROTO_MASK) { 5481 case SCSI_PROTO_FC: { 5482 struct scsi_transportid_fcp *fcp; 5483 uint64_t n_port_name; 5484 5485 fcp = (struct scsi_transportid_fcp *)hdr; 5486 5487 n_port_name = scsi_8btou64(fcp->n_port_name); 5488 5489 sbuf_printf(sb, "FCP address: 0x%.16jx",(uintmax_t)n_port_name); 5490 break; 5491 } 5492 case SCSI_PROTO_SPI: { 5493 struct scsi_transportid_spi *spi; 5494 5495 spi = (struct scsi_transportid_spi *)hdr; 5496 5497 sbuf_printf(sb, "SPI address: %u,%u", 5498 scsi_2btoul(spi->scsi_addr), 5499 scsi_2btoul(spi->rel_trgt_port_id)); 5500 break; 5501 } 5502 case SCSI_PROTO_SSA: 5503 /* 5504 * XXX KDM there is no transport ID defined in SPC-4 for 5505 * SSA. 5506 */ 5507 break; 5508 case SCSI_PROTO_1394: { 5509 struct scsi_transportid_1394 *sbp; 5510 uint64_t eui64; 5511 5512 sbp = (struct scsi_transportid_1394 *)hdr; 5513 5514 eui64 = scsi_8btou64(sbp->eui64); 5515 sbuf_printf(sb, "SBP address: 0x%.16jx", (uintmax_t)eui64); 5516 break; 5517 } 5518 case SCSI_PROTO_RDMA: { 5519 struct scsi_transportid_rdma *rdma; 5520 unsigned int i; 5521 5522 rdma = (struct scsi_transportid_rdma *)hdr; 5523 5524 sbuf_printf(sb, "RDMA address: 0x"); 5525 for (i = 0; i < sizeof(rdma->initiator_port_id); i++) 5526 sbuf_printf(sb, "%02x", rdma->initiator_port_id[i]); 5527 break; 5528 } 5529 case SCSI_PROTO_ISCSI: { 5530 uint32_t add_len, i; 5531 uint8_t *iscsi_name = NULL; 5532 int nul_found = 0; 5533 5534 sbuf_printf(sb, "iSCSI address: "); 5535 if ((hdr->format_protocol & SCSI_TRN_FORMAT_MASK) == 5536 SCSI_TRN_ISCSI_FORMAT_DEVICE) { 5537 struct scsi_transportid_iscsi_device *dev; 5538 5539 dev = (struct scsi_transportid_iscsi_device *)hdr; 5540 5541 /* 5542 * Verify how much additional data we really have. 5543 */ 5544 add_len = scsi_2btoul(dev->additional_length); 5545 add_len = MIN(add_len, valid_len - 5546 __offsetof(struct scsi_transportid_iscsi_device, 5547 iscsi_name)); 5548 iscsi_name = &dev->iscsi_name[0]; 5549 5550 } else if ((hdr->format_protocol & SCSI_TRN_FORMAT_MASK) == 5551 SCSI_TRN_ISCSI_FORMAT_PORT) { 5552 struct scsi_transportid_iscsi_port *port; 5553 5554 port = (struct scsi_transportid_iscsi_port *)hdr; 5555 5556 add_len = scsi_2btoul(port->additional_length); 5557 add_len = MIN(add_len, valid_len - 5558 __offsetof(struct scsi_transportid_iscsi_port, 5559 iscsi_name)); 5560 iscsi_name = &port->iscsi_name[0]; 5561 } else { 5562 sbuf_printf(sb, "unknown format %x", 5563 (hdr->format_protocol & 5564 SCSI_TRN_FORMAT_MASK) >> 5565 SCSI_TRN_FORMAT_SHIFT); 5566 break; 5567 } 5568 if (add_len == 0) { 5569 sbuf_printf(sb, "not enough data"); 5570 break; 5571 } 5572 /* 5573 * This is supposed to be a NUL-terminated ASCII 5574 * string, but you never know. So we're going to 5575 * check. We need to do this because there is no 5576 * sbuf equivalent of strncat(). 5577 */ 5578 for (i = 0; i < add_len; i++) { 5579 if (iscsi_name[i] == '\0') { 5580 nul_found = 1; 5581 break; 5582 } 5583 } 5584 /* 5585 * If there is a NUL in the name, we can just use 5586 * sbuf_cat(). Otherwise we need to use sbuf_bcat(). 5587 */ 5588 if (nul_found != 0) 5589 sbuf_cat(sb, iscsi_name); 5590 else 5591 sbuf_bcat(sb, iscsi_name, add_len); 5592 break; 5593 } 5594 case SCSI_PROTO_SAS: { 5595 struct scsi_transportid_sas *sas; 5596 uint64_t sas_addr; 5597 5598 sas = (struct scsi_transportid_sas *)hdr; 5599 5600 sas_addr = scsi_8btou64(sas->sas_address); 5601 sbuf_printf(sb, "SAS address: 0x%.16jx", (uintmax_t)sas_addr); 5602 break; 5603 } 5604 case SCSI_PROTO_ADITP: 5605 case SCSI_PROTO_ATA: 5606 case SCSI_PROTO_UAS: 5607 /* 5608 * No Transport ID format for ADI, ATA or USB is defined in 5609 * SPC-4. 5610 */ 5611 sbuf_printf(sb, "No known Transport ID format for protocol " 5612 "%#x", hdr->format_protocol & SCSI_TRN_PROTO_MASK); 5613 break; 5614 case SCSI_PROTO_SOP: { 5615 struct scsi_transportid_sop *sop; 5616 struct scsi_sop_routing_id_norm *rid; 5617 5618 sop = (struct scsi_transportid_sop *)hdr; 5619 rid = (struct scsi_sop_routing_id_norm *)sop->routing_id; 5620 5621 /* 5622 * Note that there is no alternate format specified in SPC-4 5623 * for the PCIe routing ID, so we don't really have a way 5624 * to know whether the second byte of the routing ID is 5625 * a device and function or just a function. So we just 5626 * assume bus,device,function. 5627 */ 5628 sbuf_printf(sb, "SOP Routing ID: %u,%u,%u", 5629 rid->bus, rid->devfunc >> SCSI_TRN_SOP_DEV_SHIFT, 5630 rid->devfunc & SCSI_TRN_SOP_FUNC_NORM_MAX); 5631 break; 5632 } 5633 case SCSI_PROTO_NONE: 5634 default: 5635 sbuf_printf(sb, "Unknown protocol %#x", 5636 hdr->format_protocol & SCSI_TRN_PROTO_MASK); 5637 break; 5638 } 5639 5640 return (0); 5641} 5642 5643struct scsi_nv scsi_proto_map[] = { 5644 { "fcp", SCSI_PROTO_FC }, 5645 { "spi", SCSI_PROTO_SPI }, 5646 { "ssa", SCSI_PROTO_SSA }, 5647 { "sbp", SCSI_PROTO_1394 }, 5648 { "1394", SCSI_PROTO_1394 }, 5649 { "srp", SCSI_PROTO_RDMA }, 5650 { "rdma", SCSI_PROTO_RDMA }, 5651 { "iscsi", SCSI_PROTO_ISCSI }, 5652 { "iqn", SCSI_PROTO_ISCSI }, 5653 { "sas", SCSI_PROTO_SAS }, 5654 { "aditp", SCSI_PROTO_ADITP }, 5655 { "ata", SCSI_PROTO_ATA }, 5656 { "uas", SCSI_PROTO_UAS }, 5657 { "usb", SCSI_PROTO_UAS }, 5658 { "sop", SCSI_PROTO_SOP } 5659}; 5660 5661const char * 5662scsi_nv_to_str(struct scsi_nv *table, int num_table_entries, uint64_t value) 5663{ 5664 int i; 5665 5666 for (i = 0; i < num_table_entries; i++) { 5667 if (table[i].value == value) 5668 return (table[i].name); 5669 } 5670 5671 return (NULL); 5672} 5673 5674/* 5675 * Given a name/value table, find a value matching the given name. 5676 * Return values: 5677 * SCSI_NV_FOUND - match found 5678 * SCSI_NV_AMBIGUOUS - more than one match, none of them exact 5679 * SCSI_NV_NOT_FOUND - no match found 5680 */ 5681scsi_nv_status 5682scsi_get_nv(struct scsi_nv *table, int num_table_entries, 5683 char *name, int *table_entry, scsi_nv_flags flags) 5684{ 5685 int i, num_matches = 0; 5686 5687 for (i = 0; i < num_table_entries; i++) { 5688 size_t table_len, name_len; 5689 5690 table_len = strlen(table[i].name); 5691 name_len = strlen(name); 5692 5693 if ((((flags & SCSI_NV_FLAG_IG_CASE) != 0) 5694 && (strncasecmp(table[i].name, name, name_len) == 0)) 5695 || (((flags & SCSI_NV_FLAG_IG_CASE) == 0) 5696 && (strncmp(table[i].name, name, name_len) == 0))) { 5697 *table_entry = i; 5698 5699 /* 5700 * Check for an exact match. If we have the same 5701 * number of characters in the table as the argument, 5702 * and we already know they're the same, we have 5703 * an exact match. 5704 */ 5705 if (table_len == name_len) 5706 return (SCSI_NV_FOUND); 5707 5708 /* 5709 * Otherwise, bump up the number of matches. We'll 5710 * see later how many we have. 5711 */ 5712 num_matches++; 5713 } 5714 } 5715 5716 if (num_matches > 1) 5717 return (SCSI_NV_AMBIGUOUS); 5718 else if (num_matches == 1) 5719 return (SCSI_NV_FOUND); 5720 else 5721 return (SCSI_NV_NOT_FOUND); 5722} 5723 5724/* 5725 * Parse transport IDs for Fibre Channel, 1394 and SAS. Since these are 5726 * all 64-bit numbers, the code is similar. 5727 */ 5728int 5729scsi_parse_transportid_64bit(int proto_id, char *id_str, 5730 struct scsi_transportid_header **hdr, 5731 unsigned int *alloc_len, 5732#ifdef _KERNEL 5733 struct malloc_type *type, int flags, 5734#endif 5735 char *error_str, int error_str_len) 5736{ 5737 uint64_t value; 5738 char *endptr; 5739 int retval; 5740 size_t alloc_size; 5741 5742 retval = 0; 5743 5744 value = strtouq(id_str, &endptr, 0); 5745 if (*endptr != '\0') { 5746 if (error_str != NULL) { 5747 snprintf(error_str, error_str_len, "%s: error " 5748 "parsing ID %s, 64-bit number required", 5749 __func__, id_str); 5750 } 5751 retval = 1; 5752 goto bailout; 5753 } 5754 5755 switch (proto_id) { 5756 case SCSI_PROTO_FC: 5757 alloc_size = sizeof(struct scsi_transportid_fcp); 5758 break; 5759 case SCSI_PROTO_1394: 5760 alloc_size = sizeof(struct scsi_transportid_1394); 5761 break; 5762 case SCSI_PROTO_SAS: 5763 alloc_size = sizeof(struct scsi_transportid_sas); 5764 break; 5765 default: 5766 if (error_str != NULL) { 5767 snprintf(error_str, error_str_len, "%s: unsupoprted " 5768 "protocol %d", __func__, proto_id); 5769 } 5770 retval = 1; 5771 goto bailout; 5772 break; /* NOTREACHED */ 5773 } 5774#ifdef _KERNEL 5775 *hdr = malloc(alloc_size, type, flags); 5776#else /* _KERNEL */ 5777 *hdr = malloc(alloc_size); 5778#endif /*_KERNEL */ 5779 if (*hdr == NULL) { 5780 if (error_str != NULL) { 5781 snprintf(error_str, error_str_len, "%s: unable to " 5782 "allocate %zu bytes", __func__, alloc_size); 5783 } 5784 retval = 1; 5785 goto bailout; 5786 } 5787 5788 *alloc_len = alloc_size; 5789 5790 bzero(*hdr, alloc_size); 5791 5792 switch (proto_id) { 5793 case SCSI_PROTO_FC: { 5794 struct scsi_transportid_fcp *fcp; 5795 5796 fcp = (struct scsi_transportid_fcp *)(*hdr); 5797 fcp->format_protocol = SCSI_PROTO_FC | 5798 SCSI_TRN_FCP_FORMAT_DEFAULT; 5799 scsi_u64to8b(value, fcp->n_port_name); 5800 break; 5801 } 5802 case SCSI_PROTO_1394: { 5803 struct scsi_transportid_1394 *sbp; 5804 5805 sbp = (struct scsi_transportid_1394 *)(*hdr); 5806 sbp->format_protocol = SCSI_PROTO_1394 | 5807 SCSI_TRN_1394_FORMAT_DEFAULT; 5808 scsi_u64to8b(value, sbp->eui64); 5809 break; 5810 } 5811 case SCSI_PROTO_SAS: { 5812 struct scsi_transportid_sas *sas; 5813 5814 sas = (struct scsi_transportid_sas *)(*hdr); 5815 sas->format_protocol = SCSI_PROTO_SAS | 5816 SCSI_TRN_SAS_FORMAT_DEFAULT; 5817 scsi_u64to8b(value, sas->sas_address); 5818 break; 5819 } 5820 default: 5821 break; 5822 } 5823bailout: 5824 return (retval); 5825} 5826 5827/* 5828 * Parse a SPI (Parallel SCSI) address of the form: id,rel_tgt_port 5829 */ 5830int 5831scsi_parse_transportid_spi(char *id_str, struct scsi_transportid_header **hdr, 5832 unsigned int *alloc_len, 5833#ifdef _KERNEL 5834 struct malloc_type *type, int flags, 5835#endif 5836 char *error_str, int error_str_len) 5837{ 5838 unsigned long scsi_addr, target_port; 5839 struct scsi_transportid_spi *spi; 5840 char *tmpstr, *endptr; 5841 int retval; 5842 5843 retval = 0; 5844 5845 tmpstr = strsep(&id_str, ","); 5846 if (tmpstr == NULL) { 5847 if (error_str != NULL) { 5848 snprintf(error_str, error_str_len, 5849 "%s: no ID found", __func__); 5850 } 5851 retval = 1; 5852 goto bailout; 5853 } 5854 scsi_addr = strtoul(tmpstr, &endptr, 0); 5855 if (*endptr != '\0') { 5856 if (error_str != NULL) { 5857 snprintf(error_str, error_str_len, "%s: error " 5858 "parsing SCSI ID %s, number required", 5859 __func__, tmpstr); 5860 } 5861 retval = 1; 5862 goto bailout; 5863 } 5864 5865 if (id_str == NULL) { 5866 if (error_str != NULL) { 5867 snprintf(error_str, error_str_len, "%s: no relative " 5868 "target port found", __func__); 5869 } 5870 retval = 1; 5871 goto bailout; 5872 } 5873 5874 target_port = strtoul(id_str, &endptr, 0); 5875 if (*endptr != '\0') { 5876 if (error_str != NULL) { 5877 snprintf(error_str, error_str_len, "%s: error " 5878 "parsing relative target port %s, number " 5879 "required", __func__, id_str); 5880 } 5881 retval = 1; 5882 goto bailout; 5883 } 5884#ifdef _KERNEL 5885 spi = malloc(sizeof(*spi), type, flags); 5886#else 5887 spi = malloc(sizeof(*spi)); 5888#endif 5889 if (spi == NULL) { 5890 if (error_str != NULL) { 5891 snprintf(error_str, error_str_len, "%s: unable to " 5892 "allocate %zu bytes", __func__, 5893 sizeof(*spi)); 5894 } 5895 retval = 1; 5896 goto bailout; 5897 } 5898 *alloc_len = sizeof(*spi); 5899 bzero(spi, sizeof(*spi)); 5900 5901 spi->format_protocol = SCSI_PROTO_SPI | SCSI_TRN_SPI_FORMAT_DEFAULT; 5902 scsi_ulto2b(scsi_addr, spi->scsi_addr); 5903 scsi_ulto2b(target_port, spi->rel_trgt_port_id); 5904 5905 *hdr = (struct scsi_transportid_header *)spi; 5906bailout: 5907 return (retval); 5908} 5909 5910/* 5911 * Parse an RDMA/SRP Initiator Port ID string. This is 32 hexadecimal digits, 5912 * optionally prefixed by "0x" or "0X". 5913 */ 5914int 5915scsi_parse_transportid_rdma(char *id_str, struct scsi_transportid_header **hdr, 5916 unsigned int *alloc_len, 5917#ifdef _KERNEL 5918 struct malloc_type *type, int flags, 5919#endif 5920 char *error_str, int error_str_len) 5921{ 5922 struct scsi_transportid_rdma *rdma; 5923 int retval; 5924 size_t id_len, rdma_id_size; 5925 uint8_t rdma_id[SCSI_TRN_RDMA_PORT_LEN]; 5926 char *tmpstr; 5927 unsigned int i, j; 5928 5929 retval = 0; 5930 id_len = strlen(id_str); 5931 rdma_id_size = SCSI_TRN_RDMA_PORT_LEN; 5932 5933 /* 5934 * Check the size. It needs to be either 32 or 34 characters long. 5935 */ 5936 if ((id_len != (rdma_id_size * 2)) 5937 && (id_len != ((rdma_id_size * 2) + 2))) { 5938 if (error_str != NULL) { 5939 snprintf(error_str, error_str_len, "%s: RDMA ID " 5940 "must be 32 hex digits (0x prefix " 5941 "optional), only %zu seen", __func__, id_len); 5942 } 5943 retval = 1; 5944 goto bailout; 5945 } 5946 5947 tmpstr = id_str; 5948 /* 5949 * If the user gave us 34 characters, the string needs to start 5950 * with '0x'. 5951 */ 5952 if (id_len == ((rdma_id_size * 2) + 2)) { 5953 if ((tmpstr[0] == '0') 5954 && ((tmpstr[1] == 'x') || (tmpstr[1] == 'X'))) { 5955 tmpstr += 2; 5956 } else { 5957 if (error_str != NULL) { 5958 snprintf(error_str, error_str_len, "%s: RDMA " 5959 "ID prefix, if used, must be \"0x\", " 5960 "got %s", __func__, tmpstr); 5961 } 5962 retval = 1; 5963 goto bailout; 5964 } 5965 } 5966 bzero(rdma_id, sizeof(rdma_id)); 5967 5968 /* 5969 * Convert ASCII hex into binary bytes. There is no standard 5970 * 128-bit integer type, and so no strtou128t() routine to convert 5971 * from hex into a large integer. In the end, we're not going to 5972 * an integer, but rather to a byte array, so that and the fact 5973 * that we require the user to give us 32 hex digits simplifies the 5974 * logic. 5975 */ 5976 for (i = 0; i < (rdma_id_size * 2); i++) { 5977 int cur_shift; 5978 unsigned char c; 5979 5980 /* Increment the byte array one for every 2 hex digits */ 5981 j = i >> 1; 5982 5983 /* 5984 * The first digit in every pair is the most significant 5985 * 4 bits. The second is the least significant 4 bits. 5986 */ 5987 if ((i % 2) == 0) 5988 cur_shift = 4; 5989 else 5990 cur_shift = 0; 5991 5992 c = tmpstr[i]; 5993 /* Convert the ASCII hex character into a number */ 5994 if (isdigit(c)) 5995 c -= '0'; 5996 else if (isalpha(c)) 5997 c -= isupper(c) ? 'A' - 10 : 'a' - 10; 5998 else { 5999 if (error_str != NULL) { 6000 snprintf(error_str, error_str_len, "%s: " 6001 "RDMA ID must be hex digits, got " 6002 "invalid character %c", __func__, 6003 tmpstr[i]); 6004 } 6005 retval = 1; 6006 goto bailout; 6007 } 6008 /* 6009 * The converted number can't be less than 0; the type is 6010 * unsigned, and the subtraction logic will not give us 6011 * a negative number. So we only need to make sure that 6012 * the value is not greater than 0xf. (i.e. make sure the 6013 * user didn't give us a value like "0x12jklmno"). 6014 */ 6015 if (c > 0xf) { 6016 if (error_str != NULL) { 6017 snprintf(error_str, error_str_len, "%s: " 6018 "RDMA ID must be hex digits, got " 6019 "invalid character %c", __func__, 6020 tmpstr[i]); 6021 } 6022 retval = 1; 6023 goto bailout; 6024 } 6025 6026 rdma_id[j] |= c << cur_shift; 6027 } 6028 6029#ifdef _KERNEL 6030 rdma = malloc(sizeof(*rdma), type, flags); 6031#else 6032 rdma = malloc(sizeof(*rdma)); 6033#endif 6034 if (rdma == NULL) { 6035 if (error_str != NULL) { 6036 snprintf(error_str, error_str_len, "%s: unable to " 6037 "allocate %zu bytes", __func__, 6038 sizeof(*rdma)); 6039 } 6040 retval = 1; 6041 goto bailout; 6042 } 6043 *alloc_len = sizeof(*rdma); 6044 bzero(rdma, *alloc_len); 6045 6046 rdma->format_protocol = SCSI_PROTO_RDMA | SCSI_TRN_RDMA_FORMAT_DEFAULT; 6047 bcopy(rdma_id, rdma->initiator_port_id, SCSI_TRN_RDMA_PORT_LEN); 6048 6049 *hdr = (struct scsi_transportid_header *)rdma; 6050 6051bailout: 6052 return (retval); 6053} 6054 6055/* 6056 * Parse an iSCSI name. The format is either just the name: 6057 * 6058 * iqn.2012-06.com.example:target0 6059 * or the name, separator and initiator session ID: 6060 * 6061 * iqn.2012-06.com.example:target0,i,0x123 6062 * 6063 * The separator format is exact. 6064 */ 6065int 6066scsi_parse_transportid_iscsi(char *id_str, struct scsi_transportid_header **hdr, 6067 unsigned int *alloc_len, 6068#ifdef _KERNEL 6069 struct malloc_type *type, int flags, 6070#endif 6071 char *error_str, int error_str_len) 6072{ 6073 size_t id_len, sep_len, id_size, name_len; 6074 int retval; 6075 unsigned int i, sep_pos, sep_found; 6076 const char *sep_template = ",i,0x"; 6077 const char *iqn_prefix = "iqn."; 6078 struct scsi_transportid_iscsi_device *iscsi; 6079 6080 retval = 0; 6081 sep_found = 0; 6082 6083 id_len = strlen(id_str); 6084 sep_len = strlen(sep_template); 6085 6086 /* 6087 * The separator is defined as exactly ',i,0x'. Any other commas, 6088 * or any other form, is an error. So look for a comma, and once 6089 * we find that, the next few characters must match the separator 6090 * exactly. Once we get through the separator, there should be at 6091 * least one character. 6092 */ 6093 for (i = 0, sep_pos = 0; i < id_len; i++) { 6094 if (sep_pos == 0) { 6095 if (id_str[i] == sep_template[sep_pos]) 6096 sep_pos++; 6097 6098 continue; 6099 } 6100 if (sep_pos < sep_len) { 6101 if (id_str[i] == sep_template[sep_pos]) { 6102 sep_pos++; 6103 continue; 6104 } 6105 if (error_str != NULL) { 6106 snprintf(error_str, error_str_len, "%s: " 6107 "invalid separator in iSCSI name " 6108 "\"%s\"", 6109 __func__, id_str); 6110 } 6111 retval = 1; 6112 goto bailout; 6113 } else { 6114 sep_found = 1; 6115 break; 6116 } 6117 } 6118 6119 /* 6120 * Check to see whether we have a separator but no digits after it. 6121 */ 6122 if ((sep_pos != 0) 6123 && (sep_found == 0)) { 6124 if (error_str != NULL) { 6125 snprintf(error_str, error_str_len, "%s: no digits " 6126 "found after separator in iSCSI name \"%s\"", 6127 __func__, id_str); 6128 } 6129 retval = 1; 6130 goto bailout; 6131 } 6132 6133 /* 6134 * The incoming ID string has the "iqn." prefix stripped off. We 6135 * need enough space for the base structure (the structures are the 6136 * same for the two iSCSI forms), the prefix, the ID string and a 6137 * terminating NUL. 6138 */ 6139 id_size = sizeof(*iscsi) + strlen(iqn_prefix) + id_len + 1; 6140 6141#ifdef _KERNEL 6142 iscsi = malloc(id_size, type, flags); 6143#else 6144 iscsi = malloc(id_size); 6145#endif 6146 if (iscsi == NULL) { 6147 if (error_str != NULL) { 6148 snprintf(error_str, error_str_len, "%s: unable to " 6149 "allocate %zu bytes", __func__, id_size); 6150 } 6151 retval = 1; 6152 goto bailout; 6153 } 6154 *alloc_len = id_size; 6155 bzero(iscsi, id_size); 6156 6157 iscsi->format_protocol = SCSI_PROTO_ISCSI; 6158 if (sep_found == 0) 6159 iscsi->format_protocol |= SCSI_TRN_ISCSI_FORMAT_DEVICE; 6160 else 6161 iscsi->format_protocol |= SCSI_TRN_ISCSI_FORMAT_PORT; 6162 name_len = id_size - sizeof(*iscsi); 6163 scsi_ulto2b(name_len, iscsi->additional_length); 6164 snprintf(iscsi->iscsi_name, name_len, "%s%s", iqn_prefix, id_str); 6165 6166 *hdr = (struct scsi_transportid_header *)iscsi; 6167 6168bailout: 6169 return (retval); 6170} 6171 6172/* 6173 * Parse a SCSI over PCIe (SOP) identifier. The Routing ID can either be 6174 * of the form 'bus,device,function' or 'bus,function'. 6175 */ 6176int 6177scsi_parse_transportid_sop(char *id_str, struct scsi_transportid_header **hdr, 6178 unsigned int *alloc_len, 6179#ifdef _KERNEL 6180 struct malloc_type *type, int flags, 6181#endif 6182 char *error_str, int error_str_len) 6183{ 6184 struct scsi_transportid_sop *sop; 6185 unsigned long bus, device, function; 6186 char *tmpstr, *endptr; 6187 int retval, device_spec; 6188 6189 retval = 0; 6190 device_spec = 0; 6191 device = 0; 6192 6193 tmpstr = strsep(&id_str, ","); 6194 if ((tmpstr == NULL) 6195 || (*tmpstr == '\0')) { 6196 if (error_str != NULL) { 6197 snprintf(error_str, error_str_len, "%s: no ID found", 6198 __func__); 6199 } 6200 retval = 1; 6201 goto bailout; 6202 } 6203 bus = strtoul(tmpstr, &endptr, 0); 6204 if (*endptr != '\0') { 6205 if (error_str != NULL) { 6206 snprintf(error_str, error_str_len, "%s: error " 6207 "parsing PCIe bus %s, number required", 6208 __func__, tmpstr); 6209 } 6210 retval = 1; 6211 goto bailout; 6212 } 6213 if ((id_str == NULL) 6214 || (*id_str == '\0')) { 6215 if (error_str != NULL) { 6216 snprintf(error_str, error_str_len, "%s: no PCIe " 6217 "device or function found", __func__); 6218 } 6219 retval = 1; 6220 goto bailout; 6221 } 6222 tmpstr = strsep(&id_str, ","); 6223 function = strtoul(tmpstr, &endptr, 0); 6224 if (*endptr != '\0') { 6225 if (error_str != NULL) { 6226 snprintf(error_str, error_str_len, "%s: error " 6227 "parsing PCIe device/function %s, number " 6228 "required", __func__, tmpstr); 6229 } 6230 retval = 1; 6231 goto bailout; 6232 } 6233 /* 6234 * Check to see whether the user specified a third value. If so, 6235 * the second is the device. 6236 */ 6237 if (id_str != NULL) { 6238 if (*id_str == '\0') { 6239 if (error_str != NULL) { 6240 snprintf(error_str, error_str_len, "%s: " 6241 "no PCIe function found", __func__); 6242 } 6243 retval = 1; 6244 goto bailout; 6245 } 6246 device = function; 6247 device_spec = 1; 6248 function = strtoul(id_str, &endptr, 0); 6249 if (*endptr != '\0') { 6250 if (error_str != NULL) { 6251 snprintf(error_str, error_str_len, "%s: " 6252 "error parsing PCIe function %s, " 6253 "number required", __func__, id_str); 6254 } 6255 retval = 1; 6256 goto bailout; 6257 } 6258 } 6259 if (bus > SCSI_TRN_SOP_BUS_MAX) { 6260 if (error_str != NULL) { 6261 snprintf(error_str, error_str_len, "%s: bus value " 6262 "%lu greater than maximum %u", __func__, 6263 bus, SCSI_TRN_SOP_BUS_MAX); 6264 } 6265 retval = 1; 6266 goto bailout; 6267 } 6268 6269 if ((device_spec != 0) 6270 && (device > SCSI_TRN_SOP_DEV_MASK)) { 6271 if (error_str != NULL) { 6272 snprintf(error_str, error_str_len, "%s: device value " 6273 "%lu greater than maximum %u", __func__, 6274 device, SCSI_TRN_SOP_DEV_MAX); 6275 } 6276 retval = 1; 6277 goto bailout; 6278 } 6279 6280 if (((device_spec != 0) 6281 && (function > SCSI_TRN_SOP_FUNC_NORM_MAX)) 6282 || ((device_spec == 0) 6283 && (function > SCSI_TRN_SOP_FUNC_ALT_MAX))) { 6284 if (error_str != NULL) { 6285 snprintf(error_str, error_str_len, "%s: function value " 6286 "%lu greater than maximum %u", __func__, 6287 function, (device_spec == 0) ? 6288 SCSI_TRN_SOP_FUNC_ALT_MAX : 6289 SCSI_TRN_SOP_FUNC_NORM_MAX); 6290 } 6291 retval = 1; 6292 goto bailout; 6293 } 6294 6295#ifdef _KERNEL 6296 sop = malloc(sizeof(*sop), type, flags); 6297#else 6298 sop = malloc(sizeof(*sop)); 6299#endif 6300 if (sop == NULL) { 6301 if (error_str != NULL) { 6302 snprintf(error_str, error_str_len, "%s: unable to " 6303 "allocate %zu bytes", __func__, sizeof(*sop)); 6304 } 6305 retval = 1; 6306 goto bailout; 6307 } 6308 *alloc_len = sizeof(*sop); 6309 bzero(sop, sizeof(*sop)); 6310 sop->format_protocol = SCSI_PROTO_SOP | SCSI_TRN_SOP_FORMAT_DEFAULT; 6311 if (device_spec != 0) { 6312 struct scsi_sop_routing_id_norm rid; 6313 6314 rid.bus = bus; 6315 rid.devfunc = (device << SCSI_TRN_SOP_DEV_SHIFT) | function; 6316 bcopy(&rid, sop->routing_id, MIN(sizeof(rid), 6317 sizeof(sop->routing_id))); 6318 } else { 6319 struct scsi_sop_routing_id_alt rid; 6320 6321 rid.bus = bus; 6322 rid.function = function; 6323 bcopy(&rid, sop->routing_id, MIN(sizeof(rid), 6324 sizeof(sop->routing_id))); 6325 } 6326 6327 *hdr = (struct scsi_transportid_header *)sop; 6328bailout: 6329 return (retval); 6330} 6331 6332/* 6333 * transportid_str: NUL-terminated string with format: protcol,id 6334 * The ID is protocol specific. 6335 * hdr: Storage will be allocated for the transport ID. 6336 * alloc_len: The amount of memory allocated is returned here. 6337 * type: Malloc bucket (kernel only). 6338 * flags: Malloc flags (kernel only). 6339 * error_str: If non-NULL, it will contain error information (without 6340 * a terminating newline) if an error is returned. 6341 * error_str_len: Allocated length of the error string. 6342 * 6343 * Returns 0 for success, non-zero for failure. 6344 */ 6345int 6346scsi_parse_transportid(char *transportid_str, 6347 struct scsi_transportid_header **hdr, 6348 unsigned int *alloc_len, 6349#ifdef _KERNEL 6350 struct malloc_type *type, int flags, 6351#endif 6352 char *error_str, int error_str_len) 6353{ 6354 char *tmpstr; 6355 scsi_nv_status status; 6356 int retval, num_proto_entries, table_entry; 6357 6358 retval = 0; 6359 table_entry = 0; 6360 6361 /* 6362 * We do allow a period as well as a comma to separate the protocol 6363 * from the ID string. This is to accommodate iSCSI names, which 6364 * start with "iqn.". 6365 */ 6366 tmpstr = strsep(&transportid_str, ",."); 6367 if (tmpstr == NULL) { 6368 if (error_str != NULL) { 6369 snprintf(error_str, error_str_len, 6370 "%s: transportid_str is NULL", __func__); 6371 } 6372 retval = 1; 6373 goto bailout; 6374 } 6375 6376 num_proto_entries = sizeof(scsi_proto_map) / 6377 sizeof(scsi_proto_map[0]); 6378 status = scsi_get_nv(scsi_proto_map, num_proto_entries, tmpstr, 6379 &table_entry, SCSI_NV_FLAG_IG_CASE); 6380 if (status != SCSI_NV_FOUND) { 6381 if (error_str != NULL) { 6382 snprintf(error_str, error_str_len, "%s: %s protocol " 6383 "name %s", __func__, 6384 (status == SCSI_NV_AMBIGUOUS) ? "ambiguous" : 6385 "invalid", tmpstr); 6386 } 6387 retval = 1; 6388 goto bailout; 6389 } 6390 switch (scsi_proto_map[table_entry].value) { 6391 case SCSI_PROTO_FC: 6392 case SCSI_PROTO_1394: 6393 case SCSI_PROTO_SAS: 6394 retval = scsi_parse_transportid_64bit( 6395 scsi_proto_map[table_entry].value, transportid_str, hdr, 6396 alloc_len, 6397#ifdef _KERNEL 6398 type, flags, 6399#endif 6400 error_str, error_str_len); 6401 break; 6402 case SCSI_PROTO_SPI: 6403 retval = scsi_parse_transportid_spi(transportid_str, hdr, 6404 alloc_len, 6405#ifdef _KERNEL 6406 type, flags, 6407#endif 6408 error_str, error_str_len); 6409 break; 6410 case SCSI_PROTO_RDMA: 6411 retval = scsi_parse_transportid_rdma(transportid_str, hdr, 6412 alloc_len, 6413#ifdef _KERNEL 6414 type, flags, 6415#endif 6416 error_str, error_str_len); 6417 break; 6418 case SCSI_PROTO_ISCSI: 6419 retval = scsi_parse_transportid_iscsi(transportid_str, hdr, 6420 alloc_len, 6421#ifdef _KERNEL 6422 type, flags, 6423#endif 6424 error_str, error_str_len); 6425 break; 6426 case SCSI_PROTO_SOP: 6427 retval = scsi_parse_transportid_sop(transportid_str, hdr, 6428 alloc_len, 6429#ifdef _KERNEL 6430 type, flags, 6431#endif 6432 error_str, error_str_len); 6433 break; 6434 case SCSI_PROTO_SSA: 6435 case SCSI_PROTO_ADITP: 6436 case SCSI_PROTO_ATA: 6437 case SCSI_PROTO_UAS: 6438 case SCSI_PROTO_NONE: 6439 default: 6440 /* 6441 * There is no format defined for a Transport ID for these 6442 * protocols. So even if the user gives us something, we 6443 * have no way to turn it into a standard SCSI Transport ID. 6444 */ 6445 retval = 1; 6446 if (error_str != NULL) { 6447 snprintf(error_str, error_str_len, "%s: no Transport " 6448 "ID format exists for protocol %s", 6449 __func__, tmpstr); 6450 } 6451 goto bailout; 6452 break; /* NOTREACHED */ 6453 } 6454bailout: 6455 return (retval); 6456} 6457 6458struct scsi_attrib_table_entry scsi_mam_attr_table[] = { 6459 { SMA_ATTR_REM_CAP_PARTITION, SCSI_ATTR_FLAG_NONE, 6460 "Remaining Capacity in Partition", 6461 /*suffix*/ "MB", /*to_str*/ scsi_attrib_int_sbuf,/*parse_str*/ NULL }, 6462 { SMA_ATTR_MAX_CAP_PARTITION, SCSI_ATTR_FLAG_NONE, 6463 "Maximum Capacity in Partition", 6464 /*suffix*/"MB", /*to_str*/ scsi_attrib_int_sbuf, /*parse_str*/ NULL }, 6465 { SMA_ATTR_TAPEALERT_FLAGS, SCSI_ATTR_FLAG_HEX, 6466 "TapeAlert Flags", 6467 /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf, /*parse_str*/ NULL }, 6468 { SMA_ATTR_LOAD_COUNT, SCSI_ATTR_FLAG_NONE, 6469 "Load Count", 6470 /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf, /*parse_str*/ NULL }, 6471 { SMA_ATTR_MAM_SPACE_REMAINING, SCSI_ATTR_FLAG_NONE, 6472 "MAM Space Remaining", 6473 /*suffix*/"bytes", /*to_str*/ scsi_attrib_int_sbuf, 6474 /*parse_str*/ NULL }, 6475 { SMA_ATTR_DEV_ASSIGNING_ORG, SCSI_ATTR_FLAG_NONE, 6476 "Assigning Organization", 6477 /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf, 6478 /*parse_str*/ NULL }, 6479 { SMA_ATTR_FORMAT_DENSITY_CODE, SCSI_ATTR_FLAG_HEX, 6480 "Format Density Code", 6481 /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf, /*parse_str*/ NULL }, 6482 { SMA_ATTR_INITIALIZATION_COUNT, SCSI_ATTR_FLAG_NONE, 6483 "Initialization Count", 6484 /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf, /*parse_str*/ NULL }, 6485 { SMA_ATTR_VOLUME_ID, SCSI_ATTR_FLAG_NONE, 6486 "Volume Identifier", 6487 /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf, 6488 /*parse_str*/ NULL }, 6489 { SMA_ATTR_VOLUME_CHANGE_REF, SCSI_ATTR_FLAG_HEX, 6490 "Volume Change Reference", 6491 /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf, 6492 /*parse_str*/ NULL }, 6493 { SMA_ATTR_DEV_SERIAL_LAST_LOAD, SCSI_ATTR_FLAG_NONE, 6494 "Device Vendor/Serial at Last Load", 6495 /*suffix*/NULL, /*to_str*/ scsi_attrib_vendser_sbuf, 6496 /*parse_str*/ NULL }, 6497 { SMA_ATTR_DEV_SERIAL_LAST_LOAD_1, SCSI_ATTR_FLAG_NONE, 6498 "Device Vendor/Serial at Last Load - 1", 6499 /*suffix*/NULL, /*to_str*/ scsi_attrib_vendser_sbuf, 6500 /*parse_str*/ NULL }, 6501 { SMA_ATTR_DEV_SERIAL_LAST_LOAD_2, SCSI_ATTR_FLAG_NONE, 6502 "Device Vendor/Serial at Last Load - 2", 6503 /*suffix*/NULL, /*to_str*/ scsi_attrib_vendser_sbuf, 6504 /*parse_str*/ NULL }, 6505 { SMA_ATTR_DEV_SERIAL_LAST_LOAD_3, SCSI_ATTR_FLAG_NONE, 6506 "Device Vendor/Serial at Last Load - 3", 6507 /*suffix*/NULL, /*to_str*/ scsi_attrib_vendser_sbuf, 6508 /*parse_str*/ NULL }, 6509 { SMA_ATTR_TOTAL_MB_WRITTEN_LT, SCSI_ATTR_FLAG_NONE, 6510 "Total MB Written in Medium Life", 6511 /*suffix*/ "MB", /*to_str*/ scsi_attrib_int_sbuf, 6512 /*parse_str*/ NULL }, 6513 { SMA_ATTR_TOTAL_MB_READ_LT, SCSI_ATTR_FLAG_NONE, 6514 "Total MB Read in Medium Life", 6515 /*suffix*/ "MB", /*to_str*/ scsi_attrib_int_sbuf, 6516 /*parse_str*/ NULL }, 6517 { SMA_ATTR_TOTAL_MB_WRITTEN_CUR, SCSI_ATTR_FLAG_NONE, 6518 "Total MB Written in Current/Last Load", 6519 /*suffix*/ "MB", /*to_str*/ scsi_attrib_int_sbuf, 6520 /*parse_str*/ NULL }, 6521 { SMA_ATTR_TOTAL_MB_READ_CUR, SCSI_ATTR_FLAG_NONE, 6522 "Total MB Read in Current/Last Load", 6523 /*suffix*/ "MB", /*to_str*/ scsi_attrib_int_sbuf, 6524 /*parse_str*/ NULL }, 6525 { SMA_ATTR_FIRST_ENC_BLOCK, SCSI_ATTR_FLAG_NONE, 6526 "Logical Position of First Encrypted Block", 6527 /*suffix*/ NULL, /*to_str*/ scsi_attrib_int_sbuf, 6528 /*parse_str*/ NULL }, 6529 { SMA_ATTR_NEXT_UNENC_BLOCK, SCSI_ATTR_FLAG_NONE, 6530 "Logical Position of First Unencrypted Block after First " 6531 "Encrypted Block", 6532 /*suffix*/ NULL, /*to_str*/ scsi_attrib_int_sbuf, 6533 /*parse_str*/ NULL }, 6534 { SMA_ATTR_MEDIUM_USAGE_HIST, SCSI_ATTR_FLAG_NONE, 6535 "Medium Usage History", 6536 /*suffix*/ NULL, /*to_str*/ NULL, 6537 /*parse_str*/ NULL }, 6538 { SMA_ATTR_PART_USAGE_HIST, SCSI_ATTR_FLAG_NONE, 6539 "Partition Usage History", 6540 /*suffix*/ NULL, /*to_str*/ NULL, 6541 /*parse_str*/ NULL }, 6542 { SMA_ATTR_MED_MANUF, SCSI_ATTR_FLAG_NONE, 6543 "Medium Manufacturer", 6544 /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf, 6545 /*parse_str*/ NULL }, 6546 { SMA_ATTR_MED_SERIAL, SCSI_ATTR_FLAG_NONE, 6547 "Medium Serial Number", 6548 /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf, 6549 /*parse_str*/ NULL }, 6550 { SMA_ATTR_MED_LENGTH, SCSI_ATTR_FLAG_NONE, 6551 "Medium Length", 6552 /*suffix*/"m", /*to_str*/ scsi_attrib_int_sbuf, 6553 /*parse_str*/ NULL }, 6554 { SMA_ATTR_MED_WIDTH, SCSI_ATTR_FLAG_FP | SCSI_ATTR_FLAG_DIV_10 | 6555 SCSI_ATTR_FLAG_FP_1DIGIT, 6556 "Medium Width", 6557 /*suffix*/"mm", /*to_str*/ scsi_attrib_int_sbuf, 6558 /*parse_str*/ NULL }, 6559 { SMA_ATTR_MED_ASSIGNING_ORG, SCSI_ATTR_FLAG_NONE, 6560 "Assigning Organization", 6561 /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf, 6562 /*parse_str*/ NULL }, 6563 { SMA_ATTR_MED_DENSITY_CODE, SCSI_ATTR_FLAG_HEX, 6564 "Medium Density Code", 6565 /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf, 6566 /*parse_str*/ NULL }, 6567 { SMA_ATTR_MED_MANUF_DATE, SCSI_ATTR_FLAG_NONE, 6568 "Medium Manufacture Date", 6569 /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf, 6570 /*parse_str*/ NULL }, 6571 { SMA_ATTR_MAM_CAPACITY, SCSI_ATTR_FLAG_NONE, 6572 "MAM Capacity", 6573 /*suffix*/"bytes", /*to_str*/ scsi_attrib_int_sbuf, 6574 /*parse_str*/ NULL }, 6575 { SMA_ATTR_MED_TYPE, SCSI_ATTR_FLAG_HEX, 6576 "Medium Type", 6577 /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf, 6578 /*parse_str*/ NULL }, 6579 { SMA_ATTR_MED_TYPE_INFO, SCSI_ATTR_FLAG_HEX, 6580 "Medium Type Information", 6581 /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf, 6582 /*parse_str*/ NULL }, 6583 { SMA_ATTR_MED_SERIAL_NUM, SCSI_ATTR_FLAG_NONE, 6584 "Medium Serial Number", 6585 /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf, 6586 /*parse_str*/ NULL }, 6587 { SMA_ATTR_APP_VENDOR, SCSI_ATTR_FLAG_NONE, 6588 "Application Vendor", 6589 /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf, 6590 /*parse_str*/ NULL }, 6591 { SMA_ATTR_APP_NAME, SCSI_ATTR_FLAG_NONE, 6592 "Application Name", 6593 /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf, 6594 /*parse_str*/ NULL }, 6595 { SMA_ATTR_APP_VERSION, SCSI_ATTR_FLAG_NONE, 6596 "Application Version", 6597 /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf, 6598 /*parse_str*/ NULL }, 6599 { SMA_ATTR_USER_MED_TEXT_LABEL, SCSI_ATTR_FLAG_NONE, 6600 "User Medium Text Label", 6601 /*suffix*/NULL, /*to_str*/ scsi_attrib_text_sbuf, 6602 /*parse_str*/ NULL }, 6603 { SMA_ATTR_LAST_WRITTEN_TIME, SCSI_ATTR_FLAG_NONE, 6604 "Date and Time Last Written", 6605 /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf, 6606 /*parse_str*/ NULL }, 6607 { SMA_ATTR_TEXT_LOCAL_ID, SCSI_ATTR_FLAG_HEX, 6608 "Text Localization Identifier", 6609 /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf, 6610 /*parse_str*/ NULL }, 6611 { SMA_ATTR_BARCODE, SCSI_ATTR_FLAG_NONE, 6612 "Barcode", 6613 /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf, 6614 /*parse_str*/ NULL }, 6615 { SMA_ATTR_HOST_OWNER_NAME, SCSI_ATTR_FLAG_NONE, 6616 "Owning Host Textual Name", 6617 /*suffix*/NULL, /*to_str*/ scsi_attrib_text_sbuf, 6618 /*parse_str*/ NULL }, 6619 { SMA_ATTR_MEDIA_POOL, SCSI_ATTR_FLAG_NONE, 6620 "Media Pool", 6621 /*suffix*/NULL, /*to_str*/ scsi_attrib_text_sbuf, 6622 /*parse_str*/ NULL }, 6623 { SMA_ATTR_PART_USER_LABEL, SCSI_ATTR_FLAG_NONE, 6624 "Partition User Text Label", 6625 /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf, 6626 /*parse_str*/ NULL }, 6627 { SMA_ATTR_LOAD_UNLOAD_AT_PART, SCSI_ATTR_FLAG_NONE, 6628 "Load/Unload at Partition", 6629 /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf, 6630 /*parse_str*/ NULL }, 6631 { SMA_ATTR_APP_FORMAT_VERSION, SCSI_ATTR_FLAG_NONE, 6632 "Application Format Version", 6633 /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf, 6634 /*parse_str*/ NULL }, 6635 { SMA_ATTR_VOL_COHERENCY_INFO, SCSI_ATTR_FLAG_NONE, 6636 "Volume Coherency Information", 6637 /*suffix*/NULL, /*to_str*/ scsi_attrib_volcoh_sbuf, 6638 /*parse_str*/ NULL }, 6639 { 0x0ff1, SCSI_ATTR_FLAG_NONE, 6640 "Spectra MLM Creation", 6641 /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf, 6642 /*parse_str*/ NULL }, 6643 { 0x0ff2, SCSI_ATTR_FLAG_NONE, 6644 "Spectra MLM C3", 6645 /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf, 6646 /*parse_str*/ NULL }, 6647 { 0x0ff3, SCSI_ATTR_FLAG_NONE, 6648 "Spectra MLM RW", 6649 /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf, 6650 /*parse_str*/ NULL }, 6651 { 0x0ff4, SCSI_ATTR_FLAG_NONE, 6652 "Spectra MLM SDC List", 6653 /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf, 6654 /*parse_str*/ NULL }, 6655 { 0x0ff7, SCSI_ATTR_FLAG_NONE, 6656 "Spectra MLM Post Scan", 6657 /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf, 6658 /*parse_str*/ NULL }, 6659 { 0x0ffe, SCSI_ATTR_FLAG_NONE, 6660 "Spectra MLM Checksum", 6661 /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf, 6662 /*parse_str*/ NULL }, 6663 { 0x17f1, SCSI_ATTR_FLAG_NONE, 6664 "Spectra MLM Creation", 6665 /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf, 6666 /*parse_str*/ NULL }, 6667 { 0x17f2, SCSI_ATTR_FLAG_NONE, 6668 "Spectra MLM C3", 6669 /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf, 6670 /*parse_str*/ NULL }, 6671 { 0x17f3, SCSI_ATTR_FLAG_NONE, 6672 "Spectra MLM RW", 6673 /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf, 6674 /*parse_str*/ NULL }, 6675 { 0x17f4, SCSI_ATTR_FLAG_NONE, 6676 "Spectra MLM SDC List", 6677 /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf, 6678 /*parse_str*/ NULL }, 6679 { 0x17f7, SCSI_ATTR_FLAG_NONE, 6680 "Spectra MLM Post Scan", 6681 /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf, 6682 /*parse_str*/ NULL }, 6683 { 0x17ff, SCSI_ATTR_FLAG_NONE, 6684 "Spectra MLM Checksum", 6685 /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf, 6686 /*parse_str*/ NULL }, 6687}; 6688 6689/* 6690 * Print out Volume Coherency Information (Attribute 0x080c). 6691 * This field has two variable length members, including one at the 6692 * beginning, so it isn't practical to have a fixed structure definition. 6693 * This is current as of SSC4r03 (see section 4.2.21.3), dated March 25, 6694 * 2013. 6695 */ 6696int 6697scsi_attrib_volcoh_sbuf(struct sbuf *sb, struct scsi_mam_attribute_header *hdr, 6698 uint32_t valid_len, uint32_t flags, 6699 uint32_t output_flags, char *error_str, 6700 int error_str_len) 6701{ 6702 size_t avail_len; 6703 uint32_t field_size; 6704 uint64_t tmp_val; 6705 uint8_t *cur_ptr; 6706 int retval; 6707 int vcr_len, as_len; 6708 6709 retval = 0; 6710 tmp_val = 0; 6711 6712 field_size = scsi_2btoul(hdr->length); 6713 avail_len = valid_len - sizeof(*hdr); 6714 if (field_size > avail_len) { 6715 if (error_str != NULL) { 6716 snprintf(error_str, error_str_len, "Available " 6717 "length of attribute ID 0x%.4x %zu < field " 6718 "length %u", scsi_2btoul(hdr->id), avail_len, 6719 field_size); 6720 } 6721 retval = 1; 6722 goto bailout; 6723 } else if (field_size == 0) { 6724 /* 6725 * It isn't clear from the spec whether a field length of 6726 * 0 is invalid here. It probably is, but be lenient here 6727 * to avoid inconveniencing the user. 6728 */ 6729 goto bailout; 6730 } 6731 cur_ptr = hdr->attribute; 6732 vcr_len = *cur_ptr; 6733 cur_ptr++; 6734 6735 sbuf_printf(sb, "\n\tVolume Change Reference Value:"); 6736 6737 switch (vcr_len) { 6738 case 0: 6739 if (error_str != NULL) { 6740 snprintf(error_str, error_str_len, "Volume Change " 6741 "Reference value has length of 0"); 6742 } 6743 retval = 1; 6744 goto bailout; 6745 break; /*NOTREACHED*/ 6746 case 1: 6747 tmp_val = *cur_ptr; 6748 break; 6749 case 2: 6750 tmp_val = scsi_2btoul(cur_ptr); 6751 break; 6752 case 3: 6753 tmp_val = scsi_3btoul(cur_ptr); 6754 break; 6755 case 4: 6756 tmp_val = scsi_4btoul(cur_ptr); 6757 break; 6758 case 8: 6759 tmp_val = scsi_8btou64(cur_ptr); 6760 break; 6761 default: 6762 sbuf_printf(sb, "\n"); 6763 sbuf_hexdump(sb, cur_ptr, vcr_len, NULL, 0); 6764 break; 6765 } 6766 if (vcr_len <= 8) 6767 sbuf_printf(sb, " 0x%jx\n", (uintmax_t)tmp_val); 6768 6769 cur_ptr += vcr_len; 6770 tmp_val = scsi_8btou64(cur_ptr); 6771 sbuf_printf(sb, "\tVolume Coherency Count: %ju\n", (uintmax_t)tmp_val); 6772 6773 cur_ptr += sizeof(tmp_val); 6774 tmp_val = scsi_8btou64(cur_ptr); 6775 sbuf_printf(sb, "\tVolume Coherency Set Identifier: 0x%jx\n", 6776 (uintmax_t)tmp_val); 6777 6778 /* 6779 * Figure out how long the Application Client Specific Information 6780 * is and produce a hexdump. 6781 */ 6782 cur_ptr += sizeof(tmp_val); 6783 as_len = scsi_2btoul(cur_ptr); 6784 cur_ptr += sizeof(uint16_t); 6785 sbuf_printf(sb, "\tApplication Client Specific Information: "); 6786 if (((as_len == SCSI_LTFS_VER0_LEN) 6787 || (as_len == SCSI_LTFS_VER1_LEN)) 6788 && (strncmp(cur_ptr, SCSI_LTFS_STR_NAME, SCSI_LTFS_STR_LEN) == 0)) { 6789 sbuf_printf(sb, "LTFS\n"); 6790 cur_ptr += SCSI_LTFS_STR_LEN + 1; 6791 if (cur_ptr[SCSI_LTFS_UUID_LEN] != '\0') 6792 cur_ptr[SCSI_LTFS_UUID_LEN] = '\0'; 6793 sbuf_printf(sb, "\tLTFS UUID: %s\n", cur_ptr); 6794 cur_ptr += SCSI_LTFS_UUID_LEN + 1; 6795 /* XXX KDM check the length */ 6796 sbuf_printf(sb, "\tLTFS Version: %d\n", *cur_ptr); 6797 } else { 6798 sbuf_printf(sb, "Unknown\n"); 6799 sbuf_hexdump(sb, cur_ptr, as_len, NULL, 0); 6800 } 6801 6802bailout: 6803 return (retval); 6804} 6805 6806int 6807scsi_attrib_vendser_sbuf(struct sbuf *sb, struct scsi_mam_attribute_header *hdr, 6808 uint32_t valid_len, uint32_t flags, 6809 uint32_t output_flags, char *error_str, 6810 int error_str_len) 6811{ 6812 size_t avail_len; 6813 uint32_t field_size; 6814 struct scsi_attrib_vendser *vendser; 6815 cam_strvis_flags strvis_flags; 6816 int retval = 0; 6817 6818 field_size = scsi_2btoul(hdr->length); 6819 avail_len = valid_len - sizeof(*hdr); 6820 if (field_size > avail_len) { 6821 if (error_str != NULL) { 6822 snprintf(error_str, error_str_len, "Available " 6823 "length of attribute ID 0x%.4x %zu < field " 6824 "length %u", scsi_2btoul(hdr->id), avail_len, 6825 field_size); 6826 } 6827 retval = 1; 6828 goto bailout; 6829 } else if (field_size == 0) { 6830 /* 6831 * A field size of 0 doesn't make sense here. The device 6832 * can at least give you the vendor ID, even if it can't 6833 * give you the serial number. 6834 */ 6835 if (error_str != NULL) { 6836 snprintf(error_str, error_str_len, "The length of " 6837 "attribute ID 0x%.4x is 0", 6838 scsi_2btoul(hdr->id)); 6839 } 6840 retval = 1; 6841 goto bailout; 6842 } 6843 vendser = (struct scsi_attrib_vendser *)hdr->attribute; 6844 6845 switch (output_flags & SCSI_ATTR_OUTPUT_NONASCII_MASK) { 6846 case SCSI_ATTR_OUTPUT_NONASCII_TRIM: 6847 strvis_flags = CAM_STRVIS_FLAG_NONASCII_TRIM; 6848 break; 6849 case SCSI_ATTR_OUTPUT_NONASCII_RAW: 6850 strvis_flags = CAM_STRVIS_FLAG_NONASCII_RAW; 6851 break; 6852 case SCSI_ATTR_OUTPUT_NONASCII_ESC: 6853 default: 6854 strvis_flags = CAM_STRVIS_FLAG_NONASCII_ESC; 6855 break;; 6856 } 6857 cam_strvis_sbuf(sb, vendser->vendor, sizeof(vendser->vendor), 6858 strvis_flags); 6859 sbuf_putc(sb, ' '); 6860 cam_strvis_sbuf(sb, vendser->serial_num, sizeof(vendser->serial_num), 6861 strvis_flags); 6862bailout: 6863 return (retval); 6864} 6865 6866int 6867scsi_attrib_hexdump_sbuf(struct sbuf *sb, struct scsi_mam_attribute_header *hdr, 6868 uint32_t valid_len, uint32_t flags, 6869 uint32_t output_flags, char *error_str, 6870 int error_str_len) 6871{ 6872 uint32_t field_size; 6873 ssize_t avail_len; 6874 uint32_t print_len; 6875 uint8_t *num_ptr; 6876 int retval = 0; 6877 6878 field_size = scsi_2btoul(hdr->length); 6879 avail_len = valid_len - sizeof(*hdr); 6880 print_len = MIN(avail_len, field_size); 6881 num_ptr = hdr->attribute; 6882 6883 if (print_len > 0) { 6884 sbuf_printf(sb, "\n"); 6885 sbuf_hexdump(sb, num_ptr, print_len, NULL, 0); 6886 } 6887 6888 return (retval); 6889} 6890 6891int 6892scsi_attrib_int_sbuf(struct sbuf *sb, struct scsi_mam_attribute_header *hdr, 6893 uint32_t valid_len, uint32_t flags, 6894 uint32_t output_flags, char *error_str, 6895 int error_str_len) 6896{ 6897 uint64_t print_number; 6898 size_t avail_len; 6899 uint32_t number_size; 6900 int retval = 0; 6901 6902 number_size = scsi_2btoul(hdr->length); 6903 6904 avail_len = valid_len - sizeof(*hdr); 6905 if (avail_len < number_size) { 6906 if (error_str != NULL) { 6907 snprintf(error_str, error_str_len, "Available " 6908 "length of attribute ID 0x%.4x %zu < field " 6909 "length %u", scsi_2btoul(hdr->id), avail_len, 6910 number_size); 6911 } 6912 retval = 1; 6913 goto bailout; 6914 } 6915 6916 switch (number_size) { 6917 case 0: 6918 /* 6919 * We don't treat this as an error, since there may be 6920 * scenarios where a device reports a field but then gives 6921 * a length of 0. See the note in scsi_attrib_ascii_sbuf(). 6922 */ 6923 goto bailout; 6924 break; /*NOTREACHED*/ 6925 case 1: 6926 print_number = hdr->attribute[0]; 6927 break; 6928 case 2: 6929 print_number = scsi_2btoul(hdr->attribute); 6930 break; 6931 case 3: 6932 print_number = scsi_3btoul(hdr->attribute); 6933 break; 6934 case 4: 6935 print_number = scsi_4btoul(hdr->attribute); 6936 break; 6937 case 8: 6938 print_number = scsi_8btou64(hdr->attribute); 6939 break; 6940 default: 6941 /* 6942 * If we wind up here, the number is too big to print 6943 * normally, so just do a hexdump. 6944 */ 6945 retval = scsi_attrib_hexdump_sbuf(sb, hdr, valid_len, 6946 flags, output_flags, 6947 error_str, error_str_len); 6948 goto bailout; 6949 break; 6950 } 6951 6952 if (flags & SCSI_ATTR_FLAG_FP) { 6953#ifndef _KERNEL 6954 long double num_float; 6955 6956 num_float = (long double)print_number; 6957 6958 if (flags & SCSI_ATTR_FLAG_DIV_10) 6959 num_float /= 10; 6960 6961 sbuf_printf(sb, "%.*Lf", (flags & SCSI_ATTR_FLAG_FP_1DIGIT) ? 6962 1 : 0, num_float); 6963#else /* _KERNEL */ 6964 sbuf_printf(sb, "%ju", (flags & SCSI_ATTR_FLAG_DIV_10) ? 6965 (print_number / 10) : print_number); 6966#endif /* _KERNEL */ 6967 } else if (flags & SCSI_ATTR_FLAG_HEX) { 6968 sbuf_printf(sb, "0x%jx", (uintmax_t)print_number); 6969 } else 6970 sbuf_printf(sb, "%ju", (uintmax_t)print_number); 6971 6972bailout: 6973 return (retval); 6974} 6975 6976int 6977scsi_attrib_ascii_sbuf(struct sbuf *sb, struct scsi_mam_attribute_header *hdr, 6978 uint32_t valid_len, uint32_t flags, 6979 uint32_t output_flags, char *error_str, 6980 int error_str_len) 6981{ 6982 size_t avail_len; 6983 uint32_t field_size, print_size; 6984 int retval = 0; 6985 6986 avail_len = valid_len - sizeof(*hdr); 6987 field_size = scsi_2btoul(hdr->length); 6988 print_size = MIN(avail_len, field_size); 6989 6990 if (print_size > 0) { 6991 cam_strvis_flags strvis_flags; 6992 6993 switch (output_flags & SCSI_ATTR_OUTPUT_NONASCII_MASK) { 6994 case SCSI_ATTR_OUTPUT_NONASCII_TRIM: 6995 strvis_flags = CAM_STRVIS_FLAG_NONASCII_TRIM; 6996 break; 6997 case SCSI_ATTR_OUTPUT_NONASCII_RAW: 6998 strvis_flags = CAM_STRVIS_FLAG_NONASCII_RAW; 6999 break; 7000 case SCSI_ATTR_OUTPUT_NONASCII_ESC: 7001 default: 7002 strvis_flags = CAM_STRVIS_FLAG_NONASCII_ESC; 7003 break; 7004 } 7005 cam_strvis_sbuf(sb, hdr->attribute, print_size, strvis_flags); 7006 } else if (avail_len < field_size) { 7007 /* 7008 * We only report an error if the user didn't allocate 7009 * enough space to hold the full value of this field. If 7010 * the field length is 0, that is allowed by the spec. 7011 * e.g. in SPC-4r37, section 7.4.2.2.5, VOLUME IDENTIFIER 7012 * "This attribute indicates the current volume identifier 7013 * (see SMC-3) of the medium. If the device server supports 7014 * this attribute but does not have access to the volume 7015 * identifier, the device server shall report this attribute 7016 * with an attribute length value of zero." 7017 */ 7018 if (error_str != NULL) { 7019 snprintf(error_str, error_str_len, "Available " 7020 "length of attribute ID 0x%.4x %zu < field " 7021 "length %u", scsi_2btoul(hdr->id), avail_len, 7022 field_size); 7023 } 7024 retval = 1; 7025 } 7026 7027 return (retval); 7028} 7029 7030int 7031scsi_attrib_text_sbuf(struct sbuf *sb, struct scsi_mam_attribute_header *hdr, 7032 uint32_t valid_len, uint32_t flags, 7033 uint32_t output_flags, char *error_str, 7034 int error_str_len) 7035{ 7036 size_t avail_len; 7037 uint32_t field_size, print_size; 7038 int retval = 0; 7039 int esc_text = 1; 7040 7041 avail_len = valid_len - sizeof(*hdr); 7042 field_size = scsi_2btoul(hdr->length); 7043 print_size = MIN(avail_len, field_size); 7044 7045 if ((output_flags & SCSI_ATTR_OUTPUT_TEXT_MASK) == 7046 SCSI_ATTR_OUTPUT_TEXT_RAW) 7047 esc_text = 0; 7048 7049 if (print_size > 0) { 7050 uint32_t i; 7051 7052 for (i = 0; i < print_size; i++) { 7053 if (hdr->attribute[i] == '\0') 7054 continue; 7055 else if (((unsigned char)hdr->attribute[i] < 0x80) 7056 || (esc_text == 0)) 7057 sbuf_putc(sb, hdr->attribute[i]); 7058 else 7059 sbuf_printf(sb, "%%%02x", 7060 (unsigned char)hdr->attribute[i]); 7061 } 7062 } else if (avail_len < field_size) { 7063 /* 7064 * We only report an error if the user didn't allocate 7065 * enough space to hold the full value of this field. 7066 */ 7067 if (error_str != NULL) { 7068 snprintf(error_str, error_str_len, "Available " 7069 "length of attribute ID 0x%.4x %zu < field " 7070 "length %u", scsi_2btoul(hdr->id), avail_len, 7071 field_size); 7072 } 7073 retval = 1; 7074 } 7075 7076 return (retval); 7077} 7078 7079struct scsi_attrib_table_entry * 7080scsi_find_attrib_entry(struct scsi_attrib_table_entry *table, 7081 size_t num_table_entries, uint32_t id) 7082{ 7083 uint32_t i; 7084 7085 for (i = 0; i < num_table_entries; i++) { 7086 if (table[i].id == id) 7087 return (&table[i]); 7088 } 7089 7090 return (NULL); 7091} 7092 7093struct scsi_attrib_table_entry * 7094scsi_get_attrib_entry(uint32_t id) 7095{ 7096 return (scsi_find_attrib_entry(scsi_mam_attr_table, 7097 sizeof(scsi_mam_attr_table) / sizeof(scsi_mam_attr_table[0]), 7098 id)); 7099} 7100 7101int 7102scsi_attrib_value_sbuf(struct sbuf *sb, uint32_t valid_len, 7103 struct scsi_mam_attribute_header *hdr, uint32_t output_flags, 7104 char *error_str, size_t error_str_len) 7105{ 7106 int retval; 7107 7108 switch (hdr->byte2 & SMA_FORMAT_MASK) { 7109 case SMA_FORMAT_ASCII: 7110 retval = scsi_attrib_ascii_sbuf(sb, hdr, valid_len, 7111 SCSI_ATTR_FLAG_NONE, output_flags, error_str,error_str_len); 7112 break; 7113 case SMA_FORMAT_BINARY: 7114 if (scsi_2btoul(hdr->length) <= 8) 7115 retval = scsi_attrib_int_sbuf(sb, hdr, valid_len, 7116 SCSI_ATTR_FLAG_NONE, output_flags, error_str, 7117 error_str_len); 7118 else 7119 retval = scsi_attrib_hexdump_sbuf(sb, hdr, valid_len, 7120 SCSI_ATTR_FLAG_NONE, output_flags, error_str, 7121 error_str_len); 7122 break; 7123 case SMA_FORMAT_TEXT: 7124 retval = scsi_attrib_text_sbuf(sb, hdr, valid_len, 7125 SCSI_ATTR_FLAG_NONE, output_flags, error_str, 7126 error_str_len); 7127 break; 7128 default: 7129 if (error_str != NULL) { 7130 snprintf(error_str, error_str_len, "Unknown attribute " 7131 "format 0x%x", hdr->byte2 & SMA_FORMAT_MASK); 7132 } 7133 retval = 1; 7134 goto bailout; 7135 break; /*NOTREACHED*/ 7136 } 7137 7138 sbuf_trim(sb); 7139 7140bailout: 7141 7142 return (retval); 7143} 7144 7145void 7146scsi_attrib_prefix_sbuf(struct sbuf *sb, uint32_t output_flags, 7147 struct scsi_mam_attribute_header *hdr, 7148 uint32_t valid_len, const char *desc) 7149{ 7150 int need_space = 0; 7151 uint32_t len; 7152 uint32_t id; 7153 7154 /* 7155 * We can't do anything if we don't have enough valid data for the 7156 * header. 7157 */ 7158 if (valid_len < sizeof(*hdr)) 7159 return; 7160 7161 id = scsi_2btoul(hdr->id); 7162 /* 7163 * Note that we print out the value of the attribute listed in the 7164 * header, regardless of whether we actually got that many bytes 7165 * back from the device through the controller. A truncated result 7166 * could be the result of a failure to ask for enough data; the 7167 * header indicates how many bytes are allocated for this attribute 7168 * in the MAM. 7169 */ 7170 len = scsi_2btoul(hdr->length); 7171 7172 if ((output_flags & SCSI_ATTR_OUTPUT_FIELD_MASK) == 7173 SCSI_ATTR_OUTPUT_FIELD_NONE) 7174 return; 7175 7176 if ((output_flags & SCSI_ATTR_OUTPUT_FIELD_DESC) 7177 && (desc != NULL)) { 7178 sbuf_printf(sb, "%s", desc); 7179 need_space = 1; 7180 } 7181 7182 if (output_flags & SCSI_ATTR_OUTPUT_FIELD_NUM) { 7183 sbuf_printf(sb, "%s(0x%.4x)", (need_space) ? " " : "", id); 7184 need_space = 0; 7185 } 7186 7187 if (output_flags & SCSI_ATTR_OUTPUT_FIELD_SIZE) { 7188 sbuf_printf(sb, "%s[%d]", (need_space) ? " " : "", len); 7189 need_space = 0; 7190 } 7191 if (output_flags & SCSI_ATTR_OUTPUT_FIELD_RW) { 7192 sbuf_printf(sb, "%s(%s)", (need_space) ? " " : "", 7193 (hdr->byte2 & SMA_READ_ONLY) ? "RO" : "RW"); 7194 } 7195 sbuf_printf(sb, ": "); 7196} 7197 7198int 7199scsi_attrib_sbuf(struct sbuf *sb, struct scsi_mam_attribute_header *hdr, 7200 uint32_t valid_len, struct scsi_attrib_table_entry *user_table, 7201 size_t num_user_entries, int prefer_user_table, 7202 uint32_t output_flags, char *error_str, int error_str_len) 7203{ 7204 int retval; 7205 struct scsi_attrib_table_entry *table1 = NULL, *table2 = NULL; 7206 struct scsi_attrib_table_entry *entry = NULL; 7207 size_t table1_size = 0, table2_size = 0; 7208 uint32_t id; 7209 7210 retval = 0; 7211 7212 if (valid_len < sizeof(*hdr)) { 7213 retval = 1; 7214 goto bailout; 7215 } 7216 7217 id = scsi_2btoul(hdr->id); 7218 7219 if (user_table != NULL) { 7220 if (prefer_user_table != 0) { 7221 table1 = user_table; 7222 table1_size = num_user_entries; 7223 table2 = scsi_mam_attr_table; 7224 table2_size = sizeof(scsi_mam_attr_table) / 7225 sizeof(scsi_mam_attr_table[0]); 7226 } else { 7227 table1 = scsi_mam_attr_table; 7228 table1_size = sizeof(scsi_mam_attr_table) / 7229 sizeof(scsi_mam_attr_table[0]); 7230 table2 = user_table; 7231 table2_size = num_user_entries; 7232 } 7233 } else { 7234 table1 = scsi_mam_attr_table; 7235 table1_size = sizeof(scsi_mam_attr_table) / 7236 sizeof(scsi_mam_attr_table[0]); 7237 } 7238 7239 entry = scsi_find_attrib_entry(table1, table1_size, id); 7240 if (entry != NULL) { 7241 scsi_attrib_prefix_sbuf(sb, output_flags, hdr, valid_len, 7242 entry->desc); 7243 if (entry->to_str == NULL) 7244 goto print_default; 7245 retval = entry->to_str(sb, hdr, valid_len, entry->flags, 7246 output_flags, error_str, error_str_len); 7247 goto bailout; 7248 } 7249 if (table2 != NULL) { 7250 entry = scsi_find_attrib_entry(table2, table2_size, id); 7251 if (entry != NULL) { 7252 if (entry->to_str == NULL) 7253 goto print_default; 7254 7255 scsi_attrib_prefix_sbuf(sb, output_flags, hdr, 7256 valid_len, entry->desc); 7257 retval = entry->to_str(sb, hdr, valid_len, entry->flags, 7258 output_flags, error_str, 7259 error_str_len); 7260 goto bailout; 7261 } 7262 } 7263 7264 scsi_attrib_prefix_sbuf(sb, output_flags, hdr, valid_len, NULL); 7265 7266print_default: 7267 retval = scsi_attrib_value_sbuf(sb, valid_len, hdr, output_flags, 7268 error_str, error_str_len); 7269bailout: 7270 if (retval == 0) { 7271 if ((entry != NULL) 7272 && (entry->suffix != NULL)) 7273 sbuf_printf(sb, " %s", entry->suffix); 7274 7275 sbuf_trim(sb); 7276 sbuf_printf(sb, "\n"); 7277 } 7278 7279 return (retval); 7280} 7281 7282void 7283scsi_test_unit_ready(struct ccb_scsiio *csio, u_int32_t retries, 7284 void (*cbfcnp)(struct cam_periph *, union ccb *), 7285 u_int8_t tag_action, u_int8_t sense_len, u_int32_t timeout) 7286{ 7287 struct scsi_test_unit_ready *scsi_cmd; 7288 7289 cam_fill_csio(csio, 7290 retries, 7291 cbfcnp, 7292 CAM_DIR_NONE, 7293 tag_action, 7294 /*data_ptr*/NULL, 7295 /*dxfer_len*/0, 7296 sense_len, 7297 sizeof(*scsi_cmd), 7298 timeout); 7299 7300 scsi_cmd = (struct scsi_test_unit_ready *)&csio->cdb_io.cdb_bytes; 7301 bzero(scsi_cmd, sizeof(*scsi_cmd)); 7302 scsi_cmd->opcode = TEST_UNIT_READY; 7303} 7304 7305void 7306scsi_request_sense(struct ccb_scsiio *csio, u_int32_t retries, 7307 void (*cbfcnp)(struct cam_periph *, union ccb *), 7308 void *data_ptr, u_int8_t dxfer_len, u_int8_t tag_action, 7309 u_int8_t sense_len, u_int32_t timeout) 7310{ 7311 struct scsi_request_sense *scsi_cmd; 7312 7313 cam_fill_csio(csio, 7314 retries, 7315 cbfcnp, 7316 CAM_DIR_IN, 7317 tag_action, 7318 data_ptr, 7319 dxfer_len, 7320 sense_len, 7321 sizeof(*scsi_cmd), 7322 timeout); 7323 7324 scsi_cmd = (struct scsi_request_sense *)&csio->cdb_io.cdb_bytes; 7325 bzero(scsi_cmd, sizeof(*scsi_cmd)); 7326 scsi_cmd->opcode = REQUEST_SENSE; 7327 scsi_cmd->length = dxfer_len; 7328} 7329 7330void 7331scsi_inquiry(struct ccb_scsiio *csio, u_int32_t retries, 7332 void (*cbfcnp)(struct cam_periph *, union ccb *), 7333 u_int8_t tag_action, u_int8_t *inq_buf, u_int32_t inq_len, 7334 int evpd, u_int8_t page_code, u_int8_t sense_len, 7335 u_int32_t timeout) 7336{ 7337 struct scsi_inquiry *scsi_cmd; 7338 7339 cam_fill_csio(csio, 7340 retries, 7341 cbfcnp, 7342 /*flags*/CAM_DIR_IN, 7343 tag_action, 7344 /*data_ptr*/inq_buf, 7345 /*dxfer_len*/inq_len, 7346 sense_len, 7347 sizeof(*scsi_cmd), 7348 timeout); 7349 7350 scsi_cmd = (struct scsi_inquiry *)&csio->cdb_io.cdb_bytes; 7351 bzero(scsi_cmd, sizeof(*scsi_cmd)); 7352 scsi_cmd->opcode = INQUIRY; 7353 if (evpd) { 7354 scsi_cmd->byte2 |= SI_EVPD; 7355 scsi_cmd->page_code = page_code; 7356 } 7357 scsi_ulto2b(inq_len, scsi_cmd->length); 7358} 7359 7360void 7361scsi_mode_sense(struct ccb_scsiio *csio, u_int32_t retries, 7362 void (*cbfcnp)(struct cam_periph *, union ccb *), 7363 u_int8_t tag_action, int dbd, u_int8_t page_code, 7364 u_int8_t page, u_int8_t *param_buf, u_int32_t param_len, 7365 u_int8_t sense_len, u_int32_t timeout) 7366{ 7367 7368 scsi_mode_sense_len(csio, retries, cbfcnp, tag_action, dbd, 7369 page_code, page, param_buf, param_len, 0, 7370 sense_len, timeout); 7371} 7372 7373void 7374scsi_mode_sense_len(struct ccb_scsiio *csio, u_int32_t retries, 7375 void (*cbfcnp)(struct cam_periph *, union ccb *), 7376 u_int8_t tag_action, int dbd, u_int8_t page_code, 7377 u_int8_t page, u_int8_t *param_buf, u_int32_t param_len, 7378 int minimum_cmd_size, u_int8_t sense_len, u_int32_t timeout) 7379{ 7380 u_int8_t cdb_len; 7381 7382 /* 7383 * Use the smallest possible command to perform the operation. 7384 */ 7385 if ((param_len < 256) 7386 && (minimum_cmd_size < 10)) { 7387 /* 7388 * We can fit in a 6 byte cdb. 7389 */ 7390 struct scsi_mode_sense_6 *scsi_cmd; 7391 7392 scsi_cmd = (struct scsi_mode_sense_6 *)&csio->cdb_io.cdb_bytes; 7393 bzero(scsi_cmd, sizeof(*scsi_cmd)); 7394 scsi_cmd->opcode = MODE_SENSE_6; 7395 if (dbd != 0) 7396 scsi_cmd->byte2 |= SMS_DBD; 7397 scsi_cmd->page = page_code | page; 7398 scsi_cmd->length = param_len; 7399 cdb_len = sizeof(*scsi_cmd); 7400 } else { 7401 /* 7402 * Need a 10 byte cdb. 7403 */ 7404 struct scsi_mode_sense_10 *scsi_cmd; 7405 7406 scsi_cmd = (struct scsi_mode_sense_10 *)&csio->cdb_io.cdb_bytes; 7407 bzero(scsi_cmd, sizeof(*scsi_cmd)); 7408 scsi_cmd->opcode = MODE_SENSE_10; 7409 if (dbd != 0) 7410 scsi_cmd->byte2 |= SMS_DBD; 7411 scsi_cmd->page = page_code | page; 7412 scsi_ulto2b(param_len, scsi_cmd->length); 7413 cdb_len = sizeof(*scsi_cmd); 7414 } 7415 cam_fill_csio(csio, 7416 retries, 7417 cbfcnp, 7418 CAM_DIR_IN, 7419 tag_action, 7420 param_buf, 7421 param_len, 7422 sense_len, 7423 cdb_len, 7424 timeout); 7425} 7426 7427void 7428scsi_mode_select(struct ccb_scsiio *csio, u_int32_t retries, 7429 void (*cbfcnp)(struct cam_periph *, union ccb *), 7430 u_int8_t tag_action, int scsi_page_fmt, int save_pages, 7431 u_int8_t *param_buf, u_int32_t param_len, u_int8_t sense_len, 7432 u_int32_t timeout) 7433{ 7434 scsi_mode_select_len(csio, retries, cbfcnp, tag_action, 7435 scsi_page_fmt, save_pages, param_buf, 7436 param_len, 0, sense_len, timeout); 7437} 7438 7439void 7440scsi_mode_select_len(struct ccb_scsiio *csio, u_int32_t retries, 7441 void (*cbfcnp)(struct cam_periph *, union ccb *), 7442 u_int8_t tag_action, int scsi_page_fmt, int save_pages, 7443 u_int8_t *param_buf, u_int32_t param_len, 7444 int minimum_cmd_size, u_int8_t sense_len, 7445 u_int32_t timeout) 7446{ 7447 u_int8_t cdb_len; 7448 7449 /* 7450 * Use the smallest possible command to perform the operation. 7451 */ 7452 if ((param_len < 256) 7453 && (minimum_cmd_size < 10)) { 7454 /* 7455 * We can fit in a 6 byte cdb. 7456 */ 7457 struct scsi_mode_select_6 *scsi_cmd; 7458 7459 scsi_cmd = (struct scsi_mode_select_6 *)&csio->cdb_io.cdb_bytes; 7460 bzero(scsi_cmd, sizeof(*scsi_cmd)); 7461 scsi_cmd->opcode = MODE_SELECT_6; 7462 if (scsi_page_fmt != 0) 7463 scsi_cmd->byte2 |= SMS_PF; 7464 if (save_pages != 0) 7465 scsi_cmd->byte2 |= SMS_SP; 7466 scsi_cmd->length = param_len; 7467 cdb_len = sizeof(*scsi_cmd); 7468 } else { 7469 /* 7470 * Need a 10 byte cdb. 7471 */ 7472 struct scsi_mode_select_10 *scsi_cmd; 7473 7474 scsi_cmd = 7475 (struct scsi_mode_select_10 *)&csio->cdb_io.cdb_bytes; 7476 bzero(scsi_cmd, sizeof(*scsi_cmd)); 7477 scsi_cmd->opcode = MODE_SELECT_10; 7478 if (scsi_page_fmt != 0) 7479 scsi_cmd->byte2 |= SMS_PF; 7480 if (save_pages != 0) 7481 scsi_cmd->byte2 |= SMS_SP; 7482 scsi_ulto2b(param_len, scsi_cmd->length); 7483 cdb_len = sizeof(*scsi_cmd); 7484 } 7485 cam_fill_csio(csio, 7486 retries, 7487 cbfcnp, 7488 CAM_DIR_OUT, 7489 tag_action, 7490 param_buf, 7491 param_len, 7492 sense_len, 7493 cdb_len, 7494 timeout); 7495} 7496 7497void 7498scsi_log_sense(struct ccb_scsiio *csio, u_int32_t retries, 7499 void (*cbfcnp)(struct cam_periph *, union ccb *), 7500 u_int8_t tag_action, u_int8_t page_code, u_int8_t page, 7501 int save_pages, int ppc, u_int32_t paramptr, 7502 u_int8_t *param_buf, u_int32_t param_len, u_int8_t sense_len, 7503 u_int32_t timeout) 7504{ 7505 struct scsi_log_sense *scsi_cmd; 7506 u_int8_t cdb_len; 7507 7508 scsi_cmd = (struct scsi_log_sense *)&csio->cdb_io.cdb_bytes; 7509 bzero(scsi_cmd, sizeof(*scsi_cmd)); 7510 scsi_cmd->opcode = LOG_SENSE; 7511 scsi_cmd->page = page_code | page; 7512 if (save_pages != 0) 7513 scsi_cmd->byte2 |= SLS_SP; 7514 if (ppc != 0) 7515 scsi_cmd->byte2 |= SLS_PPC; 7516 scsi_ulto2b(paramptr, scsi_cmd->paramptr); 7517 scsi_ulto2b(param_len, scsi_cmd->length); 7518 cdb_len = sizeof(*scsi_cmd); 7519 7520 cam_fill_csio(csio, 7521 retries, 7522 cbfcnp, 7523 /*flags*/CAM_DIR_IN, 7524 tag_action, 7525 /*data_ptr*/param_buf, 7526 /*dxfer_len*/param_len, 7527 sense_len, 7528 cdb_len, 7529 timeout); 7530} 7531 7532void 7533scsi_log_select(struct ccb_scsiio *csio, u_int32_t retries, 7534 void (*cbfcnp)(struct cam_periph *, union ccb *), 7535 u_int8_t tag_action, u_int8_t page_code, int save_pages, 7536 int pc_reset, u_int8_t *param_buf, u_int32_t param_len, 7537 u_int8_t sense_len, u_int32_t timeout) 7538{ 7539 struct scsi_log_select *scsi_cmd; 7540 u_int8_t cdb_len; 7541 7542 scsi_cmd = (struct scsi_log_select *)&csio->cdb_io.cdb_bytes; 7543 bzero(scsi_cmd, sizeof(*scsi_cmd)); 7544 scsi_cmd->opcode = LOG_SELECT; 7545 scsi_cmd->page = page_code & SLS_PAGE_CODE; 7546 if (save_pages != 0) 7547 scsi_cmd->byte2 |= SLS_SP; 7548 if (pc_reset != 0) 7549 scsi_cmd->byte2 |= SLS_PCR; 7550 scsi_ulto2b(param_len, scsi_cmd->length); 7551 cdb_len = sizeof(*scsi_cmd); 7552 7553 cam_fill_csio(csio, 7554 retries, 7555 cbfcnp, 7556 /*flags*/CAM_DIR_OUT, 7557 tag_action, 7558 /*data_ptr*/param_buf, 7559 /*dxfer_len*/param_len, 7560 sense_len, 7561 cdb_len, 7562 timeout); 7563} 7564 7565/* 7566 * Prevent or allow the user to remove the media 7567 */ 7568void 7569scsi_prevent(struct ccb_scsiio *csio, u_int32_t retries, 7570 void (*cbfcnp)(struct cam_periph *, union ccb *), 7571 u_int8_t tag_action, u_int8_t action, 7572 u_int8_t sense_len, u_int32_t timeout) 7573{ 7574 struct scsi_prevent *scsi_cmd; 7575 7576 cam_fill_csio(csio, 7577 retries, 7578 cbfcnp, 7579 /*flags*/CAM_DIR_NONE, 7580 tag_action, 7581 /*data_ptr*/NULL, 7582 /*dxfer_len*/0, 7583 sense_len, 7584 sizeof(*scsi_cmd), 7585 timeout); 7586 7587 scsi_cmd = (struct scsi_prevent *)&csio->cdb_io.cdb_bytes; 7588 bzero(scsi_cmd, sizeof(*scsi_cmd)); 7589 scsi_cmd->opcode = PREVENT_ALLOW; 7590 scsi_cmd->how = action; 7591} 7592 7593/* XXX allow specification of address and PMI bit and LBA */ 7594void 7595scsi_read_capacity(struct ccb_scsiio *csio, u_int32_t retries, 7596 void (*cbfcnp)(struct cam_periph *, union ccb *), 7597 u_int8_t tag_action, 7598 struct scsi_read_capacity_data *rcap_buf, 7599 u_int8_t sense_len, u_int32_t timeout) 7600{ 7601 struct scsi_read_capacity *scsi_cmd; 7602 7603 cam_fill_csio(csio, 7604 retries, 7605 cbfcnp, 7606 /*flags*/CAM_DIR_IN, 7607 tag_action, 7608 /*data_ptr*/(u_int8_t *)rcap_buf, 7609 /*dxfer_len*/sizeof(*rcap_buf), 7610 sense_len, 7611 sizeof(*scsi_cmd), 7612 timeout); 7613 7614 scsi_cmd = (struct scsi_read_capacity *)&csio->cdb_io.cdb_bytes; 7615 bzero(scsi_cmd, sizeof(*scsi_cmd)); 7616 scsi_cmd->opcode = READ_CAPACITY; 7617} 7618 7619void 7620scsi_read_capacity_16(struct ccb_scsiio *csio, uint32_t retries, 7621 void (*cbfcnp)(struct cam_periph *, union ccb *), 7622 uint8_t tag_action, uint64_t lba, int reladr, int pmi, 7623 uint8_t *rcap_buf, int rcap_buf_len, uint8_t sense_len, 7624 uint32_t timeout) 7625{ 7626 struct scsi_read_capacity_16 *scsi_cmd; 7627 7628 7629 cam_fill_csio(csio, 7630 retries, 7631 cbfcnp, 7632 /*flags*/CAM_DIR_IN, 7633 tag_action, 7634 /*data_ptr*/(u_int8_t *)rcap_buf, 7635 /*dxfer_len*/rcap_buf_len, 7636 sense_len, 7637 sizeof(*scsi_cmd), 7638 timeout); 7639 scsi_cmd = (struct scsi_read_capacity_16 *)&csio->cdb_io.cdb_bytes; 7640 bzero(scsi_cmd, sizeof(*scsi_cmd)); 7641 scsi_cmd->opcode = SERVICE_ACTION_IN; 7642 scsi_cmd->service_action = SRC16_SERVICE_ACTION; 7643 scsi_u64to8b(lba, scsi_cmd->addr); 7644 scsi_ulto4b(rcap_buf_len, scsi_cmd->alloc_len); 7645 if (pmi) 7646 reladr |= SRC16_PMI; 7647 if (reladr) 7648 reladr |= SRC16_RELADR; 7649} 7650 7651void 7652scsi_report_luns(struct ccb_scsiio *csio, u_int32_t retries, 7653 void (*cbfcnp)(struct cam_periph *, union ccb *), 7654 u_int8_t tag_action, u_int8_t select_report, 7655 struct scsi_report_luns_data *rpl_buf, u_int32_t alloc_len, 7656 u_int8_t sense_len, u_int32_t timeout) 7657{ 7658 struct scsi_report_luns *scsi_cmd; 7659 7660 cam_fill_csio(csio, 7661 retries, 7662 cbfcnp, 7663 /*flags*/CAM_DIR_IN, 7664 tag_action, 7665 /*data_ptr*/(u_int8_t *)rpl_buf, 7666 /*dxfer_len*/alloc_len, 7667 sense_len, 7668 sizeof(*scsi_cmd), 7669 timeout); 7670 scsi_cmd = (struct scsi_report_luns *)&csio->cdb_io.cdb_bytes; 7671 bzero(scsi_cmd, sizeof(*scsi_cmd)); 7672 scsi_cmd->opcode = REPORT_LUNS; 7673 scsi_cmd->select_report = select_report; 7674 scsi_ulto4b(alloc_len, scsi_cmd->length); 7675} 7676 7677void 7678scsi_report_target_group(struct ccb_scsiio *csio, u_int32_t retries, 7679 void (*cbfcnp)(struct cam_periph *, union ccb *), 7680 u_int8_t tag_action, u_int8_t pdf, 7681 void *buf, u_int32_t alloc_len, 7682 u_int8_t sense_len, u_int32_t timeout) 7683{ 7684 struct scsi_target_group *scsi_cmd; 7685 7686 cam_fill_csio(csio, 7687 retries, 7688 cbfcnp, 7689 /*flags*/CAM_DIR_IN, 7690 tag_action, 7691 /*data_ptr*/(u_int8_t *)buf, 7692 /*dxfer_len*/alloc_len, 7693 sense_len, 7694 sizeof(*scsi_cmd), 7695 timeout); 7696 scsi_cmd = (struct scsi_target_group *)&csio->cdb_io.cdb_bytes; 7697 bzero(scsi_cmd, sizeof(*scsi_cmd)); 7698 scsi_cmd->opcode = MAINTENANCE_IN; 7699 scsi_cmd->service_action = REPORT_TARGET_PORT_GROUPS | pdf; 7700 scsi_ulto4b(alloc_len, scsi_cmd->length); 7701} 7702 7703void 7704scsi_set_target_group(struct ccb_scsiio *csio, u_int32_t retries, 7705 void (*cbfcnp)(struct cam_periph *, union ccb *), 7706 u_int8_t tag_action, void *buf, u_int32_t alloc_len, 7707 u_int8_t sense_len, u_int32_t timeout) 7708{ 7709 struct scsi_target_group *scsi_cmd; 7710 7711 cam_fill_csio(csio, 7712 retries, 7713 cbfcnp, 7714 /*flags*/CAM_DIR_OUT, 7715 tag_action, 7716 /*data_ptr*/(u_int8_t *)buf, 7717 /*dxfer_len*/alloc_len, 7718 sense_len, 7719 sizeof(*scsi_cmd), 7720 timeout); 7721 scsi_cmd = (struct scsi_target_group *)&csio->cdb_io.cdb_bytes; 7722 bzero(scsi_cmd, sizeof(*scsi_cmd)); 7723 scsi_cmd->opcode = MAINTENANCE_OUT; 7724 scsi_cmd->service_action = SET_TARGET_PORT_GROUPS; 7725 scsi_ulto4b(alloc_len, scsi_cmd->length); 7726} 7727 7728/* 7729 * Syncronize the media to the contents of the cache for 7730 * the given lba/count pair. Specifying 0/0 means sync 7731 * the whole cache. 7732 */ 7733void 7734scsi_synchronize_cache(struct ccb_scsiio *csio, u_int32_t retries, 7735 void (*cbfcnp)(struct cam_periph *, union ccb *), 7736 u_int8_t tag_action, u_int32_t begin_lba, 7737 u_int16_t lb_count, u_int8_t sense_len, 7738 u_int32_t timeout) 7739{ 7740 struct scsi_sync_cache *scsi_cmd; 7741 7742 cam_fill_csio(csio, 7743 retries, 7744 cbfcnp, 7745 /*flags*/CAM_DIR_NONE, 7746 tag_action, 7747 /*data_ptr*/NULL, 7748 /*dxfer_len*/0, 7749 sense_len, 7750 sizeof(*scsi_cmd), 7751 timeout); 7752 7753 scsi_cmd = (struct scsi_sync_cache *)&csio->cdb_io.cdb_bytes; 7754 bzero(scsi_cmd, sizeof(*scsi_cmd)); 7755 scsi_cmd->opcode = SYNCHRONIZE_CACHE; 7756 scsi_ulto4b(begin_lba, scsi_cmd->begin_lba); 7757 scsi_ulto2b(lb_count, scsi_cmd->lb_count); 7758} 7759 7760void 7761scsi_read_write(struct ccb_scsiio *csio, u_int32_t retries, 7762 void (*cbfcnp)(struct cam_periph *, union ccb *), 7763 u_int8_t tag_action, int readop, u_int8_t byte2, 7764 int minimum_cmd_size, u_int64_t lba, u_int32_t block_count, 7765 u_int8_t *data_ptr, u_int32_t dxfer_len, u_int8_t sense_len, 7766 u_int32_t timeout) 7767{ 7768 int read; 7769 u_int8_t cdb_len; 7770 7771 read = (readop & SCSI_RW_DIRMASK) == SCSI_RW_READ; 7772 7773 /* 7774 * Use the smallest possible command to perform the operation 7775 * as some legacy hardware does not support the 10 byte commands. 7776 * If any of the bits in byte2 is set, we have to go with a larger 7777 * command. 7778 */ 7779 if ((minimum_cmd_size < 10) 7780 && ((lba & 0x1fffff) == lba) 7781 && ((block_count & 0xff) == block_count) 7782 && (byte2 == 0)) { 7783 /* 7784 * We can fit in a 6 byte cdb. 7785 */ 7786 struct scsi_rw_6 *scsi_cmd; 7787 7788 scsi_cmd = (struct scsi_rw_6 *)&csio->cdb_io.cdb_bytes; 7789 scsi_cmd->opcode = read ? READ_6 : WRITE_6; 7790 scsi_ulto3b(lba, scsi_cmd->addr); 7791 scsi_cmd->length = block_count & 0xff; 7792 scsi_cmd->control = 0; 7793 cdb_len = sizeof(*scsi_cmd); 7794 7795 CAM_DEBUG(csio->ccb_h.path, CAM_DEBUG_SUBTRACE, 7796 ("6byte: %x%x%x:%d:%d\n", scsi_cmd->addr[0], 7797 scsi_cmd->addr[1], scsi_cmd->addr[2], 7798 scsi_cmd->length, dxfer_len)); 7799 } else if ((minimum_cmd_size < 12) 7800 && ((block_count & 0xffff) == block_count) 7801 && ((lba & 0xffffffff) == lba)) { 7802 /* 7803 * Need a 10 byte cdb. 7804 */ 7805 struct scsi_rw_10 *scsi_cmd; 7806 7807 scsi_cmd = (struct scsi_rw_10 *)&csio->cdb_io.cdb_bytes; 7808 scsi_cmd->opcode = read ? READ_10 : WRITE_10; 7809 scsi_cmd->byte2 = byte2; 7810 scsi_ulto4b(lba, scsi_cmd->addr); 7811 scsi_cmd->reserved = 0; 7812 scsi_ulto2b(block_count, scsi_cmd->length); 7813 scsi_cmd->control = 0; 7814 cdb_len = sizeof(*scsi_cmd); 7815 7816 CAM_DEBUG(csio->ccb_h.path, CAM_DEBUG_SUBTRACE, 7817 ("10byte: %x%x%x%x:%x%x: %d\n", scsi_cmd->addr[0], 7818 scsi_cmd->addr[1], scsi_cmd->addr[2], 7819 scsi_cmd->addr[3], scsi_cmd->length[0], 7820 scsi_cmd->length[1], dxfer_len)); 7821 } else if ((minimum_cmd_size < 16) 7822 && ((block_count & 0xffffffff) == block_count) 7823 && ((lba & 0xffffffff) == lba)) { 7824 /* 7825 * The block count is too big for a 10 byte CDB, use a 12 7826 * byte CDB. 7827 */ 7828 struct scsi_rw_12 *scsi_cmd; 7829 7830 scsi_cmd = (struct scsi_rw_12 *)&csio->cdb_io.cdb_bytes; 7831 scsi_cmd->opcode = read ? READ_12 : WRITE_12; 7832 scsi_cmd->byte2 = byte2; 7833 scsi_ulto4b(lba, scsi_cmd->addr); 7834 scsi_cmd->reserved = 0; 7835 scsi_ulto4b(block_count, scsi_cmd->length); 7836 scsi_cmd->control = 0; 7837 cdb_len = sizeof(*scsi_cmd); 7838 7839 CAM_DEBUG(csio->ccb_h.path, CAM_DEBUG_SUBTRACE, 7840 ("12byte: %x%x%x%x:%x%x%x%x: %d\n", scsi_cmd->addr[0], 7841 scsi_cmd->addr[1], scsi_cmd->addr[2], 7842 scsi_cmd->addr[3], scsi_cmd->length[0], 7843 scsi_cmd->length[1], scsi_cmd->length[2], 7844 scsi_cmd->length[3], dxfer_len)); 7845 } else { 7846 /* 7847 * 16 byte CDB. We'll only get here if the LBA is larger 7848 * than 2^32, or if the user asks for a 16 byte command. 7849 */ 7850 struct scsi_rw_16 *scsi_cmd; 7851 7852 scsi_cmd = (struct scsi_rw_16 *)&csio->cdb_io.cdb_bytes; 7853 scsi_cmd->opcode = read ? READ_16 : WRITE_16; 7854 scsi_cmd->byte2 = byte2; 7855 scsi_u64to8b(lba, scsi_cmd->addr); 7856 scsi_cmd->reserved = 0; 7857 scsi_ulto4b(block_count, scsi_cmd->length); 7858 scsi_cmd->control = 0; 7859 cdb_len = sizeof(*scsi_cmd); 7860 } 7861 cam_fill_csio(csio, 7862 retries, 7863 cbfcnp, 7864 (read ? CAM_DIR_IN : CAM_DIR_OUT) | 7865 ((readop & SCSI_RW_BIO) != 0 ? CAM_DATA_BIO : 0), 7866 tag_action, 7867 data_ptr, 7868 dxfer_len, 7869 sense_len, 7870 cdb_len, 7871 timeout); 7872} 7873 7874void 7875scsi_write_same(struct ccb_scsiio *csio, u_int32_t retries, 7876 void (*cbfcnp)(struct cam_periph *, union ccb *), 7877 u_int8_t tag_action, u_int8_t byte2, 7878 int minimum_cmd_size, u_int64_t lba, u_int32_t block_count, 7879 u_int8_t *data_ptr, u_int32_t dxfer_len, u_int8_t sense_len, 7880 u_int32_t timeout) 7881{ 7882 u_int8_t cdb_len; 7883 if ((minimum_cmd_size < 16) && 7884 ((block_count & 0xffff) == block_count) && 7885 ((lba & 0xffffffff) == lba)) { 7886 /* 7887 * Need a 10 byte cdb. 7888 */ 7889 struct scsi_write_same_10 *scsi_cmd; 7890 7891 scsi_cmd = (struct scsi_write_same_10 *)&csio->cdb_io.cdb_bytes; 7892 scsi_cmd->opcode = WRITE_SAME_10; 7893 scsi_cmd->byte2 = byte2; 7894 scsi_ulto4b(lba, scsi_cmd->addr); 7895 scsi_cmd->group = 0; 7896 scsi_ulto2b(block_count, scsi_cmd->length); 7897 scsi_cmd->control = 0; 7898 cdb_len = sizeof(*scsi_cmd); 7899 7900 CAM_DEBUG(csio->ccb_h.path, CAM_DEBUG_SUBTRACE, 7901 ("10byte: %x%x%x%x:%x%x: %d\n", scsi_cmd->addr[0], 7902 scsi_cmd->addr[1], scsi_cmd->addr[2], 7903 scsi_cmd->addr[3], scsi_cmd->length[0], 7904 scsi_cmd->length[1], dxfer_len)); 7905 } else { 7906 /* 7907 * 16 byte CDB. We'll only get here if the LBA is larger 7908 * than 2^32, or if the user asks for a 16 byte command. 7909 */ 7910 struct scsi_write_same_16 *scsi_cmd; 7911 7912 scsi_cmd = (struct scsi_write_same_16 *)&csio->cdb_io.cdb_bytes; 7913 scsi_cmd->opcode = WRITE_SAME_16; 7914 scsi_cmd->byte2 = byte2; 7915 scsi_u64to8b(lba, scsi_cmd->addr); 7916 scsi_ulto4b(block_count, scsi_cmd->length); 7917 scsi_cmd->group = 0; 7918 scsi_cmd->control = 0; 7919 cdb_len = sizeof(*scsi_cmd); 7920 7921 CAM_DEBUG(csio->ccb_h.path, CAM_DEBUG_SUBTRACE, 7922 ("16byte: %x%x%x%x%x%x%x%x:%x%x%x%x: %d\n", 7923 scsi_cmd->addr[0], scsi_cmd->addr[1], 7924 scsi_cmd->addr[2], scsi_cmd->addr[3], 7925 scsi_cmd->addr[4], scsi_cmd->addr[5], 7926 scsi_cmd->addr[6], scsi_cmd->addr[7], 7927 scsi_cmd->length[0], scsi_cmd->length[1], 7928 scsi_cmd->length[2], scsi_cmd->length[3], 7929 dxfer_len)); 7930 } 7931 cam_fill_csio(csio, 7932 retries, 7933 cbfcnp, 7934 /*flags*/CAM_DIR_OUT, 7935 tag_action, 7936 data_ptr, 7937 dxfer_len, 7938 sense_len, 7939 cdb_len, 7940 timeout); 7941} 7942 7943void 7944scsi_ata_identify(struct ccb_scsiio *csio, u_int32_t retries, 7945 void (*cbfcnp)(struct cam_periph *, union ccb *), 7946 u_int8_t tag_action, u_int8_t *data_ptr, 7947 u_int16_t dxfer_len, u_int8_t sense_len, 7948 u_int32_t timeout) 7949{ 7950 scsi_ata_pass_16(csio, 7951 retries, 7952 cbfcnp, 7953 /*flags*/CAM_DIR_IN, 7954 tag_action, 7955 /*protocol*/AP_PROTO_PIO_IN, 7956 /*ata_flags*/AP_FLAG_TDIR_FROM_DEV| 7957 AP_FLAG_BYT_BLOK_BYTES|AP_FLAG_TLEN_SECT_CNT, 7958 /*features*/0, 7959 /*sector_count*/dxfer_len, 7960 /*lba*/0, 7961 /*command*/ATA_ATA_IDENTIFY, 7962 /*control*/0, 7963 data_ptr, 7964 dxfer_len, 7965 sense_len, 7966 timeout); 7967} 7968 7969void 7970scsi_ata_trim(struct ccb_scsiio *csio, u_int32_t retries, 7971 void (*cbfcnp)(struct cam_periph *, union ccb *), 7972 u_int8_t tag_action, u_int16_t block_count, 7973 u_int8_t *data_ptr, u_int16_t dxfer_len, u_int8_t sense_len, 7974 u_int32_t timeout) 7975{ 7976 scsi_ata_pass_16(csio, 7977 retries, 7978 cbfcnp, 7979 /*flags*/CAM_DIR_OUT, 7980 tag_action, 7981 /*protocol*/AP_EXTEND|AP_PROTO_DMA, 7982 /*ata_flags*/AP_FLAG_TLEN_SECT_CNT|AP_FLAG_BYT_BLOK_BLOCKS, 7983 /*features*/ATA_DSM_TRIM, 7984 /*sector_count*/block_count, 7985 /*lba*/0, 7986 /*command*/ATA_DATA_SET_MANAGEMENT, 7987 /*control*/0, 7988 data_ptr, 7989 dxfer_len, 7990 sense_len, 7991 timeout); 7992} 7993 7994void 7995scsi_ata_pass_16(struct ccb_scsiio *csio, u_int32_t retries, 7996 void (*cbfcnp)(struct cam_periph *, union ccb *), 7997 u_int32_t flags, u_int8_t tag_action, 7998 u_int8_t protocol, u_int8_t ata_flags, u_int16_t features, 7999 u_int16_t sector_count, uint64_t lba, u_int8_t command, 8000 u_int8_t control, u_int8_t *data_ptr, u_int16_t dxfer_len, 8001 u_int8_t sense_len, u_int32_t timeout) 8002{ 8003 struct ata_pass_16 *ata_cmd; 8004 8005 ata_cmd = (struct ata_pass_16 *)&csio->cdb_io.cdb_bytes; 8006 ata_cmd->opcode = ATA_PASS_16; 8007 ata_cmd->protocol = protocol; 8008 ata_cmd->flags = ata_flags; 8009 ata_cmd->features_ext = features >> 8; 8010 ata_cmd->features = features; 8011 ata_cmd->sector_count_ext = sector_count >> 8; 8012 ata_cmd->sector_count = sector_count; 8013 ata_cmd->lba_low = lba; 8014 ata_cmd->lba_mid = lba >> 8; 8015 ata_cmd->lba_high = lba >> 16; 8016 ata_cmd->device = ATA_DEV_LBA; 8017 if (protocol & AP_EXTEND) { 8018 ata_cmd->lba_low_ext = lba >> 24; 8019 ata_cmd->lba_mid_ext = lba >> 32; 8020 ata_cmd->lba_high_ext = lba >> 40; 8021 } else 8022 ata_cmd->device |= (lba >> 24) & 0x0f; 8023 ata_cmd->command = command; 8024 ata_cmd->control = control; 8025 8026 cam_fill_csio(csio, 8027 retries, 8028 cbfcnp, 8029 flags, 8030 tag_action, 8031 data_ptr, 8032 dxfer_len, 8033 sense_len, 8034 sizeof(*ata_cmd), 8035 timeout); 8036} 8037 8038void 8039scsi_unmap(struct ccb_scsiio *csio, u_int32_t retries, 8040 void (*cbfcnp)(struct cam_periph *, union ccb *), 8041 u_int8_t tag_action, u_int8_t byte2, 8042 u_int8_t *data_ptr, u_int16_t dxfer_len, u_int8_t sense_len, 8043 u_int32_t timeout) 8044{ 8045 struct scsi_unmap *scsi_cmd; 8046 8047 scsi_cmd = (struct scsi_unmap *)&csio->cdb_io.cdb_bytes; 8048 scsi_cmd->opcode = UNMAP; 8049 scsi_cmd->byte2 = byte2; 8050 scsi_ulto4b(0, scsi_cmd->reserved); 8051 scsi_cmd->group = 0; 8052 scsi_ulto2b(dxfer_len, scsi_cmd->length); 8053 scsi_cmd->control = 0; 8054 8055 cam_fill_csio(csio, 8056 retries, 8057 cbfcnp, 8058 /*flags*/CAM_DIR_OUT, 8059 tag_action, 8060 data_ptr, 8061 dxfer_len, 8062 sense_len, 8063 sizeof(*scsi_cmd), 8064 timeout); 8065} 8066 8067void 8068scsi_receive_diagnostic_results(struct ccb_scsiio *csio, u_int32_t retries, 8069 void (*cbfcnp)(struct cam_periph *, union ccb*), 8070 uint8_t tag_action, int pcv, uint8_t page_code, 8071 uint8_t *data_ptr, uint16_t allocation_length, 8072 uint8_t sense_len, uint32_t timeout) 8073{ 8074 struct scsi_receive_diag *scsi_cmd; 8075 8076 scsi_cmd = (struct scsi_receive_diag *)&csio->cdb_io.cdb_bytes; 8077 memset(scsi_cmd, 0, sizeof(*scsi_cmd)); 8078 scsi_cmd->opcode = RECEIVE_DIAGNOSTIC; 8079 if (pcv) { 8080 scsi_cmd->byte2 |= SRD_PCV; 8081 scsi_cmd->page_code = page_code; 8082 } 8083 scsi_ulto2b(allocation_length, scsi_cmd->length); 8084 8085 cam_fill_csio(csio, 8086 retries, 8087 cbfcnp, 8088 /*flags*/CAM_DIR_IN, 8089 tag_action, 8090 data_ptr, 8091 allocation_length, 8092 sense_len, 8093 sizeof(*scsi_cmd), 8094 timeout); 8095} 8096 8097void 8098scsi_send_diagnostic(struct ccb_scsiio *csio, u_int32_t retries, 8099 void (*cbfcnp)(struct cam_periph *, union ccb *), 8100 uint8_t tag_action, int unit_offline, int device_offline, 8101 int self_test, int page_format, int self_test_code, 8102 uint8_t *data_ptr, uint16_t param_list_length, 8103 uint8_t sense_len, uint32_t timeout) 8104{ 8105 struct scsi_send_diag *scsi_cmd; 8106 8107 scsi_cmd = (struct scsi_send_diag *)&csio->cdb_io.cdb_bytes; 8108 memset(scsi_cmd, 0, sizeof(*scsi_cmd)); 8109 scsi_cmd->opcode = SEND_DIAGNOSTIC; 8110 8111 /* 8112 * The default self-test mode control and specific test 8113 * control are mutually exclusive. 8114 */ 8115 if (self_test) 8116 self_test_code = SSD_SELF_TEST_CODE_NONE; 8117 8118 scsi_cmd->byte2 = ((self_test_code << SSD_SELF_TEST_CODE_SHIFT) 8119 & SSD_SELF_TEST_CODE_MASK) 8120 | (unit_offline ? SSD_UNITOFFL : 0) 8121 | (device_offline ? SSD_DEVOFFL : 0) 8122 | (self_test ? SSD_SELFTEST : 0) 8123 | (page_format ? SSD_PF : 0); 8124 scsi_ulto2b(param_list_length, scsi_cmd->length); 8125 8126 cam_fill_csio(csio, 8127 retries, 8128 cbfcnp, 8129 /*flags*/param_list_length ? CAM_DIR_OUT : CAM_DIR_NONE, 8130 tag_action, 8131 data_ptr, 8132 param_list_length, 8133 sense_len, 8134 sizeof(*scsi_cmd), 8135 timeout); 8136} 8137 8138void 8139scsi_read_buffer(struct ccb_scsiio *csio, u_int32_t retries, 8140 void (*cbfcnp)(struct cam_periph *, union ccb*), 8141 uint8_t tag_action, int mode, 8142 uint8_t buffer_id, u_int32_t offset, 8143 uint8_t *data_ptr, uint32_t allocation_length, 8144 uint8_t sense_len, uint32_t timeout) 8145{ 8146 struct scsi_read_buffer *scsi_cmd; 8147 8148 scsi_cmd = (struct scsi_read_buffer *)&csio->cdb_io.cdb_bytes; 8149 memset(scsi_cmd, 0, sizeof(*scsi_cmd)); 8150 scsi_cmd->opcode = READ_BUFFER; 8151 scsi_cmd->byte2 = mode; 8152 scsi_cmd->buffer_id = buffer_id; 8153 scsi_ulto3b(offset, scsi_cmd->offset); 8154 scsi_ulto3b(allocation_length, scsi_cmd->length); 8155 8156 cam_fill_csio(csio, 8157 retries, 8158 cbfcnp, 8159 /*flags*/CAM_DIR_IN, 8160 tag_action, 8161 data_ptr, 8162 allocation_length, 8163 sense_len, 8164 sizeof(*scsi_cmd), 8165 timeout); 8166} 8167 8168void 8169scsi_write_buffer(struct ccb_scsiio *csio, u_int32_t retries, 8170 void (*cbfcnp)(struct cam_periph *, union ccb *), 8171 uint8_t tag_action, int mode, 8172 uint8_t buffer_id, u_int32_t offset, 8173 uint8_t *data_ptr, uint32_t param_list_length, 8174 uint8_t sense_len, uint32_t timeout) 8175{ 8176 struct scsi_write_buffer *scsi_cmd; 8177 8178 scsi_cmd = (struct scsi_write_buffer *)&csio->cdb_io.cdb_bytes; 8179 memset(scsi_cmd, 0, sizeof(*scsi_cmd)); 8180 scsi_cmd->opcode = WRITE_BUFFER; 8181 scsi_cmd->byte2 = mode; 8182 scsi_cmd->buffer_id = buffer_id; 8183 scsi_ulto3b(offset, scsi_cmd->offset); 8184 scsi_ulto3b(param_list_length, scsi_cmd->length); 8185 8186 cam_fill_csio(csio, 8187 retries, 8188 cbfcnp, 8189 /*flags*/param_list_length ? CAM_DIR_OUT : CAM_DIR_NONE, 8190 tag_action, 8191 data_ptr, 8192 param_list_length, 8193 sense_len, 8194 sizeof(*scsi_cmd), 8195 timeout); 8196} 8197 8198void 8199scsi_start_stop(struct ccb_scsiio *csio, u_int32_t retries, 8200 void (*cbfcnp)(struct cam_periph *, union ccb *), 8201 u_int8_t tag_action, int start, int load_eject, 8202 int immediate, u_int8_t sense_len, u_int32_t timeout) 8203{ 8204 struct scsi_start_stop_unit *scsi_cmd; 8205 int extra_flags = 0; 8206 8207 scsi_cmd = (struct scsi_start_stop_unit *)&csio->cdb_io.cdb_bytes; 8208 bzero(scsi_cmd, sizeof(*scsi_cmd)); 8209 scsi_cmd->opcode = START_STOP_UNIT; 8210 if (start != 0) { 8211 scsi_cmd->how |= SSS_START; 8212 /* it takes a lot of power to start a drive */ 8213 extra_flags |= CAM_HIGH_POWER; 8214 } 8215 if (load_eject != 0) 8216 scsi_cmd->how |= SSS_LOEJ; 8217 if (immediate != 0) 8218 scsi_cmd->byte2 |= SSS_IMMED; 8219 8220 cam_fill_csio(csio, 8221 retries, 8222 cbfcnp, 8223 /*flags*/CAM_DIR_NONE | extra_flags, 8224 tag_action, 8225 /*data_ptr*/NULL, 8226 /*dxfer_len*/0, 8227 sense_len, 8228 sizeof(*scsi_cmd), 8229 timeout); 8230} 8231 8232void 8233scsi_read_attribute(struct ccb_scsiio *csio, u_int32_t retries, 8234 void (*cbfcnp)(struct cam_periph *, union ccb *), 8235 u_int8_t tag_action, u_int8_t service_action, 8236 uint32_t element, u_int8_t elem_type, int logical_volume, 8237 int partition, u_int32_t first_attribute, int cache, 8238 u_int8_t *data_ptr, u_int32_t length, int sense_len, 8239 u_int32_t timeout) 8240{ 8241 struct scsi_read_attribute *scsi_cmd; 8242 8243 scsi_cmd = (struct scsi_read_attribute *)&csio->cdb_io.cdb_bytes; 8244 bzero(scsi_cmd, sizeof(*scsi_cmd)); 8245 8246 scsi_cmd->opcode = READ_ATTRIBUTE; 8247 scsi_cmd->service_action = service_action, 8248 scsi_ulto2b(element, scsi_cmd->element); 8249 scsi_cmd->elem_type = elem_type; 8250 scsi_cmd->logical_volume = logical_volume; 8251 scsi_cmd->partition = partition; 8252 scsi_ulto2b(first_attribute, scsi_cmd->first_attribute); 8253 scsi_ulto4b(length, scsi_cmd->length); 8254 if (cache != 0) 8255 scsi_cmd->cache |= SRA_CACHE; 8256 8257 cam_fill_csio(csio, 8258 retries, 8259 cbfcnp, 8260 /*flags*/CAM_DIR_IN, 8261 tag_action, 8262 /*data_ptr*/data_ptr, 8263 /*dxfer_len*/length, 8264 sense_len, 8265 sizeof(*scsi_cmd), 8266 timeout); 8267} 8268 8269void 8270scsi_write_attribute(struct ccb_scsiio *csio, u_int32_t retries, 8271 void (*cbfcnp)(struct cam_periph *, union ccb *), 8272 u_int8_t tag_action, uint32_t element, int logical_volume, 8273 int partition, int wtc, u_int8_t *data_ptr, 8274 u_int32_t length, int sense_len, u_int32_t timeout) 8275{ 8276 struct scsi_write_attribute *scsi_cmd; 8277 8278 scsi_cmd = (struct scsi_write_attribute *)&csio->cdb_io.cdb_bytes; 8279 bzero(scsi_cmd, sizeof(*scsi_cmd)); 8280 8281 scsi_cmd->opcode = WRITE_ATTRIBUTE; 8282 if (wtc != 0) 8283 scsi_cmd->byte2 = SWA_WTC; 8284 scsi_ulto3b(element, scsi_cmd->element); 8285 scsi_cmd->logical_volume = logical_volume; 8286 scsi_cmd->partition = partition; 8287 scsi_ulto4b(length, scsi_cmd->length); 8288 8289 cam_fill_csio(csio, 8290 retries, 8291 cbfcnp, 8292 /*flags*/CAM_DIR_OUT, 8293 tag_action, 8294 /*data_ptr*/data_ptr, 8295 /*dxfer_len*/length, 8296 sense_len, 8297 sizeof(*scsi_cmd), 8298 timeout); 8299} 8300 8301void 8302scsi_persistent_reserve_in(struct ccb_scsiio *csio, uint32_t retries, 8303 void (*cbfcnp)(struct cam_periph *, union ccb *), 8304 uint8_t tag_action, int service_action, 8305 uint8_t *data_ptr, uint32_t dxfer_len, int sense_len, 8306 int timeout) 8307{ 8308 struct scsi_per_res_in *scsi_cmd; 8309 8310 scsi_cmd = (struct scsi_per_res_in *)&csio->cdb_io.cdb_bytes; 8311 bzero(scsi_cmd, sizeof(*scsi_cmd)); 8312 8313 scsi_cmd->opcode = PERSISTENT_RES_IN; 8314 scsi_cmd->action = service_action; 8315 scsi_ulto2b(dxfer_len, scsi_cmd->length); 8316 8317 cam_fill_csio(csio, 8318 retries, 8319 cbfcnp, 8320 /*flags*/CAM_DIR_IN, 8321 tag_action, 8322 data_ptr, 8323 dxfer_len, 8324 sense_len, 8325 sizeof(*scsi_cmd), 8326 timeout); 8327} 8328 8329void 8330scsi_persistent_reserve_out(struct ccb_scsiio *csio, uint32_t retries, 8331 void (*cbfcnp)(struct cam_periph *, union ccb *), 8332 uint8_t tag_action, int service_action, 8333 int scope, int res_type, uint8_t *data_ptr, 8334 uint32_t dxfer_len, int sense_len, int timeout) 8335{ 8336 struct scsi_per_res_out *scsi_cmd; 8337 8338 scsi_cmd = (struct scsi_per_res_out *)&csio->cdb_io.cdb_bytes; 8339 bzero(scsi_cmd, sizeof(*scsi_cmd)); 8340 8341 scsi_cmd->opcode = PERSISTENT_RES_OUT; 8342 scsi_cmd->action = service_action; 8343 scsi_cmd->scope_type = scope | res_type; 8344 8345 cam_fill_csio(csio, 8346 retries, 8347 cbfcnp, 8348 /*flags*/CAM_DIR_OUT, 8349 tag_action, 8350 /*data_ptr*/data_ptr, 8351 /*dxfer_len*/dxfer_len, 8352 sense_len, 8353 sizeof(*scsi_cmd), 8354 timeout); 8355} 8356 8357void 8358scsi_security_protocol_in(struct ccb_scsiio *csio, uint32_t retries, 8359 void (*cbfcnp)(struct cam_periph *, union ccb *), 8360 uint8_t tag_action, uint32_t security_protocol, 8361 uint32_t security_protocol_specific, int byte4, 8362 uint8_t *data_ptr, uint32_t dxfer_len, int sense_len, 8363 int timeout) 8364{ 8365 struct scsi_security_protocol_in *scsi_cmd; 8366 8367 scsi_cmd = (struct scsi_security_protocol_in *)&csio->cdb_io.cdb_bytes; 8368 bzero(scsi_cmd, sizeof(*scsi_cmd)); 8369 8370 scsi_cmd->opcode = SECURITY_PROTOCOL_IN; 8371 8372 scsi_cmd->security_protocol = security_protocol; 8373 scsi_ulto2b(security_protocol_specific, 8374 scsi_cmd->security_protocol_specific); 8375 scsi_cmd->byte4 = byte4; 8376 scsi_ulto4b(dxfer_len, scsi_cmd->length); 8377 8378 cam_fill_csio(csio, 8379 retries, 8380 cbfcnp, 8381 /*flags*/CAM_DIR_IN, 8382 tag_action, 8383 data_ptr, 8384 dxfer_len, 8385 sense_len, 8386 sizeof(*scsi_cmd), 8387 timeout); 8388} 8389 8390void 8391scsi_security_protocol_out(struct ccb_scsiio *csio, uint32_t retries, 8392 void (*cbfcnp)(struct cam_periph *, union ccb *), 8393 uint8_t tag_action, uint32_t security_protocol, 8394 uint32_t security_protocol_specific, int byte4, 8395 uint8_t *data_ptr, uint32_t dxfer_len, int sense_len, 8396 int timeout) 8397{ 8398 struct scsi_security_protocol_out *scsi_cmd; 8399 8400 scsi_cmd = (struct scsi_security_protocol_out *)&csio->cdb_io.cdb_bytes; 8401 bzero(scsi_cmd, sizeof(*scsi_cmd)); 8402 8403 scsi_cmd->opcode = SECURITY_PROTOCOL_OUT; 8404 8405 scsi_cmd->security_protocol = security_protocol; 8406 scsi_ulto2b(security_protocol_specific, 8407 scsi_cmd->security_protocol_specific); 8408 scsi_cmd->byte4 = byte4; 8409 scsi_ulto4b(dxfer_len, scsi_cmd->length); 8410 8411 cam_fill_csio(csio, 8412 retries, 8413 cbfcnp, 8414 /*flags*/CAM_DIR_OUT, 8415 tag_action, 8416 data_ptr, 8417 dxfer_len, 8418 sense_len, 8419 sizeof(*scsi_cmd), 8420 timeout); 8421} 8422 8423void 8424scsi_report_supported_opcodes(struct ccb_scsiio *csio, uint32_t retries, 8425 void (*cbfcnp)(struct cam_periph *, union ccb *), 8426 uint8_t tag_action, int options, int req_opcode, 8427 int req_service_action, uint8_t *data_ptr, 8428 uint32_t dxfer_len, int sense_len, int timeout) 8429{ 8430 struct scsi_report_supported_opcodes *scsi_cmd; 8431 8432 scsi_cmd = (struct scsi_report_supported_opcodes *) 8433 &csio->cdb_io.cdb_bytes; 8434 bzero(scsi_cmd, sizeof(*scsi_cmd)); 8435 8436 scsi_cmd->opcode = MAINTENANCE_IN; 8437 scsi_cmd->service_action = REPORT_SUPPORTED_OPERATION_CODES; 8438 scsi_cmd->options = options; 8439 scsi_cmd->requested_opcode = req_opcode; 8440 scsi_ulto2b(req_service_action, scsi_cmd->requested_service_action); 8441 scsi_ulto4b(dxfer_len, scsi_cmd->length); 8442 8443 cam_fill_csio(csio, 8444 retries, 8445 cbfcnp, 8446 /*flags*/CAM_DIR_IN, 8447 tag_action, 8448 data_ptr, 8449 dxfer_len, 8450 sense_len, 8451 sizeof(*scsi_cmd), 8452 timeout); 8453} 8454 8455/* 8456 * Try make as good a match as possible with 8457 * available sub drivers 8458 */ 8459int 8460scsi_inquiry_match(caddr_t inqbuffer, caddr_t table_entry) 8461{ 8462 struct scsi_inquiry_pattern *entry; 8463 struct scsi_inquiry_data *inq; 8464 8465 entry = (struct scsi_inquiry_pattern *)table_entry; 8466 inq = (struct scsi_inquiry_data *)inqbuffer; 8467 8468 if (((SID_TYPE(inq) == entry->type) 8469 || (entry->type == T_ANY)) 8470 && (SID_IS_REMOVABLE(inq) ? entry->media_type & SIP_MEDIA_REMOVABLE 8471 : entry->media_type & SIP_MEDIA_FIXED) 8472 && (cam_strmatch(inq->vendor, entry->vendor, sizeof(inq->vendor)) == 0) 8473 && (cam_strmatch(inq->product, entry->product, 8474 sizeof(inq->product)) == 0) 8475 && (cam_strmatch(inq->revision, entry->revision, 8476 sizeof(inq->revision)) == 0)) { 8477 return (0); 8478 } 8479 return (-1); 8480} 8481 8482/* 8483 * Try make as good a match as possible with 8484 * available sub drivers 8485 */ 8486int 8487scsi_static_inquiry_match(caddr_t inqbuffer, caddr_t table_entry) 8488{ 8489 struct scsi_static_inquiry_pattern *entry; 8490 struct scsi_inquiry_data *inq; 8491 8492 entry = (struct scsi_static_inquiry_pattern *)table_entry; 8493 inq = (struct scsi_inquiry_data *)inqbuffer; 8494 8495 if (((SID_TYPE(inq) == entry->type) 8496 || (entry->type == T_ANY)) 8497 && (SID_IS_REMOVABLE(inq) ? entry->media_type & SIP_MEDIA_REMOVABLE 8498 : entry->media_type & SIP_MEDIA_FIXED) 8499 && (cam_strmatch(inq->vendor, entry->vendor, sizeof(inq->vendor)) == 0) 8500 && (cam_strmatch(inq->product, entry->product, 8501 sizeof(inq->product)) == 0) 8502 && (cam_strmatch(inq->revision, entry->revision, 8503 sizeof(inq->revision)) == 0)) { 8504 return (0); 8505 } 8506 return (-1); 8507} 8508 8509/** 8510 * Compare two buffers of vpd device descriptors for a match. 8511 * 8512 * \param lhs Pointer to first buffer of descriptors to compare. 8513 * \param lhs_len The length of the first buffer. 8514 * \param rhs Pointer to second buffer of descriptors to compare. 8515 * \param rhs_len The length of the second buffer. 8516 * 8517 * \return 0 on a match, -1 otherwise. 8518 * 8519 * Treat rhs and lhs as arrays of vpd device id descriptors. Walk lhs matching 8520 * agains each element in rhs until all data are exhausted or we have found 8521 * a match. 8522 */ 8523int 8524scsi_devid_match(uint8_t *lhs, size_t lhs_len, uint8_t *rhs, size_t rhs_len) 8525{ 8526 struct scsi_vpd_id_descriptor *lhs_id; 8527 struct scsi_vpd_id_descriptor *lhs_last; 8528 struct scsi_vpd_id_descriptor *rhs_last; 8529 uint8_t *lhs_end; 8530 uint8_t *rhs_end; 8531 8532 lhs_end = lhs + lhs_len; 8533 rhs_end = rhs + rhs_len; 8534 8535 /* 8536 * rhs_last and lhs_last are the last posible position of a valid 8537 * descriptor assuming it had a zero length identifier. We use 8538 * these variables to insure we can safely dereference the length 8539 * field in our loop termination tests. 8540 */ 8541 lhs_last = (struct scsi_vpd_id_descriptor *) 8542 (lhs_end - __offsetof(struct scsi_vpd_id_descriptor, identifier)); 8543 rhs_last = (struct scsi_vpd_id_descriptor *) 8544 (rhs_end - __offsetof(struct scsi_vpd_id_descriptor, identifier)); 8545 8546 lhs_id = (struct scsi_vpd_id_descriptor *)lhs; 8547 while (lhs_id <= lhs_last 8548 && (lhs_id->identifier + lhs_id->length) <= lhs_end) { 8549 struct scsi_vpd_id_descriptor *rhs_id; 8550 8551 rhs_id = (struct scsi_vpd_id_descriptor *)rhs; 8552 while (rhs_id <= rhs_last 8553 && (rhs_id->identifier + rhs_id->length) <= rhs_end) { 8554 8555 if ((rhs_id->id_type & 8556 (SVPD_ID_ASSOC_MASK | SVPD_ID_TYPE_MASK)) == 8557 (lhs_id->id_type & 8558 (SVPD_ID_ASSOC_MASK | SVPD_ID_TYPE_MASK)) 8559 && rhs_id->length == lhs_id->length 8560 && memcmp(rhs_id->identifier, lhs_id->identifier, 8561 rhs_id->length) == 0) 8562 return (0); 8563 8564 rhs_id = (struct scsi_vpd_id_descriptor *) 8565 (rhs_id->identifier + rhs_id->length); 8566 } 8567 lhs_id = (struct scsi_vpd_id_descriptor *) 8568 (lhs_id->identifier + lhs_id->length); 8569 } 8570 return (-1); 8571} 8572 8573#ifdef _KERNEL 8574int 8575scsi_vpd_supported_page(struct cam_periph *periph, uint8_t page_id) 8576{ 8577 struct cam_ed *device; 8578 struct scsi_vpd_supported_pages *vpds; 8579 int i, num_pages; 8580 8581 device = periph->path->device; 8582 vpds = (struct scsi_vpd_supported_pages *)device->supported_vpds; 8583 8584 if (vpds != NULL) { 8585 num_pages = device->supported_vpds_len - 8586 SVPD_SUPPORTED_PAGES_HDR_LEN; 8587 for (i = 0; i < num_pages; i++) { 8588 if (vpds->page_list[i] == page_id) 8589 return (1); 8590 } 8591 } 8592 8593 return (0); 8594} 8595 8596static void 8597init_scsi_delay(void) 8598{ 8599 int delay; 8600 8601 delay = SCSI_DELAY; 8602 TUNABLE_INT_FETCH("kern.cam.scsi_delay", &delay); 8603 8604 if (set_scsi_delay(delay) != 0) { 8605 printf("cam: invalid value for tunable kern.cam.scsi_delay\n"); 8606 set_scsi_delay(SCSI_DELAY); 8607 } 8608} 8609SYSINIT(scsi_delay, SI_SUB_TUNABLES, SI_ORDER_ANY, init_scsi_delay, NULL); 8610 8611static int 8612sysctl_scsi_delay(SYSCTL_HANDLER_ARGS) 8613{ 8614 int error, delay; 8615 8616 delay = scsi_delay; 8617 error = sysctl_handle_int(oidp, &delay, 0, req); 8618 if (error != 0 || req->newptr == NULL) 8619 return (error); 8620 return (set_scsi_delay(delay)); 8621} 8622SYSCTL_PROC(_kern_cam, OID_AUTO, scsi_delay, CTLTYPE_INT|CTLFLAG_RW, 8623 0, 0, sysctl_scsi_delay, "I", 8624 "Delay to allow devices to settle after a SCSI bus reset (ms)"); 8625 8626static int 8627set_scsi_delay(int delay) 8628{ 8629 /* 8630 * If someone sets this to 0, we assume that they want the 8631 * minimum allowable bus settle delay. 8632 */ 8633 if (delay == 0) { 8634 printf("cam: using minimum scsi_delay (%dms)\n", 8635 SCSI_MIN_DELAY); 8636 delay = SCSI_MIN_DELAY; 8637 } 8638 if (delay < SCSI_MIN_DELAY) 8639 return (EINVAL); 8640 scsi_delay = delay; 8641 return (0); 8642} 8643#endif /* _KERNEL */ 8644