[qemu.git] / scsi / utils.c

/*
 *  SCSI helpers
 *
 *  Copyright 2017 Red Hat, Inc.
 *
 *  Authors:
 *   Fam Zheng <[email protected]>
 *   Paolo Bonzini <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 */

#include "qemu/osdep.h"
#include "scsi/constants.h"
#include "scsi/utils.h"
#include "qemu/bswap.h"

uint32_t scsi_data_cdb_xfer(uint8_t *buf)
{
    if ((buf[0] >> 5) == 0 && buf[4] == 0) {
        return 256;
    } else {
        return scsi_cdb_xfer(buf);
    }
}

uint32_t scsi_cdb_xfer(uint8_t *buf)
{
    switch (buf[0] >> 5) {
    case 0:
        return buf[4];
    case 1:
    case 2:
        return lduw_be_p(&buf[7]);
    case 4:
        return ldl_be_p(&buf[10]) & 0xffffffffULL;
    case 5:
        return ldl_be_p(&buf[6]) & 0xffffffffULL;
    default:
        return -1;
    }
}

uint64_t scsi_cmd_lba(SCSICommand *cmd)
{
    uint8_t *buf = cmd->buf;
    uint64_t lba;

    switch (buf[0] >> 5) {
    case 0:
        lba = ldl_be_p(&buf[0]) & 0x1fffff;
        break;
    case 1:
    case 2:
    case 5:
        lba = ldl_be_p(&buf[2]) & 0xffffffffULL;
        break;
    case 4:
        lba = ldq_be_p(&buf[2]);
        break;
    default:
        lba = -1;

    }
    return lba;
}

int scsi_cdb_length(uint8_t *buf)
{
    int cdb_len;

    switch (buf[0] >> 5) {
    case 0:
        cdb_len = 6;
        break;
    case 1:
    case 2:
        cdb_len = 10;
        break;
    case 4:
        cdb_len = 16;
        break;
    case 5:
        cdb_len = 12;
        break;
    default:
        cdb_len = -1;
    }
    return cdb_len;
}

SCSISense scsi_parse_sense_buf(const uint8_t *in_buf, int in_len)
{
    bool fixed_in;
    SCSISense sense;

    assert(in_len > 0);
    fixed_in = (in_buf[0] & 2) == 0;
    if (fixed_in) {
        if (in_len < 14) {
            return SENSE_CODE(IO_ERROR);
        }
        sense.key = in_buf[2];
        sense.asc = in_buf[12];
        sense.ascq = in_buf[13];
    } else {
        if (in_len < 4) {
            return SENSE_CODE(IO_ERROR);
        }
        sense.key = in_buf[1];
        sense.asc = in_buf[2];
        sense.ascq = in_buf[3];
    }

    return sense;
}

int scsi_build_sense_buf(uint8_t *out_buf, size_t size, SCSISense sense,
                         bool fixed_sense)
{
    int len;
    uint8_t buf[SCSI_SENSE_LEN] = { 0 };

    if (fixed_sense) {
        buf[0] = 0x70;
        buf[2] = sense.key;
        buf[7] = 10;
        buf[12] = sense.asc;
        buf[13] = sense.ascq;
        len = 18;
    } else {
        buf[0] = 0x72;
        buf[1] = sense.key;
        buf[2] = sense.asc;
        buf[3] = sense.ascq;
        len = 8;
    }
    len = MIN(len, size);
    memcpy(out_buf, buf, len);
    return len;
}

int scsi_build_sense(uint8_t *buf, SCSISense sense)
{
    return scsi_build_sense_buf(buf, SCSI_SENSE_LEN, sense, true);
}

/*
 * Predefined sense codes
 */

/* No sense data available */
const struct SCSISense sense_code_NO_SENSE = {
    .key = NO_SENSE , .asc = 0x00 , .ascq = 0x00
};

/* LUN not ready, Manual intervention required */
const struct SCSISense sense_code_LUN_NOT_READY = {
    .key = NOT_READY, .asc = 0x04, .ascq = 0x03
};

