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