drivers/scsi/scsi_common.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * SCSI functions used by both the initiator and the target code.
   4  */
   5
   6 #include <linux/bug.h>
   7 #include <linux/kernel.h>
   8 #include <linux/string.h>
   9 #include <linux/errno.h>
  10 #include <linux/module.h>
  11 #include <asm/unaligned.h>
  12 #include <scsi/scsi_common.h>
  13
  14 MODULE_LICENSE("GPL v2");
  15
  16 /* Command group 3 is reserved and should never be used.  */
  17 const unsigned char scsi_command_size_tbl[8] = {
  18         6, 10, 10, 12, 16, 12, 10, 10
  19 };
  20 EXPORT_SYMBOL(scsi_command_size_tbl);
  21
  22 /* NB: These are exposed through /proc/scsi/scsi and form part of the ABI.
  23  * You may not alter any existing entry (although adding new ones is
  24  * encouraged once assigned by ANSI/INCITS T10).
  25  */
  26 static const char *const scsi_device_types[] = {
  27         "Direct-Access    ",
  28         "Sequential-Access",
  29         "Printer          ",
  30         "Processor        ",
  31         "WORM             ",
  32         "CD-ROM           ",
  33         "Scanner          ",
  34         "Optical Device   ",
  35         "Medium Changer   ",
  36         "Communications   ",
  37         "ASC IT8          ",
  38         "ASC IT8          ",
  39         "RAID             ",
  40         "Enclosure        ",
  41         "Direct-Access-RBC",
  42         "Optical card     ",
  43         "Bridge controller",
  44         "Object storage   ",
  45         "Automation/Drive ",
  46         "Security Manager ",
  47         "Direct-Access-ZBC",
  48 };
  49
  50 /**
  51  * scsi_device_type - Return 17-char string indicating device type.
  52  * @type: type number to look up
  53  */
  54 const char *scsi_device_type(unsigned type)
  55 {
  56         if (type == 0x1e)
  57                 return "Well-known LUN   ";
  58         if (type == 0x1f)
  59                 return "No Device        ";
  60         if (type >= ARRAY_SIZE(scsi_device_types))
  61                 return "Unknown          ";
  62         return scsi_device_types[type];
  63 }
  64 EXPORT_SYMBOL(scsi_device_type);
  65
  66 /**
  67  * scsilun_to_int - convert a scsi_lun to an int
  68  * @scsilun:    struct scsi_lun to be converted.
  69  *
  70  * Description:
  71  *     Convert @scsilun from a struct scsi_lun to a four-byte host byte-ordered
  72  *     integer, and return the result. The caller must check for
  73  *     truncation before using this function.
  74  *
  75  * Notes:
  76  *     For a description of the LUN format, post SCSI-3 see the SCSI
  77  *     Architecture Model, for SCSI-3 see the SCSI Controller Commands.
  78  *
  79  *     Given a struct scsi_lun of: d2 04 0b 03 00 00 00 00, this function
  80  *     returns the integer: 0x0b03d204
  81  *
  82  *     This encoding will return a standard integer LUN for LUNs smaller
  83  *     than 256, which typically use a single level LUN structure with
  84  *     addressing method 0.
  85  */
  86 u64 scsilun_to_int(struct scsi_lun *scsilun)
  87 {
  88         int i;
  89         u64 lun;
  90
  91         lun = 0;
  92         for (i = 0; i < sizeof(lun); i += 2)
  93                 lun = lun | (((u64)scsilun->scsi_lun[i] << ((i + 1) * 8)) |
  94                              ((u64)scsilun->scsi_lun[i + 1] << (i * 8)));
  95         return lun;
  96 }
  97 EXPORT_SYMBOL(scsilun_to_int);
  98
  99 /**
 100  * int_to_scsilun - reverts an int into a scsi_lun
 101  * @lun:        integer to be reverted
 102  * @scsilun:    struct scsi_lun to be set.
 103  *
 104  * Description:
 105  *     Reverts the functionality of the scsilun_to_int, which packed
 106  *     an 8-byte lun value into an int. This routine unpacks the int
 107  *     back into the lun value.
 108  *
 109  * Notes:
 110  *     Given an integer : 0x0b03d204, this function returns a
 111  *     struct scsi_lun of: d2 04 0b 03 00 00 00 00
 112  *
 113  */
 114 void int_to_scsilun(u64 lun, struct scsi_lun *scsilun)
 115 {
 116         int i;
 117
 118         memset(scsilun->scsi_lun, 0, sizeof(scsilun->scsi_lun));
 119
 120         for (i = 0; i < sizeof(lun); i += 2) {
 121                 scsilun->scsi_lun[i] = (lun >> 8) & 0xFF;
 122                 scsilun->scsi_lun[i+1] = lun & 0xFF;
 123                 lun = lun >> 16;
 124         }
 125 }
 126 EXPORT_SYMBOL(int_to_scsilun);
 127
 128 /**
 129  * scsi_normalize_sense - normalize main elements from either fixed or
 130  *                      descriptor sense data format into a common format.
 131  *
 132  * @sense_buffer:       byte array containing sense data returned by device
 133  * @sb_len:             number of valid bytes in sense_buffer
 134  * @sshdr:              pointer to instance of structure that common
 135  *                      elements are written to.
 136  *
 137  * Notes:
 138  *      The "main elements" from sense data are: response_code, sense_key,
 139  *      asc, ascq and additional_length (only for descriptor format).
 140  *
 141  *      Typically this function can be called after a device has
 142  *      responded to a SCSI command with the CHECK_CONDITION status.
 143  *
 144  * Return value:
 145  *      true if valid sense data information found, else false;
 146  */
 147 bool scsi_normalize_sense(const u8 *sense_buffer, int sb_len,
 148                           struct scsi_sense_hdr *sshdr)
 149 {
 150         memset(sshdr, 0, sizeof(struct scsi_sense_hdr));
 151
 152         if (!sense_buffer || !sb_len)
 153                 return false;
 154
 155         sshdr->response_code = (sense_buffer[0] & 0x7f);
 156
 157         if (!scsi_sense_valid(sshdr))
 158                 return false;
 159
 160         if (sshdr->response_code >= 0x72) {
 161                 /*
 162                  * descriptor format
 163                  */
 164                 if (sb_len > 1)
 165                         sshdr->sense_key = (sense_buffer[1] & 0xf);
 166                 if (sb_len > 2)
 167                         sshdr->asc = sense_buffer[2];
 168                 if (sb_len > 3)
 169                         sshdr->ascq = sense_buffer[3];
 170                 if (sb_len > 7)
 171                         sshdr->additional_length = sense_buffer[7];
 172         } else {
 173                 /*
 174                  * fixed format
 175                  */
 176                 if (sb_len > 2)
 177                         sshdr->sense_key = (sense_buffer[2] & 0xf);
 178                 if (sb_len > 7) {
 179                         sb_len = (sb_len < (sense_buffer[7] + 8)) ?
 180                                          sb_len : (sense_buffer[7] + 8);
 181                         if (sb_len > 12)
 182                                 sshdr->asc = sense_buffer[12];
 183                         if (sb_len > 13)
 184                                 sshdr->ascq = sense_buffer[13];
 185                 }
 186         }
 187
 188         return true;
 189 }
 190 EXPORT_SYMBOL(scsi_normalize_sense);
 191
 192 /**
 193  * scsi_sense_desc_find - search for a given descriptor type in descriptor sense data format.
 194  * @sense_buffer:       byte array of descriptor format sense data
 195  * @sb_len:             number of valid bytes in sense_buffer
 196  * @desc_type:          value of descriptor type to find
 197  *                      (e.g. 0 -> information)
 198  *
 199  * Notes:
 200  *      only valid when sense data is in descriptor format
 201  *
 202  * Return value:
 203  *      pointer to start of (first) descriptor if found else NULL
 204  */
 205 const u8 * scsi_sense_desc_find(const u8 * sense_buffer, int sb_len,
 206                                 int desc_type)
 207 {
 208         int add_sen_len, add_len, desc_len, k;
 209         const u8 * descp;
 210
 211         if ((sb_len < 8) || (0 == (add_sen_len = sense_buffer[7])))
 212                 return NULL;
 213         if ((sense_buffer[0] < 0x72) || (sense_buffer[0] > 0x73))
 214                 return NULL;
 215         add_sen_len = (add_sen_len < (sb_len - 8)) ?
 216                         add_sen_len : (sb_len - 8);
 217         descp = &sense_buffer[8];
 218         for (desc_len = 0, k = 0; k < add_sen_len; k += desc_len) {
 219                 descp += desc_len;
 220                 add_len = (k < (add_sen_len - 1)) ? descp[1]: -1;
 221                 desc_len = add_len + 2;
 222                 if (descp[0] == desc_type)
 223                         return descp;
 224                 if (add_len < 0) // short descriptor ??
 225                         break;
 226         }
 227         return NULL;
 228 }
 229 EXPORT_SYMBOL(scsi_sense_desc_find);
 230
 231 /**
 232  * scsi_build_sense_buffer - build sense data in a buffer
 233  * @desc:       Sense format (non-zero == descriptor format,
 234  *              0 == fixed format)
 235  * @buf:        Where to build sense data
 236  * @key:        Sense key
 237  * @asc:        Additional sense code
 238  * @ascq:       Additional sense code qualifier
 239  *
 240  **/
 241 void scsi_build_sense_buffer(int desc, u8 *buf, u8 key, u8 asc, u8 ascq)
 242 {
 243         if (desc) {
 244                 buf[0] = 0x72;  /* descriptor, current */
 245                 buf[1] = key;
 246                 buf[2] = asc;
 247                 buf[3] = ascq;
 248                 buf[7] = 0;
 249         } else {
 250                 buf[0] = 0x70;  /* fixed, current */
 251                 buf[2] = key;
 252                 buf[7] = 0xa;
 253                 buf[12] = asc;
 254                 buf[13] = ascq;
 255         }
 256 }
 257 EXPORT_SYMBOL(scsi_build_sense_buffer);
 258
 259 /**
 260  * scsi_set_sense_information - set the information field in a
 261  *              formatted sense data buffer
 262  * @buf:        Where to build sense data
 263  * @buf_len:    buffer length
 264  * @info:       64-bit information value to be set
 265  *
 266  * Return value:
 267  *      0 on success or -EINVAL for invalid sense buffer length
 268  **/
 269 int scsi_set_sense_information(u8 *buf, int buf_len, u64 info)
 270 {
 271         if ((buf[0] & 0x7f) == 0x72) {
 272                 u8 *ucp, len;
 273
 274                 len = buf[7];
 275                 ucp = (char *)scsi_sense_desc_find(buf, len + 8, 0);
 276                 if (!ucp) {
 277                         buf[7] = len + 0xc;
 278                         ucp = buf + 8 + len;
 279                 }
 280
 281                 if (buf_len < len + 0xc)
 282                         /* Not enough room for info */
 283                         return -EINVAL;
 284
 285                 ucp[0] = 0;
 286                 ucp[1] = 0xa;
 287                 ucp[2] = 0x80; /* Valid bit */
 288                 ucp[3] = 0;
 289                 put_unaligned_be64(info, &ucp[4]);
 290         } else if ((buf[0] & 0x7f) == 0x70) {
 291                 /*
 292                  * Only set the 'VALID' bit if we can represent the value
 293                  * correctly; otherwise just fill out the lower bytes and
 294                  * clear the 'VALID' flag.
 295                  */
 296                 if (info <= 0xffffffffUL)
 297                         buf[0] |= 0x80;
 298                 else
 299                         buf[0] &= 0x7f;
 300                 put_unaligned_be32((u32)info, &buf[3]);
 301         }
 302
 303         return 0;
 304 }
 305 EXPORT_SYMBOL(scsi_set_sense_information);
 306
 307 /**
 308  * scsi_set_sense_field_pointer - set the field pointer sense key
 309  *              specific information in a formatted sense data buffer
 310  * @buf:        Where to build sense data
 311  * @buf_len:    buffer length
 312  * @fp:         field pointer to be set
 313  * @bp:         bit pointer to be set
 314  * @cd:         command/data bit
 315  *
 316  * Return value:
 317  *      0 on success or -EINVAL for invalid sense buffer length
 318  */
 319 int scsi_set_sense_field_pointer(u8 *buf, int buf_len, u16 fp, u8 bp, bool cd)
 320 {
 321         u8 *ucp, len;
 322
 323         if ((buf[0] & 0x7f) == 0x72) {
 324                 len = buf[7];
 325                 ucp = (char *)scsi_sense_desc_find(buf, len + 8, 2);
 326                 if (!ucp) {
 327                         buf[7] = len + 8;
 328                         ucp = buf + 8 + len;
 329                 }
 330
 331                 if (buf_len < len + 8)
 332                         /* Not enough room for info */
 333                         return -EINVAL;
 334
 335                 ucp[0] = 2;
 336                 ucp[1] = 6;
 337                 ucp[4] = 0x80; /* Valid bit */
 338                 if (cd)
 339                         ucp[4] |= 0x40;
 340                 if (bp < 0x8)
 341                         ucp[4] |= 0x8 | bp;
 342                 put_unaligned_be16(fp, &ucp[5]);
 343         } else if ((buf[0] & 0x7f) == 0x70) {
 344                 len = buf[7];
 345                 if (len < 18)
 346                         buf[7] = 18;
 347
 348                 buf[15] = 0x80;
 349                 if (cd)
 350                         buf[15] |= 0x40;
 351                 if (bp < 0x8)
 352                         buf[15] |= 0x8 | bp;
 353                 put_unaligned_be16(fp, &buf[16]);
 354         }
 355
 356         return 0;
 357 }
 358 EXPORT_SYMBOL(scsi_set_sense_field_pointer);