/* LUN not ready, Medium not present */
const struct SCSISense sense_code_NO_MEDIUM = {
    .key = NOT_READY, .asc = 0x3a, .ascq = 0x00
};

/* LUN not ready, medium removal prevented */
const struct SCSISense sense_code_NOT_READY_REMOVAL_PREVENTED = {
    .key = NOT_READY, .asc = 0x53, .ascq = 0x02
};

/* Hardware error, internal target failure */
const struct SCSISense sense_code_TARGET_FAILURE = {
    .key = HARDWARE_ERROR, .asc = 0x44, .ascq = 0x00
};

/* Illegal request, invalid command operation code */
const struct SCSISense sense_code_INVALID_OPCODE = {
    .key = ILLEGAL_REQUEST, .asc = 0x20, .ascq = 0x00
};

/* Illegal request, LBA out of range */
const struct SCSISense sense_code_LBA_OUT_OF_RANGE = {
    .key = ILLEGAL_REQUEST, .asc = 0x21, .ascq = 0x00
};

/* Illegal request, Invalid field in CDB */
const struct SCSISense sense_code_INVALID_FIELD = {
    .key = ILLEGAL_REQUEST, .asc = 0x24, .ascq = 0x00
};

/* Illegal request, Invalid field in parameter list */
const struct SCSISense sense_code_INVALID_PARAM = {
    .key = ILLEGAL_REQUEST, .asc = 0x26, .ascq = 0x00
};

/* Illegal request, Invalid value in parameter list */
const struct SCSISense sense_code_INVALID_PARAM_VALUE = {
    .key = ILLEGAL_REQUEST, .asc = 0x26, .ascq = 0x01
};

/* Illegal request, Parameter list length error */
const struct SCSISense sense_code_INVALID_PARAM_LEN = {
    .key = ILLEGAL_REQUEST, .asc = 0x1a, .ascq = 0x00
};

/* Illegal request, LUN not supported */
const struct SCSISense sense_code_LUN_NOT_SUPPORTED = {
    .key = ILLEGAL_REQUEST, .asc = 0x25, .ascq = 0x00
};

/* Illegal request, Saving parameters not supported */
const struct SCSISense sense_code_SAVING_PARAMS_NOT_SUPPORTED = {
    .key = ILLEGAL_REQUEST, .asc = 0x39, .ascq = 0x00
};

/* Illegal request, Incompatible medium installed */
const struct SCSISense sense_code_INCOMPATIBLE_FORMAT = {
    .key = ILLEGAL_REQUEST, .asc = 0x30, .ascq = 0x00
};

/* Illegal request, medium removal prevented */
const struct SCSISense sense_code_ILLEGAL_REQ_REMOVAL_PREVENTED = {
    .key = ILLEGAL_REQUEST, .asc = 0x53, .ascq = 0x02
};

/* Illegal request, Invalid Transfer Tag */
const struct SCSISense sense_code_INVALID_TAG = {
    .key = ILLEGAL_REQUEST, .asc = 0x4b, .ascq = 0x01
};

/* Command aborted, I/O process terminated */
const struct SCSISense sense_code_IO_ERROR = {
    .key = ABORTED_COMMAND, .asc = 0x00, .ascq = 0x06
};

/* Command aborted, I_T Nexus loss occurred */
const struct SCSISense sense_code_I_T_NEXUS_LOSS = {
    .key = ABORTED_COMMAND, .asc = 0x29, .ascq = 0x07
};

/* Command aborted, Logical Unit failure */
const struct SCSISense sense_code_LUN_FAILURE = {
    .key = ABORTED_COMMAND, .asc = 0x3e, .ascq = 0x01
};

/* Command aborted, Overlapped Commands Attempted */
const struct SCSISense sense_code_OVERLAPPED_COMMANDS = {
    .key = ABORTED_COMMAND, .asc = 0x4e, .ascq = 0x00
};

/* Command aborted, LUN Communication Failure */
const struct SCSISense sense_code_LUN_COMM_FAILURE = {
    .key = ABORTED_COMMAND, .asc = 0x08, .ascq = 0x00
};

