text: /*
   *  SCSI helpers
   *
   *  Copyright 2017 Red Hat, Inc.
   *
   *  Authors:
   *   Fam Zheng <famz@redhat.com>
   *   Paolo Bonzini <pbonzini@redhat.com>
   *
   * 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;
  }
  