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 "hw/virtio-scsi.h"
17 #include "qemu/error-report.h"
19 #include <hw/scsi-defs.h>
21 #define VIRTIO_SCSI_VQ_SIZE 128
22 #define VIRTIO_SCSI_CDB_SIZE 32
23 #define VIRTIO_SCSI_SENSE_SIZE 96
24 #define VIRTIO_SCSI_MAX_CHANNEL 0
25 #define VIRTIO_SCSI_MAX_TARGET 255
26 #define VIRTIO_SCSI_MAX_LUN 16383
29 #define VIRTIO_SCSI_S_OK 0
30 #define VIRTIO_SCSI_S_OVERRUN 1
31 #define VIRTIO_SCSI_S_ABORTED 2
32 #define VIRTIO_SCSI_S_BAD_TARGET 3
33 #define VIRTIO_SCSI_S_RESET 4
34 #define VIRTIO_SCSI_S_BUSY 5
35 #define VIRTIO_SCSI_S_TRANSPORT_FAILURE 6
36 #define VIRTIO_SCSI_S_TARGET_FAILURE 7
37 #define VIRTIO_SCSI_S_NEXUS_FAILURE 8
38 #define VIRTIO_SCSI_S_FAILURE 9
39 #define VIRTIO_SCSI_S_FUNCTION_SUCCEEDED 10
40 #define VIRTIO_SCSI_S_FUNCTION_REJECTED 11
41 #define VIRTIO_SCSI_S_INCORRECT_LUN 12
43 /* Controlq type codes. */
44 #define VIRTIO_SCSI_T_TMF 0
45 #define VIRTIO_SCSI_T_AN_QUERY 1
46 #define VIRTIO_SCSI_T_AN_SUBSCRIBE 2
48 /* Valid TMF subtypes. */
49 #define VIRTIO_SCSI_T_TMF_ABORT_TASK 0
50 #define VIRTIO_SCSI_T_TMF_ABORT_TASK_SET 1
51 #define VIRTIO_SCSI_T_TMF_CLEAR_ACA 2
52 #define VIRTIO_SCSI_T_TMF_CLEAR_TASK_SET 3
53 #define VIRTIO_SCSI_T_TMF_I_T_NEXUS_RESET 4
54 #define VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET 5
55 #define VIRTIO_SCSI_T_TMF_QUERY_TASK 6
56 #define VIRTIO_SCSI_T_TMF_QUERY_TASK_SET 7
59 #define VIRTIO_SCSI_T_EVENTS_MISSED 0x80000000
60 #define VIRTIO_SCSI_T_NO_EVENT 0
61 #define VIRTIO_SCSI_T_TRANSPORT_RESET 1
62 #define VIRTIO_SCSI_T_ASYNC_NOTIFY 2
63 #define VIRTIO_SCSI_T_PARAM_CHANGE 3
65 /* Reasons for transport reset event */
66 #define VIRTIO_SCSI_EVT_RESET_HARD 0
67 #define VIRTIO_SCSI_EVT_RESET_RESCAN 1
68 #define VIRTIO_SCSI_EVT_RESET_REMOVED 2
70 /* SCSI command request, followed by data-out */
72 uint8_t lun
[8]; /* Logical Unit Number */
73 uint64_t tag
; /* Command identifier */
74 uint8_t task_attr
; /* Task attribute */
78 } QEMU_PACKED VirtIOSCSICmdReq
;
80 /* Response, followed by sense data and data-in */
82 uint32_t sense_len
; /* Sense data length */
83 uint32_t resid
; /* Residual bytes in data buffer */
84 uint16_t status_qualifier
; /* Status qualifier */
85 uint8_t status
; /* Command completion status */
86 uint8_t response
; /* Response values */
88 } QEMU_PACKED VirtIOSCSICmdResp
;
90 /* Task Management Request */
96 } QEMU_PACKED VirtIOSCSICtrlTMFReq
;
100 } QEMU_PACKED VirtIOSCSICtrlTMFResp
;
102 /* Asynchronous notification query/subscription */
106 uint32_t event_requested
;
107 } QEMU_PACKED VirtIOSCSICtrlANReq
;
110 uint32_t event_actual
;
112 } QEMU_PACKED VirtIOSCSICtrlANResp
;
118 } QEMU_PACKED VirtIOSCSIEvent
;
123 uint32_t max_sectors
;
124 uint32_t cmd_per_lun
;
125 uint32_t event_info_size
;
128 uint16_t max_channel
;
131 } QEMU_PACKED VirtIOSCSIConfig
;
133 typedef struct VirtIOSCSIReq
{
136 VirtQueueElement elem
;
141 VirtIOSCSICmdReq
*cmd
;
142 VirtIOSCSICtrlTMFReq
*tmf
;
143 VirtIOSCSICtrlANReq
*an
;
147 VirtIOSCSICmdResp
*cmd
;
148 VirtIOSCSICtrlTMFResp
*tmf
;
149 VirtIOSCSICtrlANResp
*an
;
150 VirtIOSCSIEvent
*event
;
154 static inline int virtio_scsi_get_lun(uint8_t *lun
)
156 return ((lun
[2] << 8) | lun
[3]) & 0x3FFF;
159 static inline SCSIDevice
*virtio_scsi_device_find(VirtIOSCSI
*s
, uint8_t *lun
)
164 if (lun
[2] != 0 && !(lun
[2] >= 0x40 && lun
[2] < 0x80)) {
167 return scsi_device_find(&s
->bus
, 0, lun
[1], virtio_scsi_get_lun(lun
));
170 static void virtio_scsi_complete_req(VirtIOSCSIReq
*req
)
172 VirtIOSCSI
*s
= req
->dev
;
173 VirtQueue
*vq
= req
->vq
;
174 virtqueue_push(vq
, &req
->elem
, req
->qsgl
.size
+ req
->elem
.in_sg
[0].iov_len
);
175 qemu_sglist_destroy(&req
->qsgl
);
177 req
->sreq
->hba_private
= NULL
;
178 scsi_req_unref(req
->sreq
);
181 virtio_notify(&s
->vdev
, vq
);
184 static void virtio_scsi_bad_req(void)
186 error_report("wrong size for virtio-scsi headers");
190 static void qemu_sgl_init_external(QEMUSGList
*qsgl
, struct iovec
*sg
,
191 hwaddr
*addr
, int num
)
193 qemu_sglist_init(qsgl
, num
, &dma_context_memory
);
195 qemu_sglist_add(qsgl
, *(addr
++), (sg
++)->iov_len
);
199 static void virtio_scsi_parse_req(VirtIOSCSI
*s
, VirtQueue
*vq
,
202 assert(req
->elem
.in_num
);
206 if (req
->elem
.out_num
) {
207 req
->req
.buf
= req
->elem
.out_sg
[0].iov_base
;
209 req
->resp
.buf
= req
->elem
.in_sg
[0].iov_base
;
211 if (req
->elem
.out_num
> 1) {
212 qemu_sgl_init_external(&req
->qsgl
, &req
->elem
.out_sg
[1],
213 &req
->elem
.out_addr
[1],
214 req
->elem
.out_num
- 1);
216 qemu_sgl_init_external(&req
->qsgl
, &req
->elem
.in_sg
[1],
217 &req
->elem
.in_addr
[1],
218 req
->elem
.in_num
- 1);
222 static VirtIOSCSIReq
*virtio_scsi_pop_req(VirtIOSCSI
*s
, VirtQueue
*vq
)
225 req
= g_malloc(sizeof(*req
));
226 if (!virtqueue_pop(vq
, &req
->elem
)) {
231 virtio_scsi_parse_req(s
, vq
, req
);
235 static void virtio_scsi_save_request(QEMUFile
*f
, SCSIRequest
*sreq
)
237 VirtIOSCSIReq
*req
= sreq
->hba_private
;
238 uint32_t n
= virtio_queue_get_id(req
->vq
) - 2;
240 assert(n
< req
->dev
->conf
->num_queues
);
241 qemu_put_be32s(f
, &n
);
242 qemu_put_buffer(f
, (unsigned char *)&req
->elem
, sizeof(req
->elem
));
245 static void *virtio_scsi_load_request(QEMUFile
*f
, SCSIRequest
*sreq
)
247 SCSIBus
*bus
= sreq
->bus
;
248 VirtIOSCSI
*s
= container_of(bus
, VirtIOSCSI
, bus
);
252 req
= g_malloc(sizeof(*req
));
253 qemu_get_be32s(f
, &n
);
254 assert(n
< s
->conf
->num_queues
);
255 qemu_get_buffer(f
, (unsigned char *)&req
->elem
, sizeof(req
->elem
));
256 virtio_scsi_parse_req(s
, s
->cmd_vqs
[n
], req
);
260 if (req
->sreq
->cmd
.mode
!= SCSI_XFER_NONE
) {
262 (req
->elem
.in_num
> 1 ? SCSI_XFER_FROM_DEV
: SCSI_XFER_TO_DEV
);
264 assert(req
->sreq
->cmd
.mode
== req_mode
);
269 static void virtio_scsi_do_tmf(VirtIOSCSI
*s
, VirtIOSCSIReq
*req
)
271 SCSIDevice
*d
= virtio_scsi_device_find(s
, req
->req
.tmf
->lun
);
272 SCSIRequest
*r
, *next
;
276 /* Here VIRTIO_SCSI_S_OK means "FUNCTION COMPLETE". */
277 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_OK
;
279 switch (req
->req
.tmf
->subtype
) {
280 case VIRTIO_SCSI_T_TMF_ABORT_TASK
:
281 case VIRTIO_SCSI_T_TMF_QUERY_TASK
:
285 if (d
->lun
!= virtio_scsi_get_lun(req
->req
.tmf
->lun
)) {
288 QTAILQ_FOREACH_SAFE(r
, &d
->requests
, next
, next
) {
289 VirtIOSCSIReq
*cmd_req
= r
->hba_private
;
290 if (cmd_req
&& cmd_req
->req
.cmd
->tag
== req
->req
.tmf
->tag
) {
296 * Assert that the request has not been completed yet, we
297 * check for it in the loop above.
299 assert(r
->hba_private
);
300 if (req
->req
.tmf
->subtype
== VIRTIO_SCSI_T_TMF_QUERY_TASK
) {
301 /* "If the specified command is present in the task set, then
302 * return a service response set to FUNCTION SUCCEEDED".
304 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_FUNCTION_SUCCEEDED
;
311 case VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET
:
315 if (d
->lun
!= virtio_scsi_get_lun(req
->req
.tmf
->lun
)) {
319 qdev_reset_all(&d
->qdev
);
323 case VIRTIO_SCSI_T_TMF_ABORT_TASK_SET
:
324 case VIRTIO_SCSI_T_TMF_CLEAR_TASK_SET
:
325 case VIRTIO_SCSI_T_TMF_QUERY_TASK_SET
:
329 if (d
->lun
!= virtio_scsi_get_lun(req
->req
.tmf
->lun
)) {
332 QTAILQ_FOREACH_SAFE(r
, &d
->requests
, next
, next
) {
333 if (r
->hba_private
) {
334 if (req
->req
.tmf
->subtype
== VIRTIO_SCSI_T_TMF_QUERY_TASK_SET
) {
335 /* "If there is any command present in the task set, then
336 * return a service response set to FUNCTION SUCCEEDED".
338 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_FUNCTION_SUCCEEDED
;
347 case VIRTIO_SCSI_T_TMF_I_T_NEXUS_RESET
:
348 target
= req
->req
.tmf
->lun
[1];
350 QTAILQ_FOREACH(kid
, &s
->bus
.qbus
.children
, sibling
) {
351 d
= DO_UPCAST(SCSIDevice
, qdev
, kid
->child
);
352 if (d
->channel
== 0 && d
->id
== target
) {
353 qdev_reset_all(&d
->qdev
);
359 case VIRTIO_SCSI_T_TMF_CLEAR_ACA
:
361 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_FUNCTION_REJECTED
;
368 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_INCORRECT_LUN
;
372 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_BAD_TARGET
;
375 static void virtio_scsi_handle_ctrl(VirtIODevice
*vdev
, VirtQueue
*vq
)
377 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
380 while ((req
= virtio_scsi_pop_req(s
, vq
))) {
381 int out_size
, in_size
;
382 if (req
->elem
.out_num
< 1 || req
->elem
.in_num
< 1) {
383 virtio_scsi_bad_req();
387 out_size
= req
->elem
.out_sg
[0].iov_len
;
388 in_size
= req
->elem
.in_sg
[0].iov_len
;
389 if (req
->req
.tmf
->type
== VIRTIO_SCSI_T_TMF
) {
390 if (out_size
< sizeof(VirtIOSCSICtrlTMFReq
) ||
391 in_size
< sizeof(VirtIOSCSICtrlTMFResp
)) {
392 virtio_scsi_bad_req();
394 virtio_scsi_do_tmf(s
, req
);
396 } else if (req
->req
.tmf
->type
== VIRTIO_SCSI_T_AN_QUERY
||
397 req
->req
.tmf
->type
== VIRTIO_SCSI_T_AN_SUBSCRIBE
) {
398 if (out_size
< sizeof(VirtIOSCSICtrlANReq
) ||
399 in_size
< sizeof(VirtIOSCSICtrlANResp
)) {
400 virtio_scsi_bad_req();
402 req
->resp
.an
->event_actual
= 0;
403 req
->resp
.an
->response
= VIRTIO_SCSI_S_OK
;
405 virtio_scsi_complete_req(req
);
409 static void virtio_scsi_command_complete(SCSIRequest
*r
, uint32_t status
,
412 VirtIOSCSIReq
*req
= r
->hba_private
;
415 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_OK
;
416 req
->resp
.cmd
->status
= status
;
417 if (req
->resp
.cmd
->status
== GOOD
) {
418 req
->resp
.cmd
->resid
= tswap32(resid
);
420 req
->resp
.cmd
->resid
= 0;
421 sense_len
= scsi_req_get_sense(r
, req
->resp
.cmd
->sense
,
422 VIRTIO_SCSI_SENSE_SIZE
);
423 req
->resp
.cmd
->sense_len
= tswap32(sense_len
);
425 virtio_scsi_complete_req(req
);
428 static QEMUSGList
*virtio_scsi_get_sg_list(SCSIRequest
*r
)
430 VirtIOSCSIReq
*req
= r
->hba_private
;
435 static void virtio_scsi_request_cancelled(SCSIRequest
*r
)
437 VirtIOSCSIReq
*req
= r
->hba_private
;
442 if (req
->dev
->resetting
) {
443 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_RESET
;
445 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_ABORTED
;
447 virtio_scsi_complete_req(req
);
450 static void virtio_scsi_fail_cmd_req(VirtIOSCSIReq
*req
)
452 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_FAILURE
;
453 virtio_scsi_complete_req(req
);
456 static void virtio_scsi_handle_cmd(VirtIODevice
*vdev
, VirtQueue
*vq
)
458 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
462 while ((req
= virtio_scsi_pop_req(s
, vq
))) {
464 int out_size
, in_size
;
465 if (req
->elem
.out_num
< 1 || req
->elem
.in_num
< 1) {
466 virtio_scsi_bad_req();
469 out_size
= req
->elem
.out_sg
[0].iov_len
;
470 in_size
= req
->elem
.in_sg
[0].iov_len
;
471 if (out_size
< sizeof(VirtIOSCSICmdReq
) + s
->cdb_size
||
472 in_size
< sizeof(VirtIOSCSICmdResp
) + s
->sense_size
) {
473 virtio_scsi_bad_req();
476 if (req
->elem
.out_num
> 1 && req
->elem
.in_num
> 1) {
477 virtio_scsi_fail_cmd_req(req
);
481 d
= virtio_scsi_device_find(s
, req
->req
.cmd
->lun
);
483 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_BAD_TARGET
;
484 virtio_scsi_complete_req(req
);
487 req
->sreq
= scsi_req_new(d
, req
->req
.cmd
->tag
,
488 virtio_scsi_get_lun(req
->req
.cmd
->lun
),
489 req
->req
.cmd
->cdb
, req
);
491 if (req
->sreq
->cmd
.mode
!= SCSI_XFER_NONE
) {
493 (req
->elem
.in_num
> 1 ? SCSI_XFER_FROM_DEV
: SCSI_XFER_TO_DEV
);
495 if (req
->sreq
->cmd
.mode
!= req_mode
||
496 req
->sreq
->cmd
.xfer
> req
->qsgl
.size
) {
497 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_OVERRUN
;
498 virtio_scsi_complete_req(req
);
503 n
= scsi_req_enqueue(req
->sreq
);
505 scsi_req_continue(req
->sreq
);
510 static void virtio_scsi_get_config(VirtIODevice
*vdev
,
513 VirtIOSCSIConfig
*scsiconf
= (VirtIOSCSIConfig
*)config
;
514 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
516 stl_raw(&scsiconf
->num_queues
, s
->conf
->num_queues
);
517 stl_raw(&scsiconf
->seg_max
, 128 - 2);
518 stl_raw(&scsiconf
->max_sectors
, s
->conf
->max_sectors
);
519 stl_raw(&scsiconf
->cmd_per_lun
, s
->conf
->cmd_per_lun
);
520 stl_raw(&scsiconf
->event_info_size
, sizeof(VirtIOSCSIEvent
));
521 stl_raw(&scsiconf
->sense_size
, s
->sense_size
);
522 stl_raw(&scsiconf
->cdb_size
, s
->cdb_size
);
523 stw_raw(&scsiconf
->max_channel
, VIRTIO_SCSI_MAX_CHANNEL
);
524 stw_raw(&scsiconf
->max_target
, VIRTIO_SCSI_MAX_TARGET
);
525 stl_raw(&scsiconf
->max_lun
, VIRTIO_SCSI_MAX_LUN
);
528 static void virtio_scsi_set_config(VirtIODevice
*vdev
,
529 const uint8_t *config
)
531 VirtIOSCSIConfig
*scsiconf
= (VirtIOSCSIConfig
*)config
;
532 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
534 if ((uint32_t) ldl_raw(&scsiconf
->sense_size
) >= 65536 ||
535 (uint32_t) ldl_raw(&scsiconf
->cdb_size
) >= 256) {
536 error_report("bad data written to virtio-scsi configuration space");
540 s
->sense_size
= ldl_raw(&scsiconf
->sense_size
);
541 s
->cdb_size
= ldl_raw(&scsiconf
->cdb_size
);
544 static uint32_t virtio_scsi_get_features(VirtIODevice
*vdev
,
545 uint32_t requested_features
)
547 return requested_features
;
550 static void virtio_scsi_reset(VirtIODevice
*vdev
)
552 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
555 qbus_reset_all(&s
->bus
.qbus
);
558 s
->sense_size
= VIRTIO_SCSI_SENSE_SIZE
;
559 s
->cdb_size
= VIRTIO_SCSI_CDB_SIZE
;
560 s
->events_dropped
= false;
563 /* The device does not have anything to save beyond the virtio data.
564 * Request data is saved with callbacks from SCSI devices.
566 static void virtio_scsi_save(QEMUFile
*f
, void *opaque
)
568 VirtIOSCSI
*s
= opaque
;
569 virtio_save(&s
->vdev
, f
);
572 static int virtio_scsi_load(QEMUFile
*f
, void *opaque
, int version_id
)
574 VirtIOSCSI
*s
= opaque
;
577 ret
= virtio_load(&s
->vdev
, f
);
584 static void virtio_scsi_push_event(VirtIOSCSI
*s
, SCSIDevice
*dev
,
585 uint32_t event
, uint32_t reason
)
587 VirtIOSCSIReq
*req
= virtio_scsi_pop_req(s
, s
->event_vq
);
588 VirtIOSCSIEvent
*evt
;
591 if (!(s
->vdev
.status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
596 s
->events_dropped
= true;
600 if (req
->elem
.out_num
|| req
->elem
.in_num
!= 1) {
601 virtio_scsi_bad_req();
604 if (s
->events_dropped
) {
605 event
|= VIRTIO_SCSI_T_EVENTS_MISSED
;
606 s
->events_dropped
= false;
609 in_size
= req
->elem
.in_sg
[0].iov_len
;
610 if (in_size
< sizeof(VirtIOSCSIEvent
)) {
611 virtio_scsi_bad_req();
614 evt
= req
->resp
.event
;
615 memset(evt
, 0, sizeof(VirtIOSCSIEvent
));
617 evt
->reason
= reason
;
619 assert(event
== VIRTIO_SCSI_T_NO_EVENT
);
622 evt
->lun
[1] = dev
->id
;
624 /* Linux wants us to keep the same encoding we use for REPORT LUNS. */
625 if (dev
->lun
>= 256) {
626 evt
->lun
[2] = (dev
->lun
>> 8) | 0x40;
628 evt
->lun
[3] = dev
->lun
& 0xFF;
630 virtio_scsi_complete_req(req
);
633 static void virtio_scsi_handle_event(VirtIODevice
*vdev
, VirtQueue
*vq
)
635 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
637 if (s
->events_dropped
) {
638 virtio_scsi_push_event(s
, NULL
, VIRTIO_SCSI_T_NO_EVENT
, 0);
642 static void virtio_scsi_change(SCSIBus
*bus
, SCSIDevice
*dev
, SCSISense sense
)
644 VirtIOSCSI
*s
= container_of(bus
, VirtIOSCSI
, bus
);
646 if (((s
->vdev
.guest_features
>> VIRTIO_SCSI_F_CHANGE
) & 1) &&
647 dev
->type
!= TYPE_ROM
) {
648 virtio_scsi_push_event(s
, dev
, VIRTIO_SCSI_T_PARAM_CHANGE
,
649 sense
.asc
| (sense
.ascq
<< 8));
653 static void virtio_scsi_hotplug(SCSIBus
*bus
, SCSIDevice
*dev
)
655 VirtIOSCSI
*s
= container_of(bus
, VirtIOSCSI
, bus
);
657 if ((s
->vdev
.guest_features
>> VIRTIO_SCSI_F_HOTPLUG
) & 1) {
658 virtio_scsi_push_event(s
, dev
, VIRTIO_SCSI_T_TRANSPORT_RESET
,
659 VIRTIO_SCSI_EVT_RESET_RESCAN
);
663 static void virtio_scsi_hot_unplug(SCSIBus
*bus
, SCSIDevice
*dev
)
665 VirtIOSCSI
*s
= container_of(bus
, VirtIOSCSI
, bus
);
667 if ((s
->vdev
.guest_features
>> VIRTIO_SCSI_F_HOTPLUG
) & 1) {
668 virtio_scsi_push_event(s
, dev
, VIRTIO_SCSI_T_TRANSPORT_RESET
,
669 VIRTIO_SCSI_EVT_RESET_REMOVED
);
673 static struct SCSIBusInfo virtio_scsi_scsi_info
= {
675 .max_channel
= VIRTIO_SCSI_MAX_CHANNEL
,
676 .max_target
= VIRTIO_SCSI_MAX_TARGET
,
677 .max_lun
= VIRTIO_SCSI_MAX_LUN
,
679 .complete
= virtio_scsi_command_complete
,
680 .cancel
= virtio_scsi_request_cancelled
,
681 .change
= virtio_scsi_change
,
682 .hotplug
= virtio_scsi_hotplug
,
683 .hot_unplug
= virtio_scsi_hot_unplug
,
684 .get_sg_list
= virtio_scsi_get_sg_list
,
685 .save_request
= virtio_scsi_save_request
,
686 .load_request
= virtio_scsi_load_request
,
689 VirtIODevice
*virtio_scsi_init(DeviceState
*dev
, VirtIOSCSIConf
*proxyconf
)
692 static int virtio_scsi_id
;
696 sz
= sizeof(VirtIOSCSI
) + proxyconf
->num_queues
* sizeof(VirtQueue
*);
697 s
= (VirtIOSCSI
*)virtio_common_init("virtio-scsi", VIRTIO_ID_SCSI
,
698 sizeof(VirtIOSCSIConfig
), sz
);
703 /* TODO set up vdev function pointers */
704 s
->vdev
.get_config
= virtio_scsi_get_config
;
705 s
->vdev
.set_config
= virtio_scsi_set_config
;
706 s
->vdev
.get_features
= virtio_scsi_get_features
;
707 s
->vdev
.reset
= virtio_scsi_reset
;
709 s
->ctrl_vq
= virtio_add_queue(&s
->vdev
, VIRTIO_SCSI_VQ_SIZE
,
710 virtio_scsi_handle_ctrl
);
711 s
->event_vq
= virtio_add_queue(&s
->vdev
, VIRTIO_SCSI_VQ_SIZE
,
712 virtio_scsi_handle_event
);
713 for (i
= 0; i
< s
->conf
->num_queues
; i
++) {
714 s
->cmd_vqs
[i
] = virtio_add_queue(&s
->vdev
, VIRTIO_SCSI_VQ_SIZE
,
715 virtio_scsi_handle_cmd
);
718 scsi_bus_new(&s
->bus
, dev
, &virtio_scsi_scsi_info
);
719 if (!dev
->hotplugged
) {
720 scsi_bus_legacy_handle_cmdline(&s
->bus
);
723 register_savevm(dev
, "virtio-scsi", virtio_scsi_id
++, 1,
724 virtio_scsi_save
, virtio_scsi_load
, s
);
729 void virtio_scsi_exit(VirtIODevice
*vdev
)
731 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
732 unregister_savevm(s
->qdev
, "virtio-scsi", s
);
733 virtio_cleanup(vdev
);