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
;
136 VirtIOSCSIConf
*conf
;
145 VirtQueue
*cmd_vqs
[0];
148 typedef struct VirtIOSCSIReq
{
151 VirtQueueElement elem
;
156 VirtIOSCSICmdReq
*cmd
;
157 VirtIOSCSICtrlTMFReq
*tmf
;
158 VirtIOSCSICtrlANReq
*an
;
162 VirtIOSCSICmdResp
*cmd
;
163 VirtIOSCSICtrlTMFResp
*tmf
;
164 VirtIOSCSICtrlANResp
*an
;
165 VirtIOSCSIEvent
*event
;
169 static inline int virtio_scsi_get_lun(uint8_t *lun
)
171 return ((lun
[2] << 8) | lun
[3]) & 0x3FFF;
174 static inline SCSIDevice
*virtio_scsi_device_find(VirtIOSCSI
*s
, uint8_t *lun
)
179 if (lun
[2] != 0 && !(lun
[2] >= 0x40 && lun
[2] < 0x80)) {
182 return scsi_device_find(&s
->bus
, 0, lun
[1], virtio_scsi_get_lun(lun
));
185 static void virtio_scsi_complete_req(VirtIOSCSIReq
*req
)
187 VirtIOSCSI
*s
= req
->dev
;
188 VirtQueue
*vq
= req
->vq
;
189 virtqueue_push(vq
, &req
->elem
, req
->qsgl
.size
+ req
->elem
.in_sg
[0].iov_len
);
190 qemu_sglist_destroy(&req
->qsgl
);
192 req
->sreq
->hba_private
= NULL
;
193 scsi_req_unref(req
->sreq
);
196 virtio_notify(&s
->vdev
, vq
);
199 static void virtio_scsi_bad_req(void)
201 error_report("wrong size for virtio-scsi headers");
205 static void qemu_sgl_init_external(QEMUSGList
*qsgl
, struct iovec
*sg
,
206 hwaddr
*addr
, int num
)
208 qemu_sglist_init(qsgl
, num
, &dma_context_memory
);
210 qemu_sglist_add(qsgl
, *(addr
++), (sg
++)->iov_len
);
214 static void virtio_scsi_parse_req(VirtIOSCSI
*s
, VirtQueue
*vq
,
217 assert(req
->elem
.in_num
);
221 if (req
->elem
.out_num
) {
222 req
->req
.buf
= req
->elem
.out_sg
[0].iov_base
;
224 req
->resp
.buf
= req
->elem
.in_sg
[0].iov_base
;
226 if (req
->elem
.out_num
> 1) {
227 qemu_sgl_init_external(&req
->qsgl
, &req
->elem
.out_sg
[1],
228 &req
->elem
.out_addr
[1],
229 req
->elem
.out_num
- 1);
231 qemu_sgl_init_external(&req
->qsgl
, &req
->elem
.in_sg
[1],
232 &req
->elem
.in_addr
[1],
233 req
->elem
.in_num
- 1);
237 static VirtIOSCSIReq
*virtio_scsi_pop_req(VirtIOSCSI
*s
, VirtQueue
*vq
)
240 req
= g_malloc(sizeof(*req
));
241 if (!virtqueue_pop(vq
, &req
->elem
)) {
246 virtio_scsi_parse_req(s
, vq
, req
);
250 static void virtio_scsi_save_request(QEMUFile
*f
, SCSIRequest
*sreq
)
252 VirtIOSCSIReq
*req
= sreq
->hba_private
;
253 uint32_t n
= virtio_queue_get_id(req
->vq
) - 2;
255 assert(n
< req
->dev
->conf
->num_queues
);
256 qemu_put_be32s(f
, &n
);
257 qemu_put_buffer(f
, (unsigned char *)&req
->elem
, sizeof(req
->elem
));
260 static void *virtio_scsi_load_request(QEMUFile
*f
, SCSIRequest
*sreq
)
262 SCSIBus
*bus
= sreq
->bus
;
263 VirtIOSCSI
*s
= container_of(bus
, VirtIOSCSI
, bus
);
267 req
= g_malloc(sizeof(*req
));
268 qemu_get_be32s(f
, &n
);
269 assert(n
< s
->conf
->num_queues
);
270 qemu_get_buffer(f
, (unsigned char *)&req
->elem
, sizeof(req
->elem
));
271 virtio_scsi_parse_req(s
, s
->cmd_vqs
[n
], req
);
275 if (req
->sreq
->cmd
.mode
!= SCSI_XFER_NONE
) {
277 (req
->elem
.in_num
> 1 ? SCSI_XFER_FROM_DEV
: SCSI_XFER_TO_DEV
);
279 assert(req
->sreq
->cmd
.mode
== req_mode
);
284 static void virtio_scsi_do_tmf(VirtIOSCSI
*s
, VirtIOSCSIReq
*req
)
286 SCSIDevice
*d
= virtio_scsi_device_find(s
, req
->req
.tmf
->lun
);
287 SCSIRequest
*r
, *next
;
291 /* Here VIRTIO_SCSI_S_OK means "FUNCTION COMPLETE". */
292 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_OK
;
294 switch (req
->req
.tmf
->subtype
) {
295 case VIRTIO_SCSI_T_TMF_ABORT_TASK
:
296 case VIRTIO_SCSI_T_TMF_QUERY_TASK
:
300 if (d
->lun
!= virtio_scsi_get_lun(req
->req
.tmf
->lun
)) {
303 QTAILQ_FOREACH_SAFE(r
, &d
->requests
, next
, next
) {
304 VirtIOSCSIReq
*cmd_req
= r
->hba_private
;
305 if (cmd_req
&& cmd_req
->req
.cmd
->tag
== req
->req
.tmf
->tag
) {
311 * Assert that the request has not been completed yet, we
312 * check for it in the loop above.
314 assert(r
->hba_private
);
315 if (req
->req
.tmf
->subtype
== VIRTIO_SCSI_T_TMF_QUERY_TASK
) {
316 /* "If the specified command is present in the task set, then
317 * return a service response set to FUNCTION SUCCEEDED".
319 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_FUNCTION_SUCCEEDED
;
326 case VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET
:
330 if (d
->lun
!= virtio_scsi_get_lun(req
->req
.tmf
->lun
)) {
334 qdev_reset_all(&d
->qdev
);
338 case VIRTIO_SCSI_T_TMF_ABORT_TASK_SET
:
339 case VIRTIO_SCSI_T_TMF_CLEAR_TASK_SET
:
340 case VIRTIO_SCSI_T_TMF_QUERY_TASK_SET
:
344 if (d
->lun
!= virtio_scsi_get_lun(req
->req
.tmf
->lun
)) {
347 QTAILQ_FOREACH_SAFE(r
, &d
->requests
, next
, next
) {
348 if (r
->hba_private
) {
349 if (req
->req
.tmf
->subtype
== VIRTIO_SCSI_T_TMF_QUERY_TASK_SET
) {
350 /* "If there is any command present in the task set, then
351 * return a service response set to FUNCTION SUCCEEDED".
353 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_FUNCTION_SUCCEEDED
;
362 case VIRTIO_SCSI_T_TMF_I_T_NEXUS_RESET
:
363 target
= req
->req
.tmf
->lun
[1];
365 QTAILQ_FOREACH(kid
, &s
->bus
.qbus
.children
, sibling
) {
366 d
= DO_UPCAST(SCSIDevice
, qdev
, kid
->child
);
367 if (d
->channel
== 0 && d
->id
== target
) {
368 qdev_reset_all(&d
->qdev
);
374 case VIRTIO_SCSI_T_TMF_CLEAR_ACA
:
376 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_FUNCTION_REJECTED
;
383 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_INCORRECT_LUN
;
387 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_BAD_TARGET
;
390 static void virtio_scsi_handle_ctrl(VirtIODevice
*vdev
, VirtQueue
*vq
)
392 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
395 while ((req
= virtio_scsi_pop_req(s
, vq
))) {
396 int out_size
, in_size
;
397 if (req
->elem
.out_num
< 1 || req
->elem
.in_num
< 1) {
398 virtio_scsi_bad_req();
402 out_size
= req
->elem
.out_sg
[0].iov_len
;
403 in_size
= req
->elem
.in_sg
[0].iov_len
;
404 if (req
->req
.tmf
->type
== VIRTIO_SCSI_T_TMF
) {
405 if (out_size
< sizeof(VirtIOSCSICtrlTMFReq
) ||
406 in_size
< sizeof(VirtIOSCSICtrlTMFResp
)) {
407 virtio_scsi_bad_req();
409 virtio_scsi_do_tmf(s
, req
);
411 } else if (req
->req
.tmf
->type
== VIRTIO_SCSI_T_AN_QUERY
||
412 req
->req
.tmf
->type
== VIRTIO_SCSI_T_AN_SUBSCRIBE
) {
413 if (out_size
< sizeof(VirtIOSCSICtrlANReq
) ||
414 in_size
< sizeof(VirtIOSCSICtrlANResp
)) {
415 virtio_scsi_bad_req();
417 req
->resp
.an
->event_actual
= 0;
418 req
->resp
.an
->response
= VIRTIO_SCSI_S_OK
;
420 virtio_scsi_complete_req(req
);
424 static void virtio_scsi_command_complete(SCSIRequest
*r
, uint32_t status
,
427 VirtIOSCSIReq
*req
= r
->hba_private
;
430 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_OK
;
431 req
->resp
.cmd
->status
= status
;
432 if (req
->resp
.cmd
->status
== GOOD
) {
433 req
->resp
.cmd
->resid
= tswap32(resid
);
435 req
->resp
.cmd
->resid
= 0;
436 sense_len
= scsi_req_get_sense(r
, req
->resp
.cmd
->sense
,
437 VIRTIO_SCSI_SENSE_SIZE
);
438 req
->resp
.cmd
->sense_len
= tswap32(sense_len
);
440 virtio_scsi_complete_req(req
);
443 static QEMUSGList
*virtio_scsi_get_sg_list(SCSIRequest
*r
)
445 VirtIOSCSIReq
*req
= r
->hba_private
;
450 static void virtio_scsi_request_cancelled(SCSIRequest
*r
)
452 VirtIOSCSIReq
*req
= r
->hba_private
;
457 if (req
->dev
->resetting
) {
458 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_RESET
;
460 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_ABORTED
;
462 virtio_scsi_complete_req(req
);
465 static void virtio_scsi_fail_cmd_req(VirtIOSCSIReq
*req
)
467 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_FAILURE
;
468 virtio_scsi_complete_req(req
);
471 static void virtio_scsi_handle_cmd(VirtIODevice
*vdev
, VirtQueue
*vq
)
473 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
477 while ((req
= virtio_scsi_pop_req(s
, vq
))) {
479 int out_size
, in_size
;
480 if (req
->elem
.out_num
< 1 || req
->elem
.in_num
< 1) {
481 virtio_scsi_bad_req();
484 out_size
= req
->elem
.out_sg
[0].iov_len
;
485 in_size
= req
->elem
.in_sg
[0].iov_len
;
486 if (out_size
< sizeof(VirtIOSCSICmdReq
) + s
->cdb_size
||
487 in_size
< sizeof(VirtIOSCSICmdResp
) + s
->sense_size
) {
488 virtio_scsi_bad_req();
491 if (req
->elem
.out_num
> 1 && req
->elem
.in_num
> 1) {
492 virtio_scsi_fail_cmd_req(req
);
496 d
= virtio_scsi_device_find(s
, req
->req
.cmd
->lun
);
498 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_BAD_TARGET
;
499 virtio_scsi_complete_req(req
);
502 req
->sreq
= scsi_req_new(d
, req
->req
.cmd
->tag
,
503 virtio_scsi_get_lun(req
->req
.cmd
->lun
),
504 req
->req
.cmd
->cdb
, req
);
506 if (req
->sreq
->cmd
.mode
!= SCSI_XFER_NONE
) {
508 (req
->elem
.in_num
> 1 ? SCSI_XFER_FROM_DEV
: SCSI_XFER_TO_DEV
);
510 if (req
->sreq
->cmd
.mode
!= req_mode
||
511 req
->sreq
->cmd
.xfer
> req
->qsgl
.size
) {
512 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_OVERRUN
;
513 virtio_scsi_complete_req(req
);
518 n
= scsi_req_enqueue(req
->sreq
);
520 scsi_req_continue(req
->sreq
);
525 static void virtio_scsi_get_config(VirtIODevice
*vdev
,
528 VirtIOSCSIConfig
*scsiconf
= (VirtIOSCSIConfig
*)config
;
529 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
531 stl_raw(&scsiconf
->num_queues
, s
->conf
->num_queues
);
532 stl_raw(&scsiconf
->seg_max
, 128 - 2);
533 stl_raw(&scsiconf
->max_sectors
, s
->conf
->max_sectors
);
534 stl_raw(&scsiconf
->cmd_per_lun
, s
->conf
->cmd_per_lun
);
535 stl_raw(&scsiconf
->event_info_size
, sizeof(VirtIOSCSIEvent
));
536 stl_raw(&scsiconf
->sense_size
, s
->sense_size
);
537 stl_raw(&scsiconf
->cdb_size
, s
->cdb_size
);
538 stw_raw(&scsiconf
->max_channel
, VIRTIO_SCSI_MAX_CHANNEL
);
539 stw_raw(&scsiconf
->max_target
, VIRTIO_SCSI_MAX_TARGET
);
540 stl_raw(&scsiconf
->max_lun
, VIRTIO_SCSI_MAX_LUN
);
543 static void virtio_scsi_set_config(VirtIODevice
*vdev
,
544 const uint8_t *config
)
546 VirtIOSCSIConfig
*scsiconf
= (VirtIOSCSIConfig
*)config
;
547 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
549 if ((uint32_t) ldl_raw(&scsiconf
->sense_size
) >= 65536 ||
550 (uint32_t) ldl_raw(&scsiconf
->cdb_size
) >= 256) {
551 error_report("bad data written to virtio-scsi configuration space");
555 s
->sense_size
= ldl_raw(&scsiconf
->sense_size
);
556 s
->cdb_size
= ldl_raw(&scsiconf
->cdb_size
);
559 static uint32_t virtio_scsi_get_features(VirtIODevice
*vdev
,
560 uint32_t requested_features
)
562 return requested_features
;
565 static void virtio_scsi_reset(VirtIODevice
*vdev
)
567 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
570 qbus_reset_all(&s
->bus
.qbus
);
573 s
->sense_size
= VIRTIO_SCSI_SENSE_SIZE
;
574 s
->cdb_size
= VIRTIO_SCSI_CDB_SIZE
;
575 s
->events_dropped
= false;
578 /* The device does not have anything to save beyond the virtio data.
579 * Request data is saved with callbacks from SCSI devices.
581 static void virtio_scsi_save(QEMUFile
*f
, void *opaque
)
583 VirtIOSCSI
*s
= opaque
;
584 virtio_save(&s
->vdev
, f
);
587 static int virtio_scsi_load(QEMUFile
*f
, void *opaque
, int version_id
)
589 VirtIOSCSI
*s
= opaque
;
592 ret
= virtio_load(&s
->vdev
, f
);
599 static void virtio_scsi_push_event(VirtIOSCSI
*s
, SCSIDevice
*dev
,
600 uint32_t event
, uint32_t reason
)
602 VirtIOSCSIReq
*req
= virtio_scsi_pop_req(s
, s
->event_vq
);
603 VirtIOSCSIEvent
*evt
;
606 if (!(s
->vdev
.status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
611 s
->events_dropped
= true;
615 if (req
->elem
.out_num
|| req
->elem
.in_num
!= 1) {
616 virtio_scsi_bad_req();
619 if (s
->events_dropped
) {
620 event
|= VIRTIO_SCSI_T_EVENTS_MISSED
;
621 s
->events_dropped
= false;
624 in_size
= req
->elem
.in_sg
[0].iov_len
;
625 if (in_size
< sizeof(VirtIOSCSIEvent
)) {
626 virtio_scsi_bad_req();
629 evt
= req
->resp
.event
;
630 memset(evt
, 0, sizeof(VirtIOSCSIEvent
));
632 evt
->reason
= reason
;
634 assert(event
== VIRTIO_SCSI_T_NO_EVENT
);
637 evt
->lun
[1] = dev
->id
;
639 /* Linux wants us to keep the same encoding we use for REPORT LUNS. */
640 if (dev
->lun
>= 256) {
641 evt
->lun
[2] = (dev
->lun
>> 8) | 0x40;
643 evt
->lun
[3] = dev
->lun
& 0xFF;
645 virtio_scsi_complete_req(req
);
648 static void virtio_scsi_handle_event(VirtIODevice
*vdev
, VirtQueue
*vq
)
650 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
652 if (s
->events_dropped
) {
653 virtio_scsi_push_event(s
, NULL
, VIRTIO_SCSI_T_NO_EVENT
, 0);
657 static void virtio_scsi_change(SCSIBus
*bus
, SCSIDevice
*dev
, SCSISense sense
)
659 VirtIOSCSI
*s
= container_of(bus
, VirtIOSCSI
, bus
);
661 if (((s
->vdev
.guest_features
>> VIRTIO_SCSI_F_CHANGE
) & 1) &&
662 dev
->type
!= TYPE_ROM
) {
663 virtio_scsi_push_event(s
, dev
, VIRTIO_SCSI_T_PARAM_CHANGE
,
664 sense
.asc
| (sense
.ascq
<< 8));
668 static void virtio_scsi_hotplug(SCSIBus
*bus
, SCSIDevice
*dev
)
670 VirtIOSCSI
*s
= container_of(bus
, VirtIOSCSI
, bus
);
672 if ((s
->vdev
.guest_features
>> VIRTIO_SCSI_F_HOTPLUG
) & 1) {
673 virtio_scsi_push_event(s
, dev
, VIRTIO_SCSI_T_TRANSPORT_RESET
,
674 VIRTIO_SCSI_EVT_RESET_RESCAN
);
678 static void virtio_scsi_hot_unplug(SCSIBus
*bus
, SCSIDevice
*dev
)
680 VirtIOSCSI
*s
= container_of(bus
, VirtIOSCSI
, bus
);
682 if ((s
->vdev
.guest_features
>> VIRTIO_SCSI_F_HOTPLUG
) & 1) {
683 virtio_scsi_push_event(s
, dev
, VIRTIO_SCSI_T_TRANSPORT_RESET
,
684 VIRTIO_SCSI_EVT_RESET_REMOVED
);
688 static struct SCSIBusInfo virtio_scsi_scsi_info
= {
690 .max_channel
= VIRTIO_SCSI_MAX_CHANNEL
,
691 .max_target
= VIRTIO_SCSI_MAX_TARGET
,
692 .max_lun
= VIRTIO_SCSI_MAX_LUN
,
694 .complete
= virtio_scsi_command_complete
,
695 .cancel
= virtio_scsi_request_cancelled
,
696 .change
= virtio_scsi_change
,
697 .hotplug
= virtio_scsi_hotplug
,
698 .hot_unplug
= virtio_scsi_hot_unplug
,
699 .get_sg_list
= virtio_scsi_get_sg_list
,
700 .save_request
= virtio_scsi_save_request
,
701 .load_request
= virtio_scsi_load_request
,
704 VirtIODevice
*virtio_scsi_init(DeviceState
*dev
, VirtIOSCSIConf
*proxyconf
)
707 static int virtio_scsi_id
;
711 sz
= sizeof(VirtIOSCSI
) + proxyconf
->num_queues
* sizeof(VirtQueue
*);
712 s
= (VirtIOSCSI
*)virtio_common_init("virtio-scsi", VIRTIO_ID_SCSI
,
713 sizeof(VirtIOSCSIConfig
), sz
);
718 /* TODO set up vdev function pointers */
719 s
->vdev
.get_config
= virtio_scsi_get_config
;
720 s
->vdev
.set_config
= virtio_scsi_set_config
;
721 s
->vdev
.get_features
= virtio_scsi_get_features
;
722 s
->vdev
.reset
= virtio_scsi_reset
;
724 s
->ctrl_vq
= virtio_add_queue(&s
->vdev
, VIRTIO_SCSI_VQ_SIZE
,
725 virtio_scsi_handle_ctrl
);
726 s
->event_vq
= virtio_add_queue(&s
->vdev
, VIRTIO_SCSI_VQ_SIZE
,
727 virtio_scsi_handle_event
);
728 for (i
= 0; i
< s
->conf
->num_queues
; i
++) {
729 s
->cmd_vqs
[i
] = virtio_add_queue(&s
->vdev
, VIRTIO_SCSI_VQ_SIZE
,
730 virtio_scsi_handle_cmd
);
733 scsi_bus_new(&s
->bus
, dev
, &virtio_scsi_scsi_info
);
734 if (!dev
->hotplugged
) {
735 scsi_bus_legacy_handle_cmdline(&s
->bus
);
738 register_savevm(dev
, "virtio-scsi", virtio_scsi_id
++, 1,
739 virtio_scsi_save
, virtio_scsi_load
, s
);
744 void virtio_scsi_exit(VirtIODevice
*vdev
)
746 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
747 unregister_savevm(s
->qdev
, "virtio-scsi", s
);
748 virtio_cleanup(vdev
);