Line | Count | Source |
1 | | /* |
2 | | * SCSI helpers |
3 | | * |
4 | | * Copyright 2017 Red Hat, Inc. |
5 | | * |
6 | | * Authors: |
7 | | * Fam Zheng <famz@redhat.com> |
8 | | * Paolo Bonzini <pbonzini@redhat.com> |
9 | | * |
10 | | * This program is free software; you can redistribute it and/or modify it |
11 | | * under the terms of the GNU General Public License as published by the Free |
12 | | * Software Foundation; either version 2 of the License, or (at your option) |
13 | | * any later version. |
14 | | */ |
15 | | |
16 | | #include "qemu/osdep.h" |
17 | | #include "scsi/constants.h" |
18 | | #include "scsi/utils.h" |
19 | | #include "qemu/bswap.h" |
20 | | |
21 | | uint32_t scsi_data_cdb_xfer(uint8_t *buf) |
22 | 25.5k | { |
23 | 25.5k | if ((buf[0] >> 5) == 0 && buf[4] == 0) { |
24 | 277 | return 256; |
25 | 25.2k | } else { |
26 | 25.2k | return scsi_cdb_xfer(buf); |
27 | 25.2k | } |
28 | 25.5k | } |
29 | | |
30 | | uint32_t scsi_cdb_xfer(uint8_t *buf) |
31 | 167k | { |
32 | 167k | if (buf[0] == PR_HELPER_CLEANUP) { |
33 | 0 | return 0; |
34 | 0 | } |
35 | 167k | switch (buf[0] >> 5) { |
36 | 56.0k | case 0: |
37 | 56.0k | return buf[4]; |
38 | 43.2k | case 1: |
39 | 73.4k | case 2: |
40 | 73.4k | return lduw_be_p(&buf[7]); |
41 | 13.7k | case 4: |
42 | 13.7k | return ldl_be_p(&buf[10]) & 0xffffffffULL; |
43 | 23.8k | case 5: |
44 | 23.8k | return ldl_be_p(&buf[6]) & 0xffffffffULL; |
45 | 0 | default: |
46 | 0 | return -1; |
47 | 167k | } |
48 | 167k | } |
49 | | |
50 | | uint64_t scsi_cmd_lba(SCSICommand *cmd) |
51 | 141k | { |
52 | 141k | uint8_t *buf = cmd->buf; |
53 | 141k | uint64_t lba; |
54 | | |
55 | 141k | switch (buf[0] >> 5) { |
56 | 54.9k | case 0: |
57 | 54.9k | lba = ldl_be_p(&buf[0]) & 0x1fffff; |
58 | 54.9k | break; |
59 | 30.6k | case 1: |
60 | 59.0k | case 2: |
61 | 74.1k | case 5: |
62 | 74.1k | lba = ldl_be_p(&buf[2]) & 0xffffffffULL; |
63 | 74.1k | break; |
64 | 12.7k | case 4: |
65 | 12.7k | lba = ldq_be_p(&buf[2]); |
66 | 12.7k | break; |
67 | 0 | default: |
68 | 0 | lba = -1; |
69 | | |
70 | 141k | } |
71 | 141k | return lba; |
72 | 141k | } |
73 | | |
74 | | int scsi_cdb_length(uint8_t *buf) |
75 | 259k | { |
76 | 259k | int cdb_len; |
77 | | |
78 | 259k | switch (buf[0] >> 5) { |
79 | 98.2k | case 0: |
80 | 98.2k | cdb_len = 6; |
81 | 98.2k | break; |
82 | 36.5k | case 1: |
83 | 84.6k | case 2: |
84 | 84.6k | cdb_len = 10; |
85 | 84.6k | break; |
86 | 25.1k | case 4: |
87 | 25.1k | cdb_len = 16; |
88 | 25.1k | break; |
89 | 29.4k | case 5: |
90 | 29.4k | cdb_len = 12; |
91 | 29.4k | break; |
92 | 22.1k | default: |
93 | 22.1k | cdb_len = -1; |
94 | 259k | } |
95 | 259k | return cdb_len; |
96 | 259k | } |
97 | | |
98 | | SCSISense scsi_parse_sense_buf(const uint8_t *in_buf, int in_len) |
99 | 267 | { |
100 | 267 | bool fixed_in; |
101 | 267 | SCSISense sense; |
102 | | |
103 | 267 | assert(in_len > 0); |
104 | 267 | fixed_in = (in_buf[0] & 2) == 0; |
105 | 267 | if (fixed_in) { |
106 | 267 | if (in_len < 14) { |
107 | 0 | return SENSE_CODE(IO_ERROR); |
108 | 0 | } |
109 | 267 | sense.key = in_buf[2]; |
110 | 267 | sense.asc = in_buf[12]; |
111 | 267 | sense.ascq = in_buf[13]; |
112 | 267 | } else { |
113 | 0 | if (in_len < 4) { |
114 | 0 | return SENSE_CODE(IO_ERROR); |
115 | 0 | } |
116 | 0 | sense.key = in_buf[1]; |
117 | 0 | sense.asc = in_buf[2]; |
118 | 0 | sense.ascq = in_buf[3]; |
119 | 0 | } |
120 | | |
121 | 267 | return sense; |
122 | 267 | } |
123 | | |
124 | | int scsi_build_sense_buf(uint8_t *out_buf, size_t size, SCSISense sense, |
125 | | bool fixed_sense) |
126 | 80.9k | { |
127 | 80.9k | int len; |
128 | 80.9k | uint8_t buf[SCSI_SENSE_LEN] = { 0 }; |
129 | | |
130 | 80.9k | if (fixed_sense) { |
131 | 80.2k | buf[0] = 0x70; |
132 | 80.2k | buf[2] = sense.key; |
133 | 80.2k | buf[7] = 10; |
134 | 80.2k | buf[12] = sense.asc; |
135 | 80.2k | buf[13] = sense.ascq; |
136 | 80.2k | len = 18; |
137 | 80.2k | } else { |
138 | 675 | buf[0] = 0x72; |
139 | 675 | buf[1] = sense.key; |
140 | 675 | buf[2] = sense.asc; |
141 | 675 | buf[3] = sense.ascq; |
142 | 675 | len = 8; |
143 | 675 | } |
144 | 80.9k | len = MIN(len, size); |
145 | 80.9k | memcpy(out_buf, buf, len); |
146 | 80.9k | return len; |
147 | 80.9k | } |
148 | | |
149 | | int scsi_build_sense(uint8_t *buf, SCSISense sense) |
150 | 78.7k | { |
151 | 78.7k | return scsi_build_sense_buf(buf, SCSI_SENSE_LEN, sense, true); |
152 | 78.7k | } |
153 | | |
154 | | /* |
155 | | * Predefined sense codes |
156 | | */ |
157 | | |
158 | | /* No sense data available */ |
159 | | const struct SCSISense sense_code_NO_SENSE = { |
160 | | .key = NO_SENSE , .asc = 0x00 , .ascq = 0x00 |
161 | | }; |
162 | | |
163 | | /* LUN not ready, Manual intervention required */ |
164 | | const struct SCSISense sense_code_LUN_NOT_READY = { |
165 | | .key = NOT_READY, .asc = 0x04, .ascq = 0x03 |
166 | | }; |
167 | | |
168 | | /* LUN not ready, Medium not present */ |
169 | | const struct SCSISense sense_code_NO_MEDIUM = { |
170 | | .key = NOT_READY, .asc = 0x3a, .ascq = 0x00 |
171 | | }; |
172 | | |
173 | | /* LUN not ready, medium removal prevented */ |
174 | | const struct SCSISense sense_code_NOT_READY_REMOVAL_PREVENTED = { |
175 | | .key = NOT_READY, .asc = 0x53, .ascq = 0x02 |
176 | | }; |
177 | | |
178 | | /* Hardware error, internal target failure */ |
179 | | const struct SCSISense sense_code_TARGET_FAILURE = { |
180 | | .key = HARDWARE_ERROR, .asc = 0x44, .ascq = 0x00 |
181 | | }; |
182 | | |
183 | | /* Illegal request, invalid command operation code */ |
184 | | const struct SCSISense sense_code_INVALID_OPCODE = { |
185 | | .key = ILLEGAL_REQUEST, .asc = 0x20, .ascq = 0x00 |
186 | | }; |
187 | | |
188 | | /* Illegal request, LBA out of range */ |
189 | | const struct SCSISense sense_code_LBA_OUT_OF_RANGE = { |
190 | | .key = ILLEGAL_REQUEST, .asc = 0x21, .ascq = 0x00 |
191 | | }; |
192 | | |
193 | | /* Illegal request, Invalid field in CDB */ |
194 | | const struct SCSISense sense_code_INVALID_FIELD = { |
195 | | .key = ILLEGAL_REQUEST, .asc = 0x24, .ascq = 0x00 |
196 | | }; |
197 | | |
198 | | /* Illegal request, Invalid field in parameter list */ |
199 | | const struct SCSISense sense_code_INVALID_PARAM = { |
200 | | .key = ILLEGAL_REQUEST, .asc = 0x26, .ascq = 0x00 |
201 | | }; |
202 | | |
203 | | /* Illegal request, Invalid value in parameter list */ |
204 | | const struct SCSISense sense_code_INVALID_PARAM_VALUE = { |
205 | | .key = ILLEGAL_REQUEST, .asc = 0x26, .ascq = 0x01 |
206 | | }; |
207 | | |
208 | | /* Illegal request, Parameter list length error */ |
209 | | const struct SCSISense sense_code_INVALID_PARAM_LEN = { |
210 | | .key = ILLEGAL_REQUEST, .asc = 0x1a, .ascq = 0x00 |
211 | | }; |
212 | | |
213 | | /* Illegal request, LUN not supported */ |
214 | | const struct SCSISense sense_code_LUN_NOT_SUPPORTED = { |
215 | | .key = ILLEGAL_REQUEST, .asc = 0x25, .ascq = 0x00 |
216 | | }; |
217 | | |
218 | | /* Illegal request, Saving parameters not supported */ |
219 | | const struct SCSISense sense_code_SAVING_PARAMS_NOT_SUPPORTED = { |
220 | | .key = ILLEGAL_REQUEST, .asc = 0x39, .ascq = 0x00 |
221 | | }; |
222 | | |
223 | | /* Illegal request, Incompatible medium installed */ |
224 | | const struct SCSISense sense_code_INCOMPATIBLE_FORMAT = { |
225 | | .key = ILLEGAL_REQUEST, .asc = 0x30, .ascq = 0x00 |
226 | | }; |
227 | | |
228 | | /* Illegal request, medium removal prevented */ |
229 | | const struct SCSISense sense_code_ILLEGAL_REQ_REMOVAL_PREVENTED = { |
230 | | .key = ILLEGAL_REQUEST, .asc = 0x53, .ascq = 0x02 |
231 | | }; |
232 | | |
233 | | /* Illegal request, Invalid Transfer Tag */ |
234 | | const struct SCSISense sense_code_INVALID_TAG = { |
235 | | .key = ILLEGAL_REQUEST, .asc = 0x4b, .ascq = 0x01 |
236 | | }; |
237 | | |
238 | | /* Command aborted, I/O process terminated */ |
239 | | const struct SCSISense sense_code_IO_ERROR = { |
240 | | .key = ABORTED_COMMAND, .asc = 0x00, .ascq = 0x06 |
241 | | }; |
242 | | |
243 | | /* Command aborted, I_T Nexus loss occurred */ |
244 | | const struct SCSISense sense_code_I_T_NEXUS_LOSS = { |
245 | | .key = ABORTED_COMMAND, .asc = 0x29, .ascq = 0x07 |
246 | | }; |
247 | | |
248 | | /* Command aborted, Logical Unit failure */ |
249 | | const struct SCSISense sense_code_LUN_FAILURE = { |
250 | | .key = ABORTED_COMMAND, .asc = 0x3e, .ascq = 0x01 |
251 | | }; |
252 | | |
253 | | /* Command aborted, Overlapped Commands Attempted */ |
254 | | const struct SCSISense sense_code_OVERLAPPED_COMMANDS = { |
255 | | .key = ABORTED_COMMAND, .asc = 0x4e, .ascq = 0x00 |
256 | | }; |
257 | | |
258 | | /* Command aborted, LUN Communication Failure */ |
259 | | const struct SCSISense sense_code_LUN_COMM_FAILURE = { |
260 | | .key = ABORTED_COMMAND, .asc = 0x08, .ascq = 0x00 |
261 | | }; |
262 | | |
263 | | /* Command aborted, LUN does not respond to selection */ |
264 | | const struct SCSISense sense_code_LUN_NOT_RESPONDING = { |
265 | | .key = ABORTED_COMMAND, .asc = 0x05, .ascq = 0x00 |
266 | | }; |
267 | | |
268 | | /* Command aborted, Command Timeout during processing */ |
269 | | const struct SCSISense sense_code_COMMAND_TIMEOUT = { |
270 | | .key = ABORTED_COMMAND, .asc = 0x2e, .ascq = 0x02 |
271 | | }; |
272 | | |
273 | | /* Command aborted, Commands cleared by device server */ |
274 | | const struct SCSISense sense_code_COMMAND_ABORTED = { |
275 | | .key = ABORTED_COMMAND, .asc = 0x2f, .ascq = 0x02 |
276 | | }; |
277 | | |
278 | | /* Medium Error, Unrecovered read error */ |
279 | | const struct SCSISense sense_code_READ_ERROR = { |
280 | | .key = MEDIUM_ERROR, .asc = 0x11, .ascq = 0x00 |
281 | | }; |
282 | | |
283 | | /* Not ready, Cause not reportable */ |
284 | | const struct SCSISense sense_code_NOT_READY = { |
285 | | .key = NOT_READY, .asc = 0x04, .ascq = 0x00 |
286 | | }; |
287 | | |
288 | | /* Unit attention, Capacity data has changed */ |
289 | | const struct SCSISense sense_code_CAPACITY_CHANGED = { |
290 | | .key = UNIT_ATTENTION, .asc = 0x2a, .ascq = 0x09 |
291 | | }; |
292 | | |
293 | | /* Unit attention, Power on, reset or bus device reset occurred */ |
294 | | const struct SCSISense sense_code_RESET = { |
295 | | .key = UNIT_ATTENTION, .asc = 0x29, .ascq = 0x00 |
296 | | }; |
297 | | |
298 | | /* Unit attention, SCSI bus reset */ |
299 | | const struct SCSISense sense_code_SCSI_BUS_RESET = { |
300 | | .key = UNIT_ATTENTION, .asc = 0x29, .ascq = 0x02 |
301 | | }; |
302 | | |
303 | | /* Unit attention, No medium */ |
304 | | const struct SCSISense sense_code_UNIT_ATTENTION_NO_MEDIUM = { |
305 | | .key = UNIT_ATTENTION, .asc = 0x3a, .ascq = 0x00 |
306 | | }; |
307 | | |
308 | | /* Unit attention, Medium may have changed */ |
309 | | const struct SCSISense sense_code_MEDIUM_CHANGED = { |
310 | | .key = UNIT_ATTENTION, .asc = 0x28, .ascq = 0x00 |
311 | | }; |
312 | | |
313 | | /* Unit attention, Reported LUNs data has changed */ |
314 | | const struct SCSISense sense_code_REPORTED_LUNS_CHANGED = { |
315 | | .key = UNIT_ATTENTION, .asc = 0x3f, .ascq = 0x0e |
316 | | }; |
317 | | |
318 | | /* Unit attention, Device internal reset */ |
319 | | const struct SCSISense sense_code_DEVICE_INTERNAL_RESET = { |
320 | | .key = UNIT_ATTENTION, .asc = 0x29, .ascq = 0x04 |
321 | | }; |
322 | | |
323 | | /* Data Protection, Write Protected */ |
324 | | const struct SCSISense sense_code_WRITE_PROTECTED = { |
325 | | .key = DATA_PROTECT, .asc = 0x27, .ascq = 0x00 |
326 | | }; |
327 | | |
328 | | /* Data Protection, Space Allocation Failed Write Protect */ |
329 | | const struct SCSISense sense_code_SPACE_ALLOC_FAILED = { |
330 | | .key = DATA_PROTECT, .asc = 0x27, .ascq = 0x07 |
331 | | }; |
332 | | |
333 | | /* |
334 | | * scsi_convert_sense |
335 | | * |
336 | | * Convert between fixed and descriptor sense buffers |
337 | | */ |
338 | | int scsi_convert_sense(uint8_t *in_buf, int in_len, |
339 | | uint8_t *buf, int len, bool fixed) |
340 | 25.0k | { |
341 | 25.0k | SCSISense sense; |
342 | 25.0k | bool fixed_in; |
343 | | |
344 | 25.0k | if (in_len == 0) { |
345 | 515 | return scsi_build_sense_buf(buf, len, SENSE_CODE(NO_SENSE), fixed); |
346 | 515 | } |
347 | | |
348 | 24.4k | fixed_in = (in_buf[0] & 2) == 0; |
349 | 24.4k | if (fixed == fixed_in) { |
350 | 24.2k | memcpy(buf, in_buf, MIN(len, in_len)); |
351 | 24.2k | return MIN(len, in_len); |
352 | 24.2k | } else { |
353 | 267 | sense = scsi_parse_sense_buf(in_buf, in_len); |
354 | 267 | return scsi_build_sense_buf(buf, len, sense, fixed); |
355 | 267 | } |
356 | 24.4k | } |
357 | | |
358 | | static bool scsi_sense_is_guest_recoverable(int key, int asc, int ascq) |
359 | 0 | { |
360 | 0 | switch (key) { |
361 | 0 | case NO_SENSE: |
362 | 0 | case RECOVERED_ERROR: |
363 | 0 | case UNIT_ATTENTION: |
364 | 0 | case ABORTED_COMMAND: |
365 | 0 | return true; |
366 | 0 | case NOT_READY: |
367 | 0 | case ILLEGAL_REQUEST: |
368 | 0 | case DATA_PROTECT: |
369 | | /* Parse ASCQ */ |
370 | 0 | break; |
371 | 0 | default: |
372 | 0 | return false; |
373 | 0 | } |
374 | | |
375 | 0 | switch ((asc << 8) | ascq) { |
376 | 0 | case 0x1a00: /* PARAMETER LIST LENGTH ERROR */ |
377 | 0 | case 0x2000: /* INVALID OPERATION CODE */ |
378 | 0 | case 0x2400: /* INVALID FIELD IN CDB */ |
379 | 0 | case 0x2600: /* INVALID FIELD IN PARAMETER LIST */ |
380 | |
|
381 | 0 | case 0x2104: /* UNALIGNED WRITE COMMAND */ |
382 | 0 | case 0x2105: /* WRITE BOUNDARY VIOLATION */ |
383 | 0 | case 0x2106: /* ATTEMPT TO READ INVALID DATA */ |
384 | 0 | case 0x550e: /* INSUFFICIENT ZONE RESOURCES */ |
385 | |
|
386 | 0 | case 0x0401: /* NOT READY, IN PROGRESS OF BECOMING READY */ |
387 | 0 | case 0x0402: /* NOT READY, INITIALIZING COMMAND REQUIRED */ |
388 | 0 | return true; |
389 | 0 | default: |
390 | 0 | return false; |
391 | 0 | } |
392 | 0 | } |
393 | | |
394 | | int scsi_sense_to_errno(int key, int asc, int ascq) |
395 | 0 | { |
396 | 0 | switch (key) { |
397 | 0 | case NO_SENSE: |
398 | 0 | case RECOVERED_ERROR: |
399 | 0 | case UNIT_ATTENTION: |
400 | 0 | return EAGAIN; |
401 | 0 | case ABORTED_COMMAND: /* COMMAND ABORTED */ |
402 | 0 | return ECANCELED; |
403 | 0 | case NOT_READY: |
404 | 0 | case ILLEGAL_REQUEST: |
405 | 0 | case DATA_PROTECT: |
406 | | /* Parse ASCQ */ |
407 | 0 | break; |
408 | 0 | default: |
409 | 0 | return EIO; |
410 | 0 | } |
411 | 0 | switch ((asc << 8) | ascq) { |
412 | 0 | case 0x1a00: /* PARAMETER LIST LENGTH ERROR */ |
413 | 0 | case 0x2000: /* INVALID OPERATION CODE */ |
414 | 0 | case 0x2400: /* INVALID FIELD IN CDB */ |
415 | 0 | case 0x2600: /* INVALID FIELD IN PARAMETER LIST */ |
416 | 0 | return EINVAL; |
417 | 0 | case 0x2100: /* LBA OUT OF RANGE */ |
418 | 0 | case 0x2707: /* SPACE ALLOC FAILED */ |
419 | 0 | return ENOSPC; |
420 | 0 | case 0x2500: /* LOGICAL UNIT NOT SUPPORTED */ |
421 | 0 | return ENOTSUP; |
422 | 0 | case 0x3a00: /* MEDIUM NOT PRESENT */ |
423 | 0 | case 0x3a01: /* MEDIUM NOT PRESENT TRAY CLOSED */ |
424 | 0 | case 0x3a02: /* MEDIUM NOT PRESENT TRAY OPEN */ |
425 | 0 | return ENOMEDIUM; |
426 | 0 | case 0x2700: /* WRITE PROTECTED */ |
427 | 0 | return EACCES; |
428 | 0 | case 0x0401: /* NOT READY, IN PROGRESS OF BECOMING READY */ |
429 | 0 | return EINPROGRESS; |
430 | 0 | case 0x0402: /* NOT READY, INITIALIZING COMMAND REQUIRED */ |
431 | 0 | return ENOTCONN; |
432 | 0 | default: |
433 | 0 | return EIO; |
434 | 0 | } |
435 | 0 | } |
436 | | |
437 | | int scsi_sense_buf_to_errno(const uint8_t *in_buf, size_t in_len) |
438 | 0 | { |
439 | 0 | SCSISense sense; |
440 | 0 | if (in_len < 1) { |
441 | 0 | return EIO; |
442 | 0 | } |
443 | | |
444 | 0 | sense = scsi_parse_sense_buf(in_buf, in_len); |
445 | 0 | return scsi_sense_to_errno(sense.key, sense.asc, sense.ascq); |
446 | 0 | } |
447 | | |
448 | | bool scsi_sense_buf_is_guest_recoverable(const uint8_t *in_buf, size_t in_len) |
449 | 0 | { |
450 | 0 | SCSISense sense; |
451 | 0 | if (in_len < 1) { |
452 | 0 | return false; |
453 | 0 | } |
454 | | |
455 | 0 | sense = scsi_parse_sense_buf(in_buf, in_len); |
456 | 0 | return scsi_sense_is_guest_recoverable(sense.key, sense.asc, sense.ascq); |
457 | 0 | } |
458 | | |
459 | | const char *scsi_command_name(uint8_t cmd) |
460 | 10.2k | { |
461 | 10.2k | static const char *names[] = { |
462 | 10.2k | [ TEST_UNIT_READY ] = "TEST_UNIT_READY", |
463 | 10.2k | [ REWIND ] = "REWIND", |
464 | 10.2k | [ REQUEST_SENSE ] = "REQUEST_SENSE", |
465 | 10.2k | [ FORMAT_UNIT ] = "FORMAT_UNIT", |
466 | 10.2k | [ READ_BLOCK_LIMITS ] = "READ_BLOCK_LIMITS", |
467 | 10.2k | [ REASSIGN_BLOCKS ] = "REASSIGN_BLOCKS/INITIALIZE ELEMENT STATUS", |
468 | | /* LOAD_UNLOAD and INITIALIZE_ELEMENT_STATUS use the same operation code */ |
469 | 10.2k | [ READ_6 ] = "READ_6", |
470 | 10.2k | [ WRITE_6 ] = "WRITE_6", |
471 | 10.2k | [ SET_CAPACITY ] = "SET_CAPACITY", |
472 | 10.2k | [ READ_REVERSE ] = "READ_REVERSE", |
473 | 10.2k | [ WRITE_FILEMARKS ] = "WRITE_FILEMARKS", |
474 | 10.2k | [ SPACE ] = "SPACE", |
475 | 10.2k | [ INQUIRY ] = "INQUIRY", |
476 | 10.2k | [ RECOVER_BUFFERED_DATA ] = "RECOVER_BUFFERED_DATA", |
477 | 10.2k | [ MAINTENANCE_IN ] = "MAINTENANCE_IN", |
478 | 10.2k | [ MAINTENANCE_OUT ] = "MAINTENANCE_OUT", |
479 | 10.2k | [ MODE_SELECT ] = "MODE_SELECT", |
480 | 10.2k | [ RESERVE ] = "RESERVE", |
481 | 10.2k | [ RELEASE ] = "RELEASE", |
482 | 10.2k | [ COPY ] = "COPY", |
483 | 10.2k | [ ERASE ] = "ERASE", |
484 | 10.2k | [ MODE_SENSE ] = "MODE_SENSE", |
485 | 10.2k | [ START_STOP ] = "START_STOP/LOAD_UNLOAD", |
486 | | /* LOAD_UNLOAD and START_STOP use the same operation code */ |
487 | 10.2k | [ RECEIVE_DIAGNOSTIC ] = "RECEIVE_DIAGNOSTIC", |
488 | 10.2k | [ SEND_DIAGNOSTIC ] = "SEND_DIAGNOSTIC", |
489 | 10.2k | [ ALLOW_MEDIUM_REMOVAL ] = "ALLOW_MEDIUM_REMOVAL", |
490 | 10.2k | [ READ_CAPACITY_10 ] = "READ_CAPACITY_10", |
491 | 10.2k | [ READ_10 ] = "READ_10", |
492 | 10.2k | [ WRITE_10 ] = "WRITE_10", |
493 | 10.2k | [ SEEK_10 ] = "SEEK_10/POSITION_TO_ELEMENT", |
494 | | /* SEEK_10 and POSITION_TO_ELEMENT use the same operation code */ |
495 | 10.2k | [ WRITE_VERIFY_10 ] = "WRITE_VERIFY_10", |
496 | 10.2k | [ VERIFY_10 ] = "VERIFY_10", |
497 | 10.2k | [ SEARCH_HIGH ] = "SEARCH_HIGH", |
498 | 10.2k | [ SEARCH_EQUAL ] = "SEARCH_EQUAL", |
499 | 10.2k | [ SEARCH_LOW ] = "SEARCH_LOW", |
500 | 10.2k | [ SET_LIMITS ] = "SET_LIMITS", |
501 | 10.2k | [ PRE_FETCH ] = "PRE_FETCH/READ_POSITION", |
502 | | /* READ_POSITION and PRE_FETCH use the same operation code */ |
503 | 10.2k | [ SYNCHRONIZE_CACHE ] = "SYNCHRONIZE_CACHE", |
504 | 10.2k | [ LOCK_UNLOCK_CACHE ] = "LOCK_UNLOCK_CACHE", |
505 | 10.2k | [ READ_DEFECT_DATA ] = "READ_DEFECT_DATA/INITIALIZE_ELEMENT_STATUS_WITH_RANGE", |
506 | | /* READ_DEFECT_DATA and INITIALIZE_ELEMENT_STATUS_WITH_RANGE use the same operation code */ |
507 | 10.2k | [ MEDIUM_SCAN ] = "MEDIUM_SCAN", |
508 | 10.2k | [ COMPARE ] = "COMPARE", |
509 | 10.2k | [ COPY_VERIFY ] = "COPY_VERIFY", |
510 | 10.2k | [ WRITE_BUFFER ] = "WRITE_BUFFER", |
511 | 10.2k | [ READ_BUFFER ] = "READ_BUFFER", |
512 | 10.2k | [ UPDATE_BLOCK ] = "UPDATE_BLOCK", |
513 | 10.2k | [ READ_LONG_10 ] = "READ_LONG_10", |
514 | 10.2k | [ WRITE_LONG_10 ] = "WRITE_LONG_10", |
515 | 10.2k | [ CHANGE_DEFINITION ] = "CHANGE_DEFINITION", |
516 | 10.2k | [ WRITE_SAME_10 ] = "WRITE_SAME_10", |
517 | 10.2k | [ UNMAP ] = "UNMAP", |
518 | 10.2k | [ READ_TOC ] = "READ_TOC", |
519 | 10.2k | [ REPORT_DENSITY_SUPPORT ] = "REPORT_DENSITY_SUPPORT", |
520 | 10.2k | [ SANITIZE ] = "SANITIZE", |
521 | 10.2k | [ GET_CONFIGURATION ] = "GET_CONFIGURATION", |
522 | 10.2k | [ LOG_SELECT ] = "LOG_SELECT", |
523 | 10.2k | [ LOG_SENSE ] = "LOG_SENSE", |
524 | 10.2k | [ MODE_SELECT_10 ] = "MODE_SELECT_10", |
525 | 10.2k | [ RESERVE_10 ] = "RESERVE_10", |
526 | 10.2k | [ RELEASE_10 ] = "RELEASE_10", |
527 | 10.2k | [ MODE_SENSE_10 ] = "MODE_SENSE_10", |
528 | 10.2k | [ PERSISTENT_RESERVE_IN ] = "PERSISTENT_RESERVE_IN", |
529 | 10.2k | [ PERSISTENT_RESERVE_OUT ] = "PERSISTENT_RESERVE_OUT", |
530 | 10.2k | [ WRITE_FILEMARKS_16 ] = "WRITE_FILEMARKS_16", |
531 | 10.2k | [ EXTENDED_COPY ] = "EXTENDED_COPY", |
532 | 10.2k | [ ATA_PASSTHROUGH_16 ] = "ATA_PASSTHROUGH_16", |
533 | 10.2k | [ ACCESS_CONTROL_IN ] = "ACCESS_CONTROL_IN", |
534 | 10.2k | [ ACCESS_CONTROL_OUT ] = "ACCESS_CONTROL_OUT", |
535 | 10.2k | [ READ_16 ] = "READ_16", |
536 | 10.2k | [ COMPARE_AND_WRITE ] = "COMPARE_AND_WRITE", |
537 | 10.2k | [ WRITE_16 ] = "WRITE_16", |
538 | 10.2k | [ WRITE_VERIFY_16 ] = "WRITE_VERIFY_16", |
539 | 10.2k | [ VERIFY_16 ] = "VERIFY_16", |
540 | 10.2k | [ PRE_FETCH_16 ] = "PRE_FETCH_16", |
541 | 10.2k | [ SYNCHRONIZE_CACHE_16 ] = "SPACE_16/SYNCHRONIZE_CACHE_16", |
542 | | /* SPACE_16 and SYNCHRONIZE_CACHE_16 use the same operation code */ |
543 | 10.2k | [ LOCATE_16 ] = "LOCATE_16", |
544 | 10.2k | [ WRITE_SAME_16 ] = "ERASE_16/WRITE_SAME_16", |
545 | | /* ERASE_16 and WRITE_SAME_16 use the same operation code */ |
546 | 10.2k | [ SERVICE_ACTION_IN_16 ] = "SERVICE_ACTION_IN_16", |
547 | 10.2k | [ WRITE_LONG_16 ] = "WRITE_LONG_16", |
548 | 10.2k | [ REPORT_LUNS ] = "REPORT_LUNS", |
549 | 10.2k | [ ATA_PASSTHROUGH_12 ] = "BLANK/ATA_PASSTHROUGH_12", |
550 | 10.2k | [ MOVE_MEDIUM ] = "MOVE_MEDIUM", |
551 | 10.2k | [ EXCHANGE_MEDIUM ] = "EXCHANGE MEDIUM", |
552 | 10.2k | [ READ_12 ] = "READ_12", |
553 | 10.2k | [ WRITE_12 ] = "WRITE_12", |
554 | 10.2k | [ ERASE_12 ] = "ERASE_12/GET_PERFORMANCE", |
555 | | /* ERASE_12 and GET_PERFORMANCE use the same operation code */ |
556 | 10.2k | [ SERVICE_ACTION_IN_12 ] = "SERVICE_ACTION_IN_12", |
557 | 10.2k | [ WRITE_VERIFY_12 ] = "WRITE_VERIFY_12", |
558 | 10.2k | [ VERIFY_12 ] = "VERIFY_12", |
559 | 10.2k | [ SEARCH_HIGH_12 ] = "SEARCH_HIGH_12", |
560 | 10.2k | [ SEARCH_EQUAL_12 ] = "SEARCH_EQUAL_12", |
561 | 10.2k | [ SEARCH_LOW_12 ] = "SEARCH_LOW_12", |
562 | 10.2k | [ READ_ELEMENT_STATUS ] = "READ_ELEMENT_STATUS", |
563 | 10.2k | [ SEND_VOLUME_TAG ] = "SEND_VOLUME_TAG/SET_STREAMING", |
564 | | /* SEND_VOLUME_TAG and SET_STREAMING use the same operation code */ |
565 | 10.2k | [ READ_CD ] = "READ_CD", |
566 | 10.2k | [ READ_DEFECT_DATA_12 ] = "READ_DEFECT_DATA_12", |
567 | 10.2k | [ READ_DVD_STRUCTURE ] = "READ_DVD_STRUCTURE", |
568 | 10.2k | [ RESERVE_TRACK ] = "RESERVE_TRACK", |
569 | 10.2k | [ SEND_CUE_SHEET ] = "SEND_CUE_SHEET", |
570 | 10.2k | [ SEND_DVD_STRUCTURE ] = "SEND_DVD_STRUCTURE", |
571 | 10.2k | [ SET_CD_SPEED ] = "SET_CD_SPEED", |
572 | 10.2k | [ SET_READ_AHEAD ] = "SET_READ_AHEAD", |
573 | 10.2k | [ ALLOW_OVERWRITE ] = "ALLOW_OVERWRITE", |
574 | 10.2k | [ MECHANISM_STATUS ] = "MECHANISM_STATUS", |
575 | 10.2k | [ GET_EVENT_STATUS_NOTIFICATION ] = "GET_EVENT_STATUS_NOTIFICATION", |
576 | 10.2k | [ READ_DISC_INFORMATION ] = "READ_DISC_INFORMATION", |
577 | 10.2k | }; |
578 | | |
579 | 10.2k | if (cmd >= ARRAY_SIZE(names) || names[cmd] == NULL) { |
580 | 1.86k | return "*UNKNOWN*"; |
581 | 1.86k | } |
582 | 8.38k | return names[cmd]; |
583 | 10.2k | } |
584 | | |
585 | | int scsi_sense_from_errno(int errno_value, SCSISense *sense) |
586 | 0 | { |
587 | 0 | switch (errno_value) { |
588 | 0 | case 0: |
589 | 0 | return GOOD; |
590 | 0 | case EDOM: |
591 | 0 | return TASK_SET_FULL; |
592 | 0 | #if ENODEV != ENOMEDIUM |
593 | 0 | case ENODEV: |
594 | | /* |
595 | | * Some of the BSDs have ENODEV and ENOMEDIUM as synonyms. For |
596 | | * everyone else, give a more severe sense code for ENODEV. |
597 | | */ |
598 | 0 | #endif |
599 | 0 | #ifdef CONFIG_LINUX |
600 | | /* These errno mapping are specific to Linux. For more information: |
601 | | * - scsi_check_sense and scsi_decide_disposition in drivers/scsi/scsi_error.c |
602 | | * - scsi_result_to_blk_status in drivers/scsi/scsi_lib.c |
603 | | * - blk_errors[] in block/blk-core.c |
604 | | */ |
605 | 0 | case EREMOTEIO: |
606 | 0 | *sense = SENSE_CODE(TARGET_FAILURE); |
607 | 0 | return CHECK_CONDITION; |
608 | 0 | case EBADE: |
609 | 0 | return RESERVATION_CONFLICT; |
610 | 0 | case ENODATA: |
611 | 0 | *sense = SENSE_CODE(READ_ERROR); |
612 | 0 | return CHECK_CONDITION; |
613 | 0 | #endif |
614 | 0 | case ENOMEDIUM: |
615 | 0 | *sense = SENSE_CODE(NO_MEDIUM); |
616 | 0 | return CHECK_CONDITION; |
617 | 0 | case ENOMEM: |
618 | 0 | *sense = SENSE_CODE(TARGET_FAILURE); |
619 | 0 | return CHECK_CONDITION; |
620 | 0 | case EINVAL: |
621 | 0 | *sense = SENSE_CODE(INVALID_FIELD); |
622 | 0 | return CHECK_CONDITION; |
623 | 0 | case ENOSPC: |
624 | 0 | *sense = SENSE_CODE(SPACE_ALLOC_FAILED); |
625 | 0 | return CHECK_CONDITION; |
626 | 0 | default: |
627 | 0 | *sense = SENSE_CODE(IO_ERROR); |
628 | 0 | return CHECK_CONDITION; |
629 | 0 | } |
630 | 0 | } |
631 | | |
632 | | int scsi_sense_from_host_status(uint8_t host_status, |
633 | | SCSISense *sense) |
634 | 0 | { |
635 | 0 | switch (host_status) { |
636 | 0 | case SCSI_HOST_NO_LUN: |
637 | 0 | *sense = SENSE_CODE(LUN_NOT_RESPONDING); |
638 | 0 | return CHECK_CONDITION; |
639 | 0 | case SCSI_HOST_BUSY: |
640 | 0 | return BUSY; |
641 | 0 | case SCSI_HOST_TIME_OUT: |
642 | 0 | *sense = SENSE_CODE(COMMAND_TIMEOUT); |
643 | 0 | return CHECK_CONDITION; |
644 | 0 | case SCSI_HOST_BAD_RESPONSE: |
645 | 0 | *sense = SENSE_CODE(LUN_COMM_FAILURE); |
646 | 0 | return CHECK_CONDITION; |
647 | 0 | case SCSI_HOST_ABORTED: |
648 | 0 | *sense = SENSE_CODE(COMMAND_ABORTED); |
649 | 0 | return CHECK_CONDITION; |
650 | 0 | case SCSI_HOST_RESET: |
651 | 0 | *sense = SENSE_CODE(RESET); |
652 | 0 | return CHECK_CONDITION; |
653 | 0 | case SCSI_HOST_TRANSPORT_DISRUPTED: |
654 | 0 | *sense = SENSE_CODE(I_T_NEXUS_LOSS); |
655 | 0 | return CHECK_CONDITION; |
656 | 0 | case SCSI_HOST_TARGET_FAILURE: |
657 | 0 | *sense = SENSE_CODE(TARGET_FAILURE); |
658 | 0 | return CHECK_CONDITION; |
659 | 0 | case SCSI_HOST_RESERVATION_ERROR: |
660 | 0 | return RESERVATION_CONFLICT; |
661 | 0 | case SCSI_HOST_ALLOCATION_FAILURE: |
662 | 0 | *sense = SENSE_CODE(SPACE_ALLOC_FAILED); |
663 | 0 | return CHECK_CONDITION; |
664 | 0 | case SCSI_HOST_MEDIUM_ERROR: |
665 | 0 | *sense = SENSE_CODE(READ_ERROR); |
666 | 0 | return CHECK_CONDITION; |
667 | 0 | } |
668 | 0 | return GOOD; |
669 | 0 | } |