2 #include "qemu-error.h"
9 static char *scsibus_get_fw_dev_path(DeviceState
*dev
);
11 static struct BusInfo scsi_bus_info
= {
13 .size
= sizeof(SCSIBus
),
14 .get_fw_dev_path
= scsibus_get_fw_dev_path
,
15 .props
= (Property
[]) {
16 DEFINE_PROP_UINT32("scsi-id", SCSIDevice
, id
, -1),
17 DEFINE_PROP_END_OF_LIST(),
20 static int next_scsi_bus
;
22 /* Create a scsi bus, and attach devices to it. */
23 void scsi_bus_new(SCSIBus
*bus
, DeviceState
*host
, int tcq
, int ndev
,
24 const SCSIBusOps
*ops
)
26 qbus_create_inplace(&bus
->qbus
, &scsi_bus_info
, host
, NULL
);
27 bus
->busnr
= next_scsi_bus
++;
31 bus
->qbus
.allow_hotplug
= 1;
34 static int scsi_qdev_init(DeviceState
*qdev
, DeviceInfo
*base
)
36 SCSIDevice
*dev
= DO_UPCAST(SCSIDevice
, qdev
, qdev
);
37 SCSIDeviceInfo
*info
= DO_UPCAST(SCSIDeviceInfo
, qdev
, base
);
38 SCSIBus
*bus
= DO_UPCAST(SCSIBus
, qbus
, dev
->qdev
.parent_bus
);
42 for (dev
->id
= 0; dev
->id
< bus
->ndev
; dev
->id
++) {
43 if (bus
->devs
[dev
->id
] == NULL
)
47 if (dev
->id
>= bus
->ndev
) {
48 error_report("bad scsi device id: %d", dev
->id
);
52 if (bus
->devs
[dev
->id
]) {
53 qdev_free(&bus
->devs
[dev
->id
]->qdev
);
55 bus
->devs
[dev
->id
] = dev
;
58 QTAILQ_INIT(&dev
->requests
);
59 rc
= dev
->info
->init(dev
);
61 bus
->devs
[dev
->id
] = NULL
;
68 static int scsi_qdev_exit(DeviceState
*qdev
)
70 SCSIDevice
*dev
= DO_UPCAST(SCSIDevice
, qdev
, qdev
);
71 SCSIBus
*bus
= DO_UPCAST(SCSIBus
, qbus
, dev
->qdev
.parent_bus
);
73 assert(bus
->devs
[dev
->id
] != NULL
);
74 if (bus
->devs
[dev
->id
]->info
->destroy
) {
75 bus
->devs
[dev
->id
]->info
->destroy(bus
->devs
[dev
->id
]);
77 bus
->devs
[dev
->id
] = NULL
;
81 void scsi_qdev_register(SCSIDeviceInfo
*info
)
83 info
->qdev
.bus_info
= &scsi_bus_info
;
84 info
->qdev
.init
= scsi_qdev_init
;
85 info
->qdev
.unplug
= qdev_simple_unplug_cb
;
86 info
->qdev
.exit
= scsi_qdev_exit
;
87 qdev_register(&info
->qdev
);
90 /* handle legacy '-drive if=scsi,...' cmd line args */
91 SCSIDevice
*scsi_bus_legacy_add_drive(SCSIBus
*bus
, BlockDriverState
*bdrv
,
92 int unit
, bool removable
)
97 driver
= bdrv_is_sg(bdrv
) ? "scsi-generic" : "scsi-disk";
98 dev
= qdev_create(&bus
->qbus
, driver
);
99 qdev_prop_set_uint32(dev
, "scsi-id", unit
);
100 if (qdev_prop_exists(dev
, "removable")) {
101 qdev_prop_set_bit(dev
, "removable", removable
);
103 if (qdev_prop_set_drive(dev
, "drive", bdrv
) < 0) {
107 if (qdev_init(dev
) < 0)
109 return DO_UPCAST(SCSIDevice
, qdev
, dev
);
112 int scsi_bus_legacy_handle_cmdline(SCSIBus
*bus
)
119 for (unit
= 0; unit
< bus
->ndev
; unit
++) {
120 dinfo
= drive_get(IF_SCSI
, bus
->busnr
, unit
);
124 qemu_opts_loc_restore(dinfo
->opts
);
125 if (!scsi_bus_legacy_add_drive(bus
, dinfo
->bdrv
, unit
, false)) {
134 SCSIRequest
*scsi_req_alloc(size_t size
, SCSIDevice
*d
, uint32_t tag
, uint32_t lun
)
138 req
= qemu_mallocz(size
);
140 req
->bus
= scsi_bus_from_device(d
);
145 trace_scsi_req_alloc(req
->dev
->id
, req
->lun
, req
->tag
);
149 int32_t scsi_req_enqueue(SCSIRequest
*req
, uint8_t *buf
)
153 assert(!req
->enqueued
);
155 req
->enqueued
= true;
156 QTAILQ_INSERT_TAIL(&req
->dev
->requests
, req
, next
);
159 rc
= req
->dev
->info
->send_command(req
, buf
);
164 static void scsi_req_dequeue(SCSIRequest
*req
)
166 trace_scsi_req_dequeue(req
->dev
->id
, req
->lun
, req
->tag
);
168 QTAILQ_REMOVE(&req
->dev
->requests
, req
, next
);
169 req
->enqueued
= false;
174 static int scsi_req_length(SCSIRequest
*req
, uint8_t *cmd
)
176 switch (cmd
[0] >> 5) {
178 req
->cmd
.xfer
= cmd
[4];
180 /* length 0 means 256 blocks */
181 if (req
->cmd
.xfer
== 0)
186 req
->cmd
.xfer
= cmd
[8] | (cmd
[7] << 8);
190 req
->cmd
.xfer
= cmd
[13] | (cmd
[12] << 8) | (cmd
[11] << 16) | (cmd
[10] << 24);
194 req
->cmd
.xfer
= cmd
[9] | (cmd
[8] << 8) | (cmd
[7] << 16) | (cmd
[6] << 24);
198 trace_scsi_req_parse_bad(req
->dev
->id
, req
->lun
, req
->tag
, cmd
[0]);
203 case TEST_UNIT_READY
:
207 case WRITE_FILEMARKS
:
212 case ALLOW_MEDIUM_REMOVAL
:
215 case SYNCHRONIZE_CACHE
:
216 case LOCK_UNLOCK_CACHE
:
233 case READ_BLOCK_LIMITS
:
239 case SEND_VOLUME_TAG
:
249 case WRITE_VERIFY_12
:
251 case WRITE_VERIFY_16
:
252 req
->cmd
.xfer
*= req
->dev
->blocksize
;
257 case RECOVER_BUFFERED_DATA
:
260 req
->cmd
.xfer
*= req
->dev
->blocksize
;
263 req
->cmd
.xfer
= cmd
[4] | (cmd
[3] << 8);
265 case MAINTENANCE_OUT
:
267 if (req
->dev
->type
== TYPE_ROM
) {
268 /* GPCMD_REPORT_KEY and GPCMD_SEND_KEY from multi media commands */
269 req
->cmd
.xfer
= cmd
[9] | (cmd
[8] << 8);
276 static int scsi_req_stream_length(SCSIRequest
*req
, uint8_t *cmd
)
279 /* stream commands */
282 case RECOVER_BUFFERED_DATA
:
285 req
->cmd
.xfer
= cmd
[4] | (cmd
[3] << 8) | (cmd
[2] << 16);
286 if (cmd
[1] & 0x01) /* fixed */
287 req
->cmd
.xfer
*= req
->dev
->blocksize
;
294 /* generic commands */
296 return scsi_req_length(req
, cmd
);
301 static void scsi_req_xfer_mode(SCSIRequest
*req
)
303 switch (req
->cmd
.buf
[0]) {
308 case WRITE_VERIFY_12
:
310 case WRITE_VERIFY_16
:
314 case CHANGE_DEFINITION
:
318 case SEND_DIAGNOSTIC
:
321 case REASSIGN_BLOCKS
:
329 case SEARCH_EQUAL_12
:
333 case SEND_VOLUME_TAG
:
335 case PERSISTENT_RESERVE_OUT
:
336 case MAINTENANCE_OUT
:
337 req
->cmd
.mode
= SCSI_XFER_TO_DEV
;
341 req
->cmd
.mode
= SCSI_XFER_FROM_DEV
;
343 req
->cmd
.mode
= SCSI_XFER_NONE
;
349 static uint64_t scsi_req_lba(SCSIRequest
*req
)
351 uint8_t *buf
= req
->cmd
.buf
;
354 switch (buf
[0] >> 5) {
356 lba
= (uint64_t) buf
[3] | ((uint64_t) buf
[2] << 8) |
357 (((uint64_t) buf
[1] & 0x1f) << 16);
361 lba
= (uint64_t) buf
[5] | ((uint64_t) buf
[4] << 8) |
362 ((uint64_t) buf
[3] << 16) | ((uint64_t) buf
[2] << 24);
365 lba
= (uint64_t) buf
[9] | ((uint64_t) buf
[8] << 8) |
366 ((uint64_t) buf
[7] << 16) | ((uint64_t) buf
[6] << 24) |
367 ((uint64_t) buf
[5] << 32) | ((uint64_t) buf
[4] << 40) |
368 ((uint64_t) buf
[3] << 48) | ((uint64_t) buf
[2] << 56);
371 lba
= (uint64_t) buf
[5] | ((uint64_t) buf
[4] << 8) |
372 ((uint64_t) buf
[3] << 16) | ((uint64_t) buf
[2] << 24);
381 int scsi_req_parse(SCSIRequest
*req
, uint8_t *buf
)
385 if (req
->dev
->type
== TYPE_TAPE
) {
386 rc
= scsi_req_stream_length(req
, buf
);
388 rc
= scsi_req_length(req
, buf
);
393 memcpy(req
->cmd
.buf
, buf
, req
->cmd
.len
);
394 scsi_req_xfer_mode(req
);
395 req
->cmd
.lba
= scsi_req_lba(req
);
396 trace_scsi_req_parsed(req
->dev
->id
, req
->lun
, req
->tag
, buf
[0],
397 req
->cmd
.mode
, req
->cmd
.xfer
, req
->cmd
.lba
);
402 * Predefined sense codes
405 /* No sense data available */
406 const struct SCSISense sense_code_NO_SENSE
= {
407 .key
= NO_SENSE
, .asc
= 0x00 , .ascq
= 0x00
410 /* LUN not ready, Manual intervention required */
411 const struct SCSISense sense_code_LUN_NOT_READY
= {
412 .key
= NOT_READY
, .asc
= 0x04, .ascq
= 0x03
415 /* LUN not ready, Medium not present */
416 const struct SCSISense sense_code_NO_MEDIUM
= {
417 .key
= NOT_READY
, .asc
= 0x3a, .ascq
= 0x00
420 /* Hardware error, internal target failure */
421 const struct SCSISense sense_code_TARGET_FAILURE
= {
422 .key
= HARDWARE_ERROR
, .asc
= 0x44, .ascq
= 0x00
425 /* Illegal request, invalid command operation code */
426 const struct SCSISense sense_code_INVALID_OPCODE
= {
427 .key
= ILLEGAL_REQUEST
, .asc
= 0x20, .ascq
= 0x00
430 /* Illegal request, LBA out of range */
431 const struct SCSISense sense_code_LBA_OUT_OF_RANGE
= {
432 .key
= ILLEGAL_REQUEST
, .asc
= 0x21, .ascq
= 0x00
435 /* Illegal request, Invalid field in CDB */
436 const struct SCSISense sense_code_INVALID_FIELD
= {
437 .key
= ILLEGAL_REQUEST
, .asc
= 0x24, .ascq
= 0x00
440 /* Illegal request, LUN not supported */
441 const struct SCSISense sense_code_LUN_NOT_SUPPORTED
= {
442 .key
= ILLEGAL_REQUEST
, .asc
= 0x25, .ascq
= 0x00
445 /* Command aborted, I/O process terminated */
446 const struct SCSISense sense_code_IO_ERROR
= {
447 .key
= ABORTED_COMMAND
, .asc
= 0x00, .ascq
= 0x06
450 /* Command aborted, I_T Nexus loss occurred */
451 const struct SCSISense sense_code_I_T_NEXUS_LOSS
= {
452 .key
= ABORTED_COMMAND
, .asc
= 0x29, .ascq
= 0x07
455 /* Command aborted, Logical Unit failure */
456 const struct SCSISense sense_code_LUN_FAILURE
= {
457 .key
= ABORTED_COMMAND
, .asc
= 0x3e, .ascq
= 0x01
463 * Build a sense buffer
465 int scsi_build_sense(SCSISense sense
, uint8_t *buf
, int len
, int fixed
)
467 if (!fixed
&& len
< 8) {
473 /* Return fixed format sense buffer */
478 buf
[13] = sense
.ascq
;
481 /* Return descriptor format sense buffer */
490 static const char *scsi_command_name(uint8_t cmd
)
492 static const char *names
[] = {
493 [ TEST_UNIT_READY
] = "TEST_UNIT_READY",
494 [ REZERO_UNIT
] = "REZERO_UNIT",
495 /* REWIND and REZERO_UNIT use the same operation code */
496 [ REQUEST_SENSE
] = "REQUEST_SENSE",
497 [ FORMAT_UNIT
] = "FORMAT_UNIT",
498 [ READ_BLOCK_LIMITS
] = "READ_BLOCK_LIMITS",
499 [ REASSIGN_BLOCKS
] = "REASSIGN_BLOCKS",
500 [ READ_6
] = "READ_6",
501 [ WRITE_6
] = "WRITE_6",
502 [ SEEK_6
] = "SEEK_6",
503 [ READ_REVERSE
] = "READ_REVERSE",
504 [ WRITE_FILEMARKS
] = "WRITE_FILEMARKS",
506 [ INQUIRY
] = "INQUIRY",
507 [ RECOVER_BUFFERED_DATA
] = "RECOVER_BUFFERED_DATA",
508 [ MAINTENANCE_IN
] = "MAINTENANCE_IN",
509 [ MAINTENANCE_OUT
] = "MAINTENANCE_OUT",
510 [ MODE_SELECT
] = "MODE_SELECT",
511 [ RESERVE
] = "RESERVE",
512 [ RELEASE
] = "RELEASE",
515 [ MODE_SENSE
] = "MODE_SENSE",
516 [ START_STOP
] = "START_STOP",
517 [ RECEIVE_DIAGNOSTIC
] = "RECEIVE_DIAGNOSTIC",
518 [ SEND_DIAGNOSTIC
] = "SEND_DIAGNOSTIC",
519 [ ALLOW_MEDIUM_REMOVAL
] = "ALLOW_MEDIUM_REMOVAL",
521 [ SET_WINDOW
] = "SET_WINDOW",
522 [ READ_CAPACITY
] = "READ_CAPACITY",
523 [ READ_10
] = "READ_10",
524 [ WRITE_10
] = "WRITE_10",
525 [ SEEK_10
] = "SEEK_10",
526 [ WRITE_VERIFY
] = "WRITE_VERIFY",
527 [ VERIFY
] = "VERIFY",
528 [ SEARCH_HIGH
] = "SEARCH_HIGH",
529 [ SEARCH_EQUAL
] = "SEARCH_EQUAL",
530 [ SEARCH_LOW
] = "SEARCH_LOW",
531 [ SET_LIMITS
] = "SET_LIMITS",
532 [ PRE_FETCH
] = "PRE_FETCH",
533 /* READ_POSITION and PRE_FETCH use the same operation code */
534 [ SYNCHRONIZE_CACHE
] = "SYNCHRONIZE_CACHE",
535 [ LOCK_UNLOCK_CACHE
] = "LOCK_UNLOCK_CACHE",
536 [ READ_DEFECT_DATA
] = "READ_DEFECT_DATA",
537 [ MEDIUM_SCAN
] = "MEDIUM_SCAN",
538 [ COMPARE
] = "COMPARE",
539 [ COPY_VERIFY
] = "COPY_VERIFY",
540 [ WRITE_BUFFER
] = "WRITE_BUFFER",
541 [ READ_BUFFER
] = "READ_BUFFER",
542 [ UPDATE_BLOCK
] = "UPDATE_BLOCK",
543 [ READ_LONG
] = "READ_LONG",
544 [ WRITE_LONG
] = "WRITE_LONG",
545 [ CHANGE_DEFINITION
] = "CHANGE_DEFINITION",
546 [ WRITE_SAME
] = "WRITE_SAME",
547 [ READ_TOC
] = "READ_TOC",
548 [ LOG_SELECT
] = "LOG_SELECT",
549 [ LOG_SENSE
] = "LOG_SENSE",
550 [ MODE_SELECT_10
] = "MODE_SELECT_10",
551 [ RESERVE_10
] = "RESERVE_10",
552 [ RELEASE_10
] = "RELEASE_10",
553 [ MODE_SENSE_10
] = "MODE_SENSE_10",
554 [ PERSISTENT_RESERVE_IN
] = "PERSISTENT_RESERVE_IN",
555 [ PERSISTENT_RESERVE_OUT
] = "PERSISTENT_RESERVE_OUT",
556 [ MOVE_MEDIUM
] = "MOVE_MEDIUM",
557 [ READ_12
] = "READ_12",
558 [ WRITE_12
] = "WRITE_12",
559 [ WRITE_VERIFY_12
] = "WRITE_VERIFY_12",
560 [ SEARCH_HIGH_12
] = "SEARCH_HIGH_12",
561 [ SEARCH_EQUAL_12
] = "SEARCH_EQUAL_12",
562 [ SEARCH_LOW_12
] = "SEARCH_LOW_12",
563 [ READ_ELEMENT_STATUS
] = "READ_ELEMENT_STATUS",
564 [ SEND_VOLUME_TAG
] = "SEND_VOLUME_TAG",
565 [ WRITE_LONG_2
] = "WRITE_LONG_2",
567 [ REPORT_DENSITY_SUPPORT
] = "REPORT_DENSITY_SUPPORT",
568 [ GET_CONFIGURATION
] = "GET_CONFIGURATION",
569 [ READ_16
] = "READ_16",
570 [ WRITE_16
] = "WRITE_16",
571 [ WRITE_VERIFY_16
] = "WRITE_VERIFY_16",
572 [ SERVICE_ACTION_IN
] = "SERVICE_ACTION_IN",
573 [ REPORT_LUNS
] = "REPORT_LUNS",
574 [ LOAD_UNLOAD
] = "LOAD_UNLOAD",
575 [ SET_CD_SPEED
] = "SET_CD_SPEED",
579 if (cmd
>= ARRAY_SIZE(names
) || names
[cmd
] == NULL
)
584 SCSIRequest
*scsi_req_ref(SCSIRequest
*req
)
590 void scsi_req_unref(SCSIRequest
*req
)
592 if (--req
->refcount
== 0) {
593 if (req
->dev
->info
->free_req
) {
594 req
->dev
->info
->free_req(req
);
600 /* Called by the devices when data is ready for the HBA. The HBA should
601 start a DMA operation to read or fill the device's data buffer.
602 Once it completes, calling one of req->dev->info->read_data or
603 req->dev->info->write_data (depending on the direction of the
604 transfer) will restart I/O. */
605 void scsi_req_data(SCSIRequest
*req
, int len
)
607 trace_scsi_req_data(req
->dev
->id
, req
->lun
, req
->tag
, len
);
608 req
->bus
->ops
->complete(req
, SCSI_REASON_DATA
, len
);
611 void scsi_req_print(SCSIRequest
*req
)
616 fprintf(fp
, "[%s id=%d] %s",
617 req
->dev
->qdev
.parent_bus
->name
,
619 scsi_command_name(req
->cmd
.buf
[0]));
620 for (i
= 1; i
< req
->cmd
.len
; i
++) {
621 fprintf(fp
, " 0x%02x", req
->cmd
.buf
[i
]);
623 switch (req
->cmd
.mode
) {
625 fprintf(fp
, " - none\n");
627 case SCSI_XFER_FROM_DEV
:
628 fprintf(fp
, " - from-dev len=%zd\n", req
->cmd
.xfer
);
630 case SCSI_XFER_TO_DEV
:
631 fprintf(fp
, " - to-dev len=%zd\n", req
->cmd
.xfer
);
634 fprintf(fp
, " - Oops\n");
639 void scsi_req_complete(SCSIRequest
*req
)
641 assert(req
->status
!= -1);
643 scsi_req_dequeue(req
);
644 req
->bus
->ops
->complete(req
, SCSI_REASON_DONE
, req
->status
);
648 void scsi_req_cancel(SCSIRequest
*req
)
650 if (req
->dev
&& req
->dev
->info
->cancel_io
) {
651 req
->dev
->info
->cancel_io(req
);
654 scsi_req_dequeue(req
);
655 if (req
->bus
->ops
->cancel
) {
656 req
->bus
->ops
->cancel(req
);
661 void scsi_req_abort(SCSIRequest
*req
, int status
)
663 req
->status
= status
;
664 if (req
->dev
&& req
->dev
->info
->cancel_io
) {
665 req
->dev
->info
->cancel_io(req
);
667 scsi_req_complete(req
);
670 void scsi_device_purge_requests(SCSIDevice
*sdev
)
674 while (!QTAILQ_EMPTY(&sdev
->requests
)) {
675 req
= QTAILQ_FIRST(&sdev
->requests
);
676 scsi_req_cancel(req
);
680 static char *scsibus_get_fw_dev_path(DeviceState
*dev
)
682 SCSIDevice
*d
= (SCSIDevice
*)dev
;
683 SCSIBus
*bus
= scsi_bus_from_device(d
);
687 for (i
= 0; i
< bus
->ndev
; i
++) {
688 if (bus
->devs
[i
] == d
) {
693 assert(i
!= bus
->ndev
);
695 snprintf(path
, sizeof(path
), "%s@%x", qdev_fw_name(dev
), i
);