/* Command aborted, LUN does not respond to selection */
const struct SCSISense sense_code_LUN_NOT_RESPONDING = {
    .key = ABORTED_COMMAND, .asc = 0x05, .ascq = 0x00
};

/* Command aborted, Command Timeout during processing */
const struct SCSISense sense_code_COMMAND_TIMEOUT = {
    .key = ABORTED_COMMAND, .asc = 0x2e, .ascq = 0x02
};

/* Command aborted, Commands cleared by device server */
const struct SCSISense sense_code_COMMAND_ABORTED = {
    .key = ABORTED_COMMAND, .asc = 0x2f, .ascq = 0x02
};

/* Medium Error, Unrecovered read error */
const struct SCSISense sense_code_READ_ERROR = {
    .key = MEDIUM_ERROR, .asc = 0x11, .ascq = 0x00
};

/* Not ready, Cause not reportable */
const struct SCSISense sense_code_NOT_READY = {
    .key = NOT_READY, .asc = 0x04, .ascq = 0x00
};

/* Unit attention, Capacity data has changed */
const struct SCSISense sense_code_CAPACITY_CHANGED = {
    .key = UNIT_ATTENTION, .asc = 0x2a, .ascq = 0x09
};

/* Unit attention, Power on, reset or bus device reset occurred */
const struct SCSISense sense_code_RESET = {
    .key = UNIT_ATTENTION, .asc = 0x29, .ascq = 0x00
};

/* Unit attention, SCSI bus reset */
const struct SCSISense sense_code_SCSI_BUS_RESET = {
    .key = UNIT_ATTENTION, .asc = 0x29, .ascq = 0x02
};

/* Unit attention, No medium */
const struct SCSISense sense_code_UNIT_ATTENTION_NO_MEDIUM = {
    .key = UNIT_ATTENTION, .asc = 0x3a, .ascq = 0x00
};

/* Unit attention, Medium may have changed */
const struct SCSISense sense_code_MEDIUM_CHANGED = {
    .key = UNIT_ATTENTION, .asc = 0x28, .ascq = 0x00
};

/* Unit attention, Reported LUNs data has changed */
const struct SCSISense sense_code_REPORTED_LUNS_CHANGED = {
    .key = UNIT_ATTENTION, .asc = 0x3f, .ascq = 0x0e
};

/* Unit attention, Device internal reset */
const struct SCSISense sense_code_DEVICE_INTERNAL_RESET = {
    .key = UNIT_ATTENTION, .asc = 0x29, .ascq = 0x04
};

/* Data Protection, Write Protected */
const struct SCSISense sense_code_WRITE_PROTECTED = {
    .key = DATA_PROTECT, .asc = 0x27, .ascq = 0x00
};

/* Data Protection, Space Allocation Failed Write Protect */
const struct SCSISense sense_code_SPACE_ALLOC_FAILED = {
    .key = DATA_PROTECT, .asc = 0x27, .ascq = 0x07
};

/*
 * scsi_convert_sense
 *
 * Convert between fixed and descriptor sense buffers
 */
int scsi_convert_sense(uint8_t *in_buf, int in_len,
                       uint8_t *buf, int len, bool fixed)
{
    SCSISense sense;
    bool fixed_in;

    if (in_len == 0) {
        return scsi_build_sense_buf(buf, len, SENSE_CODE(NO_SENSE), fixed);
    }

    fixed_in = (in_buf[0] & 2) == 0;
    if (fixed == fixed_in) {
        memcpy(buf, in_buf, MIN(len, in_len));
        return MIN(len, in_len);
    } else {
        sense = scsi_parse_sense_buf(in_buf, in_len);
        return scsi_build_sense_buf(buf, len, sense, fixed);
    }
}

