xref: /openbmc/qemu/scsi/utils.c (revision 1b507e55)
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 
scsi_data_cdb_xfer(uint8_t * buf)21 uint32_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 
scsi_cdb_xfer(uint8_t * buf)30 uint32_t scsi_cdb_xfer(uint8_t *buf)
31 {
32     switch (buf[0] >> 5) {
33     case 0:
34         return buf[4];
35     case 1:
36     case 2:
37         return lduw_be_p(&buf[7]);
38     case 4:
39         return ldl_be_p(&buf[10]) & 0xffffffffULL;
40     case 5:
41         return ldl_be_p(&buf[6]) & 0xffffffffULL;
42     default:
43         return -1;
44     }
45 }
46 
scsi_cmd_lba(SCSICommand * cmd)47 uint64_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 
scsi_cdb_length(uint8_t * buf)71 int 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 
scsi_parse_sense_buf(const uint8_t * in_buf,int in_len)95 SCSISense 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 
scsi_build_sense_buf(uint8_t * out_buf,size_t size,SCSISense sense,bool fixed_sense)121 int 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 
scsi_build_sense(uint8_t * buf,SCSISense sense)146 int scsi_build_sense(uint8_t *buf, SCSISense sense)
147 {
148     return scsi_build_sense_buf(buf, SCSI_SENSE_LEN, sense, true);
149 }
150 
151 /*
152  * Predefined sense codes
153  */
154 
155 /* No sense data available */
156 const struct SCSISense sense_code_NO_SENSE = {
157     .key = NO_SENSE , .asc = 0x00 , .ascq = 0x00
158 };
159 
160 /* LUN not ready, Manual intervention required */
161 const struct SCSISense sense_code_LUN_NOT_READY = {
162     .key = NOT_READY, .asc = 0x04, .ascq = 0x03
163 };
164 
165 /* LUN not ready, Medium not present */
166 const struct SCSISense sense_code_NO_MEDIUM = {
167     .key = NOT_READY, .asc = 0x3a, .ascq = 0x00
168 };
169 
170 /* LUN not ready, medium removal prevented */
171 const struct SCSISense sense_code_NOT_READY_REMOVAL_PREVENTED = {
172     .key = NOT_READY, .asc = 0x53, .ascq = 0x02
173 };
174 
175 /* Hardware error, internal target failure */
176 const struct SCSISense sense_code_TARGET_FAILURE = {
177     .key = HARDWARE_ERROR, .asc = 0x44, .ascq = 0x00
178 };
179 
180 /* Illegal request, invalid command operation code */
181 const struct SCSISense sense_code_INVALID_OPCODE = {
182     .key = ILLEGAL_REQUEST, .asc = 0x20, .ascq = 0x00
183 };
184 
185 /* Illegal request, LBA out of range */
186 const 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 */
191 const struct SCSISense sense_code_INVALID_FIELD = {
192     .key = ILLEGAL_REQUEST, .asc = 0x24, .ascq = 0x00
193 };
194 
195 /* Illegal request, Invalid field in parameter list */
196 const struct SCSISense sense_code_INVALID_PARAM = {
197     .key = ILLEGAL_REQUEST, .asc = 0x26, .ascq = 0x00
198 };
199 
200 /* Illegal request, Invalid value in parameter list */
201 const struct SCSISense sense_code_INVALID_PARAM_VALUE = {
202     .key = ILLEGAL_REQUEST, .asc = 0x26, .ascq = 0x01
203 };
204 
205 /* Illegal request, Parameter list length error */
206 const struct SCSISense sense_code_INVALID_PARAM_LEN = {
207     .key = ILLEGAL_REQUEST, .asc = 0x1a, .ascq = 0x00
208 };
209 
210 /* Illegal request, LUN not supported */
211 const struct SCSISense sense_code_LUN_NOT_SUPPORTED = {
212     .key = ILLEGAL_REQUEST, .asc = 0x25, .ascq = 0x00
213 };
214 
215 /* Illegal request, Saving parameters not supported */
216 const struct SCSISense sense_code_SAVING_PARAMS_NOT_SUPPORTED = {
217     .key = ILLEGAL_REQUEST, .asc = 0x39, .ascq = 0x00
218 };
219 
220 /* Illegal request, Incompatible medium installed */
221 const struct SCSISense sense_code_INCOMPATIBLE_FORMAT = {
222     .key = ILLEGAL_REQUEST, .asc = 0x30, .ascq = 0x00
223 };
224 
225 /* Illegal request, medium removal prevented */
226 const struct SCSISense sense_code_ILLEGAL_REQ_REMOVAL_PREVENTED = {
227     .key = ILLEGAL_REQUEST, .asc = 0x53, .ascq = 0x02
228 };
229 
230 /* Illegal request, Invalid Transfer Tag */
231 const struct SCSISense sense_code_INVALID_TAG = {
232     .key = ILLEGAL_REQUEST, .asc = 0x4b, .ascq = 0x01
233 };
234 
235 /* Command aborted, I/O process terminated */
236 const struct SCSISense sense_code_IO_ERROR = {
237     .key = ABORTED_COMMAND, .asc = 0x00, .ascq = 0x06
238 };
239 
240 /* Command aborted, I_T Nexus loss occurred */
241 const struct SCSISense sense_code_I_T_NEXUS_LOSS = {
242     .key = ABORTED_COMMAND, .asc = 0x29, .ascq = 0x07
243 };
244 
245 /* Command aborted, Logical Unit failure */
246 const struct SCSISense sense_code_LUN_FAILURE = {
247     .key = ABORTED_COMMAND, .asc = 0x3e, .ascq = 0x01
248 };
249 
250 /* Command aborted, Overlapped Commands Attempted */
251 const struct SCSISense sense_code_OVERLAPPED_COMMANDS = {
252     .key = ABORTED_COMMAND, .asc = 0x4e, .ascq = 0x00
253 };
254 
255 /* Command aborted, LUN Communication Failure */
256 const struct SCSISense sense_code_LUN_COMM_FAILURE = {
257     .key = ABORTED_COMMAND, .asc = 0x08, .ascq = 0x00
258 };
259 
260 /* Command aborted, LUN does not respond to selection */
261 const struct SCSISense sense_code_LUN_NOT_RESPONDING = {
262     .key = ABORTED_COMMAND, .asc = 0x05, .ascq = 0x00
263 };
264 
265 /* Command aborted, Command Timeout during processing */
266 const struct SCSISense sense_code_COMMAND_TIMEOUT = {
267     .key = ABORTED_COMMAND, .asc = 0x2e, .ascq = 0x02
268 };
269 
270 /* Command aborted, Commands cleared by device server */
271 const struct SCSISense sense_code_COMMAND_ABORTED = {
272     .key = ABORTED_COMMAND, .asc = 0x2f, .ascq = 0x02
273 };
274 
275 /* Medium Error, Unrecovered read error */
276 const struct SCSISense sense_code_READ_ERROR = {
277     .key = MEDIUM_ERROR, .asc = 0x11, .ascq = 0x00
278 };
279 
280 /* Not ready, Cause not reportable */
281 const struct SCSISense sense_code_NOT_READY = {
282     .key = NOT_READY, .asc = 0x04, .ascq = 0x00
283 };
284 
285 /* Unit attention, Capacity data has changed */
286 const 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 */
291 const struct SCSISense sense_code_RESET = {
292     .key = UNIT_ATTENTION, .asc = 0x29, .ascq = 0x00
293 };
294 
295 /* Unit attention, SCSI bus reset */
296 const struct SCSISense sense_code_SCSI_BUS_RESET = {
297     .key = UNIT_ATTENTION, .asc = 0x29, .ascq = 0x02
298 };
299 
300 /* Unit attention, No medium */
301 const 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 */
306 const struct SCSISense sense_code_MEDIUM_CHANGED = {
307     .key = UNIT_ATTENTION, .asc = 0x28, .ascq = 0x00
308 };
309 
310 /* Unit attention, Reported LUNs data has changed */
311 const struct SCSISense sense_code_REPORTED_LUNS_CHANGED = {
312     .key = UNIT_ATTENTION, .asc = 0x3f, .ascq = 0x0e
313 };
314 
315 /* Unit attention, Device internal reset */
316 const struct SCSISense sense_code_DEVICE_INTERNAL_RESET = {
317     .key = UNIT_ATTENTION, .asc = 0x29, .ascq = 0x04
318 };
319 
320 /* Data Protection, Write Protected */
321 const struct SCSISense sense_code_WRITE_PROTECTED = {
322     .key = DATA_PROTECT, .asc = 0x27, .ascq = 0x00
323 };
324 
325 /* Data Protection, Space Allocation Failed Write Protect */
326 const 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  */
scsi_convert_sense(uint8_t * in_buf,int in_len,uint8_t * buf,int len,bool fixed)335 int scsi_convert_sense(uint8_t *in_buf, int in_len,
336                        uint8_t *buf, int len, bool fixed)
337 {
338     SCSISense sense;
339     bool fixed_in;
340 
341     if (in_len == 0) {
342         return scsi_build_sense_buf(buf, len, SENSE_CODE(NO_SENSE), fixed);
343     }
344 
345     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);
349     } else {
350         sense = scsi_parse_sense_buf(in_buf, in_len);
351         return scsi_build_sense_buf(buf, len, sense, fixed);
352     }
353 }
354 
scsi_sense_is_guest_recoverable(int key,int asc,int ascq)355 static 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 
379     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 
384     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 
scsi_sense_to_errno(int key,int asc,int ascq)392 int scsi_sense_to_errno(int key, int asc, int ascq)
393 {
394     switch (key) {
395     case NO_SENSE:
396     case RECOVERED_ERROR:
397     case UNIT_ATTENTION:
398         return EAGAIN;
399     case ABORTED_COMMAND: /* COMMAND ABORTED */
400         return ECANCELED;
401     case NOT_READY:
402     case ILLEGAL_REQUEST:
403     case DATA_PROTECT:
404         /* 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 */
427         return EINPROGRESS;
428     case 0x0402: /* NOT READY, INITIALIZING COMMAND REQUIRED */
429         return ENOTCONN;
430     default:
431         return EIO;
432     }
433 }
434 
scsi_sense_buf_to_errno(const uint8_t * in_buf,size_t in_len)435 int scsi_sense_buf_to_errno(const uint8_t *in_buf, size_t in_len)
436 {
437     SCSISense sense;
438     if (in_len < 1) {
439         return EIO;
440     }
441 
442     sense = scsi_parse_sense_buf(in_buf, in_len);
443     return scsi_sense_to_errno(sense.key, sense.asc, sense.ascq);
444 }
445 
scsi_sense_buf_is_guest_recoverable(const uint8_t * in_buf,size_t in_len)446 bool 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 
scsi_command_name(uint8_t cmd)457 const 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 }
582 
scsi_sense_from_errno(int errno_value,SCSISense * sense)583 int 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:
592          * - scsi_check_sense and scsi_decide_disposition in drivers/scsi/scsi_error.c
593          * - 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:
602         *sense = SENSE_CODE(TARGET_FAILURE);
603         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 
scsi_sense_from_host_status(uint8_t host_status,SCSISense * sense)623 int 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 }
661