2 #include "qemu-error.h"
9 static char *scsibus_get_fw_dev_path(DeviceState
*dev
);
10 static int scsi_build_sense(uint8_t *in_buf
, int in_len
,
11 uint8_t *buf
, int len
, bool fixed
);
13 static struct BusInfo scsi_bus_info
= {
15 .size
= sizeof(SCSIBus
),
16 .get_fw_dev_path
= scsibus_get_fw_dev_path
,
17 .props
= (Property
[]) {
18 DEFINE_PROP_UINT32("scsi-id", SCSIDevice
, id
, -1),
19 DEFINE_PROP_UINT32("lun", SCSIDevice
, lun
, 0),
20 DEFINE_PROP_END_OF_LIST(),
23 static int next_scsi_bus
;
25 /* Create a scsi bus, and attach devices to it. */
26 void scsi_bus_new(SCSIBus
*bus
, DeviceState
*host
, int tcq
, int ndev
,
27 const SCSIBusOps
*ops
)
29 qbus_create_inplace(&bus
->qbus
, &scsi_bus_info
, host
, NULL
);
30 bus
->busnr
= next_scsi_bus
++;
34 bus
->qbus
.allow_hotplug
= 1;
37 static int scsi_qdev_init(DeviceState
*qdev
, DeviceInfo
*base
)
39 SCSIDevice
*dev
= DO_UPCAST(SCSIDevice
, qdev
, qdev
);
40 SCSIDeviceInfo
*info
= DO_UPCAST(SCSIDeviceInfo
, qdev
, base
);
41 SCSIBus
*bus
= DO_UPCAST(SCSIBus
, qbus
, dev
->qdev
.parent_bus
);
45 for (dev
->id
= 0; dev
->id
< bus
->ndev
; dev
->id
++) {
46 if (bus
->devs
[dev
->id
] == NULL
)
50 if (dev
->id
>= bus
->ndev
) {
51 error_report("bad scsi device id: %d", dev
->id
);
55 if (bus
->devs
[dev
->id
]) {
56 qdev_free(&bus
->devs
[dev
->id
]->qdev
);
58 bus
->devs
[dev
->id
] = dev
;
61 QTAILQ_INIT(&dev
->requests
);
62 rc
= dev
->info
->init(dev
);
64 bus
->devs
[dev
->id
] = NULL
;
71 static int scsi_qdev_exit(DeviceState
*qdev
)
73 SCSIDevice
*dev
= DO_UPCAST(SCSIDevice
, qdev
, qdev
);
74 SCSIBus
*bus
= DO_UPCAST(SCSIBus
, qbus
, dev
->qdev
.parent_bus
);
76 assert(bus
->devs
[dev
->id
] != NULL
);
77 if (bus
->devs
[dev
->id
]->info
->destroy
) {
78 bus
->devs
[dev
->id
]->info
->destroy(bus
->devs
[dev
->id
]);
80 bus
->devs
[dev
->id
] = NULL
;
84 void scsi_qdev_register(SCSIDeviceInfo
*info
)
86 info
->qdev
.bus_info
= &scsi_bus_info
;
87 info
->qdev
.init
= scsi_qdev_init
;
88 info
->qdev
.unplug
= qdev_simple_unplug_cb
;
89 info
->qdev
.exit
= scsi_qdev_exit
;
90 qdev_register(&info
->qdev
);
93 /* handle legacy '-drive if=scsi,...' cmd line args */
94 SCSIDevice
*scsi_bus_legacy_add_drive(SCSIBus
*bus
, BlockDriverState
*bdrv
,
95 int unit
, bool removable
)
100 driver
= bdrv_is_sg(bdrv
) ? "scsi-generic" : "scsi-disk";
101 dev
= qdev_create(&bus
->qbus
, driver
);
102 qdev_prop_set_uint32(dev
, "scsi-id", unit
);
103 if (qdev_prop_exists(dev
, "removable")) {
104 qdev_prop_set_bit(dev
, "removable", removable
);
106 if (qdev_prop_set_drive(dev
, "drive", bdrv
) < 0) {
110 if (qdev_init(dev
) < 0)
112 return DO_UPCAST(SCSIDevice
, qdev
, dev
);
115 int scsi_bus_legacy_handle_cmdline(SCSIBus
*bus
)
122 for (unit
= 0; unit
< bus
->ndev
; unit
++) {
123 dinfo
= drive_get(IF_SCSI
, bus
->busnr
, unit
);
127 qemu_opts_loc_restore(dinfo
->opts
);
128 if (!scsi_bus_legacy_add_drive(bus
, dinfo
->bdrv
, unit
, false)) {
137 SCSIRequest
*scsi_req_alloc(SCSIReqOps
*reqops
, SCSIDevice
*d
, uint32_t tag
,
138 uint32_t lun
, void *hba_private
)
142 req
= qemu_mallocz(reqops
->size
);
144 req
->bus
= scsi_bus_from_device(d
);
148 req
->hba_private
= hba_private
;
152 trace_scsi_req_alloc(req
->dev
->id
, req
->lun
, req
->tag
);
156 SCSIRequest
*scsi_req_new(SCSIDevice
*d
, uint32_t tag
, uint32_t lun
,
157 uint8_t *buf
, void *hba_private
)
160 req
= d
->info
->alloc_req(d
, tag
, lun
, hba_private
);
161 memcpy(req
->cmd
.buf
, buf
, 16);
165 uint8_t *scsi_req_get_buf(SCSIRequest
*req
)
167 return req
->ops
->get_buf(req
);
170 int scsi_req_get_sense(SCSIRequest
*req
, uint8_t *buf
, int len
)
173 if (!req
->sense_len
) {
176 return scsi_build_sense(req
->sense
, req
->sense_len
, buf
, len
, true);
179 int scsi_device_get_sense(SCSIDevice
*dev
, uint8_t *buf
, int len
, bool fixed
)
181 return scsi_build_sense(dev
->sense
, dev
->sense_len
, buf
, len
, fixed
);
184 void scsi_req_build_sense(SCSIRequest
*req
, SCSISense sense
)
186 trace_scsi_req_build_sense(req
->dev
->id
, req
->lun
, req
->tag
,
187 sense
.key
, sense
.asc
, sense
.ascq
);
188 memset(req
->sense
, 0, 18);
189 req
->sense
[0] = 0xf0;
190 req
->sense
[2] = sense
.key
;
191 req
->sense
[12] = sense
.asc
;
192 req
->sense
[13] = sense
.ascq
;
196 int32_t scsi_req_enqueue(SCSIRequest
*req
)
200 assert(!req
->enqueued
);
202 req
->enqueued
= true;
203 QTAILQ_INSERT_TAIL(&req
->dev
->requests
, req
, next
);
206 rc
= req
->ops
->send_command(req
, req
->cmd
.buf
);
211 static void scsi_req_dequeue(SCSIRequest
*req
)
213 trace_scsi_req_dequeue(req
->dev
->id
, req
->lun
, req
->tag
);
215 QTAILQ_REMOVE(&req
->dev
->requests
, req
, next
);
216 req
->enqueued
= false;
221 static int scsi_req_length(SCSICommand
*cmd
, SCSIDevice
*dev
, uint8_t *buf
)
223 switch (buf
[0] >> 5) {
227 /* length 0 means 256 blocks */
228 if (cmd
->xfer
== 0) {
234 cmd
->xfer
= buf
[8] | (buf
[7] << 8);
238 cmd
->xfer
= buf
[13] | (buf
[12] << 8) | (buf
[11] << 16) | (buf
[10] << 24);
242 cmd
->xfer
= buf
[9] | (buf
[8] << 8) | (buf
[7] << 16) | (buf
[6] << 24);
250 case TEST_UNIT_READY
:
254 case WRITE_FILEMARKS
:
259 case ALLOW_MEDIUM_REMOVAL
:
262 case SYNCHRONIZE_CACHE
:
263 case LOCK_UNLOCK_CACHE
:
277 case READ_CAPACITY_10
:
280 case READ_BLOCK_LIMITS
:
286 case SEND_VOLUME_TAG
:
293 case WRITE_VERIFY_10
:
296 case WRITE_VERIFY_12
:
298 case WRITE_VERIFY_16
:
299 cmd
->xfer
*= dev
->blocksize
;
304 case RECOVER_BUFFERED_DATA
:
307 cmd
->xfer
*= dev
->blocksize
;
310 cmd
->xfer
= buf
[4] | (buf
[3] << 8);
312 case MAINTENANCE_OUT
:
314 if (dev
->type
== TYPE_ROM
) {
315 /* GPCMD_REPORT_KEY and GPCMD_SEND_KEY from multi media commands */
316 cmd
->xfer
= buf
[9] | (buf
[8] << 8);
323 static int scsi_req_stream_length(SCSICommand
*cmd
, SCSIDevice
*dev
, uint8_t *buf
)
326 /* stream commands */
329 case RECOVER_BUFFERED_DATA
:
332 cmd
->xfer
= buf
[4] | (buf
[3] << 8) | (buf
[2] << 16);
333 if (buf
[1] & 0x01) { /* fixed */
334 cmd
->xfer
*= dev
->blocksize
;
342 /* generic commands */
344 return scsi_req_length(cmd
, dev
, buf
);
349 static void scsi_cmd_xfer_mode(SCSICommand
*cmd
)
351 switch (cmd
->buf
[0]) {
354 case WRITE_VERIFY_10
:
356 case WRITE_VERIFY_12
:
358 case WRITE_VERIFY_16
:
362 case CHANGE_DEFINITION
:
366 case SEND_DIAGNOSTIC
:
369 case REASSIGN_BLOCKS
:
377 case SEARCH_EQUAL_12
:
380 case SEND_VOLUME_TAG
:
381 case PERSISTENT_RESERVE_OUT
:
382 case MAINTENANCE_OUT
:
383 cmd
->mode
= SCSI_XFER_TO_DEV
;
387 cmd
->mode
= SCSI_XFER_FROM_DEV
;
389 cmd
->mode
= SCSI_XFER_NONE
;
395 static uint64_t scsi_cmd_lba(SCSICommand
*cmd
)
397 uint8_t *buf
= cmd
->buf
;
400 switch (buf
[0] >> 5) {
402 lba
= (uint64_t) buf
[3] | ((uint64_t) buf
[2] << 8) |
403 (((uint64_t) buf
[1] & 0x1f) << 16);
407 lba
= (uint64_t) buf
[5] | ((uint64_t) buf
[4] << 8) |
408 ((uint64_t) buf
[3] << 16) | ((uint64_t) buf
[2] << 24);
411 lba
= (uint64_t) buf
[9] | ((uint64_t) buf
[8] << 8) |
412 ((uint64_t) buf
[7] << 16) | ((uint64_t) buf
[6] << 24) |
413 ((uint64_t) buf
[5] << 32) | ((uint64_t) buf
[4] << 40) |
414 ((uint64_t) buf
[3] << 48) | ((uint64_t) buf
[2] << 56);
417 lba
= (uint64_t) buf
[5] | ((uint64_t) buf
[4] << 8) |
418 ((uint64_t) buf
[3] << 16) | ((uint64_t) buf
[2] << 24);
427 int scsi_req_parse(SCSIRequest
*req
, uint8_t *buf
)
431 if (req
->dev
->type
== TYPE_TAPE
) {
432 rc
= scsi_req_stream_length(&req
->cmd
, req
->dev
, buf
);
434 rc
= scsi_req_length(&req
->cmd
, req
->dev
, buf
);
439 assert(buf
== req
->cmd
.buf
);
440 scsi_cmd_xfer_mode(&req
->cmd
);
441 req
->cmd
.lba
= scsi_cmd_lba(&req
->cmd
);
442 trace_scsi_req_parsed(req
->dev
->id
, req
->lun
, req
->tag
, buf
[0],
443 req
->cmd
.mode
, req
->cmd
.xfer
);
444 if (req
->cmd
.lba
!= -1) {
445 trace_scsi_req_parsed_lba(req
->dev
->id
, req
->lun
, req
->tag
, buf
[0],
452 * Predefined sense codes
455 /* No sense data available */
456 const struct SCSISense sense_code_NO_SENSE
= {
457 .key
= NO_SENSE
, .asc
= 0x00 , .ascq
= 0x00
460 /* LUN not ready, Manual intervention required */
461 const struct SCSISense sense_code_LUN_NOT_READY
= {
462 .key
= NOT_READY
, .asc
= 0x04, .ascq
= 0x03
465 /* LUN not ready, Medium not present */
466 const struct SCSISense sense_code_NO_MEDIUM
= {
467 .key
= NOT_READY
, .asc
= 0x3a, .ascq
= 0x00
470 /* Hardware error, internal target failure */
471 const struct SCSISense sense_code_TARGET_FAILURE
= {
472 .key
= HARDWARE_ERROR
, .asc
= 0x44, .ascq
= 0x00
475 /* Illegal request, invalid command operation code */
476 const struct SCSISense sense_code_INVALID_OPCODE
= {
477 .key
= ILLEGAL_REQUEST
, .asc
= 0x20, .ascq
= 0x00
480 /* Illegal request, LBA out of range */
481 const struct SCSISense sense_code_LBA_OUT_OF_RANGE
= {
482 .key
= ILLEGAL_REQUEST
, .asc
= 0x21, .ascq
= 0x00
485 /* Illegal request, Invalid field in CDB */
486 const struct SCSISense sense_code_INVALID_FIELD
= {
487 .key
= ILLEGAL_REQUEST
, .asc
= 0x24, .ascq
= 0x00
490 /* Illegal request, LUN not supported */
491 const struct SCSISense sense_code_LUN_NOT_SUPPORTED
= {
492 .key
= ILLEGAL_REQUEST
, .asc
= 0x25, .ascq
= 0x00
495 /* Command aborted, I/O process terminated */
496 const struct SCSISense sense_code_IO_ERROR
= {
497 .key
= ABORTED_COMMAND
, .asc
= 0x00, .ascq
= 0x06
500 /* Command aborted, I_T Nexus loss occurred */
501 const struct SCSISense sense_code_I_T_NEXUS_LOSS
= {
502 .key
= ABORTED_COMMAND
, .asc
= 0x29, .ascq
= 0x07
505 /* Command aborted, Logical Unit failure */
506 const struct SCSISense sense_code_LUN_FAILURE
= {
507 .key
= ABORTED_COMMAND
, .asc
= 0x3e, .ascq
= 0x01
513 * Convert between fixed and descriptor sense buffers
515 int scsi_build_sense(uint8_t *in_buf
, int in_len
,
516 uint8_t *buf
, int len
, bool fixed
)
520 if (!fixed
&& len
< 8) {
525 sense
.key
= NO_SENSE
;
529 fixed_in
= (in_buf
[0] & 2) == 0;
531 if (fixed
== fixed_in
) {
532 memcpy(buf
, in_buf
, MIN(len
, in_len
));
533 return MIN(len
, in_len
);
537 sense
.key
= in_buf
[2];
538 sense
.asc
= in_buf
[12];
539 sense
.ascq
= in_buf
[13];
541 sense
.key
= in_buf
[1];
542 sense
.asc
= in_buf
[2];
543 sense
.ascq
= in_buf
[3];
549 /* Return fixed format sense buffer */
554 buf
[13] = sense
.ascq
;
557 /* Return descriptor format sense buffer */
566 static const char *scsi_command_name(uint8_t cmd
)
568 static const char *names
[] = {
569 [ TEST_UNIT_READY
] = "TEST_UNIT_READY",
570 [ REWIND
] = "REWIND",
571 [ REQUEST_SENSE
] = "REQUEST_SENSE",
572 [ FORMAT_UNIT
] = "FORMAT_UNIT",
573 [ READ_BLOCK_LIMITS
] = "READ_BLOCK_LIMITS",
574 [ REASSIGN_BLOCKS
] = "REASSIGN_BLOCKS",
575 [ READ_6
] = "READ_6",
576 [ WRITE_6
] = "WRITE_6",
577 [ SEEK_6
] = "SEEK_6",
578 [ READ_REVERSE
] = "READ_REVERSE",
579 [ WRITE_FILEMARKS
] = "WRITE_FILEMARKS",
581 [ INQUIRY
] = "INQUIRY",
582 [ RECOVER_BUFFERED_DATA
] = "RECOVER_BUFFERED_DATA",
583 [ MAINTENANCE_IN
] = "MAINTENANCE_IN",
584 [ MAINTENANCE_OUT
] = "MAINTENANCE_OUT",
585 [ MODE_SELECT
] = "MODE_SELECT",
586 [ RESERVE
] = "RESERVE",
587 [ RELEASE
] = "RELEASE",
590 [ MODE_SENSE
] = "MODE_SENSE",
591 [ START_STOP
] = "START_STOP",
592 [ RECEIVE_DIAGNOSTIC
] = "RECEIVE_DIAGNOSTIC",
593 [ SEND_DIAGNOSTIC
] = "SEND_DIAGNOSTIC",
594 [ ALLOW_MEDIUM_REMOVAL
] = "ALLOW_MEDIUM_REMOVAL",
595 [ READ_CAPACITY_10
] = "READ_CAPACITY_10",
596 [ READ_10
] = "READ_10",
597 [ WRITE_10
] = "WRITE_10",
598 [ SEEK_10
] = "SEEK_10",
599 [ WRITE_VERIFY_10
] = "WRITE_VERIFY_10",
600 [ VERIFY_10
] = "VERIFY_10",
601 [ SEARCH_HIGH
] = "SEARCH_HIGH",
602 [ SEARCH_EQUAL
] = "SEARCH_EQUAL",
603 [ SEARCH_LOW
] = "SEARCH_LOW",
604 [ SET_LIMITS
] = "SET_LIMITS",
605 [ PRE_FETCH
] = "PRE_FETCH",
606 /* READ_POSITION and PRE_FETCH use the same operation code */
607 [ SYNCHRONIZE_CACHE
] = "SYNCHRONIZE_CACHE",
608 [ LOCK_UNLOCK_CACHE
] = "LOCK_UNLOCK_CACHE",
609 [ READ_DEFECT_DATA
] = "READ_DEFECT_DATA",
610 [ MEDIUM_SCAN
] = "MEDIUM_SCAN",
611 [ COMPARE
] = "COMPARE",
612 [ COPY_VERIFY
] = "COPY_VERIFY",
613 [ WRITE_BUFFER
] = "WRITE_BUFFER",
614 [ READ_BUFFER
] = "READ_BUFFER",
615 [ UPDATE_BLOCK
] = "UPDATE_BLOCK",
616 [ READ_LONG_10
] = "READ_LONG_10",
617 [ WRITE_LONG_10
] = "WRITE_LONG_10",
618 [ CHANGE_DEFINITION
] = "CHANGE_DEFINITION",
619 [ WRITE_SAME_10
] = "WRITE_SAME_10",
621 [ READ_TOC
] = "READ_TOC",
622 [ REPORT_DENSITY_SUPPORT
] = "REPORT_DENSITY_SUPPORT",
623 [ GET_CONFIGURATION
] = "GET_CONFIGURATION",
624 [ LOG_SELECT
] = "LOG_SELECT",
625 [ LOG_SENSE
] = "LOG_SENSE",
626 [ MODE_SELECT_10
] = "MODE_SELECT_10",
627 [ RESERVE_10
] = "RESERVE_10",
628 [ RELEASE_10
] = "RELEASE_10",
629 [ MODE_SENSE_10
] = "MODE_SENSE_10",
630 [ PERSISTENT_RESERVE_IN
] = "PERSISTENT_RESERVE_IN",
631 [ PERSISTENT_RESERVE_OUT
] = "PERSISTENT_RESERVE_OUT",
632 [ WRITE_FILEMARKS_16
] = "WRITE_FILEMARKS_16",
633 [ EXTENDED_COPY
] = "EXTENDED_COPY",
634 [ ATA_PASSTHROUGH
] = "ATA_PASSTHROUGH",
635 [ ACCESS_CONTROL_IN
] = "ACCESS_CONTROL_IN",
636 [ ACCESS_CONTROL_OUT
] = "ACCESS_CONTROL_OUT",
637 [ READ_16
] = "READ_16",
638 [ COMPARE_AND_WRITE
] = "COMPARE_AND_WRITE",
639 [ WRITE_16
] = "WRITE_16",
640 [ WRITE_VERIFY_16
] = "WRITE_VERIFY_16",
641 [ VERIFY_16
] = "VERIFY_16",
642 [ SYNCHRONIZE_CACHE_16
] = "SYNCHRONIZE_CACHE_16",
643 [ LOCATE_16
] = "LOCATE_16",
644 [ WRITE_SAME_16
] = "WRITE_SAME_16",
645 [ ERASE_16
] = "ERASE_16",
646 [ SERVICE_ACTION_IN
] = "SERVICE_ACTION_IN",
647 [ WRITE_LONG_16
] = "WRITE_LONG_16",
648 [ REPORT_LUNS
] = "REPORT_LUNS",
650 [ MAINTENANCE_IN
] = "MAINTENANCE_IN",
651 [ MAINTENANCE_OUT
] = "MAINTENANCE_OUT",
652 [ MOVE_MEDIUM
] = "MOVE_MEDIUM",
653 [ LOAD_UNLOAD
] = "LOAD_UNLOAD",
654 [ READ_12
] = "READ_12",
655 [ WRITE_12
] = "WRITE_12",
656 [ WRITE_VERIFY_12
] = "WRITE_VERIFY_12",
657 [ VERIFY_12
] = "VERIFY_12",
658 [ SEARCH_HIGH_12
] = "SEARCH_HIGH_12",
659 [ SEARCH_EQUAL_12
] = "SEARCH_EQUAL_12",
660 [ SEARCH_LOW_12
] = "SEARCH_LOW_12",
661 [ READ_ELEMENT_STATUS
] = "READ_ELEMENT_STATUS",
662 [ SEND_VOLUME_TAG
] = "SEND_VOLUME_TAG",
663 [ READ_DEFECT_DATA_12
] = "READ_DEFECT_DATA_12",
664 [ SET_CD_SPEED
] = "SET_CD_SPEED",
667 if (cmd
>= ARRAY_SIZE(names
) || names
[cmd
] == NULL
)
672 SCSIRequest
*scsi_req_ref(SCSIRequest
*req
)
678 void scsi_req_unref(SCSIRequest
*req
)
680 if (--req
->refcount
== 0) {
681 if (req
->ops
->free_req
) {
682 req
->ops
->free_req(req
);
688 /* Tell the device that we finished processing this chunk of I/O. It
689 will start the next chunk or complete the command. */
690 void scsi_req_continue(SCSIRequest
*req
)
692 trace_scsi_req_continue(req
->dev
->id
, req
->lun
, req
->tag
);
693 if (req
->cmd
.mode
== SCSI_XFER_TO_DEV
) {
694 req
->ops
->write_data(req
);
696 req
->ops
->read_data(req
);
700 /* Called by the devices when data is ready for the HBA. The HBA should
701 start a DMA operation to read or fill the device's data buffer.
702 Once it completes, calling scsi_req_continue will restart I/O. */
703 void scsi_req_data(SCSIRequest
*req
, int len
)
705 trace_scsi_req_data(req
->dev
->id
, req
->lun
, req
->tag
, len
);
706 req
->bus
->ops
->transfer_data(req
, len
);
709 void scsi_req_print(SCSIRequest
*req
)
714 fprintf(fp
, "[%s id=%d] %s",
715 req
->dev
->qdev
.parent_bus
->name
,
717 scsi_command_name(req
->cmd
.buf
[0]));
718 for (i
= 1; i
< req
->cmd
.len
; i
++) {
719 fprintf(fp
, " 0x%02x", req
->cmd
.buf
[i
]);
721 switch (req
->cmd
.mode
) {
723 fprintf(fp
, " - none\n");
725 case SCSI_XFER_FROM_DEV
:
726 fprintf(fp
, " - from-dev len=%zd\n", req
->cmd
.xfer
);
728 case SCSI_XFER_TO_DEV
:
729 fprintf(fp
, " - to-dev len=%zd\n", req
->cmd
.xfer
);
732 fprintf(fp
, " - Oops\n");
737 void scsi_req_complete(SCSIRequest
*req
, int status
)
739 assert(req
->status
== -1);
740 req
->status
= status
;
742 assert(req
->sense_len
< sizeof(req
->sense
));
743 if (status
== GOOD
) {
747 if (req
->sense_len
) {
748 memcpy(req
->dev
->sense
, req
->sense
, req
->sense_len
);
750 req
->dev
->sense_len
= req
->sense_len
;
753 scsi_req_dequeue(req
);
754 req
->bus
->ops
->complete(req
, req
->status
);
758 void scsi_req_cancel(SCSIRequest
*req
)
760 if (req
->ops
->cancel_io
) {
761 req
->ops
->cancel_io(req
);
764 scsi_req_dequeue(req
);
765 if (req
->bus
->ops
->cancel
) {
766 req
->bus
->ops
->cancel(req
);
771 void scsi_req_abort(SCSIRequest
*req
, int status
)
773 if (req
->ops
->cancel_io
) {
774 req
->ops
->cancel_io(req
);
776 scsi_req_complete(req
, status
);
779 void scsi_device_purge_requests(SCSIDevice
*sdev
)
783 while (!QTAILQ_EMPTY(&sdev
->requests
)) {
784 req
= QTAILQ_FIRST(&sdev
->requests
);
785 scsi_req_cancel(req
);
789 static char *scsibus_get_fw_dev_path(DeviceState
*dev
)
791 SCSIDevice
*d
= DO_UPCAST(SCSIDevice
, qdev
, dev
);
792 SCSIBus
*bus
= scsi_bus_from_device(d
);
796 for (i
= 0; i
< bus
->ndev
; i
++) {
797 if (bus
->devs
[i
] == d
) {
802 assert(i
!= bus
->ndev
);
804 snprintf(path
, sizeof(path
), "%s@%x", qdev_fw_name(dev
), i
);