static bool scsi_sense_is_guest_recoverable(int key, int asc, int ascq)
{
    switch (key) {
    case NO_SENSE:
    case RECOVERED_ERROR:
    case UNIT_ATTENTION:
    case ABORTED_COMMAND:
        return true;
    case NOT_READY:
    case ILLEGAL_REQUEST:
    case DATA_PROTECT:
        /* Parse ASCQ */
        break;
    default:
        return false;
    }

    switch ((asc << 8) | ascq) {
    case 0x1a00: /* PARAMETER LIST LENGTH ERROR */
    case 0x2000: /* INVALID OPERATION CODE */
    case 0x2400: /* INVALID FIELD IN CDB */
    case 0x2500: /* LOGICAL UNIT NOT SUPPORTED */
    case 0x2600: /* INVALID FIELD IN PARAMETER LIST */

    case 0x2104: /* UNALIGNED WRITE COMMAND */
    case 0x2105: /* WRITE BOUNDARY VIOLATION */
    case 0x2106: /* ATTEMPT TO READ INVALID DATA */
    case 0x550e: /* INSUFFICIENT ZONE RESOURCES */

    case 0x0401: /* NOT READY, IN PROGRESS OF BECOMING READY */
    case 0x0402: /* NOT READY, INITIALIZING COMMAND REQUIRED */
        return true;
    default:
        return false;
    }
}

int scsi_sense_to_errno(int key, int asc, int ascq)
{
    switch (key) {
    case NO_SENSE:
    case RECOVERED_ERROR:
    case UNIT_ATTENTION:
        return EAGAIN;
    case ABORTED_COMMAND: /* COMMAND ABORTED */
        return ECANCELED;
    case NOT_READY:
    case ILLEGAL_REQUEST:
    case DATA_PROTECT:
        /* Parse ASCQ */
        break;
    default:
        return EIO;
    }
    switch ((asc << 8) | ascq) {
    case 0x1a00: /* PARAMETER LIST LENGTH ERROR */
    case 0x2000: /* INVALID OPERATION CODE */
    case 0x2400: /* INVALID FIELD IN CDB */
    case 0x2600: /* INVALID FIELD IN PARAMETER LIST */
        return EINVAL;
    case 0x2100: /* LBA OUT OF RANGE */
    case 0x2707: /* SPACE ALLOC FAILED */
        return ENOSPC;
    case 0x2500: /* LOGICAL UNIT NOT SUPPORTED */
        return ENOTSUP;
    case 0x3a00: /* MEDIUM NOT PRESENT */
    case 0x3a01: /* MEDIUM NOT PRESENT TRAY CLOSED */
    case 0x3a02: /* MEDIUM NOT PRESENT TRAY OPEN */
        return ENOMEDIUM;
    case 0x2700: /* WRITE PROTECTED */
        return EACCES;
    case 0x0401: /* NOT READY, IN PROGRESS OF BECOMING READY */
        return EINPROGRESS;
    case 0x0402: /* NOT READY, INITIALIZING COMMAND REQUIRED */
        return ENOTCONN;
    default:
        return EIO;
    }
}

int scsi_sense_buf_to_errno(const uint8_t *in_buf, size_t in_len)
{
    SCSISense sense;
    if (in_len < 1) {
        return EIO;
    }

    sense = scsi_parse_sense_buf(in_buf, in_len);
    return scsi_sense_to_errno(sense.key, sense.asc, sense.ascq);
}

bool scsi_sense_buf_is_guest_recoverable(const uint8_t *in_buf, size_t in_len)
{
    SCSISense sense;
    if (in_len < 1) {
        return false;
    }

    sense = scsi_parse_sense_buf(in_buf, in_len);
    return scsi_sense_is_guest_recoverable(sense.key, sense.asc, sense.ascq);
}

