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 "standard-headers/linux/virtio_ids.h"
17 #include "hw/virtio/virtio-scsi.h"
18 #include "qemu/error-report.h"
20 #include "sysemu/block-backend.h"
21 #include <hw/scsi/scsi.h>
22 #include <block/scsi.h>
23 #include <hw/virtio/virtio-bus.h>
24 #include "hw/virtio/virtio-access.h"
25 #include "migration/migration.h"
27 static inline int virtio_scsi_get_lun(uint8_t *lun
)
29 return ((lun
[2] << 8) | lun
[3]) & 0x3FFF;
32 static inline SCSIDevice
*virtio_scsi_device_find(VirtIOSCSI
*s
, uint8_t *lun
)
37 if (lun
[2] != 0 && !(lun
[2] >= 0x40 && lun
[2] < 0x80)) {
40 return scsi_device_find(&s
->bus
, 0, lun
[1], virtio_scsi_get_lun(lun
));
43 VirtIOSCSIReq
*virtio_scsi_init_req(VirtIOSCSI
*s
, VirtQueue
*vq
)
46 VirtIOSCSICommon
*vs
= (VirtIOSCSICommon
*)s
;
47 const size_t zero_skip
= offsetof(VirtIOSCSIReq
, elem
)
48 + sizeof(VirtQueueElement
);
50 req
= g_slice_alloc(sizeof(*req
) + vs
->cdb_size
);
53 qemu_sglist_init(&req
->qsgl
, DEVICE(s
), 8, &address_space_memory
);
54 qemu_iovec_init(&req
->resp_iov
, 1);
55 memset((uint8_t *)req
+ zero_skip
, 0, sizeof(*req
) - zero_skip
);
59 void virtio_scsi_free_req(VirtIOSCSIReq
*req
)
61 VirtIOSCSICommon
*vs
= (VirtIOSCSICommon
*)req
->dev
;
63 qemu_iovec_destroy(&req
->resp_iov
);
64 qemu_sglist_destroy(&req
->qsgl
);
65 g_slice_free1(sizeof(*req
) + vs
->cdb_size
, req
);
68 static void virtio_scsi_complete_req(VirtIOSCSIReq
*req
)
70 VirtIOSCSI
*s
= req
->dev
;
71 VirtQueue
*vq
= req
->vq
;
72 VirtIODevice
*vdev
= VIRTIO_DEVICE(s
);
74 qemu_iovec_from_buf(&req
->resp_iov
, 0, &req
->resp
, req
->resp_size
);
76 assert(req
->vq
== NULL
);
77 virtio_scsi_vring_push_notify(req
);
79 virtqueue_push(vq
, &req
->elem
, req
->qsgl
.size
+ req
->resp_iov
.size
);
80 virtio_notify(vdev
, vq
);
84 req
->sreq
->hba_private
= NULL
;
85 scsi_req_unref(req
->sreq
);
87 virtio_scsi_free_req(req
);
90 static void virtio_scsi_bad_req(void)
92 error_report("wrong size for virtio-scsi headers");
96 static size_t qemu_sgl_concat(VirtIOSCSIReq
*req
, struct iovec
*iov
,
97 hwaddr
*addr
, int num
, size_t skip
)
99 QEMUSGList
*qsgl
= &req
->qsgl
;
103 if (skip
>= iov
->iov_len
) {
104 skip
-= iov
->iov_len
;
106 qemu_sglist_add(qsgl
, *addr
+ skip
, iov
->iov_len
- skip
);
107 copied
+= iov
->iov_len
- skip
;
119 static int virtio_scsi_parse_req(VirtIOSCSIReq
*req
,
120 unsigned req_size
, unsigned resp_size
)
122 VirtIODevice
*vdev
= (VirtIODevice
*) req
->dev
;
123 size_t in_size
, out_size
;
125 if (iov_to_buf(req
->elem
.out_sg
, req
->elem
.out_num
, 0,
126 &req
->req
, req_size
) < req_size
) {
130 if (qemu_iovec_concat_iov(&req
->resp_iov
,
131 req
->elem
.in_sg
, req
->elem
.in_num
, 0,
132 resp_size
) < resp_size
) {
136 req
->resp_size
= resp_size
;
138 /* Old BIOSes left some padding by mistake after the req_size/resp_size.
139 * As a workaround, always consider the first buffer as the virtio-scsi
140 * request/response, making the payload start at the second element
143 * The actual length of the response header, stored in req->resp_size,
146 * TODO: always disable this workaround for virtio 1.0 devices.
148 if (!virtio_has_feature(vdev
, VIRTIO_F_ANY_LAYOUT
)) {
149 req_size
= req
->elem
.out_sg
[0].iov_len
;
150 resp_size
= req
->elem
.in_sg
[0].iov_len
;
153 out_size
= qemu_sgl_concat(req
, req
->elem
.out_sg
,
154 &req
->elem
.out_addr
[0], req
->elem
.out_num
,
156 in_size
= qemu_sgl_concat(req
, req
->elem
.in_sg
,
157 &req
->elem
.in_addr
[0], req
->elem
.in_num
,
160 if (out_size
&& in_size
) {
165 req
->mode
= SCSI_XFER_TO_DEV
;
166 } else if (in_size
) {
167 req
->mode
= SCSI_XFER_FROM_DEV
;
173 static VirtIOSCSIReq
*virtio_scsi_pop_req(VirtIOSCSI
*s
, VirtQueue
*vq
)
175 VirtIOSCSIReq
*req
= virtio_scsi_init_req(s
, vq
);
176 if (!virtqueue_pop(vq
, &req
->elem
)) {
177 virtio_scsi_free_req(req
);
183 static void virtio_scsi_save_request(QEMUFile
*f
, SCSIRequest
*sreq
)
185 VirtIOSCSIReq
*req
= sreq
->hba_private
;
186 VirtIOSCSICommon
*vs
= VIRTIO_SCSI_COMMON(req
->dev
);
187 uint32_t n
= virtio_queue_get_id(req
->vq
) - 2;
189 assert(n
< vs
->conf
.num_queues
);
190 qemu_put_be32s(f
, &n
);
191 qemu_put_buffer(f
, (unsigned char *)&req
->elem
, sizeof(req
->elem
));
194 static void *virtio_scsi_load_request(QEMUFile
*f
, SCSIRequest
*sreq
)
196 SCSIBus
*bus
= sreq
->bus
;
197 VirtIOSCSI
*s
= container_of(bus
, VirtIOSCSI
, bus
);
198 VirtIOSCSICommon
*vs
= VIRTIO_SCSI_COMMON(s
);
202 qemu_get_be32s(f
, &n
);
203 assert(n
< vs
->conf
.num_queues
);
204 req
= virtio_scsi_init_req(s
, vs
->cmd_vqs
[n
]);
205 qemu_get_buffer(f
, (unsigned char *)&req
->elem
, sizeof(req
->elem
));
206 /* TODO: add a way for SCSIBusInfo's load_request to fail,
207 * and fail migration instead of asserting here.
208 * When we do, we might be able to re-enable NDEBUG below.
211 #error building with NDEBUG is not supported
213 assert(req
->elem
.in_num
<= ARRAY_SIZE(req
->elem
.in_sg
));
214 assert(req
->elem
.out_num
<= ARRAY_SIZE(req
->elem
.out_sg
));
216 if (virtio_scsi_parse_req(req
, sizeof(VirtIOSCSICmdReq
) + vs
->cdb_size
,
217 sizeof(VirtIOSCSICmdResp
) + vs
->sense_size
) < 0) {
218 error_report("invalid SCSI request migration data");
224 if (req
->sreq
->cmd
.mode
!= SCSI_XFER_NONE
) {
225 assert(req
->sreq
->cmd
.mode
== req
->mode
);
232 VirtIOSCSIReq
*tmf_req
;
233 } VirtIOSCSICancelNotifier
;
235 static void virtio_scsi_cancel_notify(Notifier
*notifier
, void *data
)
237 VirtIOSCSICancelNotifier
*n
= container_of(notifier
,
238 VirtIOSCSICancelNotifier
,
241 if (--n
->tmf_req
->remaining
== 0) {
242 virtio_scsi_complete_req(n
->tmf_req
);
244 g_slice_free(VirtIOSCSICancelNotifier
, n
);
247 /* Return 0 if the request is ready to be completed and return to guest;
248 * -EINPROGRESS if the request is submitted and will be completed later, in the
249 * case of async cancellation. */
250 static int virtio_scsi_do_tmf(VirtIOSCSI
*s
, VirtIOSCSIReq
*req
)
252 SCSIDevice
*d
= virtio_scsi_device_find(s
, req
->req
.tmf
.lun
);
253 SCSIRequest
*r
, *next
;
258 if (s
->dataplane_started
&& blk_get_aio_context(d
->conf
.blk
) != s
->ctx
) {
259 aio_context_acquire(s
->ctx
);
260 blk_set_aio_context(d
->conf
.blk
, s
->ctx
);
261 aio_context_release(s
->ctx
);
263 /* Here VIRTIO_SCSI_S_OK means "FUNCTION COMPLETE". */
264 req
->resp
.tmf
.response
= VIRTIO_SCSI_S_OK
;
266 virtio_tswap32s(VIRTIO_DEVICE(s
), &req
->req
.tmf
.subtype
);
267 switch (req
->req
.tmf
.subtype
) {
268 case VIRTIO_SCSI_T_TMF_ABORT_TASK
:
269 case VIRTIO_SCSI_T_TMF_QUERY_TASK
:
273 if (d
->lun
!= virtio_scsi_get_lun(req
->req
.tmf
.lun
)) {
276 QTAILQ_FOREACH_SAFE(r
, &d
->requests
, next
, next
) {
277 VirtIOSCSIReq
*cmd_req
= r
->hba_private
;
278 if (cmd_req
&& cmd_req
->req
.cmd
.tag
== req
->req
.tmf
.tag
) {
284 * Assert that the request has not been completed yet, we
285 * check for it in the loop above.
287 assert(r
->hba_private
);
288 if (req
->req
.tmf
.subtype
== VIRTIO_SCSI_T_TMF_QUERY_TASK
) {
289 /* "If the specified command is present in the task set, then
290 * return a service response set to FUNCTION SUCCEEDED".
292 req
->resp
.tmf
.response
= VIRTIO_SCSI_S_FUNCTION_SUCCEEDED
;
294 VirtIOSCSICancelNotifier
*notifier
;
297 notifier
= g_slice_new(VirtIOSCSICancelNotifier
);
298 notifier
->tmf_req
= req
;
299 notifier
->notifier
.notify
= virtio_scsi_cancel_notify
;
300 scsi_req_cancel_async(r
, ¬ifier
->notifier
);
306 case VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET
:
310 if (d
->lun
!= virtio_scsi_get_lun(req
->req
.tmf
.lun
)) {
314 qdev_reset_all(&d
->qdev
);
318 case VIRTIO_SCSI_T_TMF_ABORT_TASK_SET
:
319 case VIRTIO_SCSI_T_TMF_CLEAR_TASK_SET
:
320 case VIRTIO_SCSI_T_TMF_QUERY_TASK_SET
:
324 if (d
->lun
!= virtio_scsi_get_lun(req
->req
.tmf
.lun
)) {
328 /* Add 1 to "remaining" until virtio_scsi_do_tmf returns.
329 * This way, if the bus starts calling back to the notifiers
330 * even before we finish the loop, virtio_scsi_cancel_notify
331 * will not complete the TMF too early.
334 QTAILQ_FOREACH_SAFE(r
, &d
->requests
, next
, next
) {
335 if (r
->hba_private
) {
336 if (req
->req
.tmf
.subtype
== VIRTIO_SCSI_T_TMF_QUERY_TASK_SET
) {
337 /* "If there is any command present in the task set, then
338 * return a service response set to FUNCTION SUCCEEDED".
340 req
->resp
.tmf
.response
= VIRTIO_SCSI_S_FUNCTION_SUCCEEDED
;
343 VirtIOSCSICancelNotifier
*notifier
;
346 notifier
= g_slice_new(VirtIOSCSICancelNotifier
);
347 notifier
->notifier
.notify
= virtio_scsi_cancel_notify
;
348 notifier
->tmf_req
= req
;
349 scsi_req_cancel_async(r
, ¬ifier
->notifier
);
353 if (--req
->remaining
> 0) {
358 case VIRTIO_SCSI_T_TMF_I_T_NEXUS_RESET
:
359 target
= req
->req
.tmf
.lun
[1];
361 QTAILQ_FOREACH(kid
, &s
->bus
.qbus
.children
, sibling
) {
362 d
= DO_UPCAST(SCSIDevice
, qdev
, kid
->child
);
363 if (d
->channel
== 0 && d
->id
== target
) {
364 qdev_reset_all(&d
->qdev
);
370 case VIRTIO_SCSI_T_TMF_CLEAR_ACA
:
372 req
->resp
.tmf
.response
= VIRTIO_SCSI_S_FUNCTION_REJECTED
;
379 req
->resp
.tmf
.response
= VIRTIO_SCSI_S_INCORRECT_LUN
;
383 req
->resp
.tmf
.response
= VIRTIO_SCSI_S_BAD_TARGET
;
387 void virtio_scsi_handle_ctrl_req(VirtIOSCSI
*s
, VirtIOSCSIReq
*req
)
389 VirtIODevice
*vdev
= (VirtIODevice
*)s
;
393 if (iov_to_buf(req
->elem
.out_sg
, req
->elem
.out_num
, 0,
394 &type
, sizeof(type
)) < sizeof(type
)) {
395 virtio_scsi_bad_req();
399 virtio_tswap32s(vdev
, &type
);
400 if (type
== VIRTIO_SCSI_T_TMF
) {
401 if (virtio_scsi_parse_req(req
, sizeof(VirtIOSCSICtrlTMFReq
),
402 sizeof(VirtIOSCSICtrlTMFResp
)) < 0) {
403 virtio_scsi_bad_req();
405 r
= virtio_scsi_do_tmf(s
, req
);
408 } else if (type
== VIRTIO_SCSI_T_AN_QUERY
||
409 type
== VIRTIO_SCSI_T_AN_SUBSCRIBE
) {
410 if (virtio_scsi_parse_req(req
, sizeof(VirtIOSCSICtrlANReq
),
411 sizeof(VirtIOSCSICtrlANResp
)) < 0) {
412 virtio_scsi_bad_req();
414 req
->resp
.an
.event_actual
= 0;
415 req
->resp
.an
.response
= VIRTIO_SCSI_S_OK
;
419 virtio_scsi_complete_req(req
);
421 assert(r
== -EINPROGRESS
);
425 static void virtio_scsi_handle_ctrl(VirtIODevice
*vdev
, VirtQueue
*vq
)
427 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
430 if (s
->ctx
&& !s
->dataplane_disabled
) {
431 virtio_scsi_dataplane_start(s
);
434 while ((req
= virtio_scsi_pop_req(s
, vq
))) {
435 virtio_scsi_handle_ctrl_req(s
, req
);
439 static void virtio_scsi_complete_cmd_req(VirtIOSCSIReq
*req
)
441 /* Sense data is not in req->resp and is copied separately
442 * in virtio_scsi_command_complete.
444 req
->resp_size
= sizeof(VirtIOSCSICmdResp
);
445 virtio_scsi_complete_req(req
);
448 static void virtio_scsi_command_complete(SCSIRequest
*r
, uint32_t status
,
451 VirtIOSCSIReq
*req
= r
->hba_private
;
452 uint8_t sense
[SCSI_SENSE_BUF_SIZE
];
454 VirtIODevice
*vdev
= VIRTIO_DEVICE(req
->dev
);
456 if (r
->io_canceled
) {
460 req
->resp
.cmd
.response
= VIRTIO_SCSI_S_OK
;
461 req
->resp
.cmd
.status
= status
;
462 if (req
->resp
.cmd
.status
== GOOD
) {
463 req
->resp
.cmd
.resid
= virtio_tswap32(vdev
, resid
);
465 req
->resp
.cmd
.resid
= 0;
466 sense_len
= scsi_req_get_sense(r
, sense
, sizeof(sense
));
467 sense_len
= MIN(sense_len
, req
->resp_iov
.size
- sizeof(req
->resp
.cmd
));
468 qemu_iovec_from_buf(&req
->resp_iov
, sizeof(req
->resp
.cmd
),
470 req
->resp
.cmd
.sense_len
= virtio_tswap32(vdev
, sense_len
);
472 virtio_scsi_complete_cmd_req(req
);
475 static int virtio_scsi_parse_cdb(SCSIDevice
*dev
, SCSICommand
*cmd
,
476 uint8_t *buf
, void *hba_private
)
478 VirtIOSCSIReq
*req
= hba_private
;
481 cmd
->len
= MIN(VIRTIO_SCSI_CDB_SIZE
, SCSI_CMD_BUF_SIZE
);
482 memcpy(cmd
->buf
, buf
, cmd
->len
);
485 /* Extract the direction and mode directly from the request, for
486 * host device passthrough.
488 cmd
->xfer
= req
->qsgl
.size
;
489 cmd
->mode
= req
->mode
;
493 static QEMUSGList
*virtio_scsi_get_sg_list(SCSIRequest
*r
)
495 VirtIOSCSIReq
*req
= r
->hba_private
;
500 static void virtio_scsi_request_cancelled(SCSIRequest
*r
)
502 VirtIOSCSIReq
*req
= r
->hba_private
;
507 if (req
->dev
->resetting
) {
508 req
->resp
.cmd
.response
= VIRTIO_SCSI_S_RESET
;
510 req
->resp
.cmd
.response
= VIRTIO_SCSI_S_ABORTED
;
512 virtio_scsi_complete_cmd_req(req
);
515 static void virtio_scsi_fail_cmd_req(VirtIOSCSIReq
*req
)
517 req
->resp
.cmd
.response
= VIRTIO_SCSI_S_FAILURE
;
518 virtio_scsi_complete_cmd_req(req
);
521 bool virtio_scsi_handle_cmd_req_prepare(VirtIOSCSI
*s
, VirtIOSCSIReq
*req
)
523 VirtIOSCSICommon
*vs
= &s
->parent_obj
;
527 rc
= virtio_scsi_parse_req(req
, sizeof(VirtIOSCSICmdReq
) + vs
->cdb_size
,
528 sizeof(VirtIOSCSICmdResp
) + vs
->sense_size
);
530 if (rc
== -ENOTSUP
) {
531 virtio_scsi_fail_cmd_req(req
);
533 virtio_scsi_bad_req();
538 d
= virtio_scsi_device_find(s
, req
->req
.cmd
.lun
);
540 req
->resp
.cmd
.response
= VIRTIO_SCSI_S_BAD_TARGET
;
541 virtio_scsi_complete_cmd_req(req
);
544 if (s
->dataplane_started
&& blk_get_aio_context(d
->conf
.blk
) != s
->ctx
) {
545 aio_context_acquire(s
->ctx
);
546 blk_set_aio_context(d
->conf
.blk
, s
->ctx
);
547 aio_context_release(s
->ctx
);
549 req
->sreq
= scsi_req_new(d
, req
->req
.cmd
.tag
,
550 virtio_scsi_get_lun(req
->req
.cmd
.lun
),
553 if (req
->sreq
->cmd
.mode
!= SCSI_XFER_NONE
554 && (req
->sreq
->cmd
.mode
!= req
->mode
||
555 req
->sreq
->cmd
.xfer
> req
->qsgl
.size
)) {
556 req
->resp
.cmd
.response
= VIRTIO_SCSI_S_OVERRUN
;
557 virtio_scsi_complete_cmd_req(req
);
560 scsi_req_ref(req
->sreq
);
561 blk_io_plug(d
->conf
.blk
);
565 void virtio_scsi_handle_cmd_req_submit(VirtIOSCSI
*s
, VirtIOSCSIReq
*req
)
567 SCSIRequest
*sreq
= req
->sreq
;
568 if (scsi_req_enqueue(sreq
)) {
569 scsi_req_continue(sreq
);
571 blk_io_unplug(sreq
->dev
->conf
.blk
);
572 scsi_req_unref(sreq
);
575 static void virtio_scsi_handle_cmd(VirtIODevice
*vdev
, VirtQueue
*vq
)
577 /* use non-QOM casts in the data path */
578 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
579 VirtIOSCSIReq
*req
, *next
;
580 QTAILQ_HEAD(, VirtIOSCSIReq
) reqs
= QTAILQ_HEAD_INITIALIZER(reqs
);
582 if (s
->ctx
&& !s
->dataplane_disabled
) {
583 virtio_scsi_dataplane_start(s
);
586 while ((req
= virtio_scsi_pop_req(s
, vq
))) {
587 if (virtio_scsi_handle_cmd_req_prepare(s
, req
)) {
588 QTAILQ_INSERT_TAIL(&reqs
, req
, next
);
592 QTAILQ_FOREACH_SAFE(req
, &reqs
, next
, next
) {
593 virtio_scsi_handle_cmd_req_submit(s
, req
);
597 static void virtio_scsi_get_config(VirtIODevice
*vdev
,
600 VirtIOSCSIConfig
*scsiconf
= (VirtIOSCSIConfig
*)config
;
601 VirtIOSCSICommon
*s
= VIRTIO_SCSI_COMMON(vdev
);
603 virtio_stl_p(vdev
, &scsiconf
->num_queues
, s
->conf
.num_queues
);
604 virtio_stl_p(vdev
, &scsiconf
->seg_max
, 128 - 2);
605 virtio_stl_p(vdev
, &scsiconf
->max_sectors
, s
->conf
.max_sectors
);
606 virtio_stl_p(vdev
, &scsiconf
->cmd_per_lun
, s
->conf
.cmd_per_lun
);
607 virtio_stl_p(vdev
, &scsiconf
->event_info_size
, sizeof(VirtIOSCSIEvent
));
608 virtio_stl_p(vdev
, &scsiconf
->sense_size
, s
->sense_size
);
609 virtio_stl_p(vdev
, &scsiconf
->cdb_size
, s
->cdb_size
);
610 virtio_stw_p(vdev
, &scsiconf
->max_channel
, VIRTIO_SCSI_MAX_CHANNEL
);
611 virtio_stw_p(vdev
, &scsiconf
->max_target
, VIRTIO_SCSI_MAX_TARGET
);
612 virtio_stl_p(vdev
, &scsiconf
->max_lun
, VIRTIO_SCSI_MAX_LUN
);
615 static void virtio_scsi_set_config(VirtIODevice
*vdev
,
616 const uint8_t *config
)
618 VirtIOSCSIConfig
*scsiconf
= (VirtIOSCSIConfig
*)config
;
619 VirtIOSCSICommon
*vs
= VIRTIO_SCSI_COMMON(vdev
);
621 if ((uint32_t) virtio_ldl_p(vdev
, &scsiconf
->sense_size
) >= 65536 ||
622 (uint32_t) virtio_ldl_p(vdev
, &scsiconf
->cdb_size
) >= 256) {
623 error_report("bad data written to virtio-scsi configuration space");
627 vs
->sense_size
= virtio_ldl_p(vdev
, &scsiconf
->sense_size
);
628 vs
->cdb_size
= virtio_ldl_p(vdev
, &scsiconf
->cdb_size
);
631 static uint32_t virtio_scsi_get_features(VirtIODevice
*vdev
,
632 uint32_t requested_features
)
634 return requested_features
;
637 static void virtio_scsi_reset(VirtIODevice
*vdev
)
639 VirtIOSCSI
*s
= VIRTIO_SCSI(vdev
);
640 VirtIOSCSICommon
*vs
= VIRTIO_SCSI_COMMON(vdev
);
643 virtio_scsi_dataplane_stop(s
);
646 qbus_reset_all(&s
->bus
.qbus
);
649 vs
->sense_size
= VIRTIO_SCSI_SENSE_SIZE
;
650 vs
->cdb_size
= VIRTIO_SCSI_CDB_SIZE
;
651 s
->events_dropped
= false;
654 /* The device does not have anything to save beyond the virtio data.
655 * Request data is saved with callbacks from SCSI devices.
657 static void virtio_scsi_save(QEMUFile
*f
, void *opaque
)
659 VirtIODevice
*vdev
= VIRTIO_DEVICE(opaque
);
660 virtio_save(vdev
, f
);
663 static int virtio_scsi_load(QEMUFile
*f
, void *opaque
, int version_id
)
665 VirtIODevice
*vdev
= VIRTIO_DEVICE(opaque
);
668 ret
= virtio_load(vdev
, f
, version_id
);
675 void virtio_scsi_push_event(VirtIOSCSI
*s
, SCSIDevice
*dev
,
676 uint32_t event
, uint32_t reason
)
678 VirtIOSCSICommon
*vs
= VIRTIO_SCSI_COMMON(s
);
680 VirtIOSCSIEvent
*evt
;
681 VirtIODevice
*vdev
= VIRTIO_DEVICE(s
);
683 if (!(vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
687 if (s
->dataplane_started
) {
689 aio_context_acquire(s
->ctx
);
692 if (s
->dataplane_started
) {
693 req
= virtio_scsi_pop_req_vring(s
, s
->event_vring
);
695 req
= virtio_scsi_pop_req(s
, vs
->event_vq
);
698 s
->events_dropped
= true;
702 if (s
->events_dropped
) {
703 event
|= VIRTIO_SCSI_T_EVENTS_MISSED
;
704 s
->events_dropped
= false;
707 if (virtio_scsi_parse_req(req
, 0, sizeof(VirtIOSCSIEvent
))) {
708 virtio_scsi_bad_req();
711 evt
= &req
->resp
.event
;
712 memset(evt
, 0, sizeof(VirtIOSCSIEvent
));
713 evt
->event
= virtio_tswap32(vdev
, event
);
714 evt
->reason
= virtio_tswap32(vdev
, reason
);
716 assert(event
== VIRTIO_SCSI_T_EVENTS_MISSED
);
719 evt
->lun
[1] = dev
->id
;
721 /* Linux wants us to keep the same encoding we use for REPORT LUNS. */
722 if (dev
->lun
>= 256) {
723 evt
->lun
[2] = (dev
->lun
>> 8) | 0x40;
725 evt
->lun
[3] = dev
->lun
& 0xFF;
727 virtio_scsi_complete_req(req
);
729 if (s
->dataplane_started
) {
730 aio_context_release(s
->ctx
);
734 static void virtio_scsi_handle_event(VirtIODevice
*vdev
, VirtQueue
*vq
)
736 VirtIOSCSI
*s
= VIRTIO_SCSI(vdev
);
738 if (s
->ctx
&& !s
->dataplane_disabled
) {
739 virtio_scsi_dataplane_start(s
);
742 if (s
->events_dropped
) {
743 virtio_scsi_push_event(s
, NULL
, VIRTIO_SCSI_T_NO_EVENT
, 0);
747 static void virtio_scsi_change(SCSIBus
*bus
, SCSIDevice
*dev
, SCSISense sense
)
749 VirtIOSCSI
*s
= container_of(bus
, VirtIOSCSI
, bus
);
750 VirtIODevice
*vdev
= VIRTIO_DEVICE(s
);
752 if (virtio_has_feature(vdev
, VIRTIO_SCSI_F_CHANGE
) &&
753 dev
->type
!= TYPE_ROM
) {
754 virtio_scsi_push_event(s
, dev
, VIRTIO_SCSI_T_PARAM_CHANGE
,
755 sense
.asc
| (sense
.ascq
<< 8));
759 static void virtio_scsi_hotplug(HotplugHandler
*hotplug_dev
, DeviceState
*dev
,
762 VirtIODevice
*vdev
= VIRTIO_DEVICE(hotplug_dev
);
763 VirtIOSCSI
*s
= VIRTIO_SCSI(vdev
);
764 SCSIDevice
*sd
= SCSI_DEVICE(dev
);
766 if (s
->ctx
&& !s
->dataplane_disabled
) {
767 if (blk_op_is_blocked(sd
->conf
.blk
, BLOCK_OP_TYPE_DATAPLANE
, errp
)) {
770 blk_op_block_all(sd
->conf
.blk
, s
->blocker
);
773 if (virtio_has_feature(vdev
, VIRTIO_SCSI_F_HOTPLUG
)) {
774 virtio_scsi_push_event(s
, sd
,
775 VIRTIO_SCSI_T_TRANSPORT_RESET
,
776 VIRTIO_SCSI_EVT_RESET_RESCAN
);
780 static void virtio_scsi_hotunplug(HotplugHandler
*hotplug_dev
, DeviceState
*dev
,
783 VirtIODevice
*vdev
= VIRTIO_DEVICE(hotplug_dev
);
784 VirtIOSCSI
*s
= VIRTIO_SCSI(vdev
);
785 SCSIDevice
*sd
= SCSI_DEVICE(dev
);
787 if (virtio_has_feature(vdev
, VIRTIO_SCSI_F_HOTPLUG
)) {
788 virtio_scsi_push_event(s
, sd
,
789 VIRTIO_SCSI_T_TRANSPORT_RESET
,
790 VIRTIO_SCSI_EVT_RESET_REMOVED
);
794 blk_op_unblock_all(sd
->conf
.blk
, s
->blocker
);
796 qdev_simple_device_unplug_cb(hotplug_dev
, dev
, errp
);
799 static struct SCSIBusInfo virtio_scsi_scsi_info
= {
801 .max_channel
= VIRTIO_SCSI_MAX_CHANNEL
,
802 .max_target
= VIRTIO_SCSI_MAX_TARGET
,
803 .max_lun
= VIRTIO_SCSI_MAX_LUN
,
805 .complete
= virtio_scsi_command_complete
,
806 .cancel
= virtio_scsi_request_cancelled
,
807 .change
= virtio_scsi_change
,
808 .parse_cdb
= virtio_scsi_parse_cdb
,
809 .get_sg_list
= virtio_scsi_get_sg_list
,
810 .save_request
= virtio_scsi_save_request
,
811 .load_request
= virtio_scsi_load_request
,
814 void virtio_scsi_common_realize(DeviceState
*dev
, Error
**errp
,
815 HandleOutput ctrl
, HandleOutput evt
,
818 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
819 VirtIOSCSICommon
*s
= VIRTIO_SCSI_COMMON(dev
);
822 virtio_init(vdev
, "virtio-scsi", VIRTIO_ID_SCSI
,
823 sizeof(VirtIOSCSIConfig
));
825 if (s
->conf
.num_queues
== 0 ||
826 s
->conf
.num_queues
> VIRTIO_PCI_QUEUE_MAX
- 2) {
827 error_setg(errp
, "Invalid number of queues (= %" PRIu32
"), "
828 "must be a positive integer less than %d.",
829 s
->conf
.num_queues
, VIRTIO_PCI_QUEUE_MAX
- 2);
830 virtio_cleanup(vdev
);
833 s
->cmd_vqs
= g_new0(VirtQueue
*, s
->conf
.num_queues
);
834 s
->sense_size
= VIRTIO_SCSI_SENSE_SIZE
;
835 s
->cdb_size
= VIRTIO_SCSI_CDB_SIZE
;
837 s
->ctrl_vq
= virtio_add_queue(vdev
, VIRTIO_SCSI_VQ_SIZE
,
839 s
->event_vq
= virtio_add_queue(vdev
, VIRTIO_SCSI_VQ_SIZE
,
841 for (i
= 0; i
< s
->conf
.num_queues
; i
++) {
842 s
->cmd_vqs
[i
] = virtio_add_queue(vdev
, VIRTIO_SCSI_VQ_SIZE
,
846 if (s
->conf
.iothread
) {
847 virtio_scsi_set_iothread(VIRTIO_SCSI(s
), s
->conf
.iothread
);
851 /* Disable dataplane thread during live migration since it does not
852 * update the dirty memory bitmap yet.
854 static void virtio_scsi_migration_state_changed(Notifier
*notifier
, void *data
)
856 VirtIOSCSI
*s
= container_of(notifier
, VirtIOSCSI
,
857 migration_state_notifier
);
858 MigrationState
*mig
= data
;
860 if (migration_in_setup(mig
)) {
861 if (!s
->dataplane_started
) {
864 virtio_scsi_dataplane_stop(s
);
865 s
->dataplane_disabled
= true;
866 } else if (migration_has_finished(mig
) ||
867 migration_has_failed(mig
)) {
868 if (s
->dataplane_started
) {
871 blk_drain_all(); /* complete in-flight non-dataplane requests */
872 s
->dataplane_disabled
= false;
876 static void virtio_scsi_device_realize(DeviceState
*dev
, Error
**errp
)
878 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
879 VirtIOSCSI
*s
= VIRTIO_SCSI(dev
);
880 static int virtio_scsi_id
;
883 virtio_scsi_common_realize(dev
, &err
, virtio_scsi_handle_ctrl
,
884 virtio_scsi_handle_event
,
885 virtio_scsi_handle_cmd
);
887 error_propagate(errp
, err
);
891 scsi_bus_new(&s
->bus
, sizeof(s
->bus
), dev
,
892 &virtio_scsi_scsi_info
, vdev
->bus_name
);
893 /* override default SCSI bus hotplug-handler, with virtio-scsi's one */
894 qbus_set_hotplug_handler(BUS(&s
->bus
), dev
, &error_abort
);
896 if (!dev
->hotplugged
) {
897 scsi_bus_legacy_handle_cmdline(&s
->bus
, &err
);
899 error_propagate(errp
, err
);
904 register_savevm(dev
, "virtio-scsi", virtio_scsi_id
++, 1,
905 virtio_scsi_save
, virtio_scsi_load
, s
);
906 s
->migration_state_notifier
.notify
= virtio_scsi_migration_state_changed
;
907 add_migration_state_change_notifier(&s
->migration_state_notifier
);
910 static void virtio_scsi_instance_init(Object
*obj
)
912 VirtIOSCSICommon
*vs
= VIRTIO_SCSI_COMMON(obj
);
914 object_property_add_link(obj
, "iothread", TYPE_IOTHREAD
,
915 (Object
**)&vs
->conf
.iothread
,
916 qdev_prop_allow_set_link_before_realize
,
917 OBJ_PROP_LINK_UNREF_ON_RELEASE
, &error_abort
);
920 void virtio_scsi_common_unrealize(DeviceState
*dev
, Error
**errp
)
922 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
923 VirtIOSCSICommon
*vs
= VIRTIO_SCSI_COMMON(dev
);
926 virtio_cleanup(vdev
);
929 static void virtio_scsi_device_unrealize(DeviceState
*dev
, Error
**errp
)
931 VirtIOSCSI
*s
= VIRTIO_SCSI(dev
);
933 unregister_savevm(dev
, "virtio-scsi", s
);
934 remove_migration_state_change_notifier(&s
->migration_state_notifier
);
936 virtio_scsi_common_unrealize(dev
, errp
);
939 static Property virtio_scsi_properties
[] = {
940 DEFINE_VIRTIO_SCSI_PROPERTIES(VirtIOSCSI
, parent_obj
.conf
),
941 DEFINE_PROP_END_OF_LIST(),
944 static void virtio_scsi_common_class_init(ObjectClass
*klass
, void *data
)
946 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_CLASS(klass
);
947 DeviceClass
*dc
= DEVICE_CLASS(klass
);
949 vdc
->get_config
= virtio_scsi_get_config
;
950 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
953 static void virtio_scsi_class_init(ObjectClass
*klass
, void *data
)
955 DeviceClass
*dc
= DEVICE_CLASS(klass
);
956 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_CLASS(klass
);
957 HotplugHandlerClass
*hc
= HOTPLUG_HANDLER_CLASS(klass
);
959 dc
->props
= virtio_scsi_properties
;
960 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
961 vdc
->realize
= virtio_scsi_device_realize
;
962 vdc
->unrealize
= virtio_scsi_device_unrealize
;
963 vdc
->set_config
= virtio_scsi_set_config
;
964 vdc
->get_features
= virtio_scsi_get_features
;
965 vdc
->reset
= virtio_scsi_reset
;
966 hc
->plug
= virtio_scsi_hotplug
;
967 hc
->unplug
= virtio_scsi_hotunplug
;
970 static const TypeInfo virtio_scsi_common_info
= {
971 .name
= TYPE_VIRTIO_SCSI_COMMON
,
972 .parent
= TYPE_VIRTIO_DEVICE
,
973 .instance_size
= sizeof(VirtIOSCSICommon
),
975 .class_init
= virtio_scsi_common_class_init
,
978 static const TypeInfo virtio_scsi_info
= {
979 .name
= TYPE_VIRTIO_SCSI
,
980 .parent
= TYPE_VIRTIO_SCSI_COMMON
,
981 .instance_size
= sizeof(VirtIOSCSI
),
982 .instance_init
= virtio_scsi_instance_init
,
983 .class_init
= virtio_scsi_class_init
,
984 .interfaces
= (InterfaceInfo
[]) {
985 { TYPE_HOTPLUG_HANDLER
},
990 static void virtio_register_types(void)
992 type_register_static(&virtio_scsi_common_info
);
993 type_register_static(&virtio_scsi_info
);
996 type_init(virtio_register_types
)