4 * Copyright IBM, Corp. 2010
5 * Copyright Red Hat, Inc. 2011
8 * Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
9 * Paolo Bonzini <pbonzini@redhat.com>
11 * This work is licensed under the terms of the GNU GPL, version 2 or later.
12 * See the COPYING file in the top-level directory.
16 #include "virtio-scsi.h"
18 #include <hw/scsi-defs.h>
20 #define VIRTIO_SCSI_VQ_SIZE 128
21 #define VIRTIO_SCSI_CDB_SIZE 32
22 #define VIRTIO_SCSI_SENSE_SIZE 96
23 #define VIRTIO_SCSI_MAX_CHANNEL 0
24 #define VIRTIO_SCSI_MAX_TARGET 255
25 #define VIRTIO_SCSI_MAX_LUN 16383
28 #define VIRTIO_SCSI_F_INOUT 0
29 #define VIRTIO_SCSI_F_HOTPLUG 1
32 #define VIRTIO_SCSI_S_OK 0
33 #define VIRTIO_SCSI_S_OVERRUN 1
34 #define VIRTIO_SCSI_S_ABORTED 2
35 #define VIRTIO_SCSI_S_BAD_TARGET 3
36 #define VIRTIO_SCSI_S_RESET 4
37 #define VIRTIO_SCSI_S_BUSY 5
38 #define VIRTIO_SCSI_S_TRANSPORT_FAILURE 6
39 #define VIRTIO_SCSI_S_TARGET_FAILURE 7
40 #define VIRTIO_SCSI_S_NEXUS_FAILURE 8
41 #define VIRTIO_SCSI_S_FAILURE 9
42 #define VIRTIO_SCSI_S_FUNCTION_SUCCEEDED 10
43 #define VIRTIO_SCSI_S_FUNCTION_REJECTED 11
44 #define VIRTIO_SCSI_S_INCORRECT_LUN 12
46 /* Controlq type codes. */
47 #define VIRTIO_SCSI_T_TMF 0
48 #define VIRTIO_SCSI_T_AN_QUERY 1
49 #define VIRTIO_SCSI_T_AN_SUBSCRIBE 2
51 /* Valid TMF subtypes. */
52 #define VIRTIO_SCSI_T_TMF_ABORT_TASK 0
53 #define VIRTIO_SCSI_T_TMF_ABORT_TASK_SET 1
54 #define VIRTIO_SCSI_T_TMF_CLEAR_ACA 2
55 #define VIRTIO_SCSI_T_TMF_CLEAR_TASK_SET 3
56 #define VIRTIO_SCSI_T_TMF_I_T_NEXUS_RESET 4
57 #define VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET 5
58 #define VIRTIO_SCSI_T_TMF_QUERY_TASK 6
59 #define VIRTIO_SCSI_T_TMF_QUERY_TASK_SET 7
62 #define VIRTIO_SCSI_T_EVENTS_MISSED 0x80000000
63 #define VIRTIO_SCSI_T_NO_EVENT 0
64 #define VIRTIO_SCSI_T_TRANSPORT_RESET 1
65 #define VIRTIO_SCSI_T_ASYNC_NOTIFY 2
67 /* Reasons for transport reset event */
68 #define VIRTIO_SCSI_EVT_RESET_HARD 0
69 #define VIRTIO_SCSI_EVT_RESET_RESCAN 1
70 #define VIRTIO_SCSI_EVT_RESET_REMOVED 2
72 /* SCSI command request, followed by data-out */
74 uint8_t lun
[8]; /* Logical Unit Number */
75 uint64_t tag
; /* Command identifier */
76 uint8_t task_attr
; /* Task attribute */
80 } QEMU_PACKED VirtIOSCSICmdReq
;
82 /* Response, followed by sense data and data-in */
84 uint32_t sense_len
; /* Sense data length */
85 uint32_t resid
; /* Residual bytes in data buffer */
86 uint16_t status_qualifier
; /* Status qualifier */
87 uint8_t status
; /* Command completion status */
88 uint8_t response
; /* Response values */
90 } QEMU_PACKED VirtIOSCSICmdResp
;
92 /* Task Management Request */
98 } QEMU_PACKED VirtIOSCSICtrlTMFReq
;
102 } QEMU_PACKED VirtIOSCSICtrlTMFResp
;
104 /* Asynchronous notification query/subscription */
108 uint32_t event_requested
;
109 } QEMU_PACKED VirtIOSCSICtrlANReq
;
112 uint32_t event_actual
;
114 } QEMU_PACKED VirtIOSCSICtrlANResp
;
120 } QEMU_PACKED VirtIOSCSIEvent
;
125 uint32_t max_sectors
;
126 uint32_t cmd_per_lun
;
127 uint32_t event_info_size
;
130 uint16_t max_channel
;
133 } QEMU_PACKED VirtIOSCSIConfig
;
138 VirtIOSCSIConf
*conf
;
146 VirtQueue
*cmd_vqs
[0];
149 typedef struct VirtIOSCSIReq
{
152 VirtQueueElement elem
;
157 VirtIOSCSICmdReq
*cmd
;
158 VirtIOSCSICtrlTMFReq
*tmf
;
159 VirtIOSCSICtrlANReq
*an
;
163 VirtIOSCSICmdResp
*cmd
;
164 VirtIOSCSICtrlTMFResp
*tmf
;
165 VirtIOSCSICtrlANResp
*an
;
166 VirtIOSCSIEvent
*event
;
170 static inline int virtio_scsi_get_lun(uint8_t *lun
)
172 return ((lun
[2] << 8) | lun
[3]) & 0x3FFF;
175 static inline SCSIDevice
*virtio_scsi_device_find(VirtIOSCSI
*s
, uint8_t *lun
)
180 if (lun
[2] != 0 && !(lun
[2] >= 0x40 && lun
[2] < 0x80)) {
183 return scsi_device_find(&s
->bus
, 0, lun
[1], virtio_scsi_get_lun(lun
));
186 static void virtio_scsi_complete_req(VirtIOSCSIReq
*req
)
188 VirtIOSCSI
*s
= req
->dev
;
189 VirtQueue
*vq
= req
->vq
;
190 virtqueue_push(vq
, &req
->elem
, req
->qsgl
.size
+ req
->elem
.in_sg
[0].iov_len
);
191 qemu_sglist_destroy(&req
->qsgl
);
193 req
->sreq
->hba_private
= NULL
;
194 scsi_req_unref(req
->sreq
);
197 virtio_notify(&s
->vdev
, vq
);
200 static void virtio_scsi_bad_req(void)
202 error_report("wrong size for virtio-scsi headers");
206 static void qemu_sgl_init_external(QEMUSGList
*qsgl
, struct iovec
*sg
,
207 target_phys_addr_t
*addr
, int num
)
209 memset(qsgl
, 0, sizeof(*qsgl
));
211 qemu_sglist_add(qsgl
, *(addr
++), (sg
++)->iov_len
);
215 static void virtio_scsi_parse_req(VirtIOSCSI
*s
, VirtQueue
*vq
,
218 assert(req
->elem
.in_num
);
222 if (req
->elem
.out_num
) {
223 req
->req
.buf
= req
->elem
.out_sg
[0].iov_base
;
225 req
->resp
.buf
= req
->elem
.in_sg
[0].iov_base
;
227 if (req
->elem
.out_num
> 1) {
228 qemu_sgl_init_external(&req
->qsgl
, &req
->elem
.out_sg
[1],
229 &req
->elem
.out_addr
[1],
230 req
->elem
.out_num
- 1);
232 qemu_sgl_init_external(&req
->qsgl
, &req
->elem
.in_sg
[1],
233 &req
->elem
.in_addr
[1],
234 req
->elem
.in_num
- 1);
238 static VirtIOSCSIReq
*virtio_scsi_pop_req(VirtIOSCSI
*s
, VirtQueue
*vq
)
241 req
= g_malloc(sizeof(*req
));
242 if (!virtqueue_pop(vq
, &req
->elem
)) {
247 virtio_scsi_parse_req(s
, vq
, req
);
251 static void virtio_scsi_save_request(QEMUFile
*f
, SCSIRequest
*sreq
)
253 VirtIOSCSIReq
*req
= sreq
->hba_private
;
254 uint32_t n
= virtio_queue_get_id(req
->vq
) - 2;
256 assert(n
< req
->dev
->conf
->num_queues
);
257 qemu_put_be32s(f
, &n
);
258 qemu_put_buffer(f
, (unsigned char *)&req
->elem
, sizeof(req
->elem
));
261 static void *virtio_scsi_load_request(QEMUFile
*f
, SCSIRequest
*sreq
)
263 SCSIBus
*bus
= sreq
->bus
;
264 VirtIOSCSI
*s
= container_of(bus
, VirtIOSCSI
, bus
);
268 req
= g_malloc(sizeof(*req
));
269 qemu_get_be32s(f
, &n
);
270 assert(n
< s
->conf
->num_queues
);
271 qemu_get_buffer(f
, (unsigned char *)&req
->elem
, sizeof(req
->elem
));
272 virtio_scsi_parse_req(s
, s
->cmd_vqs
[n
], req
);
276 if (req
->sreq
->cmd
.mode
!= SCSI_XFER_NONE
) {
278 (req
->elem
.in_num
> 1 ? SCSI_XFER_FROM_DEV
: SCSI_XFER_TO_DEV
);
280 assert(req
->sreq
->cmd
.mode
== req_mode
);
285 static void virtio_scsi_do_tmf(VirtIOSCSI
*s
, VirtIOSCSIReq
*req
)
287 SCSIDevice
*d
= virtio_scsi_device_find(s
, req
->req
.tmf
->lun
);
288 SCSIRequest
*r
, *next
;
292 /* Here VIRTIO_SCSI_S_OK means "FUNCTION COMPLETE". */
293 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_OK
;
295 switch (req
->req
.tmf
->subtype
) {
296 case VIRTIO_SCSI_T_TMF_ABORT_TASK
:
297 case VIRTIO_SCSI_T_TMF_QUERY_TASK
:
301 if (d
->lun
!= virtio_scsi_get_lun(req
->req
.tmf
->lun
)) {
304 QTAILQ_FOREACH_SAFE(r
, &d
->requests
, next
, next
) {
305 if (r
->tag
== req
->req
.tmf
->tag
) {
309 if (r
&& r
->hba_private
) {
310 if (req
->req
.tmf
->subtype
== VIRTIO_SCSI_T_TMF_QUERY_TASK
) {
311 /* "If the specified command is present in the task set, then
312 * return a service response set to FUNCTION SUCCEEDED".
314 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_FUNCTION_SUCCEEDED
;
321 case VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET
:
325 if (d
->lun
!= virtio_scsi_get_lun(req
->req
.tmf
->lun
)) {
329 qdev_reset_all(&d
->qdev
);
333 case VIRTIO_SCSI_T_TMF_ABORT_TASK_SET
:
334 case VIRTIO_SCSI_T_TMF_CLEAR_TASK_SET
:
335 case VIRTIO_SCSI_T_TMF_QUERY_TASK_SET
:
339 if (d
->lun
!= virtio_scsi_get_lun(req
->req
.tmf
->lun
)) {
342 QTAILQ_FOREACH_SAFE(r
, &d
->requests
, next
, next
) {
343 if (r
->hba_private
) {
344 if (req
->req
.tmf
->subtype
== VIRTIO_SCSI_T_TMF_QUERY_TASK_SET
) {
345 /* "If there is any command present in the task set, then
346 * return a service response set to FUNCTION SUCCEEDED".
348 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_FUNCTION_SUCCEEDED
;
357 case VIRTIO_SCSI_T_TMF_I_T_NEXUS_RESET
:
358 target
= req
->req
.tmf
->lun
[1];
360 QTAILQ_FOREACH(kid
, &s
->bus
.qbus
.children
, sibling
) {
361 d
= DO_UPCAST(SCSIDevice
, qdev
, kid
->child
);
362 if (d
->channel
== 0 && d
->id
== target
) {
363 qdev_reset_all(&d
->qdev
);
369 case VIRTIO_SCSI_T_TMF_CLEAR_ACA
:
371 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_FUNCTION_REJECTED
;
378 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_INCORRECT_LUN
;
382 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_BAD_TARGET
;
385 static void virtio_scsi_handle_ctrl(VirtIODevice
*vdev
, VirtQueue
*vq
)
387 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
390 while ((req
= virtio_scsi_pop_req(s
, vq
))) {
391 int out_size
, in_size
;
392 if (req
->elem
.out_num
< 1 || req
->elem
.in_num
< 1) {
393 virtio_scsi_bad_req();
397 out_size
= req
->elem
.out_sg
[0].iov_len
;
398 in_size
= req
->elem
.in_sg
[0].iov_len
;
399 if (req
->req
.tmf
->type
== VIRTIO_SCSI_T_TMF
) {
400 if (out_size
< sizeof(VirtIOSCSICtrlTMFReq
) ||
401 in_size
< sizeof(VirtIOSCSICtrlTMFResp
)) {
402 virtio_scsi_bad_req();
404 virtio_scsi_do_tmf(s
, req
);
406 } else if (req
->req
.tmf
->type
== VIRTIO_SCSI_T_AN_QUERY
||
407 req
->req
.tmf
->type
== VIRTIO_SCSI_T_AN_SUBSCRIBE
) {
408 if (out_size
< sizeof(VirtIOSCSICtrlANReq
) ||
409 in_size
< sizeof(VirtIOSCSICtrlANResp
)) {
410 virtio_scsi_bad_req();
412 req
->resp
.an
->event_actual
= 0;
413 req
->resp
.an
->response
= VIRTIO_SCSI_S_OK
;
415 virtio_scsi_complete_req(req
);
419 static void virtio_scsi_handle_event(VirtIODevice
*vdev
, VirtQueue
*vq
)
423 static void virtio_scsi_command_complete(SCSIRequest
*r
, uint32_t status
,
426 VirtIOSCSIReq
*req
= r
->hba_private
;
428 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_OK
;
429 req
->resp
.cmd
->status
= status
;
430 if (req
->resp
.cmd
->status
== GOOD
) {
431 req
->resp
.cmd
->resid
= resid
;
433 req
->resp
.cmd
->resid
= 0;
434 req
->resp
.cmd
->sense_len
=
435 scsi_req_get_sense(r
, req
->resp
.cmd
->sense
, VIRTIO_SCSI_SENSE_SIZE
);
437 virtio_scsi_complete_req(req
);
440 static QEMUSGList
*virtio_scsi_get_sg_list(SCSIRequest
*r
)
442 VirtIOSCSIReq
*req
= r
->hba_private
;
447 static void virtio_scsi_request_cancelled(SCSIRequest
*r
)
449 VirtIOSCSIReq
*req
= r
->hba_private
;
454 if (req
->dev
->resetting
) {
455 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_RESET
;
457 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_ABORTED
;
459 virtio_scsi_complete_req(req
);
462 static void virtio_scsi_fail_cmd_req(VirtIOSCSIReq
*req
)
464 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_FAILURE
;
465 virtio_scsi_complete_req(req
);
468 static void virtio_scsi_handle_cmd(VirtIODevice
*vdev
, VirtQueue
*vq
)
470 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
474 while ((req
= virtio_scsi_pop_req(s
, vq
))) {
476 int out_size
, in_size
;
477 if (req
->elem
.out_num
< 1 || req
->elem
.in_num
< 1) {
478 virtio_scsi_bad_req();
481 out_size
= req
->elem
.out_sg
[0].iov_len
;
482 in_size
= req
->elem
.in_sg
[0].iov_len
;
483 if (out_size
< sizeof(VirtIOSCSICmdReq
) + s
->cdb_size
||
484 in_size
< sizeof(VirtIOSCSICmdResp
) + s
->sense_size
) {
485 virtio_scsi_bad_req();
488 if (req
->elem
.out_num
> 1 && req
->elem
.in_num
> 1) {
489 virtio_scsi_fail_cmd_req(req
);
493 d
= virtio_scsi_device_find(s
, req
->req
.cmd
->lun
);
495 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_BAD_TARGET
;
496 virtio_scsi_complete_req(req
);
499 req
->sreq
= scsi_req_new(d
, req
->req
.cmd
->tag
,
500 virtio_scsi_get_lun(req
->req
.cmd
->lun
),
501 req
->req
.cmd
->cdb
, req
);
503 if (req
->sreq
->cmd
.mode
!= SCSI_XFER_NONE
) {
505 (req
->elem
.in_num
> 1 ? SCSI_XFER_FROM_DEV
: SCSI_XFER_TO_DEV
);
507 if (req
->sreq
->cmd
.mode
!= req_mode
||
508 req
->sreq
->cmd
.xfer
> req
->qsgl
.size
) {
509 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_OVERRUN
;
510 virtio_scsi_complete_req(req
);
515 n
= scsi_req_enqueue(req
->sreq
);
517 scsi_req_continue(req
->sreq
);
522 static void virtio_scsi_get_config(VirtIODevice
*vdev
,
525 VirtIOSCSIConfig
*scsiconf
= (VirtIOSCSIConfig
*)config
;
526 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
528 stl_raw(&scsiconf
->num_queues
, s
->conf
->num_queues
);
529 stl_raw(&scsiconf
->seg_max
, 128 - 2);
530 stl_raw(&scsiconf
->max_sectors
, s
->conf
->max_sectors
);
531 stl_raw(&scsiconf
->cmd_per_lun
, s
->conf
->cmd_per_lun
);
532 stl_raw(&scsiconf
->event_info_size
, sizeof(VirtIOSCSIEvent
));
533 stl_raw(&scsiconf
->sense_size
, s
->sense_size
);
534 stl_raw(&scsiconf
->cdb_size
, s
->cdb_size
);
535 stl_raw(&scsiconf
->max_channel
, VIRTIO_SCSI_MAX_CHANNEL
);
536 stl_raw(&scsiconf
->max_target
, VIRTIO_SCSI_MAX_TARGET
);
537 stl_raw(&scsiconf
->max_lun
, VIRTIO_SCSI_MAX_LUN
);
540 static void virtio_scsi_set_config(VirtIODevice
*vdev
,
541 const uint8_t *config
)
543 VirtIOSCSIConfig
*scsiconf
= (VirtIOSCSIConfig
*)config
;
544 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
546 if ((uint32_t) ldl_raw(&scsiconf
->sense_size
) >= 65536 ||
547 (uint32_t) ldl_raw(&scsiconf
->cdb_size
) >= 256) {
548 error_report("bad data written to virtio-scsi configuration space");
552 s
->sense_size
= ldl_raw(&scsiconf
->sense_size
);
553 s
->cdb_size
= ldl_raw(&scsiconf
->cdb_size
);
556 static uint32_t virtio_scsi_get_features(VirtIODevice
*vdev
,
557 uint32_t requested_features
)
559 requested_features
|= (1UL << VIRTIO_SCSI_F_HOTPLUG
);
560 return requested_features
;
563 static void virtio_scsi_reset(VirtIODevice
*vdev
)
565 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
567 s
->sense_size
= VIRTIO_SCSI_SENSE_SIZE
;
568 s
->cdb_size
= VIRTIO_SCSI_CDB_SIZE
;
571 /* The device does not have anything to save beyond the virtio data.
572 * Request data is saved with callbacks from SCSI devices.
574 static void virtio_scsi_save(QEMUFile
*f
, void *opaque
)
576 VirtIOSCSI
*s
= opaque
;
577 virtio_save(&s
->vdev
, f
);
580 static int virtio_scsi_load(QEMUFile
*f
, void *opaque
, int version_id
)
582 VirtIOSCSI
*s
= opaque
;
585 ret
= virtio_load(&s
->vdev
, f
);
592 static void virtio_scsi_push_event(VirtIOSCSI
*s
, SCSIDevice
*dev
,
593 uint32_t event
, uint32_t reason
)
595 VirtIOSCSIReq
*req
= virtio_scsi_pop_req(s
, s
->event_vq
);
596 VirtIOSCSIEvent
*evt
;
600 if (req
->elem
.out_num
|| req
->elem
.in_num
!= 1) {
601 virtio_scsi_bad_req();
604 in_size
= req
->elem
.in_sg
[0].iov_len
;
605 if (in_size
< sizeof(VirtIOSCSIEvent
)) {
606 virtio_scsi_bad_req();
609 evt
= req
->resp
.event
;
610 memset(evt
, 0, sizeof(VirtIOSCSIEvent
));
612 evt
->reason
= reason
;
614 evt
->lun
[1] = dev
->id
;
616 /* Linux wants us to keep the same encoding we use for REPORT LUNS. */
617 if (dev
->lun
>= 256) {
618 evt
->lun
[2] = (dev
->lun
>> 8) | 0x40;
620 evt
->lun
[3] = dev
->lun
& 0xFF;
621 virtio_scsi_complete_req(req
);
625 static void virtio_scsi_hotplug(SCSIBus
*bus
, SCSIDevice
*dev
)
627 VirtIOSCSI
*s
= container_of(bus
, VirtIOSCSI
, bus
);
629 if (((s
->vdev
.guest_features
>> VIRTIO_SCSI_F_HOTPLUG
) & 1) &&
630 (s
->vdev
.status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
631 virtio_scsi_push_event(s
, dev
, VIRTIO_SCSI_T_TRANSPORT_RESET
,
632 VIRTIO_SCSI_EVT_RESET_RESCAN
);
636 static void virtio_scsi_hot_unplug(SCSIBus
*bus
, SCSIDevice
*dev
)
638 VirtIOSCSI
*s
= container_of(bus
, VirtIOSCSI
, bus
);
640 if ((s
->vdev
.guest_features
>> VIRTIO_SCSI_F_HOTPLUG
) & 1) {
641 virtio_scsi_push_event(s
, dev
, VIRTIO_SCSI_T_TRANSPORT_RESET
,
642 VIRTIO_SCSI_EVT_RESET_REMOVED
);
646 static struct SCSIBusInfo virtio_scsi_scsi_info
= {
648 .max_channel
= VIRTIO_SCSI_MAX_CHANNEL
,
649 .max_target
= VIRTIO_SCSI_MAX_TARGET
,
650 .max_lun
= VIRTIO_SCSI_MAX_LUN
,
652 .complete
= virtio_scsi_command_complete
,
653 .cancel
= virtio_scsi_request_cancelled
,
654 .hotplug
= virtio_scsi_hotplug
,
655 .hot_unplug
= virtio_scsi_hot_unplug
,
656 .get_sg_list
= virtio_scsi_get_sg_list
,
657 .save_request
= virtio_scsi_save_request
,
658 .load_request
= virtio_scsi_load_request
,
661 VirtIODevice
*virtio_scsi_init(DeviceState
*dev
, VirtIOSCSIConf
*proxyconf
)
664 static int virtio_scsi_id
;
668 sz
= sizeof(VirtIOSCSI
) + proxyconf
->num_queues
* sizeof(VirtQueue
*);
669 s
= (VirtIOSCSI
*)virtio_common_init("virtio-scsi", VIRTIO_ID_SCSI
,
670 sizeof(VirtIOSCSIConfig
), sz
);
675 /* TODO set up vdev function pointers */
676 s
->vdev
.get_config
= virtio_scsi_get_config
;
677 s
->vdev
.set_config
= virtio_scsi_set_config
;
678 s
->vdev
.get_features
= virtio_scsi_get_features
;
679 s
->vdev
.reset
= virtio_scsi_reset
;
681 s
->ctrl_vq
= virtio_add_queue(&s
->vdev
, VIRTIO_SCSI_VQ_SIZE
,
682 virtio_scsi_handle_ctrl
);
683 s
->event_vq
= virtio_add_queue(&s
->vdev
, VIRTIO_SCSI_VQ_SIZE
,
684 virtio_scsi_handle_event
);
685 for (i
= 0; i
< s
->conf
->num_queues
; i
++) {
686 s
->cmd_vqs
[i
] = virtio_add_queue(&s
->vdev
, VIRTIO_SCSI_VQ_SIZE
,
687 virtio_scsi_handle_cmd
);
690 scsi_bus_new(&s
->bus
, dev
, &virtio_scsi_scsi_info
);
691 if (!dev
->hotplugged
) {
692 scsi_bus_legacy_handle_cmdline(&s
->bus
);
695 register_savevm(dev
, "virtio-scsi", virtio_scsi_id
++, 1,
696 virtio_scsi_save
, virtio_scsi_load
, s
);
701 void virtio_scsi_exit(VirtIODevice
*vdev
)
703 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
704 unregister_savevm(s
->qdev
, "virtio-scsi", s
);
705 virtio_cleanup(vdev
);