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