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