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 "qemu/osdep.h"
17 #include "qapi/error.h"
18 #include "standard-headers/linux/virtio_ids.h"
19 #include "hw/virtio/virtio-scsi.h"
20 #include "qemu/error-report.h"
22 #include "sysemu/block-backend.h"
23 #include "hw/scsi/scsi.h"
24 #include "block/scsi.h"
25 #include "hw/virtio/virtio-bus.h"
26 #include "hw/virtio/virtio-access.h"
28 static inline int virtio_scsi_get_lun(uint8_t *lun
)
30 return ((lun
[2] << 8) | lun
[3]) & 0x3FFF;
33 static inline SCSIDevice
*virtio_scsi_device_find(VirtIOSCSI
*s
, uint8_t *lun
)
38 if (lun
[2] != 0 && !(lun
[2] >= 0x40 && lun
[2] < 0x80)) {
41 return scsi_device_find(&s
->bus
, 0, lun
[1], virtio_scsi_get_lun(lun
));
44 void virtio_scsi_init_req(VirtIOSCSI
*s
, VirtQueue
*vq
, VirtIOSCSIReq
*req
)
46 VirtIODevice
*vdev
= VIRTIO_DEVICE(s
);
47 const size_t zero_skip
=
48 offsetof(VirtIOSCSIReq
, resp_iov
) + sizeof(req
->resp_iov
);
52 qemu_sglist_init(&req
->qsgl
, DEVICE(s
), 8, vdev
->dma_as
);
53 qemu_iovec_init(&req
->resp_iov
, 1);
54 memset((uint8_t *)req
+ zero_skip
, 0, sizeof(*req
) - zero_skip
);
57 void virtio_scsi_free_req(VirtIOSCSIReq
*req
)
59 qemu_iovec_destroy(&req
->resp_iov
);
60 qemu_sglist_destroy(&req
->qsgl
);
64 static void virtio_scsi_complete_req(VirtIOSCSIReq
*req
)
66 VirtIOSCSI
*s
= req
->dev
;
67 VirtQueue
*vq
= req
->vq
;
68 VirtIODevice
*vdev
= VIRTIO_DEVICE(s
);
70 qemu_iovec_from_buf(&req
->resp_iov
, 0, &req
->resp
, req
->resp_size
);
71 virtqueue_push(vq
, &req
->elem
, req
->qsgl
.size
+ req
->resp_iov
.size
);
72 if (s
->dataplane_started
&& !s
->dataplane_fenced
) {
73 virtio_notify_irqfd(vdev
, vq
);
75 virtio_notify(vdev
, vq
);
79 req
->sreq
->hba_private
= NULL
;
80 scsi_req_unref(req
->sreq
);
82 virtio_scsi_free_req(req
);
85 static void virtio_scsi_bad_req(VirtIOSCSIReq
*req
)
87 virtio_error(VIRTIO_DEVICE(req
->dev
), "wrong size for virtio-scsi headers");
88 virtqueue_detach_element(req
->vq
, &req
->elem
, 0);
89 virtio_scsi_free_req(req
);
92 static size_t qemu_sgl_concat(VirtIOSCSIReq
*req
, struct iovec
*iov
,
93 hwaddr
*addr
, int num
, size_t skip
)
95 QEMUSGList
*qsgl
= &req
->qsgl
;
99 if (skip
>= iov
->iov_len
) {
100 skip
-= iov
->iov_len
;
102 qemu_sglist_add(qsgl
, *addr
+ skip
, iov
->iov_len
- skip
);
103 copied
+= iov
->iov_len
- skip
;
115 static int virtio_scsi_parse_req(VirtIOSCSIReq
*req
,
116 unsigned req_size
, unsigned resp_size
)
118 VirtIODevice
*vdev
= (VirtIODevice
*) req
->dev
;
119 size_t in_size
, out_size
;
121 if (iov_to_buf(req
->elem
.out_sg
, req
->elem
.out_num
, 0,
122 &req
->req
, req_size
) < req_size
) {
126 if (qemu_iovec_concat_iov(&req
->resp_iov
,
127 req
->elem
.in_sg
, req
->elem
.in_num
, 0,
128 resp_size
) < resp_size
) {
132 req
->resp_size
= resp_size
;
134 /* Old BIOSes left some padding by mistake after the req_size/resp_size.
135 * As a workaround, always consider the first buffer as the virtio-scsi
136 * request/response, making the payload start at the second element
139 * The actual length of the response header, stored in req->resp_size,
142 * TODO: always disable this workaround for virtio 1.0 devices.
144 if (!virtio_vdev_has_feature(vdev
, VIRTIO_F_ANY_LAYOUT
)) {
145 if (req
->elem
.out_num
) {
146 req_size
= req
->elem
.out_sg
[0].iov_len
;
148 if (req
->elem
.in_num
) {
149 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 VirtIOSCSICommon
*vs
= (VirtIOSCSICommon
*)s
;
178 req
= virtqueue_pop(vq
, sizeof(VirtIOSCSIReq
) + vs
->cdb_size
);
182 virtio_scsi_init_req(s
, vq
, req
);
186 static void virtio_scsi_save_request(QEMUFile
*f
, SCSIRequest
*sreq
)
188 VirtIOSCSIReq
*req
= sreq
->hba_private
;
189 VirtIOSCSICommon
*vs
= VIRTIO_SCSI_COMMON(req
->dev
);
190 uint32_t n
= virtio_get_queue_index(req
->vq
) - 2;
192 assert(n
< vs
->conf
.num_queues
);
193 qemu_put_be32s(f
, &n
);
194 qemu_put_virtqueue_element(f
, &req
->elem
);
197 static void *virtio_scsi_load_request(QEMUFile
*f
, SCSIRequest
*sreq
)
199 SCSIBus
*bus
= sreq
->bus
;
200 VirtIOSCSI
*s
= container_of(bus
, VirtIOSCSI
, bus
);
201 VirtIOSCSICommon
*vs
= VIRTIO_SCSI_COMMON(s
);
202 VirtIODevice
*vdev
= VIRTIO_DEVICE(s
);
206 qemu_get_be32s(f
, &n
);
207 assert(n
< vs
->conf
.num_queues
);
208 req
= qemu_get_virtqueue_element(vdev
, f
,
209 sizeof(VirtIOSCSIReq
) + vs
->cdb_size
);
210 virtio_scsi_init_req(s
, vs
->cmd_vqs
[n
], req
);
212 if (virtio_scsi_parse_req(req
, sizeof(VirtIOSCSICmdReq
) + vs
->cdb_size
,
213 sizeof(VirtIOSCSICmdResp
) + vs
->sense_size
) < 0) {
214 error_report("invalid SCSI request migration data");
220 if (req
->sreq
->cmd
.mode
!= SCSI_XFER_NONE
) {
221 assert(req
->sreq
->cmd
.mode
== req
->mode
);
228 VirtIOSCSIReq
*tmf_req
;
229 } VirtIOSCSICancelNotifier
;
231 static void virtio_scsi_cancel_notify(Notifier
*notifier
, void *data
)
233 VirtIOSCSICancelNotifier
*n
= container_of(notifier
,
234 VirtIOSCSICancelNotifier
,
237 if (--n
->tmf_req
->remaining
== 0) {
238 virtio_scsi_complete_req(n
->tmf_req
);
243 static inline void virtio_scsi_ctx_check(VirtIOSCSI
*s
, SCSIDevice
*d
)
245 if (s
->dataplane_started
&& d
&& blk_is_available(d
->conf
.blk
)) {
246 assert(blk_get_aio_context(d
->conf
.blk
) == s
->ctx
);
250 /* Return 0 if the request is ready to be completed and return to guest;
251 * -EINPROGRESS if the request is submitted and will be completed later, in the
252 * case of async cancellation. */
253 static int virtio_scsi_do_tmf(VirtIOSCSI
*s
, VirtIOSCSIReq
*req
)
255 SCSIDevice
*d
= virtio_scsi_device_find(s
, req
->req
.tmf
.lun
);
256 SCSIRequest
*r
, *next
;
261 virtio_scsi_ctx_check(s
, d
);
262 /* Here VIRTIO_SCSI_S_OK means "FUNCTION COMPLETE". */
263 req
->resp
.tmf
.response
= VIRTIO_SCSI_S_OK
;
265 virtio_tswap32s(VIRTIO_DEVICE(s
), &req
->req
.tmf
.subtype
);
266 switch (req
->req
.tmf
.subtype
) {
267 case VIRTIO_SCSI_T_TMF_ABORT_TASK
:
268 case VIRTIO_SCSI_T_TMF_QUERY_TASK
:
272 if (d
->lun
!= virtio_scsi_get_lun(req
->req
.tmf
.lun
)) {
275 QTAILQ_FOREACH_SAFE(r
, &d
->requests
, next
, next
) {
276 VirtIOSCSIReq
*cmd_req
= r
->hba_private
;
277 if (cmd_req
&& cmd_req
->req
.cmd
.tag
== req
->req
.tmf
.tag
) {
283 * Assert that the request has not been completed yet, we
284 * check for it in the loop above.
286 assert(r
->hba_private
);
287 if (req
->req
.tmf
.subtype
== VIRTIO_SCSI_T_TMF_QUERY_TASK
) {
288 /* "If the specified command is present in the task set, then
289 * return a service response set to FUNCTION SUCCEEDED".
291 req
->resp
.tmf
.response
= VIRTIO_SCSI_S_FUNCTION_SUCCEEDED
;
293 VirtIOSCSICancelNotifier
*notifier
;
296 notifier
= g_new(VirtIOSCSICancelNotifier
, 1);
297 notifier
->tmf_req
= req
;
298 notifier
->notifier
.notify
= virtio_scsi_cancel_notify
;
299 scsi_req_cancel_async(r
, ¬ifier
->notifier
);
305 case VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET
:
309 if (d
->lun
!= virtio_scsi_get_lun(req
->req
.tmf
.lun
)) {
313 qdev_reset_all(&d
->qdev
);
317 case VIRTIO_SCSI_T_TMF_ABORT_TASK_SET
:
318 case VIRTIO_SCSI_T_TMF_CLEAR_TASK_SET
:
319 case VIRTIO_SCSI_T_TMF_QUERY_TASK_SET
:
323 if (d
->lun
!= virtio_scsi_get_lun(req
->req
.tmf
.lun
)) {
327 /* Add 1 to "remaining" until virtio_scsi_do_tmf returns.
328 * This way, if the bus starts calling back to the notifiers
329 * even before we finish the loop, virtio_scsi_cancel_notify
330 * will not complete the TMF too early.
333 QTAILQ_FOREACH_SAFE(r
, &d
->requests
, next
, next
) {
334 if (r
->hba_private
) {
335 if (req
->req
.tmf
.subtype
== VIRTIO_SCSI_T_TMF_QUERY_TASK_SET
) {
336 /* "If there is any command present in the task set, then
337 * return a service response set to FUNCTION SUCCEEDED".
339 req
->resp
.tmf
.response
= VIRTIO_SCSI_S_FUNCTION_SUCCEEDED
;
342 VirtIOSCSICancelNotifier
*notifier
;
345 notifier
= g_new(VirtIOSCSICancelNotifier
, 1);
346 notifier
->notifier
.notify
= virtio_scsi_cancel_notify
;
347 notifier
->tmf_req
= req
;
348 scsi_req_cancel_async(r
, ¬ifier
->notifier
);
352 if (--req
->remaining
> 0) {
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
= SCSI_DEVICE(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
;
386 static void virtio_scsi_handle_ctrl_req(VirtIOSCSI
*s
, VirtIOSCSIReq
*req
)
388 VirtIODevice
*vdev
= (VirtIODevice
*)s
;
392 if (iov_to_buf(req
->elem
.out_sg
, req
->elem
.out_num
, 0,
393 &type
, sizeof(type
)) < sizeof(type
)) {
394 virtio_scsi_bad_req(req
);
398 virtio_tswap32s(vdev
, &type
);
399 if (type
== VIRTIO_SCSI_T_TMF
) {
400 if (virtio_scsi_parse_req(req
, sizeof(VirtIOSCSICtrlTMFReq
),
401 sizeof(VirtIOSCSICtrlTMFResp
)) < 0) {
402 virtio_scsi_bad_req(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(req
);
415 req
->resp
.an
.event_actual
= 0;
416 req
->resp
.an
.response
= VIRTIO_SCSI_S_OK
;
420 virtio_scsi_complete_req(req
);
422 assert(r
== -EINPROGRESS
);
426 bool virtio_scsi_handle_ctrl_vq(VirtIOSCSI
*s
, VirtQueue
*vq
)
429 bool progress
= false;
431 while ((req
= virtio_scsi_pop_req(s
, vq
))) {
433 virtio_scsi_handle_ctrl_req(s
, req
);
438 static void virtio_scsi_handle_ctrl(VirtIODevice
*vdev
, VirtQueue
*vq
)
440 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
443 virtio_device_start_ioeventfd(vdev
);
444 if (!s
->dataplane_fenced
) {
448 virtio_scsi_acquire(s
);
449 virtio_scsi_handle_ctrl_vq(s
, vq
);
450 virtio_scsi_release(s
);
453 static void virtio_scsi_complete_cmd_req(VirtIOSCSIReq
*req
)
455 /* Sense data is not in req->resp and is copied separately
456 * in virtio_scsi_command_complete.
458 req
->resp_size
= sizeof(VirtIOSCSICmdResp
);
459 virtio_scsi_complete_req(req
);
462 static void virtio_scsi_command_complete(SCSIRequest
*r
, uint32_t status
,
465 VirtIOSCSIReq
*req
= r
->hba_private
;
466 uint8_t sense
[SCSI_SENSE_BUF_SIZE
];
468 VirtIODevice
*vdev
= VIRTIO_DEVICE(req
->dev
);
470 if (r
->io_canceled
) {
474 req
->resp
.cmd
.response
= VIRTIO_SCSI_S_OK
;
475 req
->resp
.cmd
.status
= status
;
476 if (req
->resp
.cmd
.status
== GOOD
) {
477 req
->resp
.cmd
.resid
= virtio_tswap32(vdev
, resid
);
479 req
->resp
.cmd
.resid
= 0;
480 sense_len
= scsi_req_get_sense(r
, sense
, sizeof(sense
));
481 sense_len
= MIN(sense_len
, req
->resp_iov
.size
- sizeof(req
->resp
.cmd
));
482 qemu_iovec_from_buf(&req
->resp_iov
, sizeof(req
->resp
.cmd
),
484 req
->resp
.cmd
.sense_len
= virtio_tswap32(vdev
, sense_len
);
486 virtio_scsi_complete_cmd_req(req
);
489 static int virtio_scsi_parse_cdb(SCSIDevice
*dev
, SCSICommand
*cmd
,
490 uint8_t *buf
, void *hba_private
)
492 VirtIOSCSIReq
*req
= hba_private
;
495 cmd
->len
= MIN(VIRTIO_SCSI_CDB_DEFAULT_SIZE
, SCSI_CMD_BUF_SIZE
);
496 memcpy(cmd
->buf
, buf
, cmd
->len
);
499 /* Extract the direction and mode directly from the request, for
500 * host device passthrough.
502 cmd
->xfer
= req
->qsgl
.size
;
503 cmd
->mode
= req
->mode
;
507 static QEMUSGList
*virtio_scsi_get_sg_list(SCSIRequest
*r
)
509 VirtIOSCSIReq
*req
= r
->hba_private
;
514 static void virtio_scsi_request_cancelled(SCSIRequest
*r
)
516 VirtIOSCSIReq
*req
= r
->hba_private
;
521 if (req
->dev
->resetting
) {
522 req
->resp
.cmd
.response
= VIRTIO_SCSI_S_RESET
;
524 req
->resp
.cmd
.response
= VIRTIO_SCSI_S_ABORTED
;
526 virtio_scsi_complete_cmd_req(req
);
529 static void virtio_scsi_fail_cmd_req(VirtIOSCSIReq
*req
)
531 req
->resp
.cmd
.response
= VIRTIO_SCSI_S_FAILURE
;
532 virtio_scsi_complete_cmd_req(req
);
535 static int virtio_scsi_handle_cmd_req_prepare(VirtIOSCSI
*s
, VirtIOSCSIReq
*req
)
537 VirtIOSCSICommon
*vs
= &s
->parent_obj
;
541 rc
= virtio_scsi_parse_req(req
, sizeof(VirtIOSCSICmdReq
) + vs
->cdb_size
,
542 sizeof(VirtIOSCSICmdResp
) + vs
->sense_size
);
544 if (rc
== -ENOTSUP
) {
545 virtio_scsi_fail_cmd_req(req
);
548 virtio_scsi_bad_req(req
);
553 d
= virtio_scsi_device_find(s
, req
->req
.cmd
.lun
);
555 req
->resp
.cmd
.response
= VIRTIO_SCSI_S_BAD_TARGET
;
556 virtio_scsi_complete_cmd_req(req
);
559 virtio_scsi_ctx_check(s
, d
);
560 req
->sreq
= scsi_req_new(d
, req
->req
.cmd
.tag
,
561 virtio_scsi_get_lun(req
->req
.cmd
.lun
),
562 req
->req
.cmd
.cdb
, req
);
564 if (req
->sreq
->cmd
.mode
!= SCSI_XFER_NONE
565 && (req
->sreq
->cmd
.mode
!= req
->mode
||
566 req
->sreq
->cmd
.xfer
> req
->qsgl
.size
)) {
567 req
->resp
.cmd
.response
= VIRTIO_SCSI_S_OVERRUN
;
568 virtio_scsi_complete_cmd_req(req
);
571 scsi_req_ref(req
->sreq
);
572 blk_io_plug(d
->conf
.blk
);
576 static void virtio_scsi_handle_cmd_req_submit(VirtIOSCSI
*s
, VirtIOSCSIReq
*req
)
578 SCSIRequest
*sreq
= req
->sreq
;
579 if (scsi_req_enqueue(sreq
)) {
580 scsi_req_continue(sreq
);
582 blk_io_unplug(sreq
->dev
->conf
.blk
);
583 scsi_req_unref(sreq
);
586 bool virtio_scsi_handle_cmd_vq(VirtIOSCSI
*s
, VirtQueue
*vq
)
588 VirtIOSCSIReq
*req
, *next
;
590 bool progress
= false;
592 QTAILQ_HEAD(, VirtIOSCSIReq
) reqs
= QTAILQ_HEAD_INITIALIZER(reqs
);
595 virtio_queue_set_notification(vq
, 0);
597 while ((req
= virtio_scsi_pop_req(s
, vq
))) {
599 ret
= virtio_scsi_handle_cmd_req_prepare(s
, req
);
601 QTAILQ_INSERT_TAIL(&reqs
, req
, next
);
602 } else if (ret
== -EINVAL
) {
603 /* The device is broken and shouldn't process any request */
604 while (!QTAILQ_EMPTY(&reqs
)) {
605 req
= QTAILQ_FIRST(&reqs
);
606 QTAILQ_REMOVE(&reqs
, req
, next
);
607 blk_io_unplug(req
->sreq
->dev
->conf
.blk
);
608 scsi_req_unref(req
->sreq
);
609 virtqueue_detach_element(req
->vq
, &req
->elem
, 0);
610 virtio_scsi_free_req(req
);
615 virtio_queue_set_notification(vq
, 1);
616 } while (ret
!= -EINVAL
&& !virtio_queue_empty(vq
));
618 QTAILQ_FOREACH_SAFE(req
, &reqs
, next
, next
) {
619 virtio_scsi_handle_cmd_req_submit(s
, req
);
624 static void virtio_scsi_handle_cmd(VirtIODevice
*vdev
, VirtQueue
*vq
)
626 /* use non-QOM casts in the data path */
627 VirtIOSCSI
*s
= (VirtIOSCSI
*)vdev
;
630 virtio_device_start_ioeventfd(vdev
);
631 if (!s
->dataplane_fenced
) {
635 virtio_scsi_acquire(s
);
636 virtio_scsi_handle_cmd_vq(s
, vq
);
637 virtio_scsi_release(s
);
640 static void virtio_scsi_get_config(VirtIODevice
*vdev
,
643 VirtIOSCSIConfig
*scsiconf
= (VirtIOSCSIConfig
*)config
;
644 VirtIOSCSICommon
*s
= VIRTIO_SCSI_COMMON(vdev
);
646 virtio_stl_p(vdev
, &scsiconf
->num_queues
, s
->conf
.num_queues
);
647 virtio_stl_p(vdev
, &scsiconf
->seg_max
, 128 - 2);
648 virtio_stl_p(vdev
, &scsiconf
->max_sectors
, s
->conf
.max_sectors
);
649 virtio_stl_p(vdev
, &scsiconf
->cmd_per_lun
, s
->conf
.cmd_per_lun
);
650 virtio_stl_p(vdev
, &scsiconf
->event_info_size
, sizeof(VirtIOSCSIEvent
));
651 virtio_stl_p(vdev
, &scsiconf
->sense_size
, s
->sense_size
);
652 virtio_stl_p(vdev
, &scsiconf
->cdb_size
, s
->cdb_size
);
653 virtio_stw_p(vdev
, &scsiconf
->max_channel
, VIRTIO_SCSI_MAX_CHANNEL
);
654 virtio_stw_p(vdev
, &scsiconf
->max_target
, VIRTIO_SCSI_MAX_TARGET
);
655 virtio_stl_p(vdev
, &scsiconf
->max_lun
, VIRTIO_SCSI_MAX_LUN
);
658 static void virtio_scsi_set_config(VirtIODevice
*vdev
,
659 const uint8_t *config
)
661 VirtIOSCSIConfig
*scsiconf
= (VirtIOSCSIConfig
*)config
;
662 VirtIOSCSICommon
*vs
= VIRTIO_SCSI_COMMON(vdev
);
664 if ((uint32_t) virtio_ldl_p(vdev
, &scsiconf
->sense_size
) >= 65536 ||
665 (uint32_t) virtio_ldl_p(vdev
, &scsiconf
->cdb_size
) >= 256) {
667 "bad data written to virtio-scsi configuration space");
671 vs
->sense_size
= virtio_ldl_p(vdev
, &scsiconf
->sense_size
);
672 vs
->cdb_size
= virtio_ldl_p(vdev
, &scsiconf
->cdb_size
);
675 static uint64_t virtio_scsi_get_features(VirtIODevice
*vdev
,
676 uint64_t requested_features
,
679 VirtIOSCSI
*s
= VIRTIO_SCSI(vdev
);
681 /* Firstly sync all virtio-scsi possible supported features */
682 requested_features
|= s
->host_features
;
683 return requested_features
;
686 static void virtio_scsi_reset(VirtIODevice
*vdev
)
688 VirtIOSCSI
*s
= VIRTIO_SCSI(vdev
);
689 VirtIOSCSICommon
*vs
= VIRTIO_SCSI_COMMON(vdev
);
691 assert(!s
->dataplane_started
);
693 qbus_reset_all(&s
->bus
.qbus
);
696 vs
->sense_size
= VIRTIO_SCSI_SENSE_DEFAULT_SIZE
;
697 vs
->cdb_size
= VIRTIO_SCSI_CDB_DEFAULT_SIZE
;
698 s
->events_dropped
= false;
701 void virtio_scsi_push_event(VirtIOSCSI
*s
, SCSIDevice
*dev
,
702 uint32_t event
, uint32_t reason
)
704 VirtIOSCSICommon
*vs
= VIRTIO_SCSI_COMMON(s
);
706 VirtIOSCSIEvent
*evt
;
707 VirtIODevice
*vdev
= VIRTIO_DEVICE(s
);
709 if (!(vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
713 req
= virtio_scsi_pop_req(s
, vs
->event_vq
);
715 s
->events_dropped
= true;
719 if (s
->events_dropped
) {
720 event
|= VIRTIO_SCSI_T_EVENTS_MISSED
;
721 s
->events_dropped
= false;
724 if (virtio_scsi_parse_req(req
, 0, sizeof(VirtIOSCSIEvent
))) {
725 virtio_scsi_bad_req(req
);
729 evt
= &req
->resp
.event
;
730 memset(evt
, 0, sizeof(VirtIOSCSIEvent
));
731 evt
->event
= virtio_tswap32(vdev
, event
);
732 evt
->reason
= virtio_tswap32(vdev
, reason
);
734 assert(event
== VIRTIO_SCSI_T_EVENTS_MISSED
);
737 evt
->lun
[1] = dev
->id
;
739 /* Linux wants us to keep the same encoding we use for REPORT LUNS. */
740 if (dev
->lun
>= 256) {
741 evt
->lun
[2] = (dev
->lun
>> 8) | 0x40;
743 evt
->lun
[3] = dev
->lun
& 0xFF;
745 virtio_scsi_complete_req(req
);
748 bool virtio_scsi_handle_event_vq(VirtIOSCSI
*s
, VirtQueue
*vq
)
750 if (s
->events_dropped
) {
751 virtio_scsi_push_event(s
, NULL
, VIRTIO_SCSI_T_NO_EVENT
, 0);
757 static void virtio_scsi_handle_event(VirtIODevice
*vdev
, VirtQueue
*vq
)
759 VirtIOSCSI
*s
= VIRTIO_SCSI(vdev
);
762 virtio_device_start_ioeventfd(vdev
);
763 if (!s
->dataplane_fenced
) {
767 virtio_scsi_acquire(s
);
768 virtio_scsi_handle_event_vq(s
, vq
);
769 virtio_scsi_release(s
);
772 static void virtio_scsi_change(SCSIBus
*bus
, SCSIDevice
*dev
, SCSISense sense
)
774 VirtIOSCSI
*s
= container_of(bus
, VirtIOSCSI
, bus
);
775 VirtIODevice
*vdev
= VIRTIO_DEVICE(s
);
777 if (virtio_vdev_has_feature(vdev
, VIRTIO_SCSI_F_CHANGE
) &&
778 dev
->type
!= TYPE_ROM
) {
779 virtio_scsi_acquire(s
);
780 virtio_scsi_push_event(s
, dev
, VIRTIO_SCSI_T_PARAM_CHANGE
,
781 sense
.asc
| (sense
.ascq
<< 8));
782 virtio_scsi_release(s
);
786 static void virtio_scsi_hotplug(HotplugHandler
*hotplug_dev
, DeviceState
*dev
,
789 VirtIODevice
*vdev
= VIRTIO_DEVICE(hotplug_dev
);
790 VirtIOSCSI
*s
= VIRTIO_SCSI(vdev
);
791 SCSIDevice
*sd
= SCSI_DEVICE(dev
);
793 if (s
->ctx
&& !s
->dataplane_fenced
) {
794 if (blk_op_is_blocked(sd
->conf
.blk
, BLOCK_OP_TYPE_DATAPLANE
, errp
)) {
797 virtio_scsi_acquire(s
);
798 blk_set_aio_context(sd
->conf
.blk
, s
->ctx
);
799 virtio_scsi_release(s
);
803 if (virtio_vdev_has_feature(vdev
, VIRTIO_SCSI_F_HOTPLUG
)) {
804 virtio_scsi_acquire(s
);
805 virtio_scsi_push_event(s
, sd
,
806 VIRTIO_SCSI_T_TRANSPORT_RESET
,
807 VIRTIO_SCSI_EVT_RESET_RESCAN
);
808 virtio_scsi_release(s
);
812 static void virtio_scsi_hotunplug(HotplugHandler
*hotplug_dev
, DeviceState
*dev
,
815 VirtIODevice
*vdev
= VIRTIO_DEVICE(hotplug_dev
);
816 VirtIOSCSI
*s
= VIRTIO_SCSI(vdev
);
817 SCSIDevice
*sd
= SCSI_DEVICE(dev
);
819 if (virtio_vdev_has_feature(vdev
, VIRTIO_SCSI_F_HOTPLUG
)) {
820 virtio_scsi_acquire(s
);
821 virtio_scsi_push_event(s
, sd
,
822 VIRTIO_SCSI_T_TRANSPORT_RESET
,
823 VIRTIO_SCSI_EVT_RESET_REMOVED
);
824 virtio_scsi_release(s
);
827 qdev_simple_device_unplug_cb(hotplug_dev
, dev
, errp
);
830 static struct SCSIBusInfo virtio_scsi_scsi_info
= {
832 .max_channel
= VIRTIO_SCSI_MAX_CHANNEL
,
833 .max_target
= VIRTIO_SCSI_MAX_TARGET
,
834 .max_lun
= VIRTIO_SCSI_MAX_LUN
,
836 .complete
= virtio_scsi_command_complete
,
837 .cancel
= virtio_scsi_request_cancelled
,
838 .change
= virtio_scsi_change
,
839 .parse_cdb
= virtio_scsi_parse_cdb
,
840 .get_sg_list
= virtio_scsi_get_sg_list
,
841 .save_request
= virtio_scsi_save_request
,
842 .load_request
= virtio_scsi_load_request
,
845 void virtio_scsi_common_realize(DeviceState
*dev
,
846 VirtIOHandleOutput ctrl
,
847 VirtIOHandleOutput evt
,
848 VirtIOHandleOutput cmd
,
851 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
852 VirtIOSCSICommon
*s
= VIRTIO_SCSI_COMMON(dev
);
855 virtio_init(vdev
, "virtio-scsi", VIRTIO_ID_SCSI
,
856 sizeof(VirtIOSCSIConfig
));
858 if (s
->conf
.num_queues
== 0 ||
859 s
->conf
.num_queues
> VIRTIO_QUEUE_MAX
- 2) {
860 error_setg(errp
, "Invalid number of queues (= %" PRIu32
"), "
861 "must be a positive integer less than %d.",
862 s
->conf
.num_queues
, VIRTIO_QUEUE_MAX
- 2);
863 virtio_cleanup(vdev
);
866 s
->cmd_vqs
= g_new0(VirtQueue
*, s
->conf
.num_queues
);
867 s
->sense_size
= VIRTIO_SCSI_SENSE_DEFAULT_SIZE
;
868 s
->cdb_size
= VIRTIO_SCSI_CDB_DEFAULT_SIZE
;
870 s
->ctrl_vq
= virtio_add_queue(vdev
, VIRTIO_SCSI_VQ_SIZE
, ctrl
);
871 s
->event_vq
= virtio_add_queue(vdev
, VIRTIO_SCSI_VQ_SIZE
, evt
);
872 for (i
= 0; i
< s
->conf
.num_queues
; i
++) {
873 s
->cmd_vqs
[i
] = virtio_add_queue(vdev
, VIRTIO_SCSI_VQ_SIZE
, cmd
);
877 static void virtio_scsi_device_realize(DeviceState
*dev
, Error
**errp
)
879 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
880 VirtIOSCSI
*s
= VIRTIO_SCSI(dev
);
883 virtio_scsi_common_realize(dev
,
884 virtio_scsi_handle_ctrl
,
885 virtio_scsi_handle_event
,
886 virtio_scsi_handle_cmd
,
889 error_propagate(errp
, err
);
893 scsi_bus_new(&s
->bus
, sizeof(s
->bus
), dev
,
894 &virtio_scsi_scsi_info
, vdev
->bus_name
);
895 /* override default SCSI bus hotplug-handler, with virtio-scsi's one */
896 qbus_set_hotplug_handler(BUS(&s
->bus
), dev
, &error_abort
);
898 virtio_scsi_dataplane_setup(s
, errp
);
901 static void virtio_scsi_instance_init(Object
*obj
)
903 VirtIOSCSICommon
*vs
= VIRTIO_SCSI_COMMON(obj
);
905 object_property_add_link(obj
, "iothread", TYPE_IOTHREAD
,
906 (Object
**)&vs
->conf
.iothread
,
907 qdev_prop_allow_set_link_before_realize
,
908 OBJ_PROP_LINK_UNREF_ON_RELEASE
, &error_abort
);
911 void virtio_scsi_common_unrealize(DeviceState
*dev
, Error
**errp
)
913 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
914 VirtIOSCSICommon
*vs
= VIRTIO_SCSI_COMMON(dev
);
917 virtio_cleanup(vdev
);
920 static void virtio_scsi_device_unrealize(DeviceState
*dev
, Error
**errp
)
922 VirtIOSCSI
*s
= VIRTIO_SCSI(dev
);
924 qbus_set_hotplug_handler(BUS(&s
->bus
), NULL
, &error_abort
);
925 virtio_scsi_common_unrealize(dev
, errp
);
928 static Property virtio_scsi_properties
[] = {
929 DEFINE_PROP_UINT32("num_queues", VirtIOSCSI
, parent_obj
.conf
.num_queues
, 1),
930 DEFINE_PROP_UINT32("max_sectors", VirtIOSCSI
, parent_obj
.conf
.max_sectors
,
932 DEFINE_PROP_UINT32("cmd_per_lun", VirtIOSCSI
, parent_obj
.conf
.cmd_per_lun
,
934 DEFINE_PROP_BIT("hotplug", VirtIOSCSI
, host_features
,
935 VIRTIO_SCSI_F_HOTPLUG
, true),
936 DEFINE_PROP_BIT("param_change", VirtIOSCSI
, host_features
,
937 VIRTIO_SCSI_F_CHANGE
, true),
938 DEFINE_PROP_END_OF_LIST(),
941 static const VMStateDescription vmstate_virtio_scsi
= {
942 .name
= "virtio-scsi",
943 .minimum_version_id
= 1,
945 .fields
= (VMStateField
[]) {
946 VMSTATE_VIRTIO_DEVICE
,
947 VMSTATE_END_OF_LIST()
951 static void virtio_scsi_common_class_init(ObjectClass
*klass
, void *data
)
953 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_CLASS(klass
);
954 DeviceClass
*dc
= DEVICE_CLASS(klass
);
956 vdc
->get_config
= virtio_scsi_get_config
;
957 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
960 static void virtio_scsi_class_init(ObjectClass
*klass
, void *data
)
962 DeviceClass
*dc
= DEVICE_CLASS(klass
);
963 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_CLASS(klass
);
964 HotplugHandlerClass
*hc
= HOTPLUG_HANDLER_CLASS(klass
);
966 dc
->props
= virtio_scsi_properties
;
967 dc
->vmsd
= &vmstate_virtio_scsi
;
968 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
969 vdc
->realize
= virtio_scsi_device_realize
;
970 vdc
->unrealize
= virtio_scsi_device_unrealize
;
971 vdc
->set_config
= virtio_scsi_set_config
;
972 vdc
->get_features
= virtio_scsi_get_features
;
973 vdc
->reset
= virtio_scsi_reset
;
974 vdc
->start_ioeventfd
= virtio_scsi_dataplane_start
;
975 vdc
->stop_ioeventfd
= virtio_scsi_dataplane_stop
;
976 hc
->plug
= virtio_scsi_hotplug
;
977 hc
->unplug
= virtio_scsi_hotunplug
;
980 static const TypeInfo virtio_scsi_common_info
= {
981 .name
= TYPE_VIRTIO_SCSI_COMMON
,
982 .parent
= TYPE_VIRTIO_DEVICE
,
983 .instance_size
= sizeof(VirtIOSCSICommon
),
985 .class_init
= virtio_scsi_common_class_init
,
988 static const TypeInfo virtio_scsi_info
= {
989 .name
= TYPE_VIRTIO_SCSI
,
990 .parent
= TYPE_VIRTIO_SCSI_COMMON
,
991 .instance_size
= sizeof(VirtIOSCSI
),
992 .instance_init
= virtio_scsi_instance_init
,
993 .class_init
= virtio_scsi_class_init
,
994 .interfaces
= (InterfaceInfo
[]) {
995 { TYPE_HOTPLUG_HANDLER
},
1000 static void virtio_register_types(void)
1002 type_register_static(&virtio_scsi_common_info
);
1003 type_register_static(&virtio_scsi_info
);
1006 type_init(virtio_register_types
)