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
30 #define VIRTIO_SCSI_F_CHANGE 2
33 #define VIRTIO_SCSI_S_OK 0
34 #define VIRTIO_SCSI_S_OVERRUN 1
35 #define VIRTIO_SCSI_S_ABORTED 2
36 #define VIRTIO_SCSI_S_BAD_TARGET 3
37 #define VIRTIO_SCSI_S_RESET 4
38 #define VIRTIO_SCSI_S_BUSY 5
39 #define VIRTIO_SCSI_S_TRANSPORT_FAILURE 6
40 #define VIRTIO_SCSI_S_TARGET_FAILURE 7
41 #define VIRTIO_SCSI_S_NEXUS_FAILURE 8
42 #define VIRTIO_SCSI_S_FAILURE 9
43 #define VIRTIO_SCSI_S_FUNCTION_SUCCEEDED 10
44 #define VIRTIO_SCSI_S_FUNCTION_REJECTED 11
45 #define VIRTIO_SCSI_S_INCORRECT_LUN 12
47 /* Controlq type codes. */
48 #define VIRTIO_SCSI_T_TMF 0
49 #define VIRTIO_SCSI_T_AN_QUERY 1
50 #define VIRTIO_SCSI_T_AN_SUBSCRIBE 2
52 /* Valid TMF subtypes. */
53 #define VIRTIO_SCSI_T_TMF_ABORT_TASK 0
54 #define VIRTIO_SCSI_T_TMF_ABORT_TASK_SET 1
55 #define VIRTIO_SCSI_T_TMF_CLEAR_ACA 2
56 #define VIRTIO_SCSI_T_TMF_CLEAR_TASK_SET 3
57 #define VIRTIO_SCSI_T_TMF_I_T_NEXUS_RESET 4
58 #define VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET 5
59 #define VIRTIO_SCSI_T_TMF_QUERY_TASK 6
60 #define VIRTIO_SCSI_T_TMF_QUERY_TASK_SET 7
63 #define VIRTIO_SCSI_T_EVENTS_MISSED 0x80000000
64 #define VIRTIO_SCSI_T_NO_EVENT 0
65 #define VIRTIO_SCSI_T_TRANSPORT_RESET 1
66 #define VIRTIO_SCSI_T_ASYNC_NOTIFY 2
67 #define VIRTIO_SCSI_T_PARAM_CHANGE 3
69 /* Reasons for transport reset event */
70 #define VIRTIO_SCSI_EVT_RESET_HARD 0
71 #define VIRTIO_SCSI_EVT_RESET_RESCAN 1
72 #define VIRTIO_SCSI_EVT_RESET_REMOVED 2
74 /* SCSI command request, followed by data-out */
76 uint8_t lun
[8]; /* Logical Unit Number */
77 uint64_t tag
; /* Command identifier */
78 uint8_t task_attr
; /* Task attribute */
82 } QEMU_PACKED VirtIOSCSICmdReq
;
84 /* Response, followed by sense data and data-in */
86 uint32_t sense_len
; /* Sense data length */
87 uint32_t resid
; /* Residual bytes in data buffer */
88 uint16_t status_qualifier
; /* Status qualifier */
89 uint8_t status
; /* Command completion status */
90 uint8_t response
; /* Response values */
92 } QEMU_PACKED VirtIOSCSICmdResp
;
94 /* Task Management Request */
100 } QEMU_PACKED VirtIOSCSICtrlTMFReq
;
104 } QEMU_PACKED VirtIOSCSICtrlTMFResp
;
106 /* Asynchronous notification query/subscription */
110 uint32_t event_requested
;
111 } QEMU_PACKED VirtIOSCSICtrlANReq
;
114 uint32_t event_actual
;
116 } QEMU_PACKED VirtIOSCSICtrlANResp
;
122 } QEMU_PACKED VirtIOSCSIEvent
;
127 uint32_t max_sectors
;
128 uint32_t cmd_per_lun
;
129 uint32_t event_info_size
;
132 uint16_t max_channel
;
135 } QEMU_PACKED VirtIOSCSIConfig
;
140 VirtIOSCSIConf
*conf
;
149 VirtQueue
*cmd_vqs
[0];
152 typedef struct VirtIOSCSIReq
{
155 VirtQueueElement elem
;
160 VirtIOSCSICmdReq
*cmd
;
161 VirtIOSCSICtrlTMFReq
*tmf
;
162 VirtIOSCSICtrlANReq
*an
;
166 VirtIOSCSICmdResp
*cmd
;
167 VirtIOSCSICtrlTMFResp
*tmf
;
168 VirtIOSCSICtrlANResp
*an
;
169 VirtIOSCSIEvent
*event
;
173 static inline int virtio_scsi_get_lun(uint8_t *lun
)
175 return ((lun
[2] << 8) | lun
[3]) & 0x3FFF;
178 static inline SCSIDevice
*virtio_scsi_device_find(VirtIOSCSI
*s
, uint8_t *lun
)
183 if (lun
[2] != 0 && !(lun
[2] >= 0x40 && lun
[2] < 0x80)) {
186 return scsi_device_find(&s
->bus
, 0, lun
[1], virtio_scsi_get_lun(lun
));
189 static void virtio_scsi_complete_req(VirtIOSCSIReq
*req
)
191 VirtIOSCSI
*s
= req
->dev
;
192 VirtQueue
*vq
= req
->vq
;
193 virtqueue_push(vq
, &req
->elem
, req
->qsgl
.size
+ req
->elem
.in_sg
[0].iov_len
);
194 qemu_sglist_destroy(&req
->qsgl
);
196 req
->sreq
->hba_private
= NULL
;
197 scsi_req_unref(req
->sreq
);
200 virtio_notify(&s
->vdev
, vq
);
203 static void virtio_scsi_bad_req(void)
205 error_report("wrong size for virtio-scsi headers");
209 static void qemu_sgl_init_external(QEMUSGList
*qsgl
, struct iovec
*sg
,
210 target_phys_addr_t
*addr
, int num
)
212 memset(qsgl
, 0, sizeof(*qsgl
));
214 qemu_sglist_add(qsgl
, *(addr
++), (sg
++)->iov_len
);
218 static void virtio_scsi_parse_req(VirtIOSCSI
*s
, VirtQueue
*vq
,
221 assert(req
->elem
.in_num
);
225 if (req
->elem
.out_num
) {
226 req
->req
.buf
= req
->elem
.out_sg
[0].iov_base
;
228 req
->resp
.buf
= req
->elem
.in_sg
[0].iov_base
;
230 if (req
->elem
.out_num
> 1) {
231 qemu_sgl_init_external(&req
->qsgl
, &req
->elem
.out_sg
[1],
232 &req
->elem
.out_addr
[1],
233 req
->elem
.out_num
- 1);
235 qemu_sgl_init_external(&req
->qsgl
, &req
->elem
.in_sg
[1],
236 &req
->elem
.in_addr
[1],
237 req
->elem
.in_num
- 1);
241 static VirtIOSCSIReq
*virtio_scsi_pop_req(VirtIOSCSI
*s
, VirtQueue
*vq
)
244 req
= g_malloc(sizeof(*req
));
245 if (!virtqueue_pop(vq
, &req
->elem
)) {
250 virtio_scsi_parse_req(s
, vq
, req
);
254 static void virtio_scsi_save_request(QEMUFile
*f
, SCSIRequest
*sreq
)
256 VirtIOSCSIReq
*req
= sreq
->hba_private
;
257 uint32_t n
= virtio_queue_get_id(req
->vq
) - 2;
259 assert(n
< req
->dev
->conf
->num_queues
);
260 qemu_put_be32s(f
, &n
);
261 qemu_put_buffer(f
, (unsigned char *)&req
->elem
, sizeof(req
->elem
));
264 static void *virtio_scsi_load_request(QEMUFile
*f
, SCSIRequest
*sreq
)
266 SCSIBus
*bus
= sreq
->bus
;
267 VirtIOSCSI
*s
= container_of(bus
, VirtIOSCSI
, bus
);
271 req
= g_malloc(sizeof(*req
));
272 qemu_get_be32s(f
, &n
);
273 assert(n
< s
->conf
->num_queues
);
274 qemu_get_buffer(f
, (unsigned char *)&req
->elem
, sizeof(req
->elem
));
275 virtio_scsi_parse_req(s
, s
->cmd_vqs
[n
], req
);
279 if (req
->sreq
->cmd
.mode
!= SCSI_XFER_NONE
) {
281 (req
->elem
.in_num
> 1 ? SCSI_XFER_FROM_DEV
: SCSI_XFER_TO_DEV
);
283 assert(req
->sreq
->cmd
.mode
== req_mode
);
288 static void virtio_scsi_do_tmf(VirtIOSCSI
*s
, VirtIOSCSIReq
*req
)
290 SCSIDevice
*d
= virtio_scsi_device_find(s
, req
->req
.tmf
->lun
);
291 SCSIRequest
*r
, *next
;
295 /* Here VIRTIO_SCSI_S_OK means "FUNCTION COMPLETE". */
296 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_OK
;
298 switch (req
->req
.tmf
->subtype
) {
299 case VIRTIO_SCSI_T_TMF_ABORT_TASK
:
300 case VIRTIO_SCSI_T_TMF_QUERY_TASK
:
304 if (d
->lun
!= virtio_scsi_get_lun(req
->req
.tmf
->lun
)) {
307 QTAILQ_FOREACH_SAFE(r
, &d
->requests
, next
, next
) {
308 if (r
->tag
== req
->req
.tmf
->tag
) {
312 if (r
&& r
->hba_private
) {
313 if (req
->req
.tmf
->subtype
== VIRTIO_SCSI_T_TMF_QUERY_TASK
) {
314 /* "If the specified command is present in the task set, then
315 * return a service response set to FUNCTION SUCCEEDED".
317 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_FUNCTION_SUCCEEDED
;
324 case VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET
:
328 if (d
->lun
!= virtio_scsi_get_lun(req
->req
.tmf
->lun
)) {
332 qdev_reset_all(&d
->qdev
);
336 case VIRTIO_SCSI_T_TMF_ABORT_TASK_SET
:
337 case VIRTIO_SCSI_T_TMF_CLEAR_TASK_SET
:
338 case VIRTIO_SCSI_T_TMF_QUERY_TASK_SET
:
342 if (d
->lun
!= virtio_scsi_get_lun(req
->req
.tmf
->lun
)) {
345 QTAILQ_FOREACH_SAFE(r
, &d
->requests
, next
, next
) {
346 if (r
->hba_private
) {
347 if (req
->req
.tmf
->subtype
== VIRTIO_SCSI_T_TMF_QUERY_TASK_SET
) {
348 /* "If there is any command present in the task set, then
349 * return a service response set to FUNCTION SUCCEEDED".
351 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_FUNCTION_SUCCEEDED
;
360 case VIRTIO_SCSI_T_TMF_I_T_NEXUS_RESET
:
361 target
= req
->req
.tmf
->lun
[1];
363 QTAILQ_FOREACH(kid
, &s
->bus
.qbus
.children
, sibling
) {
364 d
= DO_UPCAST(SCSIDevice
, qdev
, kid
->child
);
365 if (d
->channel
== 0 && d
->id
== target
) {
366 qdev_reset_all(&d
->qdev
);
372 case VIRTIO_SCSI_T_TMF_CLEAR_ACA
:
374 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_FUNCTION_REJECTED
;
381 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_INCORRECT_LUN
;
385 req
->resp
.tmf
->response
= VIRTIO_SCSI_S_BAD_TARGET
;
388 static void virtio_scsi_handle_ctrl(VirtIODevice
*vdev
, VirtQueue
*vq
)
390 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
393 while ((req
= virtio_scsi_pop_req(s
, vq
))) {
394 int out_size
, in_size
;
395 if (req
->elem
.out_num
< 1 || req
->elem
.in_num
< 1) {
396 virtio_scsi_bad_req();
400 out_size
= req
->elem
.out_sg
[0].iov_len
;
401 in_size
= req
->elem
.in_sg
[0].iov_len
;
402 if (req
->req
.tmf
->type
== VIRTIO_SCSI_T_TMF
) {
403 if (out_size
< sizeof(VirtIOSCSICtrlTMFReq
) ||
404 in_size
< sizeof(VirtIOSCSICtrlTMFResp
)) {
405 virtio_scsi_bad_req();
407 virtio_scsi_do_tmf(s
, req
);
409 } else if (req
->req
.tmf
->type
== VIRTIO_SCSI_T_AN_QUERY
||
410 req
->req
.tmf
->type
== VIRTIO_SCSI_T_AN_SUBSCRIBE
) {
411 if (out_size
< sizeof(VirtIOSCSICtrlANReq
) ||
412 in_size
< sizeof(VirtIOSCSICtrlANResp
)) {
413 virtio_scsi_bad_req();
415 req
->resp
.an
->event_actual
= 0;
416 req
->resp
.an
->response
= VIRTIO_SCSI_S_OK
;
418 virtio_scsi_complete_req(req
);
422 static void virtio_scsi_command_complete(SCSIRequest
*r
, uint32_t status
,
425 VirtIOSCSIReq
*req
= r
->hba_private
;
427 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_OK
;
428 req
->resp
.cmd
->status
= status
;
429 if (req
->resp
.cmd
->status
== GOOD
) {
430 req
->resp
.cmd
->resid
= resid
;
432 req
->resp
.cmd
->resid
= 0;
433 req
->resp
.cmd
->sense_len
=
434 scsi_req_get_sense(r
, req
->resp
.cmd
->sense
, VIRTIO_SCSI_SENSE_SIZE
);
436 virtio_scsi_complete_req(req
);
439 static QEMUSGList
*virtio_scsi_get_sg_list(SCSIRequest
*r
)
441 VirtIOSCSIReq
*req
= r
->hba_private
;
446 static void virtio_scsi_request_cancelled(SCSIRequest
*r
)
448 VirtIOSCSIReq
*req
= r
->hba_private
;
453 if (req
->dev
->resetting
) {
454 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_RESET
;
456 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_ABORTED
;
458 virtio_scsi_complete_req(req
);
461 static void virtio_scsi_fail_cmd_req(VirtIOSCSIReq
*req
)
463 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_FAILURE
;
464 virtio_scsi_complete_req(req
);
467 static void virtio_scsi_handle_cmd(VirtIODevice
*vdev
, VirtQueue
*vq
)
469 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
473 while ((req
= virtio_scsi_pop_req(s
, vq
))) {
475 int out_size
, in_size
;
476 if (req
->elem
.out_num
< 1 || req
->elem
.in_num
< 1) {
477 virtio_scsi_bad_req();
480 out_size
= req
->elem
.out_sg
[0].iov_len
;
481 in_size
= req
->elem
.in_sg
[0].iov_len
;
482 if (out_size
< sizeof(VirtIOSCSICmdReq
) + s
->cdb_size
||
483 in_size
< sizeof(VirtIOSCSICmdResp
) + s
->sense_size
) {
484 virtio_scsi_bad_req();
487 if (req
->elem
.out_num
> 1 && req
->elem
.in_num
> 1) {
488 virtio_scsi_fail_cmd_req(req
);
492 d
= virtio_scsi_device_find(s
, req
->req
.cmd
->lun
);
494 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_BAD_TARGET
;
495 virtio_scsi_complete_req(req
);
498 req
->sreq
= scsi_req_new(d
, req
->req
.cmd
->tag
,
499 virtio_scsi_get_lun(req
->req
.cmd
->lun
),
500 req
->req
.cmd
->cdb
, req
);
502 if (req
->sreq
->cmd
.mode
!= SCSI_XFER_NONE
) {
504 (req
->elem
.in_num
> 1 ? SCSI_XFER_FROM_DEV
: SCSI_XFER_TO_DEV
);
506 if (req
->sreq
->cmd
.mode
!= req_mode
||
507 req
->sreq
->cmd
.xfer
> req
->qsgl
.size
) {
508 req
->resp
.cmd
->response
= VIRTIO_SCSI_S_OVERRUN
;
509 virtio_scsi_complete_req(req
);
514 n
= scsi_req_enqueue(req
->sreq
);
516 scsi_req_continue(req
->sreq
);
521 static void virtio_scsi_get_config(VirtIODevice
*vdev
,
524 VirtIOSCSIConfig
*scsiconf
= (VirtIOSCSIConfig
*)config
;
525 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
527 stl_raw(&scsiconf
->num_queues
, s
->conf
->num_queues
);
528 stl_raw(&scsiconf
->seg_max
, 128 - 2);
529 stl_raw(&scsiconf
->max_sectors
, s
->conf
->max_sectors
);
530 stl_raw(&scsiconf
->cmd_per_lun
, s
->conf
->cmd_per_lun
);
531 stl_raw(&scsiconf
->event_info_size
, sizeof(VirtIOSCSIEvent
));
532 stl_raw(&scsiconf
->sense_size
, s
->sense_size
);
533 stl_raw(&scsiconf
->cdb_size
, s
->cdb_size
);
534 stl_raw(&scsiconf
->max_channel
, VIRTIO_SCSI_MAX_CHANNEL
);
535 stl_raw(&scsiconf
->max_target
, VIRTIO_SCSI_MAX_TARGET
);
536 stl_raw(&scsiconf
->max_lun
, VIRTIO_SCSI_MAX_LUN
);
539 static void virtio_scsi_set_config(VirtIODevice
*vdev
,
540 const uint8_t *config
)
542 VirtIOSCSIConfig
*scsiconf
= (VirtIOSCSIConfig
*)config
;
543 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
545 if ((uint32_t) ldl_raw(&scsiconf
->sense_size
) >= 65536 ||
546 (uint32_t) ldl_raw(&scsiconf
->cdb_size
) >= 256) {
547 error_report("bad data written to virtio-scsi configuration space");
551 s
->sense_size
= ldl_raw(&scsiconf
->sense_size
);
552 s
->cdb_size
= ldl_raw(&scsiconf
->cdb_size
);
555 static uint32_t virtio_scsi_get_features(VirtIODevice
*vdev
,
556 uint32_t requested_features
)
558 requested_features
|= (1UL << VIRTIO_SCSI_F_HOTPLUG
);
559 requested_features
|= (1UL << VIRTIO_SCSI_F_CHANGE
);
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
;
569 s
->events_dropped
= false;
572 /* The device does not have anything to save beyond the virtio data.
573 * Request data is saved with callbacks from SCSI devices.
575 static void virtio_scsi_save(QEMUFile
*f
, void *opaque
)
577 VirtIOSCSI
*s
= opaque
;
578 virtio_save(&s
->vdev
, f
);
581 static int virtio_scsi_load(QEMUFile
*f
, void *opaque
, int version_id
)
583 VirtIOSCSI
*s
= opaque
;
586 ret
= virtio_load(&s
->vdev
, f
);
593 static void virtio_scsi_push_event(VirtIOSCSI
*s
, SCSIDevice
*dev
,
594 uint32_t event
, uint32_t reason
)
596 VirtIOSCSIReq
*req
= virtio_scsi_pop_req(s
, s
->event_vq
);
597 VirtIOSCSIEvent
*evt
;
601 s
->events_dropped
= true;
605 if (req
->elem
.out_num
|| req
->elem
.in_num
!= 1) {
606 virtio_scsi_bad_req();
609 if (s
->events_dropped
) {
610 event
|= VIRTIO_SCSI_T_EVENTS_MISSED
;
611 s
->events_dropped
= false;
614 in_size
= req
->elem
.in_sg
[0].iov_len
;
615 if (in_size
< sizeof(VirtIOSCSIEvent
)) {
616 virtio_scsi_bad_req();
619 evt
= req
->resp
.event
;
620 memset(evt
, 0, sizeof(VirtIOSCSIEvent
));
622 evt
->reason
= reason
;
624 assert(event
== VIRTIO_SCSI_T_NO_EVENT
);
627 evt
->lun
[1] = dev
->id
;
629 /* Linux wants us to keep the same encoding we use for REPORT LUNS. */
630 if (dev
->lun
>= 256) {
631 evt
->lun
[2] = (dev
->lun
>> 8) | 0x40;
633 evt
->lun
[3] = dev
->lun
& 0xFF;
635 virtio_scsi_complete_req(req
);
638 static void virtio_scsi_handle_event(VirtIODevice
*vdev
, VirtQueue
*vq
)
640 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
642 if (s
->events_dropped
) {
643 virtio_scsi_push_event(s
, NULL
, VIRTIO_SCSI_T_NO_EVENT
, 0);
647 static void virtio_scsi_change(SCSIBus
*bus
, SCSIDevice
*dev
, SCSISense sense
)
649 VirtIOSCSI
*s
= container_of(bus
, VirtIOSCSI
, bus
);
651 if (((s
->vdev
.guest_features
>> VIRTIO_SCSI_F_CHANGE
) & 1) &&
652 (s
->vdev
.status
& VIRTIO_CONFIG_S_DRIVER_OK
) &&
653 dev
->type
!= TYPE_ROM
) {
654 virtio_scsi_push_event(s
, dev
, VIRTIO_SCSI_T_PARAM_CHANGE
,
655 sense
.asc
| (sense
.ascq
<< 8));
659 static void virtio_scsi_hotplug(SCSIBus
*bus
, SCSIDevice
*dev
)
661 VirtIOSCSI
*s
= container_of(bus
, VirtIOSCSI
, bus
);
663 if (((s
->vdev
.guest_features
>> VIRTIO_SCSI_F_HOTPLUG
) & 1) &&
664 (s
->vdev
.status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
665 virtio_scsi_push_event(s
, dev
, VIRTIO_SCSI_T_TRANSPORT_RESET
,
666 VIRTIO_SCSI_EVT_RESET_RESCAN
);
670 static void virtio_scsi_hot_unplug(SCSIBus
*bus
, SCSIDevice
*dev
)
672 VirtIOSCSI
*s
= container_of(bus
, VirtIOSCSI
, bus
);
674 if ((s
->vdev
.guest_features
>> VIRTIO_SCSI_F_HOTPLUG
) & 1) {
675 virtio_scsi_push_event(s
, dev
, VIRTIO_SCSI_T_TRANSPORT_RESET
,
676 VIRTIO_SCSI_EVT_RESET_REMOVED
);
680 static struct SCSIBusInfo virtio_scsi_scsi_info
= {
682 .max_channel
= VIRTIO_SCSI_MAX_CHANNEL
,
683 .max_target
= VIRTIO_SCSI_MAX_TARGET
,
684 .max_lun
= VIRTIO_SCSI_MAX_LUN
,
686 .complete
= virtio_scsi_command_complete
,
687 .cancel
= virtio_scsi_request_cancelled
,
688 .change
= virtio_scsi_change
,
689 .hotplug
= virtio_scsi_hotplug
,
690 .hot_unplug
= virtio_scsi_hot_unplug
,
691 .get_sg_list
= virtio_scsi_get_sg_list
,
692 .save_request
= virtio_scsi_save_request
,
693 .load_request
= virtio_scsi_load_request
,
696 VirtIODevice
*virtio_scsi_init(DeviceState
*dev
, VirtIOSCSIConf
*proxyconf
)
699 static int virtio_scsi_id
;
703 sz
= sizeof(VirtIOSCSI
) + proxyconf
->num_queues
* sizeof(VirtQueue
*);
704 s
= (VirtIOSCSI
*)virtio_common_init("virtio-scsi", VIRTIO_ID_SCSI
,
705 sizeof(VirtIOSCSIConfig
), sz
);
710 /* TODO set up vdev function pointers */
711 s
->vdev
.get_config
= virtio_scsi_get_config
;
712 s
->vdev
.set_config
= virtio_scsi_set_config
;
713 s
->vdev
.get_features
= virtio_scsi_get_features
;
714 s
->vdev
.reset
= virtio_scsi_reset
;
716 s
->ctrl_vq
= virtio_add_queue(&s
->vdev
, VIRTIO_SCSI_VQ_SIZE
,
717 virtio_scsi_handle_ctrl
);
718 s
->event_vq
= virtio_add_queue(&s
->vdev
, VIRTIO_SCSI_VQ_SIZE
,
719 virtio_scsi_handle_event
);
720 for (i
= 0; i
< s
->conf
->num_queues
; i
++) {
721 s
->cmd_vqs
[i
] = virtio_add_queue(&s
->vdev
, VIRTIO_SCSI_VQ_SIZE
,
722 virtio_scsi_handle_cmd
);
725 scsi_bus_new(&s
->bus
, dev
, &virtio_scsi_scsi_info
);
726 if (!dev
->hotplugged
) {
727 scsi_bus_legacy_handle_cmdline(&s
->bus
);
730 register_savevm(dev
, "virtio-scsi", virtio_scsi_id
++, 1,
731 virtio_scsi_save
, virtio_scsi_load
, s
);
736 void virtio_scsi_exit(VirtIODevice
*vdev
)
738 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
739 unregister_savevm(s
->qdev
, "virtio-scsi", s
);
740 virtio_cleanup(vdev
);