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