1 #include "qemu/osdep.h"
3 #include "qapi/error.h"
4 #include "qemu/error-report.h"
5 #include "hw/scsi/scsi.h"
6 #include "scsi/constants.h"
8 #include "sysemu/block-backend.h"
9 #include "sysemu/blockdev.h"
11 #include "sysemu/dma.h"
12 #include "qemu/cutils.h"
14 static char *scsibus_get_dev_path(DeviceState
*dev
);
15 static char *scsibus_get_fw_dev_path(DeviceState
*dev
);
16 static void scsi_req_dequeue(SCSIRequest
*req
);
17 static uint8_t *scsi_target_alloc_buf(SCSIRequest
*req
, size_t len
);
18 static void scsi_target_free_buf(SCSIRequest
*req
);
20 static Property scsi_props
[] = {
21 DEFINE_PROP_UINT32("channel", SCSIDevice
, channel
, 0),
22 DEFINE_PROP_UINT32("scsi-id", SCSIDevice
, id
, -1),
23 DEFINE_PROP_UINT32("lun", SCSIDevice
, lun
, -1),
24 DEFINE_PROP_END_OF_LIST(),
27 static void scsi_bus_class_init(ObjectClass
*klass
, void *data
)
29 BusClass
*k
= BUS_CLASS(klass
);
30 HotplugHandlerClass
*hc
= HOTPLUG_HANDLER_CLASS(klass
);
32 k
->get_dev_path
= scsibus_get_dev_path
;
33 k
->get_fw_dev_path
= scsibus_get_fw_dev_path
;
34 hc
->unplug
= qdev_simple_device_unplug_cb
;
37 static const TypeInfo scsi_bus_info
= {
38 .name
= TYPE_SCSI_BUS
,
40 .instance_size
= sizeof(SCSIBus
),
41 .class_init
= scsi_bus_class_init
,
42 .interfaces
= (InterfaceInfo
[]) {
43 { TYPE_HOTPLUG_HANDLER
},
47 static int next_scsi_bus
;
49 static void scsi_device_realize(SCSIDevice
*s
, Error
**errp
)
51 SCSIDeviceClass
*sc
= SCSI_DEVICE_GET_CLASS(s
);
57 int scsi_bus_parse_cdb(SCSIDevice
*dev
, SCSICommand
*cmd
, uint8_t *buf
,
60 SCSIBus
*bus
= DO_UPCAST(SCSIBus
, qbus
, dev
->qdev
.parent_bus
);
63 assert(cmd
->len
== 0);
64 rc
= scsi_req_parse_cdb(dev
, cmd
, buf
);
65 if (bus
->info
->parse_cdb
) {
66 rc
= bus
->info
->parse_cdb(dev
, cmd
, buf
, hba_private
);
71 static SCSIRequest
*scsi_device_alloc_req(SCSIDevice
*s
, uint32_t tag
, uint32_t lun
,
72 uint8_t *buf
, void *hba_private
)
74 SCSIDeviceClass
*sc
= SCSI_DEVICE_GET_CLASS(s
);
76 return sc
->alloc_req(s
, tag
, lun
, buf
, hba_private
);
82 void scsi_device_unit_attention_reported(SCSIDevice
*s
)
84 SCSIDeviceClass
*sc
= SCSI_DEVICE_GET_CLASS(s
);
85 if (sc
->unit_attention_reported
) {
86 sc
->unit_attention_reported(s
);
90 /* Create a scsi bus, and attach devices to it. */
91 void scsi_bus_new(SCSIBus
*bus
, size_t bus_size
, DeviceState
*host
,
92 const SCSIBusInfo
*info
, const char *bus_name
)
94 qbus_create_inplace(bus
, bus_size
, TYPE_SCSI_BUS
, host
, bus_name
);
95 bus
->busnr
= next_scsi_bus
++;
97 qbus_set_bus_hotplug_handler(BUS(bus
), &error_abort
);
100 static void scsi_dma_restart_bh(void *opaque
)
102 SCSIDevice
*s
= opaque
;
103 SCSIRequest
*req
, *next
;
105 qemu_bh_delete(s
->bh
);
108 aio_context_acquire(blk_get_aio_context(s
->conf
.blk
));
109 QTAILQ_FOREACH_SAFE(req
, &s
->requests
, next
, next
) {
113 switch (req
->cmd
.mode
) {
114 case SCSI_XFER_FROM_DEV
:
115 case SCSI_XFER_TO_DEV
:
116 scsi_req_continue(req
);
119 scsi_req_dequeue(req
);
120 scsi_req_enqueue(req
);
126 aio_context_release(blk_get_aio_context(s
->conf
.blk
));
129 void scsi_req_retry(SCSIRequest
*req
)
131 /* No need to save a reference, because scsi_dma_restart_bh just
132 * looks at the request list. */
136 static void scsi_dma_restart_cb(void *opaque
, int running
, RunState state
)
138 SCSIDevice
*s
= opaque
;
144 AioContext
*ctx
= blk_get_aio_context(s
->conf
.blk
);
145 s
->bh
= aio_bh_new(ctx
, scsi_dma_restart_bh
, s
);
146 qemu_bh_schedule(s
->bh
);
150 static void scsi_qdev_realize(DeviceState
*qdev
, Error
**errp
)
152 SCSIDevice
*dev
= SCSI_DEVICE(qdev
);
153 SCSIBus
*bus
= DO_UPCAST(SCSIBus
, qbus
, dev
->qdev
.parent_bus
);
155 Error
*local_err
= NULL
;
157 if (dev
->channel
> bus
->info
->max_channel
) {
158 error_setg(errp
, "bad scsi channel id: %d", dev
->channel
);
161 if (dev
->id
!= -1 && dev
->id
> bus
->info
->max_target
) {
162 error_setg(errp
, "bad scsi device id: %d", dev
->id
);
165 if (dev
->lun
!= -1 && dev
->lun
> bus
->info
->max_lun
) {
166 error_setg(errp
, "bad scsi device lun: %d", dev
->lun
);
172 if (dev
->lun
== -1) {
176 d
= scsi_device_find(bus
, dev
->channel
, ++id
, dev
->lun
);
177 } while (d
&& d
->lun
== dev
->lun
&& id
< bus
->info
->max_target
);
178 if (d
&& d
->lun
== dev
->lun
) {
179 error_setg(errp
, "no free target");
183 } else if (dev
->lun
== -1) {
186 d
= scsi_device_find(bus
, dev
->channel
, dev
->id
, ++lun
);
187 } while (d
&& d
->lun
== lun
&& lun
< bus
->info
->max_lun
);
188 if (d
&& d
->lun
== lun
) {
189 error_setg(errp
, "no free lun");
194 d
= scsi_device_find(bus
, dev
->channel
, dev
->id
, dev
->lun
);
196 if (d
->lun
== dev
->lun
&& dev
!= d
) {
197 error_setg(errp
, "lun already used by '%s'", d
->qdev
.id
);
202 QTAILQ_INIT(&dev
->requests
);
203 scsi_device_realize(dev
, &local_err
);
205 error_propagate(errp
, local_err
);
208 dev
->vmsentry
= qemu_add_vm_change_state_handler(scsi_dma_restart_cb
,
212 static void scsi_qdev_unrealize(DeviceState
*qdev
, Error
**errp
)
214 SCSIDevice
*dev
= SCSI_DEVICE(qdev
);
217 qemu_del_vm_change_state_handler(dev
->vmsentry
);
220 scsi_device_purge_requests(dev
, SENSE_CODE(NO_SENSE
));
221 blockdev_mark_auto_del(dev
->conf
.blk
);
224 /* handle legacy '-drive if=scsi,...' cmd line args */
225 SCSIDevice
*scsi_bus_legacy_add_drive(SCSIBus
*bus
, BlockBackend
*blk
,
226 int unit
, bool removable
, int bootindex
,
228 const char *serial
, Error
**errp
)
235 driver
= blk_is_sg(blk
) ? "scsi-generic" : "scsi-disk";
236 dev
= qdev_create(&bus
->qbus
, driver
);
237 name
= g_strdup_printf("legacy[%d]", unit
);
238 object_property_add_child(OBJECT(bus
), name
, OBJECT(dev
), NULL
);
241 qdev_prop_set_uint32(dev
, "scsi-id", unit
);
242 if (bootindex
>= 0) {
243 object_property_set_int(OBJECT(dev
), bootindex
, "bootindex",
246 if (object_property_find(OBJECT(dev
), "removable", NULL
)) {
247 qdev_prop_set_bit(dev
, "removable", removable
);
249 if (serial
&& object_property_find(OBJECT(dev
), "serial", NULL
)) {
250 qdev_prop_set_string(dev
, "serial", serial
);
252 qdev_prop_set_drive(dev
, "drive", blk
, &err
);
254 error_propagate(errp
, err
);
255 object_unparent(OBJECT(dev
));
258 object_property_set_bool(OBJECT(dev
), share_rw
, "share-rw", &err
);
260 error_propagate(errp
, err
);
261 object_unparent(OBJECT(dev
));
264 object_property_set_bool(OBJECT(dev
), true, "realized", &err
);
266 error_propagate(errp
, err
);
267 object_unparent(OBJECT(dev
));
270 return SCSI_DEVICE(dev
);
273 void scsi_bus_legacy_handle_cmdline(SCSIBus
*bus
, bool deprecated
)
280 for (unit
= 0; unit
<= bus
->info
->max_target
; unit
++) {
281 dinfo
= drive_get(IF_SCSI
, bus
->busnr
, unit
);
285 qemu_opts_loc_restore(dinfo
->opts
);
287 /* Handling -drive not claimed by machine initialization */
288 if (blk_get_attached_dev(blk_by_legacy_dinfo(dinfo
))) {
289 continue; /* claimed */
291 if (!dinfo
->is_default
) {
292 warn_report("bus=%d,unit=%d is deprecated with this"
297 scsi_bus_legacy_add_drive(bus
, blk_by_legacy_dinfo(dinfo
),
298 unit
, false, -1, false, NULL
, &error_fatal
);
303 static bool is_scsi_hba_with_legacy_magic(Object
*obj
)
305 static const char *magic
[] = {
306 "am53c974", "dc390", "esp", "lsi53c810", "lsi53c895a",
307 "megasas", "megasas-gen2", "mptsas1068", "spapr-vscsi",
308 "virtio-scsi-device",
311 const char *typename
= object_get_typename(obj
);
314 for (i
= 0; magic
[i
]; i
++)
315 if (!strcmp(typename
, magic
[i
])) {
322 static int scsi_legacy_handle_cmdline_cb(Object
*obj
, void *opaque
)
324 SCSIBus
*bus
= (SCSIBus
*)object_dynamic_cast(obj
, TYPE_SCSI_BUS
);
326 if (bus
&& is_scsi_hba_with_legacy_magic(OBJECT(bus
->qbus
.parent
))) {
327 scsi_bus_legacy_handle_cmdline(bus
, true);
333 void scsi_legacy_handle_cmdline(void)
335 object_child_foreach_recursive(object_get_root(),
336 scsi_legacy_handle_cmdline_cb
, NULL
);
339 static int32_t scsi_invalid_field(SCSIRequest
*req
, uint8_t *buf
)
341 scsi_req_build_sense(req
, SENSE_CODE(INVALID_FIELD
));
342 scsi_req_complete(req
, CHECK_CONDITION
);
346 static const struct SCSIReqOps reqops_invalid_field
= {
347 .size
= sizeof(SCSIRequest
),
348 .send_command
= scsi_invalid_field
351 /* SCSIReqOps implementation for invalid commands. */
353 static int32_t scsi_invalid_command(SCSIRequest
*req
, uint8_t *buf
)
355 scsi_req_build_sense(req
, SENSE_CODE(INVALID_OPCODE
));
356 scsi_req_complete(req
, CHECK_CONDITION
);
360 static const struct SCSIReqOps reqops_invalid_opcode
= {
361 .size
= sizeof(SCSIRequest
),
362 .send_command
= scsi_invalid_command
365 /* SCSIReqOps implementation for unit attention conditions. */
367 static int32_t scsi_unit_attention(SCSIRequest
*req
, uint8_t *buf
)
369 if (req
->dev
->unit_attention
.key
== UNIT_ATTENTION
) {
370 scsi_req_build_sense(req
, req
->dev
->unit_attention
);
371 } else if (req
->bus
->unit_attention
.key
== UNIT_ATTENTION
) {
372 scsi_req_build_sense(req
, req
->bus
->unit_attention
);
374 scsi_req_complete(req
, CHECK_CONDITION
);
378 static const struct SCSIReqOps reqops_unit_attention
= {
379 .size
= sizeof(SCSIRequest
),
380 .send_command
= scsi_unit_attention
383 /* SCSIReqOps implementation for REPORT LUNS and for commands sent to
386 typedef struct SCSITargetReq SCSITargetReq
;
388 struct SCSITargetReq
{
395 static void store_lun(uint8_t *outbuf
, int lun
)
401 outbuf
[1] = (lun
& 255);
402 outbuf
[0] = (lun
>> 8) | 0x40;
405 static bool scsi_target_emulate_report_luns(SCSITargetReq
*r
)
412 if (r
->req
.cmd
.xfer
< 16) {
415 if (r
->req
.cmd
.buf
[2] > 2) {
418 channel
= r
->req
.dev
->channel
;
422 QTAILQ_FOREACH(kid
, &r
->req
.bus
->qbus
.children
, sibling
) {
423 DeviceState
*qdev
= kid
->child
;
424 SCSIDevice
*dev
= SCSI_DEVICE(qdev
);
426 if (dev
->channel
== channel
&& dev
->id
== id
) {
437 scsi_target_alloc_buf(&r
->req
, n
+ 8);
439 len
= MIN(n
+ 8, r
->req
.cmd
.xfer
& ~7);
440 memset(r
->buf
, 0, len
);
441 stl_be_p(&r
->buf
[0], n
);
442 i
= found_lun0
? 8 : 16;
443 QTAILQ_FOREACH(kid
, &r
->req
.bus
->qbus
.children
, sibling
) {
444 DeviceState
*qdev
= kid
->child
;
445 SCSIDevice
*dev
= SCSI_DEVICE(qdev
);
447 if (dev
->channel
== channel
&& dev
->id
== id
) {
448 store_lun(&r
->buf
[i
], dev
->lun
);
457 static bool scsi_target_emulate_inquiry(SCSITargetReq
*r
)
459 assert(r
->req
.dev
->lun
!= r
->req
.lun
);
461 scsi_target_alloc_buf(&r
->req
, SCSI_INQUIRY_LEN
);
463 if (r
->req
.cmd
.buf
[1] & 0x2) {
464 /* Command support data - optional, not implemented */
468 if (r
->req
.cmd
.buf
[1] & 0x1) {
469 /* Vital product data */
470 uint8_t page_code
= r
->req
.cmd
.buf
[2];
471 r
->buf
[r
->len
++] = page_code
; /* this page */
472 r
->buf
[r
->len
++] = 0x00;
475 case 0x00: /* Supported page codes, mandatory */
479 r
->buf
[r
->len
++] = 0x00; /* list of supported pages (this page) */
480 r
->buf
[pages
] = r
->len
- pages
- 1; /* number of pages */
487 assert(r
->len
< r
->buf_len
);
488 r
->len
= MIN(r
->req
.cmd
.xfer
, r
->len
);
492 /* Standard INQUIRY data */
493 if (r
->req
.cmd
.buf
[2] != 0) {
498 r
->len
= MIN(r
->req
.cmd
.xfer
, SCSI_INQUIRY_LEN
);
499 memset(r
->buf
, 0, r
->len
);
500 if (r
->req
.lun
!= 0) {
501 r
->buf
[0] = TYPE_NO_LUN
;
503 r
->buf
[0] = TYPE_NOT_PRESENT
| TYPE_INACTIVE
;
504 r
->buf
[2] = 5; /* Version */
505 r
->buf
[3] = 2 | 0x10; /* HiSup, response data format */
506 r
->buf
[4] = r
->len
- 5; /* Additional Length = (Len - 1) - 4 */
507 r
->buf
[7] = 0x10 | (r
->req
.bus
->info
->tcq
? 0x02 : 0); /* Sync, TCQ. */
508 memcpy(&r
->buf
[8], "QEMU ", 8);
509 memcpy(&r
->buf
[16], "QEMU TARGET ", 16);
510 pstrcpy((char *) &r
->buf
[32], 4, qemu_hw_version());
515 static size_t scsi_sense_len(SCSIRequest
*req
)
517 if (req
->dev
->type
== TYPE_SCANNER
)
518 return SCSI_SENSE_LEN_SCANNER
;
520 return SCSI_SENSE_LEN
;
523 static int32_t scsi_target_send_command(SCSIRequest
*req
, uint8_t *buf
)
525 SCSITargetReq
*r
= DO_UPCAST(SCSITargetReq
, req
, req
);
526 int fixed_sense
= (req
->cmd
.buf
[1] & 1) == 0;
529 buf
[0] != INQUIRY
&& buf
[0] != REQUEST_SENSE
) {
530 scsi_req_build_sense(req
, SENSE_CODE(LUN_NOT_SUPPORTED
));
531 scsi_req_complete(req
, CHECK_CONDITION
);
536 if (!scsi_target_emulate_report_luns(r
)) {
537 goto illegal_request
;
541 if (!scsi_target_emulate_inquiry(r
)) {
542 goto illegal_request
;
546 scsi_target_alloc_buf(&r
->req
, scsi_sense_len(req
));
548 const struct SCSISense sense
= SENSE_CODE(LUN_NOT_SUPPORTED
);
550 r
->len
= scsi_build_sense_buf(r
->buf
, req
->cmd
.xfer
,
553 r
->len
= scsi_device_get_sense(r
->req
.dev
, r
->buf
,
554 MIN(req
->cmd
.xfer
, r
->buf_len
),
557 if (r
->req
.dev
->sense_is_ua
) {
558 scsi_device_unit_attention_reported(req
->dev
);
559 r
->req
.dev
->sense_len
= 0;
560 r
->req
.dev
->sense_is_ua
= false;
563 case TEST_UNIT_READY
:
566 scsi_req_build_sense(req
, SENSE_CODE(INVALID_OPCODE
));
567 scsi_req_complete(req
, CHECK_CONDITION
);
570 scsi_req_build_sense(req
, SENSE_CODE(INVALID_FIELD
));
571 scsi_req_complete(req
, CHECK_CONDITION
);
576 scsi_req_complete(req
, GOOD
);
581 static void scsi_target_read_data(SCSIRequest
*req
)
583 SCSITargetReq
*r
= DO_UPCAST(SCSITargetReq
, req
, req
);
589 scsi_req_data(&r
->req
, n
);
591 scsi_req_complete(&r
->req
, GOOD
);
595 static uint8_t *scsi_target_get_buf(SCSIRequest
*req
)
597 SCSITargetReq
*r
= DO_UPCAST(SCSITargetReq
, req
, req
);
602 static uint8_t *scsi_target_alloc_buf(SCSIRequest
*req
, size_t len
)
604 SCSITargetReq
*r
= DO_UPCAST(SCSITargetReq
, req
, req
);
606 r
->buf
= g_malloc(len
);
612 static void scsi_target_free_buf(SCSIRequest
*req
)
614 SCSITargetReq
*r
= DO_UPCAST(SCSITargetReq
, req
, req
);
619 static const struct SCSIReqOps reqops_target_command
= {
620 .size
= sizeof(SCSITargetReq
),
621 .send_command
= scsi_target_send_command
,
622 .read_data
= scsi_target_read_data
,
623 .get_buf
= scsi_target_get_buf
,
624 .free_req
= scsi_target_free_buf
,
628 SCSIRequest
*scsi_req_alloc(const SCSIReqOps
*reqops
, SCSIDevice
*d
,
629 uint32_t tag
, uint32_t lun
, void *hba_private
)
632 SCSIBus
*bus
= scsi_bus_from_device(d
);
633 BusState
*qbus
= BUS(bus
);
634 const int memset_off
= offsetof(SCSIRequest
, sense
)
635 + sizeof(req
->sense
);
637 req
= g_malloc(reqops
->size
);
638 memset((uint8_t *)req
+ memset_off
, 0, reqops
->size
- memset_off
);
644 req
->hba_private
= hba_private
;
647 object_ref(OBJECT(d
));
648 object_ref(OBJECT(qbus
->parent
));
649 notifier_list_init(&req
->cancel_notifiers
);
650 trace_scsi_req_alloc(req
->dev
->id
, req
->lun
, req
->tag
);
654 SCSIRequest
*scsi_req_new(SCSIDevice
*d
, uint32_t tag
, uint32_t lun
,
655 uint8_t *buf
, void *hba_private
)
657 SCSIBus
*bus
= DO_UPCAST(SCSIBus
, qbus
, d
->qdev
.parent_bus
);
658 const SCSIReqOps
*ops
;
659 SCSIDeviceClass
*sc
= SCSI_DEVICE_GET_CLASS(d
);
661 SCSICommand cmd
= { .len
= 0 };
664 if ((d
->unit_attention
.key
== UNIT_ATTENTION
||
665 bus
->unit_attention
.key
== UNIT_ATTENTION
) &&
666 (buf
[0] != INQUIRY
&&
667 buf
[0] != REPORT_LUNS
&&
668 buf
[0] != GET_CONFIGURATION
&&
669 buf
[0] != GET_EVENT_STATUS_NOTIFICATION
&&
672 * If we already have a pending unit attention condition,
673 * report this one before triggering another one.
675 !(buf
[0] == REQUEST_SENSE
&& d
->sense_is_ua
))) {
676 ops
= &reqops_unit_attention
;
677 } else if (lun
!= d
->lun
||
678 buf
[0] == REPORT_LUNS
||
679 (buf
[0] == REQUEST_SENSE
&& d
->sense_len
)) {
680 ops
= &reqops_target_command
;
685 if (ops
!= NULL
|| !sc
->parse_cdb
) {
686 ret
= scsi_req_parse_cdb(d
, &cmd
, buf
);
688 ret
= sc
->parse_cdb(d
, &cmd
, buf
, hba_private
);
692 trace_scsi_req_parse_bad(d
->id
, lun
, tag
, buf
[0]);
693 req
= scsi_req_alloc(&reqops_invalid_opcode
, d
, tag
, lun
, hba_private
);
695 assert(cmd
.len
!= 0);
696 trace_scsi_req_parsed(d
->id
, lun
, tag
, buf
[0],
699 trace_scsi_req_parsed_lba(d
->id
, lun
, tag
, buf
[0],
703 if (cmd
.xfer
> INT32_MAX
) {
704 req
= scsi_req_alloc(&reqops_invalid_field
, d
, tag
, lun
, hba_private
);
706 req
= scsi_req_alloc(ops
, d
, tag
, lun
, hba_private
);
708 req
= scsi_device_alloc_req(d
, tag
, lun
, buf
, hba_private
);
713 req
->resid
= req
->cmd
.xfer
;
717 trace_scsi_inquiry(d
->id
, lun
, tag
, cmd
.buf
[1], cmd
.buf
[2]);
719 case TEST_UNIT_READY
:
720 trace_scsi_test_unit_ready(d
->id
, lun
, tag
);
723 trace_scsi_report_luns(d
->id
, lun
, tag
);
726 trace_scsi_request_sense(d
->id
, lun
, tag
);
735 uint8_t *scsi_req_get_buf(SCSIRequest
*req
)
737 return req
->ops
->get_buf(req
);
740 static void scsi_clear_unit_attention(SCSIRequest
*req
)
743 if (req
->dev
->unit_attention
.key
!= UNIT_ATTENTION
&&
744 req
->bus
->unit_attention
.key
!= UNIT_ATTENTION
) {
749 * If an INQUIRY command enters the enabled command state,
750 * the device server shall [not] clear any unit attention condition;
751 * See also MMC-6, paragraphs 6.5 and 6.6.2.
753 if (req
->cmd
.buf
[0] == INQUIRY
||
754 req
->cmd
.buf
[0] == GET_CONFIGURATION
||
755 req
->cmd
.buf
[0] == GET_EVENT_STATUS_NOTIFICATION
) {
759 if (req
->dev
->unit_attention
.key
== UNIT_ATTENTION
) {
760 ua
= &req
->dev
->unit_attention
;
762 ua
= &req
->bus
->unit_attention
;
766 * If a REPORT LUNS command enters the enabled command state, [...]
767 * the device server shall clear any pending unit attention condition
768 * with an additional sense code of REPORTED LUNS DATA HAS CHANGED.
770 if (req
->cmd
.buf
[0] == REPORT_LUNS
&&
771 !(ua
->asc
== SENSE_CODE(REPORTED_LUNS_CHANGED
).asc
&&
772 ua
->ascq
== SENSE_CODE(REPORTED_LUNS_CHANGED
).ascq
)) {
776 *ua
= SENSE_CODE(NO_SENSE
);
779 int scsi_req_get_sense(SCSIRequest
*req
, uint8_t *buf
, int len
)
784 if (!req
->sense_len
) {
788 ret
= scsi_convert_sense(req
->sense
, req
->sense_len
, buf
, len
, true);
791 * FIXME: clearing unit attention conditions upon autosense should be done
792 * only if the UA_INTLCK_CTRL field in the Control mode page is set to 00b
795 * We assume UA_INTLCK_CTRL to be 00b for HBAs that support autosense, and
796 * 10b for HBAs that do not support it (do not call scsi_req_get_sense).
797 * Here we handle unit attention clearing for UA_INTLCK_CTRL == 00b.
799 if (req
->dev
->sense_is_ua
) {
800 scsi_device_unit_attention_reported(req
->dev
);
801 req
->dev
->sense_len
= 0;
802 req
->dev
->sense_is_ua
= false;
807 int scsi_device_get_sense(SCSIDevice
*dev
, uint8_t *buf
, int len
, bool fixed
)
809 return scsi_convert_sense(dev
->sense
, dev
->sense_len
, buf
, len
, fixed
);
812 void scsi_req_build_sense(SCSIRequest
*req
, SCSISense sense
)
814 trace_scsi_req_build_sense(req
->dev
->id
, req
->lun
, req
->tag
,
815 sense
.key
, sense
.asc
, sense
.ascq
);
816 req
->sense_len
= scsi_build_sense(req
->sense
, sense
);
819 static void scsi_req_enqueue_internal(SCSIRequest
*req
)
821 assert(!req
->enqueued
);
823 if (req
->bus
->info
->get_sg_list
) {
824 req
->sg
= req
->bus
->info
->get_sg_list(req
);
828 req
->enqueued
= true;
829 QTAILQ_INSERT_TAIL(&req
->dev
->requests
, req
, next
);
832 int32_t scsi_req_enqueue(SCSIRequest
*req
)
837 scsi_req_enqueue_internal(req
);
839 rc
= req
->ops
->send_command(req
, req
->cmd
.buf
);
844 static void scsi_req_dequeue(SCSIRequest
*req
)
846 trace_scsi_req_dequeue(req
->dev
->id
, req
->lun
, req
->tag
);
849 QTAILQ_REMOVE(&req
->dev
->requests
, req
, next
);
850 req
->enqueued
= false;
855 static int scsi_get_performance_length(int num_desc
, int type
, int data_type
)
857 /* MMC-6, paragraph 6.7. */
860 if ((data_type
& 3) == 0) {
861 /* Each descriptor is as in Table 295 - Nominal performance. */
862 return 16 * num_desc
+ 8;
864 /* Each descriptor is as in Table 296 - Exceptions. */
865 return 6 * num_desc
+ 8;
870 return 8 * num_desc
+ 8;
872 return 2048 * num_desc
+ 8;
874 return 16 * num_desc
+ 8;
880 static int ata_passthrough_xfer_unit(SCSIDevice
*dev
, uint8_t *buf
)
882 int byte_block
= (buf
[2] >> 2) & 0x1;
883 int type
= (buf
[2] >> 4) & 0x1;
888 xfer_unit
= dev
->blocksize
;
899 static int ata_passthrough_12_xfer(SCSIDevice
*dev
, uint8_t *buf
)
901 int length
= buf
[2] & 0x3;
903 int unit
= ata_passthrough_xfer_unit(dev
, buf
);
907 case 3: /* USB-specific. */
922 static int ata_passthrough_16_xfer(SCSIDevice
*dev
, uint8_t *buf
)
924 int extend
= buf
[1] & 0x1;
925 int length
= buf
[2] & 0x3;
927 int unit
= ata_passthrough_xfer_unit(dev
, buf
);
931 case 3: /* USB-specific. */
937 xfer
|= (extend
? buf
[3] << 8 : 0);
941 xfer
|= (extend
? buf
[5] << 8 : 0);
948 static int scsi_req_xfer(SCSICommand
*cmd
, SCSIDevice
*dev
, uint8_t *buf
)
950 cmd
->xfer
= scsi_cdb_xfer(buf
);
952 case TEST_UNIT_READY
:
956 case WRITE_FILEMARKS
:
957 case WRITE_FILEMARKS_16
:
962 case ALLOW_MEDIUM_REMOVAL
:
964 case SYNCHRONIZE_CACHE
:
965 case SYNCHRONIZE_CACHE_16
:
967 case LOCK_UNLOCK_CACHE
:
976 case ALLOW_OVERWRITE
:
982 if ((buf
[1] & 2) == 0) {
984 } else if ((buf
[1] & 4) != 0) {
987 cmd
->xfer
*= dev
->blocksize
;
993 cmd
->xfer
= dev
->blocksize
;
995 case READ_CAPACITY_10
:
998 case READ_BLOCK_LIMITS
:
1001 case SEND_VOLUME_TAG
:
1002 /* GPCMD_SET_STREAMING from multimedia commands. */
1003 if (dev
->type
== TYPE_ROM
) {
1004 cmd
->xfer
= buf
[10] | (buf
[9] << 8);
1006 cmd
->xfer
= buf
[9] | (buf
[8] << 8);
1010 /* length 0 means 256 blocks */
1011 if (cmd
->xfer
== 0) {
1016 case WRITE_VERIFY_10
:
1018 case WRITE_VERIFY_12
:
1020 case WRITE_VERIFY_16
:
1021 cmd
->xfer
*= dev
->blocksize
;
1025 /* length 0 means 256 blocks */
1026 if (cmd
->xfer
== 0) {
1033 cmd
->xfer
*= dev
->blocksize
;
1036 /* MMC mandates the parameter list to be 12-bytes long. Parameters
1037 * for block devices are restricted to the header right now. */
1038 if (dev
->type
== TYPE_ROM
&& (buf
[1] & 16)) {
1041 cmd
->xfer
= (buf
[1] & 16) == 0 ? 0 : (buf
[1] & 32 ? 8 : 4);
1045 case RECEIVE_DIAGNOSTIC
:
1046 case SEND_DIAGNOSTIC
:
1047 cmd
->xfer
= buf
[4] | (buf
[3] << 8);
1052 case SEND_CUE_SHEET
:
1053 cmd
->xfer
= buf
[8] | (buf
[7] << 8) | (buf
[6] << 16);
1055 case PERSISTENT_RESERVE_OUT
:
1056 cmd
->xfer
= ldl_be_p(&buf
[5]) & 0xffffffffULL
;
1059 if (dev
->type
== TYPE_ROM
) {
1060 /* MMC command GET PERFORMANCE. */
1061 cmd
->xfer
= scsi_get_performance_length(buf
[9] | (buf
[8] << 8),
1062 buf
[10], buf
[1] & 0x1f);
1065 case MECHANISM_STATUS
:
1066 case READ_DVD_STRUCTURE
:
1067 case SEND_DVD_STRUCTURE
:
1068 case MAINTENANCE_OUT
:
1069 case MAINTENANCE_IN
:
1070 if (dev
->type
== TYPE_ROM
) {
1071 /* GPCMD_REPORT_KEY and GPCMD_SEND_KEY from multi media commands */
1072 cmd
->xfer
= buf
[9] | (buf
[8] << 8);
1075 case ATA_PASSTHROUGH_12
:
1076 if (dev
->type
== TYPE_ROM
) {
1077 /* BLANK command of MMC */
1080 cmd
->xfer
= ata_passthrough_12_xfer(dev
, buf
);
1083 case ATA_PASSTHROUGH_16
:
1084 cmd
->xfer
= ata_passthrough_16_xfer(dev
, buf
);
1090 static int scsi_req_stream_xfer(SCSICommand
*cmd
, SCSIDevice
*dev
, uint8_t *buf
)
1093 /* stream commands */
1100 case RECOVER_BUFFERED_DATA
:
1102 cmd
->xfer
= buf
[4] | (buf
[3] << 8) | (buf
[2] << 16);
1103 if (buf
[1] & 0x01) { /* fixed */
1104 cmd
->xfer
*= dev
->blocksize
;
1108 case READ_REVERSE_16
:
1111 cmd
->xfer
= buf
[14] | (buf
[13] << 8) | (buf
[12] << 16);
1112 if (buf
[1] & 0x01) { /* fixed */
1113 cmd
->xfer
*= dev
->blocksize
;
1121 cmd
->xfer
= buf
[13] | (buf
[12] << 8);
1124 switch (buf
[1] & 0x1f) /* operation code */ {
1125 case SHORT_FORM_BLOCK_ID
:
1126 case SHORT_FORM_VENDOR_SPECIFIC
:
1133 cmd
->xfer
= buf
[8] | (buf
[7] << 8);
1141 cmd
->xfer
= buf
[4] | (buf
[3] << 8);
1143 /* generic commands */
1145 return scsi_req_xfer(cmd
, dev
, buf
);
1150 static int scsi_req_medium_changer_xfer(SCSICommand
*cmd
, SCSIDevice
*dev
, uint8_t *buf
)
1153 /* medium changer commands */
1154 case EXCHANGE_MEDIUM
:
1155 case INITIALIZE_ELEMENT_STATUS
:
1156 case INITIALIZE_ELEMENT_STATUS_WITH_RANGE
:
1158 case POSITION_TO_ELEMENT
:
1161 case READ_ELEMENT_STATUS
:
1162 cmd
->xfer
= buf
[9] | (buf
[8] << 8) | (buf
[7] << 16);
1165 /* generic commands */
1167 return scsi_req_xfer(cmd
, dev
, buf
);
1172 static int scsi_req_scanner_length(SCSICommand
*cmd
, SCSIDevice
*dev
, uint8_t *buf
)
1175 /* Scanner commands */
1176 case OBJECT_POSITION
:
1186 cmd
->xfer
= buf
[8] | (buf
[7] << 8) | (buf
[6] << 16);
1189 /* GET_DATA_BUFFER_STATUS xfer handled by scsi_req_xfer */
1190 return scsi_req_xfer(cmd
, dev
, buf
);
1196 static void scsi_cmd_xfer_mode(SCSICommand
*cmd
)
1199 cmd
->mode
= SCSI_XFER_NONE
;
1202 switch (cmd
->buf
[0]) {
1205 case WRITE_VERIFY_10
:
1207 case WRITE_VERIFY_12
:
1209 case WRITE_VERIFY_16
:
1216 case CHANGE_DEFINITION
:
1219 case MODE_SELECT_10
:
1220 case SEND_DIAGNOSTIC
:
1223 case REASSIGN_BLOCKS
:
1232 case SEARCH_HIGH_12
:
1233 case SEARCH_EQUAL_12
:
1236 case SEND_VOLUME_TAG
:
1237 case SEND_CUE_SHEET
:
1238 case SEND_DVD_STRUCTURE
:
1239 case PERSISTENT_RESERVE_OUT
:
1240 case MAINTENANCE_OUT
:
1243 /* SCAN conflicts with START_STOP. START_STOP has cmd->xfer set to 0 for
1244 * non-scanner devices, so we only get here for SCAN and not for START_STOP.
1246 cmd
->mode
= SCSI_XFER_TO_DEV
;
1248 case ATA_PASSTHROUGH_12
:
1249 case ATA_PASSTHROUGH_16
:
1251 cmd
->mode
= (cmd
->buf
[2] & 0x8) ?
1252 SCSI_XFER_FROM_DEV
: SCSI_XFER_TO_DEV
;
1255 cmd
->mode
= SCSI_XFER_FROM_DEV
;
1260 int scsi_req_parse_cdb(SCSIDevice
*dev
, SCSICommand
*cmd
, uint8_t *buf
)
1266 len
= scsi_cdb_length(buf
);
1272 switch (dev
->type
) {
1274 rc
= scsi_req_stream_xfer(cmd
, dev
, buf
);
1276 case TYPE_MEDIUM_CHANGER
:
1277 rc
= scsi_req_medium_changer_xfer(cmd
, dev
, buf
);
1280 rc
= scsi_req_scanner_length(cmd
, dev
, buf
);
1283 rc
= scsi_req_xfer(cmd
, dev
, buf
);
1290 memcpy(cmd
->buf
, buf
, cmd
->len
);
1291 scsi_cmd_xfer_mode(cmd
);
1292 cmd
->lba
= scsi_cmd_lba(cmd
);
1296 void scsi_device_report_change(SCSIDevice
*dev
, SCSISense sense
)
1298 SCSIBus
*bus
= DO_UPCAST(SCSIBus
, qbus
, dev
->qdev
.parent_bus
);
1300 scsi_device_set_ua(dev
, sense
);
1301 if (bus
->info
->change
) {
1302 bus
->info
->change(bus
, dev
, sense
);
1306 SCSIRequest
*scsi_req_ref(SCSIRequest
*req
)
1308 assert(req
->refcount
> 0);
1313 void scsi_req_unref(SCSIRequest
*req
)
1315 assert(req
->refcount
> 0);
1316 if (--req
->refcount
== 0) {
1317 BusState
*qbus
= req
->dev
->qdev
.parent_bus
;
1318 SCSIBus
*bus
= DO_UPCAST(SCSIBus
, qbus
, qbus
);
1320 if (bus
->info
->free_request
&& req
->hba_private
) {
1321 bus
->info
->free_request(bus
, req
->hba_private
);
1323 if (req
->ops
->free_req
) {
1324 req
->ops
->free_req(req
);
1326 object_unref(OBJECT(req
->dev
));
1327 object_unref(OBJECT(qbus
->parent
));
1332 /* Tell the device that we finished processing this chunk of I/O. It
1333 will start the next chunk or complete the command. */
1334 void scsi_req_continue(SCSIRequest
*req
)
1336 if (req
->io_canceled
) {
1337 trace_scsi_req_continue_canceled(req
->dev
->id
, req
->lun
, req
->tag
);
1340 trace_scsi_req_continue(req
->dev
->id
, req
->lun
, req
->tag
);
1341 if (req
->cmd
.mode
== SCSI_XFER_TO_DEV
) {
1342 req
->ops
->write_data(req
);
1344 req
->ops
->read_data(req
);
1348 /* Called by the devices when data is ready for the HBA. The HBA should
1349 start a DMA operation to read or fill the device's data buffer.
1350 Once it completes, calling scsi_req_continue will restart I/O. */
1351 void scsi_req_data(SCSIRequest
*req
, int len
)
1354 if (req
->io_canceled
) {
1355 trace_scsi_req_data_canceled(req
->dev
->id
, req
->lun
, req
->tag
, len
);
1358 trace_scsi_req_data(req
->dev
->id
, req
->lun
, req
->tag
, len
);
1359 assert(req
->cmd
.mode
!= SCSI_XFER_NONE
);
1362 req
->bus
->info
->transfer_data(req
, len
);
1366 /* If the device calls scsi_req_data and the HBA specified a
1367 * scatter/gather list, the transfer has to happen in a single
1369 assert(!req
->dma_started
);
1370 req
->dma_started
= true;
1372 buf
= scsi_req_get_buf(req
);
1373 if (req
->cmd
.mode
== SCSI_XFER_FROM_DEV
) {
1374 req
->resid
= dma_buf_read(buf
, len
, req
->sg
);
1376 req
->resid
= dma_buf_write(buf
, len
, req
->sg
);
1378 scsi_req_continue(req
);
1381 void scsi_req_print(SCSIRequest
*req
)
1386 fprintf(fp
, "[%s id=%d] %s",
1387 req
->dev
->qdev
.parent_bus
->name
,
1389 scsi_command_name(req
->cmd
.buf
[0]));
1390 for (i
= 1; i
< req
->cmd
.len
; i
++) {
1391 fprintf(fp
, " 0x%02x", req
->cmd
.buf
[i
]);
1393 switch (req
->cmd
.mode
) {
1394 case SCSI_XFER_NONE
:
1395 fprintf(fp
, " - none\n");
1397 case SCSI_XFER_FROM_DEV
:
1398 fprintf(fp
, " - from-dev len=%zd\n", req
->cmd
.xfer
);
1400 case SCSI_XFER_TO_DEV
:
1401 fprintf(fp
, " - to-dev len=%zd\n", req
->cmd
.xfer
);
1404 fprintf(fp
, " - Oops\n");
1409 void scsi_req_complete(SCSIRequest
*req
, int status
)
1411 assert(req
->status
== -1);
1412 req
->status
= status
;
1414 assert(req
->sense_len
<= sizeof(req
->sense
));
1415 if (status
== GOOD
) {
1419 if (req
->sense_len
) {
1420 memcpy(req
->dev
->sense
, req
->sense
, req
->sense_len
);
1421 req
->dev
->sense_len
= req
->sense_len
;
1422 req
->dev
->sense_is_ua
= (req
->ops
== &reqops_unit_attention
);
1424 req
->dev
->sense_len
= 0;
1425 req
->dev
->sense_is_ua
= false;
1429 * Unit attention state is now stored in the device's sense buffer
1430 * if the HBA didn't do autosense. Clear the pending unit attention
1433 scsi_clear_unit_attention(req
);
1436 scsi_req_dequeue(req
);
1437 req
->bus
->info
->complete(req
, req
->status
, req
->resid
);
1439 /* Cancelled requests might end up being completed instead of cancelled */
1440 notifier_list_notify(&req
->cancel_notifiers
, req
);
1441 scsi_req_unref(req
);
1444 /* Called by the devices when the request is canceled. */
1445 void scsi_req_cancel_complete(SCSIRequest
*req
)
1447 assert(req
->io_canceled
);
1448 if (req
->bus
->info
->cancel
) {
1449 req
->bus
->info
->cancel(req
);
1451 notifier_list_notify(&req
->cancel_notifiers
, req
);
1452 scsi_req_unref(req
);
1455 /* Cancel @req asynchronously. @notifier is added to @req's cancellation
1456 * notifier list, the bus will be notified the requests cancellation is
1459 void scsi_req_cancel_async(SCSIRequest
*req
, Notifier
*notifier
)
1461 trace_scsi_req_cancel(req
->dev
->id
, req
->lun
, req
->tag
);
1463 notifier_list_add(&req
->cancel_notifiers
, notifier
);
1465 if (req
->io_canceled
) {
1466 /* A blk_aio_cancel_async is pending; when it finishes,
1467 * scsi_req_cancel_complete will be called and will
1468 * call the notifier we just added. Just wait for that.
1473 /* Dropped in scsi_req_cancel_complete. */
1475 scsi_req_dequeue(req
);
1476 req
->io_canceled
= true;
1478 blk_aio_cancel_async(req
->aiocb
);
1480 scsi_req_cancel_complete(req
);
1484 void scsi_req_cancel(SCSIRequest
*req
)
1486 trace_scsi_req_cancel(req
->dev
->id
, req
->lun
, req
->tag
);
1487 if (!req
->enqueued
) {
1490 assert(!req
->io_canceled
);
1491 /* Dropped in scsi_req_cancel_complete. */
1493 scsi_req_dequeue(req
);
1494 req
->io_canceled
= true;
1496 blk_aio_cancel(req
->aiocb
);
1498 scsi_req_cancel_complete(req
);
1502 static int scsi_ua_precedence(SCSISense sense
)
1504 if (sense
.key
!= UNIT_ATTENTION
) {
1507 if (sense
.asc
== 0x29 && sense
.ascq
== 0x04) {
1508 /* DEVICE INTERNAL RESET goes with POWER ON OCCURRED */
1510 } else if (sense
.asc
== 0x3F && sense
.ascq
== 0x01) {
1511 /* MICROCODE HAS BEEN CHANGED goes with SCSI BUS RESET OCCURRED */
1513 } else if (sense
.asc
== 0x29 && (sense
.ascq
== 0x05 || sense
.ascq
== 0x06)) {
1514 /* These two go with "all others". */
1516 } else if (sense
.asc
== 0x29 && sense
.ascq
<= 0x07) {
1517 /* POWER ON, RESET OR BUS DEVICE RESET OCCURRED = 0
1518 * POWER ON OCCURRED = 1
1519 * SCSI BUS RESET OCCURRED = 2
1520 * BUS DEVICE RESET FUNCTION OCCURRED = 3
1521 * I_T NEXUS LOSS OCCURRED = 7
1524 } else if (sense
.asc
== 0x2F && sense
.ascq
== 0x01) {
1525 /* COMMANDS CLEARED BY POWER LOSS NOTIFICATION */
1528 return (sense
.asc
<< 8) | sense
.ascq
;
1531 void scsi_device_set_ua(SCSIDevice
*sdev
, SCSISense sense
)
1534 if (sense
.key
!= UNIT_ATTENTION
) {
1537 trace_scsi_device_set_ua(sdev
->id
, sdev
->lun
, sense
.key
,
1538 sense
.asc
, sense
.ascq
);
1541 * Override a pre-existing unit attention condition, except for a more
1542 * important reset condition.
1544 prec1
= scsi_ua_precedence(sdev
->unit_attention
);
1545 prec2
= scsi_ua_precedence(sense
);
1546 if (prec2
< prec1
) {
1547 sdev
->unit_attention
= sense
;
1551 void scsi_device_purge_requests(SCSIDevice
*sdev
, SCSISense sense
)
1555 aio_context_acquire(blk_get_aio_context(sdev
->conf
.blk
));
1556 while (!QTAILQ_EMPTY(&sdev
->requests
)) {
1557 req
= QTAILQ_FIRST(&sdev
->requests
);
1558 scsi_req_cancel_async(req
, NULL
);
1560 blk_drain(sdev
->conf
.blk
);
1561 aio_context_release(blk_get_aio_context(sdev
->conf
.blk
));
1562 scsi_device_set_ua(sdev
, sense
);
1565 static char *scsibus_get_dev_path(DeviceState
*dev
)
1567 SCSIDevice
*d
= SCSI_DEVICE(dev
);
1568 DeviceState
*hba
= dev
->parent_bus
->parent
;
1572 id
= qdev_get_dev_path(hba
);
1574 path
= g_strdup_printf("%s/%d:%d:%d", id
, d
->channel
, d
->id
, d
->lun
);
1576 path
= g_strdup_printf("%d:%d:%d", d
->channel
, d
->id
, d
->lun
);
1582 static char *scsibus_get_fw_dev_path(DeviceState
*dev
)
1584 SCSIDevice
*d
= SCSI_DEVICE(dev
);
1585 return g_strdup_printf("channel@%x/%s@%x,%x", d
->channel
,
1586 qdev_fw_name(dev
), d
->id
, d
->lun
);
1589 SCSIDevice
*scsi_device_find(SCSIBus
*bus
, int channel
, int id
, int lun
)
1592 SCSIDevice
*target_dev
= NULL
;
1594 QTAILQ_FOREACH_REVERSE(kid
, &bus
->qbus
.children
, ChildrenHead
, sibling
) {
1595 DeviceState
*qdev
= kid
->child
;
1596 SCSIDevice
*dev
= SCSI_DEVICE(qdev
);
1598 if (dev
->channel
== channel
&& dev
->id
== id
) {
1599 if (dev
->lun
== lun
) {
1608 /* SCSI request list. For simplicity, pv points to the whole device */
1610 static int put_scsi_requests(QEMUFile
*f
, void *pv
, size_t size
,
1611 VMStateField
*field
, QJSON
*vmdesc
)
1614 SCSIBus
*bus
= DO_UPCAST(SCSIBus
, qbus
, s
->qdev
.parent_bus
);
1617 QTAILQ_FOREACH(req
, &s
->requests
, next
) {
1618 assert(!req
->io_canceled
);
1619 assert(req
->status
== -1);
1620 assert(req
->enqueued
);
1622 qemu_put_sbyte(f
, req
->retry
? 1 : 2);
1623 qemu_put_buffer(f
, req
->cmd
.buf
, sizeof(req
->cmd
.buf
));
1624 qemu_put_be32s(f
, &req
->tag
);
1625 qemu_put_be32s(f
, &req
->lun
);
1626 if (bus
->info
->save_request
) {
1627 bus
->info
->save_request(f
, req
);
1629 if (req
->ops
->save_request
) {
1630 req
->ops
->save_request(f
, req
);
1633 qemu_put_sbyte(f
, 0);
1638 static int get_scsi_requests(QEMUFile
*f
, void *pv
, size_t size
,
1639 VMStateField
*field
)
1642 SCSIBus
*bus
= DO_UPCAST(SCSIBus
, qbus
, s
->qdev
.parent_bus
);
1645 while ((sbyte
= qemu_get_sbyte(f
)) > 0) {
1646 uint8_t buf
[SCSI_CMD_BUF_SIZE
];
1651 qemu_get_buffer(f
, buf
, sizeof(buf
));
1652 qemu_get_be32s(f
, &tag
);
1653 qemu_get_be32s(f
, &lun
);
1654 req
= scsi_req_new(s
, tag
, lun
, buf
, NULL
);
1655 req
->retry
= (sbyte
== 1);
1656 if (bus
->info
->load_request
) {
1657 req
->hba_private
= bus
->info
->load_request(f
, req
);
1659 if (req
->ops
->load_request
) {
1660 req
->ops
->load_request(f
, req
);
1663 /* Just restart it later. */
1664 scsi_req_enqueue_internal(req
);
1666 /* At this point, the request will be kept alive by the reference
1667 * added by scsi_req_enqueue_internal, so we can release our reference.
1668 * The HBA of course will add its own reference in the load_request
1669 * callback if it needs to hold on the SCSIRequest.
1671 scsi_req_unref(req
);
1677 static const VMStateInfo vmstate_info_scsi_requests
= {
1678 .name
= "scsi-requests",
1679 .get
= get_scsi_requests
,
1680 .put
= put_scsi_requests
,
1683 static bool scsi_sense_state_needed(void *opaque
)
1685 SCSIDevice
*s
= opaque
;
1687 return s
->sense_len
> SCSI_SENSE_BUF_SIZE_OLD
;
1690 static const VMStateDescription vmstate_scsi_sense_state
= {
1691 .name
= "SCSIDevice/sense",
1693 .minimum_version_id
= 1,
1694 .needed
= scsi_sense_state_needed
,
1695 .fields
= (VMStateField
[]) {
1696 VMSTATE_UINT8_SUB_ARRAY(sense
, SCSIDevice
,
1697 SCSI_SENSE_BUF_SIZE_OLD
,
1698 SCSI_SENSE_BUF_SIZE
- SCSI_SENSE_BUF_SIZE_OLD
),
1699 VMSTATE_END_OF_LIST()
1703 const VMStateDescription vmstate_scsi_device
= {
1704 .name
= "SCSIDevice",
1706 .minimum_version_id
= 1,
1707 .fields
= (VMStateField
[]) {
1708 VMSTATE_UINT8(unit_attention
.key
, SCSIDevice
),
1709 VMSTATE_UINT8(unit_attention
.asc
, SCSIDevice
),
1710 VMSTATE_UINT8(unit_attention
.ascq
, SCSIDevice
),
1711 VMSTATE_BOOL(sense_is_ua
, SCSIDevice
),
1712 VMSTATE_UINT8_SUB_ARRAY(sense
, SCSIDevice
, 0, SCSI_SENSE_BUF_SIZE_OLD
),
1713 VMSTATE_UINT32(sense_len
, SCSIDevice
),
1717 .field_exists
= NULL
,
1718 .size
= 0, /* ouch */
1719 .info
= &vmstate_info_scsi_requests
,
1720 .flags
= VMS_SINGLE
,
1723 VMSTATE_END_OF_LIST()
1725 .subsections
= (const VMStateDescription
*[]) {
1726 &vmstate_scsi_sense_state
,
1731 static void scsi_device_class_init(ObjectClass
*klass
, void *data
)
1733 DeviceClass
*k
= DEVICE_CLASS(klass
);
1734 set_bit(DEVICE_CATEGORY_STORAGE
, k
->categories
);
1735 k
->bus_type
= TYPE_SCSI_BUS
;
1736 k
->realize
= scsi_qdev_realize
;
1737 k
->unrealize
= scsi_qdev_unrealize
;
1738 k
->props
= scsi_props
;
1741 static void scsi_dev_instance_init(Object
*obj
)
1743 DeviceState
*dev
= DEVICE(obj
);
1744 SCSIDevice
*s
= SCSI_DEVICE(dev
);
1746 device_add_bootindex_property(obj
, &s
->conf
.bootindex
,
1751 static const TypeInfo scsi_device_type_info
= {
1752 .name
= TYPE_SCSI_DEVICE
,
1753 .parent
= TYPE_DEVICE
,
1754 .instance_size
= sizeof(SCSIDevice
),
1756 .class_size
= sizeof(SCSIDeviceClass
),
1757 .class_init
= scsi_device_class_init
,
1758 .instance_init
= scsi_dev_instance_init
,
1761 static void scsi_register_types(void)
1763 type_register_static(&scsi_bus_info
);
1764 type_register_static(&scsi_device_type_info
);
1767 type_init(scsi_register_types
)