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