const char *scsi_command_name(uint8_t cmd)
{
    static const char *names[] = {
        [ TEST_UNIT_READY          ] = "TEST_UNIT_READY",
        [ REWIND                   ] = "REWIND",
        [ REQUEST_SENSE            ] = "REQUEST_SENSE",
        [ FORMAT_UNIT              ] = "FORMAT_UNIT",
        [ READ_BLOCK_LIMITS        ] = "READ_BLOCK_LIMITS",
        [ REASSIGN_BLOCKS          ] = "REASSIGN_BLOCKS/INITIALIZE ELEMENT STATUS",
        /* LOAD_UNLOAD and INITIALIZE_ELEMENT_STATUS use the same operation code */
        [ READ_6                   ] = "READ_6",
        [ WRITE_6                  ] = "WRITE_6",
        [ SET_CAPACITY             ] = "SET_CAPACITY",
        [ READ_REVERSE             ] = "READ_REVERSE",
        [ WRITE_FILEMARKS          ] = "WRITE_FILEMARKS",
        [ SPACE                    ] = "SPACE",
        [ INQUIRY                  ] = "INQUIRY",
        [ RECOVER_BUFFERED_DATA    ] = "RECOVER_BUFFERED_DATA",
        [ MAINTENANCE_IN           ] = "MAINTENANCE_IN",
        [ MAINTENANCE_OUT          ] = "MAINTENANCE_OUT",
        [ MODE_SELECT              ] = "MODE_SELECT",
        [ RESERVE                  ] = "RESERVE",
        [ RELEASE                  ] = "RELEASE",
        [ COPY                     ] = "COPY",
        [ ERASE                    ] = "ERASE",
        [ MODE_SENSE               ] = "MODE_SENSE",
        [ START_STOP               ] = "START_STOP/LOAD_UNLOAD",
        /* LOAD_UNLOAD and START_STOP use the same operation code */
        [ RECEIVE_DIAGNOSTIC       ] = "RECEIVE_DIAGNOSTIC",
        [ SEND_DIAGNOSTIC          ] = "SEND_DIAGNOSTIC",
        [ ALLOW_MEDIUM_REMOVAL     ] = "ALLOW_MEDIUM_REMOVAL",
        [ READ_CAPACITY_10         ] = "READ_CAPACITY_10",
        [ READ_10                  ] = "READ_10",
        [ WRITE_10                 ] = "WRITE_10",
        [ SEEK_10                  ] = "SEEK_10/POSITION_TO_ELEMENT",
        /* SEEK_10 and POSITION_TO_ELEMENT use the same operation code */
        [ WRITE_VERIFY_10          ] = "WRITE_VERIFY_10",
        [ VERIFY_10                ] = "VERIFY_10",
        [ SEARCH_HIGH              ] = "SEARCH_HIGH",
        [ SEARCH_EQUAL             ] = "SEARCH_EQUAL",
        [ SEARCH_LOW               ] = "SEARCH_LOW",
        [ SET_LIMITS               ] = "SET_LIMITS",
        [ PRE_FETCH                ] = "PRE_FETCH/READ_POSITION",
        /* READ_POSITION and PRE_FETCH use the same operation code */
        [ SYNCHRONIZE_CACHE        ] = "SYNCHRONIZE_CACHE",
        [ LOCK_UNLOCK_CACHE        ] = "LOCK_UNLOCK_CACHE",
        [ READ_DEFECT_DATA         ] = "READ_DEFECT_DATA/INITIALIZE_ELEMENT_STATUS_WITH_RANGE",
        /* READ_DEFECT_DATA and INITIALIZE_ELEMENT_STATUS_WITH_RANGE use the same operation code */
        [ MEDIUM_SCAN              ] = "MEDIUM_SCAN",
        [ COMPARE                  ] = "COMPARE",
        [ COPY_VERIFY              ] = "COPY_VERIFY",
        [ WRITE_BUFFER             ] = "WRITE_BUFFER",
        [ READ_BUFFER              ] = "READ_BUFFER",
        [ UPDATE_BLOCK             ] = "UPDATE_BLOCK",
        [ READ_LONG_10             ] = "READ_LONG_10",
        [ WRITE_LONG_10            ] = "WRITE_LONG_10",
        [ CHANGE_DEFINITION        ] = "CHANGE_DEFINITION",
        [ WRITE_SAME_10            ] = "WRITE_SAME_10",
        [ UNMAP                    ] = "UNMAP",
        [ READ_TOC                 ] = "READ_TOC",
        [ REPORT_DENSITY_SUPPORT   ] = "REPORT_DENSITY_SUPPORT",
        [ SANITIZE                 ] = "SANITIZE",
        [ GET_CONFIGURATION        ] = "GET_CONFIGURATION",
        [ LOG_SELECT               ] = "LOG_SELECT",
        [ LOG_SENSE                ] = "LOG_SENSE",
        [ MODE_SELECT_10           ] = "MODE_SELECT_10",
        [ RESERVE_10               ] = "RESERVE_10",
        [ RELEASE_10               ] = "RELEASE_10",
        [ MODE_SENSE_10            ] = "MODE_SENSE_10",
        [ PERSISTENT_RESERVE_IN    ] = "PERSISTENT_RESERVE_IN",
        [ PERSISTENT_RESERVE_OUT   ] = "PERSISTENT_RESERVE_OUT",
        [ WRITE_FILEMARKS_16       ] = "WRITE_FILEMARKS_16",
        [ EXTENDED_COPY            ] = "EXTENDED_COPY",
        [ ATA_PASSTHROUGH_16       ] = "ATA_PASSTHROUGH_16",
        [ ACCESS_CONTROL_IN        ] = "ACCESS_CONTROL_IN",
        [ ACCESS_CONTROL_OUT       ] = "ACCESS_CONTROL_OUT",
        [ READ_16                  ] = "READ_16",
        [ COMPARE_AND_WRITE        ] = "COMPARE_AND_WRITE",
        [ WRITE_16                 ] = "WRITE_16",
        [ WRITE_VERIFY_16          ] = "WRITE_VERIFY_16",
        [ VERIFY_16                ] = "VERIFY_16",
        [ PRE_FETCH_16             ] = "PRE_FETCH_16",
        [ SYNCHRONIZE_CACHE_16     ] = "SPACE_16/SYNCHRONIZE_CACHE_16",
        /* SPACE_16 and SYNCHRONIZE_CACHE_16 use the same operation code */
        [ LOCATE_16                ] = "LOCATE_16",
        [ WRITE_SAME_16            ] = "ERASE_16/WRITE_SAME_16",
        /* ERASE_16 and WRITE_SAME_16 use the same operation code */
        [ SERVICE_ACTION_IN_16     ] = "SERVICE_ACTION_IN_16",
        [ WRITE_LONG_16            ] = "WRITE_LONG_16",
        [ REPORT_LUNS              ] = "REPORT_LUNS",
        [ ATA_PASSTHROUGH_12       ] = "BLANK/ATA_PASSTHROUGH_12",
        [ MOVE_MEDIUM              ] = "MOVE_MEDIUM",
        [ EXCHANGE_MEDIUM          ] = "EXCHANGE MEDIUM",
        [ READ_12                  ] = "READ_12",
        [ WRITE_12                 ] = "WRITE_12",
        [ ERASE_12                 ] = "ERASE_12/GET_PERFORMANCE",
        /* ERASE_12 and GET_PERFORMANCE use the same operation code */
        [ SERVICE_ACTION_IN_12     ] = "SERVICE_ACTION_IN_12",
        [ WRITE_VERIFY_12          ] = "WRITE_VERIFY_12",
        [ VERIFY_12                ] = "VERIFY_12",
        [ SEARCH_HIGH_12           ] = "SEARCH_HIGH_12",
        [ SEARCH_EQUAL_12          ] = "SEARCH_EQUAL_12",
        [ SEARCH_LOW_12            ] = "SEARCH_LOW_12",
        [ READ_ELEMENT_STATUS      ] = "READ_ELEMENT_STATUS",
        [ SEND_VOLUME_TAG          ] = "SEND_VOLUME_TAG/SET_STREAMING",
        /* SEND_VOLUME_TAG and SET_STREAMING use the same operation code */
        [ READ_CD                  ] = "READ_CD",
        [ READ_DEFECT_DATA_12      ] = "READ_DEFECT_DATA_12",
        [ READ_DVD_STRUCTURE       ] = "READ_DVD_STRUCTURE",
        [ RESERVE_TRACK            ] = "RESERVE_TRACK",
        [ SEND_CUE_SHEET           ] = "SEND_CUE_SHEET",
        [ SEND_DVD_STRUCTURE       ] = "SEND_DVD_STRUCTURE",
        [ SET_CD_SPEED             ] = "SET_CD_SPEED",
        [ SET_READ_AHEAD           ] = "SET_READ_AHEAD",
        [ ALLOW_OVERWRITE          ] = "ALLOW_OVERWRITE",
        [ MECHANISM_STATUS         ] = "MECHANISM_STATUS",
        [ GET_EVENT_STATUS_NOTIFICATION ] = "GET_EVENT_STATUS_NOTIFICATION",
        [ READ_DISC_INFORMATION    ] = "READ_DISC_INFORMATION",
    };

    if (cmd >= ARRAY_SIZE(names) || names[cmd] == NULL) {
        return "*UNKNOWN*";
    }
    return names[cmd];
}

