1 /* 2 * SCSI helpers 3 * 4 * Copyright 2017 Red Hat, Inc. 5 * 6 * Authors: 7 * Fam Zheng <famz@redhat.com> 8 * Paolo Bonzini <pbonzini@redhat.com> 9 * 10 * This program is free software; you can redistribute it and/or modify it 11 * under the terms of the GNU General Public License as published by the Free 12 * Software Foundation; either version 2 of the License, or (at your option) 13 * any later version. 14 */ 15 16 #include "qemu/osdep.h" 17 #include "scsi/constants.h" 18 #include "scsi/utils.h" 19 #include "qemu/bswap.h" 20 21 uint32_t scsi_data_cdb_xfer(uint8_t *buf) 22 { 23 if ((buf[0] >> 5) == 0 && buf[4] == 0) { 24 return 256; 25 } else { 26 return scsi_cdb_xfer(buf); 27 } 28 } 29 30 uint32_t scsi_cdb_xfer(uint8_t *buf) 31 { 32 switch (buf[0] >> 5) { 33 case 0: 34 return buf[4]; 35 break; 36 case 1: 37 case 2: 38 return lduw_be_p(&buf[7]); 39 break; 40 case 4: 41 return ldl_be_p(&buf[10]) & 0xffffffffULL; 42 break; 43 case 5: 44 return ldl_be_p(&buf[6]) & 0xffffffffULL; 45 break; 46 default: 47 return -1; 48 } 49 } 50 51 uint64_t scsi_cmd_lba(SCSICommand *cmd) 52 { 53 uint8_t *buf = cmd->buf; 54 uint64_t lba; 55 56 switch (buf[0] >> 5) { 57 case 0: 58 lba = ldl_be_p(&buf[0]) & 0x1fffff; 59 break; 60 case 1: 61 case 2: 62 case 5: 63 lba = ldl_be_p(&buf[2]) & 0xffffffffULL; 64 break; 65 case 4: 66 lba = ldq_be_p(&buf[2]); 67 break; 68 default: 69 lba = -1; 70 71 } 72 return lba; 73 } 74 75 int scsi_cdb_length(uint8_t *buf) 76 { 77 int cdb_len; 78 79 switch (buf[0] >> 5) { 80 case 0: 81 cdb_len = 6; 82 break; 83 case 1: 84 case 2: 85 cdb_len = 10; 86 break; 87 case 4: 88 cdb_len = 16; 89 break; 90 case 5: 91 cdb_len = 12; 92 break; 93 default: 94 cdb_len = -1; 95 } 96 return cdb_len; 97 } 98 99 SCSISense scsi_parse_sense_buf(const uint8_t *in_buf, int in_len) 100 { 101 bool fixed_in; 102 SCSISense sense; 103 104 assert(in_len > 0); 105 fixed_in = (in_buf[0] & 2) == 0; 106 if (fixed_in) { 107 if (in_len < 14) { 108 return SENSE_CODE(IO_ERROR); 109 } 110 sense.key = in_buf[2]; 111 sense.asc = in_buf[12]; 112 sense.ascq = in_buf[13]; 113 } else { 114 if (in_len < 4) { 115 return SENSE_CODE(IO_ERROR); 116 } 117 sense.key = in_buf[1]; 118 sense.asc = in_buf[2]; 119 sense.ascq = in_buf[3]; 120 } 121 122 return sense; 123 } 124 125 int scsi_build_sense_buf(uint8_t *out_buf, size_t size, SCSISense sense, 126 bool fixed_sense) 127 { 128 int len; 129 uint8_t buf[SCSI_SENSE_LEN] = { 0 }; 130 131 if (fixed_sense) { 132 buf[0] = 0x70; 133 buf[2] = sense.key; 134 buf[7] = 10; 135 buf[12] = sense.asc; 136 buf[13] = sense.ascq; 137 len = 18; 138 } else { 139 buf[0] = 0x72; 140 buf[1] = sense.key; 141 buf[2] = sense.asc; 142 buf[3] = sense.ascq; 143 len = 8; 144 } 145 len = MIN(len, size); 146 memcpy(out_buf, buf, len); 147 return len; 148 } 149 150 int scsi_build_sense(uint8_t *buf, SCSISense sense) 151 { 152 return scsi_build_sense_buf(buf, SCSI_SENSE_LEN, sense, true); 153 } 154 155 /* 156 * Predefined sense codes 157 */ 158 159 /* No sense data available */ 160 const struct SCSISense sense_code_NO_SENSE = { 161 .key = NO_SENSE , .asc = 0x00 , .ascq = 0x00 162 }; 163 164 /* LUN not ready, Manual intervention required */ 165 const struct SCSISense sense_code_LUN_NOT_READY = { 166 .key = NOT_READY, .asc = 0x04, .ascq = 0x03 167 }; 168 169 /* LUN not ready, Medium not present */ 170 const struct SCSISense sense_code_NO_MEDIUM = { 171 .key = NOT_READY, .asc = 0x3a, .ascq = 0x00 172 }; 173 174 /* LUN not ready, medium removal prevented */ 175 const struct SCSISense sense_code_NOT_READY_REMOVAL_PREVENTED = { 176 .key = NOT_READY, .asc = 0x53, .ascq = 0x02 177 }; 178 179 /* Hardware error, internal target failure */ 180 const struct SCSISense sense_code_TARGET_FAILURE = { 181 .key = HARDWARE_ERROR, .asc = 0x44, .ascq = 0x00 182 }; 183 184 /* Illegal request, invalid command operation code */ 185 const struct SCSISense sense_code_INVALID_OPCODE = { 186 .key = ILLEGAL_REQUEST, .asc = 0x20, .ascq = 0x00 187 }; 188 189 /* Illegal request, LBA out of range */ 190 const struct SCSISense sense_code_LBA_OUT_OF_RANGE = { 191 .key = ILLEGAL_REQUEST, .asc = 0x21, .ascq = 0x00 192 }; 193 194 /* Illegal request, Invalid field in CDB */ 195 const struct SCSISense sense_code_INVALID_FIELD = { 196 .key = ILLEGAL_REQUEST, .asc = 0x24, .ascq = 0x00 197 }; 198 199 /* Illegal request, Invalid field in parameter list */ 200 const struct SCSISense sense_code_INVALID_PARAM = { 201 .key = ILLEGAL_REQUEST, .asc = 0x26, .ascq = 0x00 202 }; 203 204 /* Illegal request, Parameter list length error */ 205 const struct SCSISense sense_code_INVALID_PARAM_LEN = { 206 .key = ILLEGAL_REQUEST, .asc = 0x1a, .ascq = 0x00 207 }; 208 209 /* Illegal request, LUN not supported */ 210 const struct SCSISense sense_code_LUN_NOT_SUPPORTED = { 211 .key = ILLEGAL_REQUEST, .asc = 0x25, .ascq = 0x00 212 }; 213 214 /* Illegal request, Saving parameters not supported */ 215 const struct SCSISense sense_code_SAVING_PARAMS_NOT_SUPPORTED = { 216 .key = ILLEGAL_REQUEST, .asc = 0x39, .ascq = 0x00 217 }; 218 219 /* Illegal request, Incompatible medium installed */ 220 const struct SCSISense sense_code_INCOMPATIBLE_FORMAT = { 221 .key = ILLEGAL_REQUEST, .asc = 0x30, .ascq = 0x00 222 }; 223 224 /* Illegal request, medium removal prevented */ 225 const struct SCSISense sense_code_ILLEGAL_REQ_REMOVAL_PREVENTED = { 226 .key = ILLEGAL_REQUEST, .asc = 0x53, .ascq = 0x02 227 }; 228 229 /* Illegal request, Invalid Transfer Tag */ 230 const struct SCSISense sense_code_INVALID_TAG = { 231 .key = ILLEGAL_REQUEST, .asc = 0x4b, .ascq = 0x01 232 }; 233 234 /* Command aborted, I/O process terminated */ 235 const struct SCSISense sense_code_IO_ERROR = { 236 .key = ABORTED_COMMAND, .asc = 0x00, .ascq = 0x06 237 }; 238 239 /* Command aborted, I_T Nexus loss occurred */ 240 const struct SCSISense sense_code_I_T_NEXUS_LOSS = { 241 .key = ABORTED_COMMAND, .asc = 0x29, .ascq = 0x07 242 }; 243 244 /* Command aborted, Logical Unit failure */ 245 const struct SCSISense sense_code_LUN_FAILURE = { 246 .key = ABORTED_COMMAND, .asc = 0x3e, .ascq = 0x01 247 }; 248 249 /* Command aborted, Overlapped Commands Attempted */ 250 const struct SCSISense sense_code_OVERLAPPED_COMMANDS = { 251 .key = ABORTED_COMMAND, .asc = 0x4e, .ascq = 0x00 252 }; 253 254 /* Command aborted, LUN Communication Failure */ 255 const struct SCSISense sense_code_LUN_COMM_FAILURE = { 256 .key = ABORTED_COMMAND, .asc = 0x08, .ascq = 0x00 257 }; 258 259 /* Medium Error, Unrecovered read error */ 260 const struct SCSISense sense_code_READ_ERROR = { 261 .key = MEDIUM_ERROR, .asc = 0x11, .ascq = 0x00 262 }; 263 264 /* Not ready, Cause not reportable */ 265 const struct SCSISense sense_code_NOT_READY = { 266 .key = NOT_READY, .asc = 0x04, .ascq = 0x00 267 }; 268 269 /* Unit attention, Capacity data has changed */ 270 const struct SCSISense sense_code_CAPACITY_CHANGED = { 271 .key = UNIT_ATTENTION, .asc = 0x2a, .ascq = 0x09 272 }; 273 274 /* Unit attention, Power on, reset or bus device reset occurred */ 275 const struct SCSISense sense_code_RESET = { 276 .key = UNIT_ATTENTION, .asc = 0x29, .ascq = 0x00 277 }; 278 279 /* Unit attention, SCSI bus reset */ 280 const struct SCSISense sense_code_SCSI_BUS_RESET = { 281 .key = UNIT_ATTENTION, .asc = 0x29, .ascq = 0x02 282 }; 283 284 /* Unit attention, No medium */ 285 const struct SCSISense sense_code_UNIT_ATTENTION_NO_MEDIUM = { 286 .key = UNIT_ATTENTION, .asc = 0x3a, .ascq = 0x00 287 }; 288 289 /* Unit attention, Medium may have changed */ 290 const struct SCSISense sense_code_MEDIUM_CHANGED = { 291 .key = UNIT_ATTENTION, .asc = 0x28, .ascq = 0x00 292 }; 293 294 /* Unit attention, Reported LUNs data has changed */ 295 const struct SCSISense sense_code_REPORTED_LUNS_CHANGED = { 296 .key = UNIT_ATTENTION, .asc = 0x3f, .ascq = 0x0e 297 }; 298 299 /* Unit attention, Device internal reset */ 300 const struct SCSISense sense_code_DEVICE_INTERNAL_RESET = { 301 .key = UNIT_ATTENTION, .asc = 0x29, .ascq = 0x04 302 }; 303 304 /* Data Protection, Write Protected */ 305 const struct SCSISense sense_code_WRITE_PROTECTED = { 306 .key = DATA_PROTECT, .asc = 0x27, .ascq = 0x00 307 }; 308 309 /* Data Protection, Space Allocation Failed Write Protect */ 310 const struct SCSISense sense_code_SPACE_ALLOC_FAILED = { 311 .key = DATA_PROTECT, .asc = 0x27, .ascq = 0x07 312 }; 313 314 /* 315 * scsi_convert_sense 316 * 317 * Convert between fixed and descriptor sense buffers 318 */ 319 int scsi_convert_sense(uint8_t *in_buf, int in_len, 320 uint8_t *buf, int len, bool fixed) 321 { 322 SCSISense sense; 323 bool fixed_in; 324 325 if (in_len == 0) { 326 return scsi_build_sense_buf(buf, len, SENSE_CODE(NO_SENSE), fixed); 327 } 328 329 fixed_in = (in_buf[0] & 2) == 0; 330 if (fixed == fixed_in) { 331 memcpy(buf, in_buf, MIN(len, in_len)); 332 return MIN(len, in_len); 333 } else { 334 sense = scsi_parse_sense_buf(in_buf, in_len); 335 return scsi_build_sense_buf(buf, len, sense, fixed); 336 } 337 } 338 339 static bool scsi_sense_is_guest_recoverable(int key, int asc, int ascq) 340 { 341 switch (key) { 342 case NO_SENSE: 343 case RECOVERED_ERROR: 344 case UNIT_ATTENTION: 345 case ABORTED_COMMAND: 346 return true; 347 case NOT_READY: 348 case ILLEGAL_REQUEST: 349 case DATA_PROTECT: 350 /* Parse ASCQ */ 351 break; 352 default: 353 return false; 354 } 355 356 switch ((asc << 8) | ascq) { 357 case 0x1a00: /* PARAMETER LIST LENGTH ERROR */ 358 case 0x2000: /* INVALID OPERATION CODE */ 359 case 0x2400: /* INVALID FIELD IN CDB */ 360 case 0x2500: /* LOGICAL UNIT NOT SUPPORTED */ 361 case 0x2600: /* INVALID FIELD IN PARAMETER LIST */ 362 363 case 0x2104: /* UNALIGNED WRITE COMMAND */ 364 case 0x2105: /* WRITE BOUNDARY VIOLATION */ 365 case 0x2106: /* ATTEMPT TO READ INVALID DATA */ 366 case 0x550e: /* INSUFFICIENT ZONE RESOURCES */ 367 368 case 0x0401: /* NOT READY, IN PROGRESS OF BECOMING READY */ 369 case 0x0402: /* NOT READY, INITIALIZING COMMAND REQUIRED */ 370 return true; 371 default: 372 return false; 373 } 374 } 375 376 int scsi_sense_to_errno(int key, int asc, int ascq) 377 { 378 switch (key) { 379 case NO_SENSE: 380 case RECOVERED_ERROR: 381 case UNIT_ATTENTION: 382 return EAGAIN; 383 case ABORTED_COMMAND: /* COMMAND ABORTED */ 384 return ECANCELED; 385 case NOT_READY: 386 case ILLEGAL_REQUEST: 387 case DATA_PROTECT: 388 /* Parse ASCQ */ 389 break; 390 default: 391 return EIO; 392 } 393 switch ((asc << 8) | ascq) { 394 case 0x1a00: /* PARAMETER LIST LENGTH ERROR */ 395 case 0x2000: /* INVALID OPERATION CODE */ 396 case 0x2400: /* INVALID FIELD IN CDB */ 397 case 0x2600: /* INVALID FIELD IN PARAMETER LIST */ 398 return EINVAL; 399 case 0x2100: /* LBA OUT OF RANGE */ 400 case 0x2707: /* SPACE ALLOC FAILED */ 401 return ENOSPC; 402 case 0x2500: /* LOGICAL UNIT NOT SUPPORTED */ 403 return ENOTSUP; 404 case 0x3a00: /* MEDIUM NOT PRESENT */ 405 case 0x3a01: /* MEDIUM NOT PRESENT TRAY CLOSED */ 406 case 0x3a02: /* MEDIUM NOT PRESENT TRAY OPEN */ 407 return ENOMEDIUM; 408 case 0x2700: /* WRITE PROTECTED */ 409 return EACCES; 410 case 0x0401: /* NOT READY, IN PROGRESS OF BECOMING READY */ 411 return EINPROGRESS; 412 case 0x0402: /* NOT READY, INITIALIZING COMMAND REQUIRED */ 413 return ENOTCONN; 414 default: 415 return EIO; 416 } 417 } 418 419 int scsi_sense_buf_to_errno(const uint8_t *in_buf, size_t in_len) 420 { 421 SCSISense sense; 422 if (in_len < 1) { 423 return EIO; 424 } 425 426 sense = scsi_parse_sense_buf(in_buf, in_len); 427 return scsi_sense_to_errno(sense.key, sense.asc, sense.ascq); 428 } 429 430 bool scsi_sense_buf_is_guest_recoverable(const uint8_t *in_buf, size_t in_len) 431 { 432 SCSISense sense; 433 if (in_len < 1) { 434 return false; 435 } 436 437 sense = scsi_parse_sense_buf(in_buf, in_len); 438 return scsi_sense_is_guest_recoverable(sense.key, sense.asc, sense.ascq); 439 } 440 441 const char *scsi_command_name(uint8_t cmd) 442 { 443 static const char *names[] = { 444 [ TEST_UNIT_READY ] = "TEST_UNIT_READY", 445 [ REWIND ] = "REWIND", 446 [ REQUEST_SENSE ] = "REQUEST_SENSE", 447 [ FORMAT_UNIT ] = "FORMAT_UNIT", 448 [ READ_BLOCK_LIMITS ] = "READ_BLOCK_LIMITS", 449 [ REASSIGN_BLOCKS ] = "REASSIGN_BLOCKS/INITIALIZE ELEMENT STATUS", 450 /* LOAD_UNLOAD and INITIALIZE_ELEMENT_STATUS use the same operation code */ 451 [ READ_6 ] = "READ_6", 452 [ WRITE_6 ] = "WRITE_6", 453 [ SET_CAPACITY ] = "SET_CAPACITY", 454 [ READ_REVERSE ] = "READ_REVERSE", 455 [ WRITE_FILEMARKS ] = "WRITE_FILEMARKS", 456 [ SPACE ] = "SPACE", 457 [ INQUIRY ] = "INQUIRY", 458 [ RECOVER_BUFFERED_DATA ] = "RECOVER_BUFFERED_DATA", 459 [ MAINTENANCE_IN ] = "MAINTENANCE_IN", 460 [ MAINTENANCE_OUT ] = "MAINTENANCE_OUT", 461 [ MODE_SELECT ] = "MODE_SELECT", 462 [ RESERVE ] = "RESERVE", 463 [ RELEASE ] = "RELEASE", 464 [ COPY ] = "COPY", 465 [ ERASE ] = "ERASE", 466 [ MODE_SENSE ] = "MODE_SENSE", 467 [ START_STOP ] = "START_STOP/LOAD_UNLOAD", 468 /* LOAD_UNLOAD and START_STOP use the same operation code */ 469 [ RECEIVE_DIAGNOSTIC ] = "RECEIVE_DIAGNOSTIC", 470 [ SEND_DIAGNOSTIC ] = "SEND_DIAGNOSTIC", 471 [ ALLOW_MEDIUM_REMOVAL ] = "ALLOW_MEDIUM_REMOVAL", 472 [ READ_CAPACITY_10 ] = "READ_CAPACITY_10", 473 [ READ_10 ] = "READ_10", 474 [ WRITE_10 ] = "WRITE_10", 475 [ SEEK_10 ] = "SEEK_10/POSITION_TO_ELEMENT", 476 /* SEEK_10 and POSITION_TO_ELEMENT use the same operation code */ 477 [ WRITE_VERIFY_10 ] = "WRITE_VERIFY_10", 478 [ VERIFY_10 ] = "VERIFY_10", 479 [ SEARCH_HIGH ] = "SEARCH_HIGH", 480 [ SEARCH_EQUAL ] = "SEARCH_EQUAL", 481 [ SEARCH_LOW ] = "SEARCH_LOW", 482 [ SET_LIMITS ] = "SET_LIMITS", 483 [ PRE_FETCH ] = "PRE_FETCH/READ_POSITION", 484 /* READ_POSITION and PRE_FETCH use the same operation code */ 485 [ SYNCHRONIZE_CACHE ] = "SYNCHRONIZE_CACHE", 486 [ LOCK_UNLOCK_CACHE ] = "LOCK_UNLOCK_CACHE", 487 [ READ_DEFECT_DATA ] = "READ_DEFECT_DATA/INITIALIZE_ELEMENT_STATUS_WITH_RANGE", 488 /* READ_DEFECT_DATA and INITIALIZE_ELEMENT_STATUS_WITH_RANGE use the same operation code */ 489 [ MEDIUM_SCAN ] = "MEDIUM_SCAN", 490 [ COMPARE ] = "COMPARE", 491 [ COPY_VERIFY ] = "COPY_VERIFY", 492 [ WRITE_BUFFER ] = "WRITE_BUFFER", 493 [ READ_BUFFER ] = "READ_BUFFER", 494 [ UPDATE_BLOCK ] = "UPDATE_BLOCK", 495 [ READ_LONG_10 ] = "READ_LONG_10", 496 [ WRITE_LONG_10 ] = "WRITE_LONG_10", 497 [ CHANGE_DEFINITION ] = "CHANGE_DEFINITION", 498 [ WRITE_SAME_10 ] = "WRITE_SAME_10", 499 [ UNMAP ] = "UNMAP", 500 [ READ_TOC ] = "READ_TOC", 501 [ REPORT_DENSITY_SUPPORT ] = "REPORT_DENSITY_SUPPORT", 502 [ SANITIZE ] = "SANITIZE", 503 [ GET_CONFIGURATION ] = "GET_CONFIGURATION", 504 [ LOG_SELECT ] = "LOG_SELECT", 505 [ LOG_SENSE ] = "LOG_SENSE", 506 [ MODE_SELECT_10 ] = "MODE_SELECT_10", 507 [ RESERVE_10 ] = "RESERVE_10", 508 [ RELEASE_10 ] = "RELEASE_10", 509 [ MODE_SENSE_10 ] = "MODE_SENSE_10", 510 [ PERSISTENT_RESERVE_IN ] = "PERSISTENT_RESERVE_IN", 511 [ PERSISTENT_RESERVE_OUT ] = "PERSISTENT_RESERVE_OUT", 512 [ WRITE_FILEMARKS_16 ] = "WRITE_FILEMARKS_16", 513 [ EXTENDED_COPY ] = "EXTENDED_COPY", 514 [ ATA_PASSTHROUGH_16 ] = "ATA_PASSTHROUGH_16", 515 [ ACCESS_CONTROL_IN ] = "ACCESS_CONTROL_IN", 516 [ ACCESS_CONTROL_OUT ] = "ACCESS_CONTROL_OUT", 517 [ READ_16 ] = "READ_16", 518 [ COMPARE_AND_WRITE ] = "COMPARE_AND_WRITE", 519 [ WRITE_16 ] = "WRITE_16", 520 [ WRITE_VERIFY_16 ] = "WRITE_VERIFY_16", 521 [ VERIFY_16 ] = "VERIFY_16", 522 [ PRE_FETCH_16 ] = "PRE_FETCH_16", 523 [ SYNCHRONIZE_CACHE_16 ] = "SPACE_16/SYNCHRONIZE_CACHE_16", 524 /* SPACE_16 and SYNCHRONIZE_CACHE_16 use the same operation code */ 525 [ LOCATE_16 ] = "LOCATE_16", 526 [ WRITE_SAME_16 ] = "ERASE_16/WRITE_SAME_16", 527 /* ERASE_16 and WRITE_SAME_16 use the same operation code */ 528 [ SERVICE_ACTION_IN_16 ] = "SERVICE_ACTION_IN_16", 529 [ WRITE_LONG_16 ] = "WRITE_LONG_16", 530 [ REPORT_LUNS ] = "REPORT_LUNS", 531 [ ATA_PASSTHROUGH_12 ] = "BLANK/ATA_PASSTHROUGH_12", 532 [ MOVE_MEDIUM ] = "MOVE_MEDIUM", 533 [ EXCHANGE_MEDIUM ] = "EXCHANGE MEDIUM", 534 [ READ_12 ] = "READ_12", 535 [ WRITE_12 ] = "WRITE_12", 536 [ ERASE_12 ] = "ERASE_12/GET_PERFORMANCE", 537 /* ERASE_12 and GET_PERFORMANCE use the same operation code */ 538 [ SERVICE_ACTION_IN_12 ] = "SERVICE_ACTION_IN_12", 539 [ WRITE_VERIFY_12 ] = "WRITE_VERIFY_12", 540 [ VERIFY_12 ] = "VERIFY_12", 541 [ SEARCH_HIGH_12 ] = "SEARCH_HIGH_12", 542 [ SEARCH_EQUAL_12 ] = "SEARCH_EQUAL_12", 543 [ SEARCH_LOW_12 ] = "SEARCH_LOW_12", 544 [ READ_ELEMENT_STATUS ] = "READ_ELEMENT_STATUS", 545 [ SEND_VOLUME_TAG ] = "SEND_VOLUME_TAG/SET_STREAMING", 546 /* SEND_VOLUME_TAG and SET_STREAMING use the same operation code */ 547 [ READ_CD ] = "READ_CD", 548 [ READ_DEFECT_DATA_12 ] = "READ_DEFECT_DATA_12", 549 [ READ_DVD_STRUCTURE ] = "READ_DVD_STRUCTURE", 550 [ RESERVE_TRACK ] = "RESERVE_TRACK", 551 [ SEND_CUE_SHEET ] = "SEND_CUE_SHEET", 552 [ SEND_DVD_STRUCTURE ] = "SEND_DVD_STRUCTURE", 553 [ SET_CD_SPEED ] = "SET_CD_SPEED", 554 [ SET_READ_AHEAD ] = "SET_READ_AHEAD", 555 [ ALLOW_OVERWRITE ] = "ALLOW_OVERWRITE", 556 [ MECHANISM_STATUS ] = "MECHANISM_STATUS", 557 [ GET_EVENT_STATUS_NOTIFICATION ] = "GET_EVENT_STATUS_NOTIFICATION", 558 [ READ_DISC_INFORMATION ] = "READ_DISC_INFORMATION", 559 }; 560 561 if (cmd >= ARRAY_SIZE(names) || names[cmd] == NULL) { 562 return "*UNKNOWN*"; 563 } 564 return names[cmd]; 565 } 566 567 #ifdef CONFIG_LINUX 568 int sg_io_sense_from_errno(int errno_value, struct sg_io_hdr *io_hdr, 569 SCSISense *sense) 570 { 571 if (errno_value != 0) { 572 switch (errno_value) { 573 case EDOM: 574 return TASK_SET_FULL; 575 case ENOMEM: 576 *sense = SENSE_CODE(TARGET_FAILURE); 577 return CHECK_CONDITION; 578 default: 579 *sense = SENSE_CODE(IO_ERROR); 580 return CHECK_CONDITION; 581 } 582 } else { 583 if (io_hdr->host_status == SG_ERR_DID_NO_CONNECT || 584 io_hdr->host_status == SG_ERR_DID_BUS_BUSY || 585 io_hdr->host_status == SG_ERR_DID_TIME_OUT || 586 (io_hdr->driver_status & SG_ERR_DRIVER_TIMEOUT)) { 587 return BUSY; 588 } else if (io_hdr->host_status) { 589 *sense = SENSE_CODE(I_T_NEXUS_LOSS); 590 return CHECK_CONDITION; 591 } else if (io_hdr->status) { 592 return io_hdr->status; 593 } else if (io_hdr->driver_status & SG_ERR_DRIVER_SENSE) { 594 return CHECK_CONDITION; 595 } else { 596 return GOOD; 597 } 598 } 599 } 600 #endif 601