cachepc-qemu

Fork of AMDESE/qemu with changes for cachepc side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-qemu
Log | Files | Refs | Submodules | LICENSE | sfeed.txt

utils.c (21549B)

      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
     21uint32_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
     30uint32_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
     47uint64_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
     71int 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
     95SCSISense 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
    121int 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
    146int 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 */
    156const struct SCSISense sense_code_NO_SENSE = {
    157    .key = NO_SENSE , .asc = 0x00 , .ascq = 0x00
    158};
    159
    160/* LUN not ready, Manual intervention required */
    161const struct SCSISense sense_code_LUN_NOT_READY = {
    162    .key = NOT_READY, .asc = 0x04, .ascq = 0x03
    163};
    164
    165/* LUN not ready, Medium not present */
    166const struct SCSISense sense_code_NO_MEDIUM = {
    167    .key = NOT_READY, .asc = 0x3a, .ascq = 0x00
    168};
    169
    170/* LUN not ready, medium removal prevented */
    171const struct SCSISense sense_code_NOT_READY_REMOVAL_PREVENTED = {
    172    .key = NOT_READY, .asc = 0x53, .ascq = 0x02
    173};
    174
    175/* Hardware error, internal target failure */
    176const struct SCSISense sense_code_TARGET_FAILURE = {
    177    .key = HARDWARE_ERROR, .asc = 0x44, .ascq = 0x00
    178};
    179
    180/* Illegal request, invalid command operation code */
    181const struct SCSISense sense_code_INVALID_OPCODE = {
    182    .key = ILLEGAL_REQUEST, .asc = 0x20, .ascq = 0x00
    183};
    184
    185/* Illegal request, LBA out of range */
    186const 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 */
    191const struct SCSISense sense_code_INVALID_FIELD = {
    192    .key = ILLEGAL_REQUEST, .asc = 0x24, .ascq = 0x00
    193};
    194
    195/* Illegal request, Invalid field in parameter list */
    196const struct SCSISense sense_code_INVALID_PARAM = {
    197    .key = ILLEGAL_REQUEST, .asc = 0x26, .ascq = 0x00
    198};
    199
    200/* Illegal request, Invalid value in parameter list */
    201const struct SCSISense sense_code_INVALID_PARAM_VALUE = {
    202    .key = ILLEGAL_REQUEST, .asc = 0x26, .ascq = 0x01
    203};
    204
    205/* Illegal request, Parameter list length error */
    206const struct SCSISense sense_code_INVALID_PARAM_LEN = {
    207    .key = ILLEGAL_REQUEST, .asc = 0x1a, .ascq = 0x00
    208};
    209
    210/* Illegal request, LUN not supported */
    211const struct SCSISense sense_code_LUN_NOT_SUPPORTED = {
    212    .key = ILLEGAL_REQUEST, .asc = 0x25, .ascq = 0x00
    213};
    214
    215/* Illegal request, Saving parameters not supported */
    216const struct SCSISense sense_code_SAVING_PARAMS_NOT_SUPPORTED = {
    217    .key = ILLEGAL_REQUEST, .asc = 0x39, .ascq = 0x00
    218};
    219
    220/* Illegal request, Incompatible medium installed */
    221const struct SCSISense sense_code_INCOMPATIBLE_FORMAT = {
    222    .key = ILLEGAL_REQUEST, .asc = 0x30, .ascq = 0x00
    223};
    224
    225/* Illegal request, medium removal prevented */
    226const struct SCSISense sense_code_ILLEGAL_REQ_REMOVAL_PREVENTED = {
    227    .key = ILLEGAL_REQUEST, .asc = 0x53, .ascq = 0x02
    228};
    229
    230/* Illegal request, Invalid Transfer Tag */
    231const struct SCSISense sense_code_INVALID_TAG = {
    232    .key = ILLEGAL_REQUEST, .asc = 0x4b, .ascq = 0x01
    233};
    234
    235/* Command aborted, I/O process terminated */
    236const struct SCSISense sense_code_IO_ERROR = {
    237    .key = ABORTED_COMMAND, .asc = 0x00, .ascq = 0x06
    238};
    239
    240/* Command aborted, I_T Nexus loss occurred */
    241const struct SCSISense sense_code_I_T_NEXUS_LOSS = {
    242    .key = ABORTED_COMMAND, .asc = 0x29, .ascq = 0x07
    243};
    244
    245/* Command aborted, Logical Unit failure */
    246const struct SCSISense sense_code_LUN_FAILURE = {
    247    .key = ABORTED_COMMAND, .asc = 0x3e, .ascq = 0x01
    248};
    249
    250/* Command aborted, Overlapped Commands Attempted */
    251const struct SCSISense sense_code_OVERLAPPED_COMMANDS = {
    252    .key = ABORTED_COMMAND, .asc = 0x4e, .ascq = 0x00
    253};
    254
    255/* Command aborted, LUN Communication Failure */
    256const 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 */
    261const struct SCSISense sense_code_LUN_NOT_RESPONDING = {
    262    .key = ABORTED_COMMAND, .asc = 0x05, .ascq = 0x00
    263};
    264
    265/* Command aborted, Command Timeout during processing */
    266const struct SCSISense sense_code_COMMAND_TIMEOUT = {
    267    .key = ABORTED_COMMAND, .asc = 0x2e, .ascq = 0x02
    268};
    269
    270/* Command aborted, Commands cleared by device server */
    271const struct SCSISense sense_code_COMMAND_ABORTED = {
    272    .key = ABORTED_COMMAND, .asc = 0x2f, .ascq = 0x02
    273};
    274
    275/* Medium Error, Unrecovered read error */
    276const struct SCSISense sense_code_READ_ERROR = {
    277    .key = MEDIUM_ERROR, .asc = 0x11, .ascq = 0x00
    278};
    279
    280/* Not ready, Cause not reportable */
    281const struct SCSISense sense_code_NOT_READY = {
    282    .key = NOT_READY, .asc = 0x04, .ascq = 0x00
    283};
    284
    285/* Unit attention, Capacity data has changed */
    286const 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 */
    291const struct SCSISense sense_code_RESET = {
    292    .key = UNIT_ATTENTION, .asc = 0x29, .ascq = 0x00
    293};
    294
    295/* Unit attention, SCSI bus reset */
    296const struct SCSISense sense_code_SCSI_BUS_RESET = {
    297    .key = UNIT_ATTENTION, .asc = 0x29, .ascq = 0x02
    298};
    299
    300/* Unit attention, No medium */
    301const 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 */
    306const struct SCSISense sense_code_MEDIUM_CHANGED = {
    307    .key = UNIT_ATTENTION, .asc = 0x28, .ascq = 0x00
    308};
    309
    310/* Unit attention, Reported LUNs data has changed */
    311const struct SCSISense sense_code_REPORTED_LUNS_CHANGED = {
    312    .key = UNIT_ATTENTION, .asc = 0x3f, .ascq = 0x0e
    313};
    314
    315/* Unit attention, Device internal reset */
    316const struct SCSISense sense_code_DEVICE_INTERNAL_RESET = {
    317    .key = UNIT_ATTENTION, .asc = 0x29, .ascq = 0x04
    318};
    319
    320/* Data Protection, Write Protected */
    321const struct SCSISense sense_code_WRITE_PROTECTED = {
    322    .key = DATA_PROTECT, .asc = 0x27, .ascq = 0x00
    323};
    324
    325/* Data Protection, Space Allocation Failed Write Protect */
    326const 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 */
    335int 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
    355static 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
    392int 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
    435int 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
    446bool 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
    457const 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
    583int 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
    623int 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}