scsi/utils.c

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