Coverage Report

Created: 2026-11-20 08:13

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qemu/scsi/utils.c
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
}