int scsi_sense_from_errno(int errno_value, SCSISense *sense)
{
    switch (errno_value) {
    case 0:
        return GOOD;
    case EDOM:
        return TASK_SET_FULL;
#ifdef CONFIG_LINUX
        /* These errno mapping are specific to Linux.  For more information:
         * - scsi_check_sense and scsi_decide_disposition in drivers/scsi/scsi_error.c
         * - scsi_result_to_blk_status in drivers/scsi/scsi_lib.c
         * - blk_errors[] in block/blk-core.c
         */
    case EBADE:
        return RESERVATION_CONFLICT;
    case ENODATA:
        *sense = SENSE_CODE(READ_ERROR);
        return CHECK_CONDITION;
    case EREMOTEIO:
        *sense = SENSE_CODE(TARGET_FAILURE);
        return CHECK_CONDITION;
#endif
    case ENOMEDIUM:
        *sense = SENSE_CODE(NO_MEDIUM);
        return CHECK_CONDITION;
    case ENOMEM:
        *sense = SENSE_CODE(TARGET_FAILURE);
        return CHECK_CONDITION;
    case EINVAL:
        *sense = SENSE_CODE(INVALID_FIELD);
        return CHECK_CONDITION;
    case ENOSPC:
        *sense = SENSE_CODE(SPACE_ALLOC_FAILED);
        return CHECK_CONDITION;
    default:
        *sense = SENSE_CODE(IO_ERROR);
        return CHECK_CONDITION;
    }
}

int scsi_sense_from_host_status(uint8_t host_status,
                                SCSISense *sense)
{
    switch (host_status) {
    case SCSI_HOST_NO_LUN:
        *sense = SENSE_CODE(LUN_NOT_RESPONDING);
        return CHECK_CONDITION;
    case SCSI_HOST_BUSY:
        return BUSY;
    case SCSI_HOST_TIME_OUT:
        *sense = SENSE_CODE(COMMAND_TIMEOUT);
        return CHECK_CONDITION;
    case SCSI_HOST_BAD_RESPONSE:
        *sense = SENSE_CODE(LUN_COMM_FAILURE);
        return CHECK_CONDITION;
    case SCSI_HOST_ABORTED:
        *sense = SENSE_CODE(COMMAND_ABORTED);
        return CHECK_CONDITION;
    case SCSI_HOST_RESET:
        *sense = SENSE_CODE(RESET);
        return CHECK_CONDITION;
    case SCSI_HOST_TRANSPORT_DISRUPTED:
        *sense = SENSE_CODE(I_T_NEXUS_LOSS);
        return CHECK_CONDITION;
    case SCSI_HOST_TARGET_FAILURE:
        *sense = SENSE_CODE(TARGET_FAILURE);
        return CHECK_CONDITION;
    case SCSI_HOST_RESERVATION_ERROR:
        return RESERVATION_CONFLICT;
    case SCSI_HOST_ALLOCATION_FAILURE:
        *sense = SENSE_CODE(SPACE_ALLOC_FAILED);
        return CHECK_CONDITION;
    case SCSI_HOST_MEDIUM_ERROR:
        *sense = SENSE_CODE(READ_ERROR);
        return CHECK_CONDITION;
    }
    return GOOD;
}
Commit	Line	Data
e5b5728c PB	1	/*
	2	* SCSI helpers
	3	*
	4	* Copyright 2017 Red Hat, Inc.
	5	*
	6	* Authors:
	7	* Fam Zheng <[email protected]>
	8	* Paolo Bonzini <[email protected]>
	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"
08e2c9f1	17	#include "scsi/constants.h"
e5b5728c PB	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];
e5b5728c PB	35	case 1:
	36	case 2:
	37	return lduw_be_p(&buf[7]);
e5b5728c PB	38	case 4:
e5b5728c PB	39	return ldl_be_p(&buf[10]) & 0xffffffffULL;
e5b5728c PB	40	case 5:
e5b5728c PB	41	return ldl_be_p(&buf[6]) & 0xffffffffULL;
e5b5728c PB	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
f68d98b2 PB	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
a3760467 PB	146	int scsi_build_sense(uint8_t *buf, SCSISense sense)
a3760467 PB	147	{
f68d98b2	148	return scsi_build_sense_buf(buf, SCSI_SENSE_LEN, sense, true);
a3760467 PB	149	}
a3760467 PB	150
e5b5728c PB	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
2e8f72ac PMD	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
e5b5728c PB	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
fe8fc5ae PB	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
db66a15c HR	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
a4a9b6ea PB	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
e5b5728c PB	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
fe8fc5ae PB	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
e5b5728c PB	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	{
e5b5728c	338	SCSISense sense;
f68d98b2	339	bool fixed_in;
e5b5728c	340
2770c90d PB	341	if (in_len == 0) {
	342	return scsi_build_sense_buf(buf, len, SENSE_CODE(NO_SENSE), fixed);
	343	}
	344
f68d98b2	345	fixed_in = (in_buf[0] & 2) == 0;
2770c90d	346	if (fixed == fixed_in) {
f68d98b2 PB	347	memcpy(buf, in_buf, MIN(len, in_len));
f68d98b2 PB	348	return MIN(len, in_len);
e5b5728c	349	} else {
f68d98b2	350	sense = scsi_parse_sense_buf(in_buf, in_len);
2770c90d	351	return scsi_build_sense_buf(buf, len, sense, fixed);
e5b5728c PB	352	}
	353	}
	354
bdf9613b PB	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
396ce7b9 PB	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
bdf9613b PB	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
e5b5728c PB	392	int scsi_sense_to_errno(int key, int asc, int ascq)
	393	{
	394	switch (key) {
9661e208 PB	395	case NO_SENSE:
	396	case RECOVERED_ERROR:
	397	case UNIT_ATTENTION:
8c460269	398	return EAGAIN;
9661e208	399	case ABORTED_COMMAND: /* COMMAND ABORTED */
e5b5728c	400	return ECANCELED;
9661e208 PB	401	case NOT_READY:
	402	case ILLEGAL_REQUEST:
	403	case DATA_PROTECT:
e5b5728c PB	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 */
8c460269	427	return EINPROGRESS;
e5b5728c PB	428	case 0x0402: /* NOT READY, INITIALIZING COMMAND REQUIRED */
	429	return ENOTCONN;
	430	default:
	431	return EIO;
	432	}
	433	}
	434
f68d98b2	435	int scsi_sense_buf_to_errno(const uint8_t *in_buf, size_t in_len)
e5b5728c	436	{
f68d98b2 PB	437	SCSISense sense;
f68d98b2 PB	438	if (in_len < 1) {
e5b5728c	439	return EIO;
e5b5728c	440	}
f68d98b2 PB	441
	442	sense = scsi_parse_sense_buf(in_buf, in_len);
	443	return scsi_sense_to_errno(sense.key, sense.asc, sense.ascq);
e5b5728c PB	444	}
e5b5728c PB	445
bdf9613b PB	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
e5b5728c PB	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	}
1ead6b4e	582
d7a84021 PB	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:
dc293f60	592	* - scsi_check_sense and scsi_decide_disposition in drivers/scsi/scsi_error.c
d7a84021 PB	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:
dc293f60	602	*sense = SENSE_CODE(TARGET_FAILURE);
d7a84021 PB	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
db66a15c HR	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	}