1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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 "migration/qemu-file-types.h"
21#include "qemu/error-report.h"
22#include "qemu/iov.h"
23#include "qemu/module.h"
24#include "sysemu/block-backend.h"
25#include "hw/qdev-properties.h"
26#include "hw/scsi/scsi.h"
27#include "scsi/constants.h"
28#include "hw/virtio/virtio-bus.h"
29#include "hw/virtio/virtio-access.h"
30
31static inline int virtio_scsi_get_lun(uint8_t *lun)
32{
33 return ((lun[2] << 8) | lun[3]) & 0x3FFF;
34}
35
36static inline SCSIDevice *virtio_scsi_device_find(VirtIOSCSI *s, uint8_t *lun)
37{
38 if (lun[0] != 1) {
39 return NULL;
40 }
41 if (lun[2] != 0 && !(lun[2] >= 0x40 && lun[2] < 0x80)) {
42 return NULL;
43 }
44 return scsi_device_find(&s->bus, 0, lun[1], virtio_scsi_get_lun(lun));
45}
46
47void virtio_scsi_init_req(VirtIOSCSI *s, VirtQueue *vq, VirtIOSCSIReq *req)
48{
49 VirtIODevice *vdev = VIRTIO_DEVICE(s);
50 const size_t zero_skip =
51 offsetof(VirtIOSCSIReq, resp_iov) + sizeof(req->resp_iov);
52
53 req->vq = vq;
54 req->dev = s;
55 qemu_sglist_init(&req->qsgl, DEVICE(s), 8, vdev->dma_as);
56 qemu_iovec_init(&req->resp_iov, 1);
57 memset((uint8_t *)req + zero_skip, 0, sizeof(*req) - zero_skip);
58}
59
60void virtio_scsi_free_req(VirtIOSCSIReq *req)
61{
62 qemu_iovec_destroy(&req->resp_iov);
63 qemu_sglist_destroy(&req->qsgl);
64 g_free(req);
65}
66
67static void virtio_scsi_complete_req(VirtIOSCSIReq *req)
68{
69 VirtIOSCSI *s = req->dev;
70 VirtQueue *vq = req->vq;
71 VirtIODevice *vdev = VIRTIO_DEVICE(s);
72
73 qemu_iovec_from_buf(&req->resp_iov, 0, &req->resp, req->resp_size);
74 virtqueue_push(vq, &req->elem, req->qsgl.size + req->resp_iov.size);
75 if (s->dataplane_started && !s->dataplane_fenced) {
76 virtio_notify_irqfd(vdev, vq);
77 } else {
78 virtio_notify(vdev, vq);
79 }
80
81 if (req->sreq) {
82 req->sreq->hba_private = NULL;
83 scsi_req_unref(req->sreq);
84 }
85 virtio_scsi_free_req(req);
86}
87
88static void virtio_scsi_bad_req(VirtIOSCSIReq *req)
89{
90 virtio_error(VIRTIO_DEVICE(req->dev), "wrong size for virtio-scsi headers");
91 virtqueue_detach_element(req->vq, &req->elem, 0);
92 virtio_scsi_free_req(req);
93}
94
95static size_t qemu_sgl_concat(VirtIOSCSIReq *req, struct iovec *iov,
96 hwaddr *addr, int num, size_t skip)
97{
98 QEMUSGList *qsgl = &req->qsgl;
99 size_t copied = 0;
100
101 while (num) {
102 if (skip >= iov->iov_len) {
103 skip -= iov->iov_len;
104 } else {
105 qemu_sglist_add(qsgl, *addr + skip, iov->iov_len - skip);
106 copied += iov->iov_len - skip;
107 skip = 0;
108 }
109 iov++;
110 addr++;
111 num--;
112 }
113
114 assert(skip == 0);
115 return copied;
116}
117
118static int virtio_scsi_parse_req(VirtIOSCSIReq *req,
119 unsigned req_size, unsigned resp_size)
120{
121 VirtIODevice *vdev = (VirtIODevice *) req->dev;
122 size_t in_size, out_size;
123
124 if (iov_to_buf(req->elem.out_sg, req->elem.out_num, 0,
125 &req->req, req_size) < req_size) {
126 return -EINVAL;
127 }
128
129 if (qemu_iovec_concat_iov(&req->resp_iov,
130 req->elem.in_sg, req->elem.in_num, 0,
131 resp_size) < resp_size) {
132 return -EINVAL;
133 }
134
135 req->resp_size = resp_size;
136
137
138
139
140
141
142
143
144
145
146
147 if (!virtio_vdev_has_feature(vdev, VIRTIO_F_ANY_LAYOUT)) {
148 if (req->elem.out_num) {
149 req_size = req->elem.out_sg[0].iov_len;
150 }
151 if (req->elem.in_num) {
152 resp_size = req->elem.in_sg[0].iov_len;
153 }
154 }
155
156 out_size = qemu_sgl_concat(req, req->elem.out_sg,
157 &req->elem.out_addr[0], req->elem.out_num,
158 req_size);
159 in_size = qemu_sgl_concat(req, req->elem.in_sg,
160 &req->elem.in_addr[0], req->elem.in_num,
161 resp_size);
162
163 if (out_size && in_size) {
164 return -ENOTSUP;
165 }
166
167 if (out_size) {
168 req->mode = SCSI_XFER_TO_DEV;
169 } else if (in_size) {
170 req->mode = SCSI_XFER_FROM_DEV;
171 }
172
173 return 0;
174}
175
176static VirtIOSCSIReq *virtio_scsi_pop_req(VirtIOSCSI *s, VirtQueue *vq)
177{
178 VirtIOSCSICommon *vs = (VirtIOSCSICommon *)s;
179 VirtIOSCSIReq *req;
180
181 req = virtqueue_pop(vq, sizeof(VirtIOSCSIReq) + vs->cdb_size);
182 if (!req) {
183 return NULL;
184 }
185 virtio_scsi_init_req(s, vq, req);
186 return req;
187}
188
189static void virtio_scsi_save_request(QEMUFile *f, SCSIRequest *sreq)
190{
191 VirtIOSCSIReq *req = sreq->hba_private;
192 VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(req->dev);
193 VirtIODevice *vdev = VIRTIO_DEVICE(req->dev);
194 uint32_t n = virtio_get_queue_index(req->vq) - 2;
195
196 assert(n < vs->conf.num_queues);
197 qemu_put_be32s(f, &n);
198 qemu_put_virtqueue_element(vdev, f, &req->elem);
199}
200
201static void *virtio_scsi_load_request(QEMUFile *f, SCSIRequest *sreq)
202{
203 SCSIBus *bus = sreq->bus;
204 VirtIOSCSI *s = container_of(bus, VirtIOSCSI, bus);
205 VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);
206 VirtIODevice *vdev = VIRTIO_DEVICE(s);
207 VirtIOSCSIReq *req;
208 uint32_t n;
209
210 qemu_get_be32s(f, &n);
211 assert(n < vs->conf.num_queues);
212 req = qemu_get_virtqueue_element(vdev, f,
213 sizeof(VirtIOSCSIReq) + vs->cdb_size);
214 virtio_scsi_init_req(s, vs->cmd_vqs[n], req);
215
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");
219 exit(1);
220 }
221
222 scsi_req_ref(sreq);
223 req->sreq = sreq;
224 if (req->sreq->cmd.mode != SCSI_XFER_NONE) {
225 assert(req->sreq->cmd.mode == req->mode);
226 }
227 return req;
228}
229
230typedef struct {
231 Notifier notifier;
232 VirtIOSCSIReq *tmf_req;
233} VirtIOSCSICancelNotifier;
234
235static void virtio_scsi_cancel_notify(Notifier *notifier, void *data)
236{
237 VirtIOSCSICancelNotifier *n = container_of(notifier,
238 VirtIOSCSICancelNotifier,
239 notifier);
240
241 if (--n->tmf_req->remaining == 0) {
242 virtio_scsi_complete_req(n->tmf_req);
243 }
244 g_free(n);
245}
246
247static inline void virtio_scsi_ctx_check(VirtIOSCSI *s, SCSIDevice *d)
248{
249 if (s->dataplane_started && d && blk_is_available(d->conf.blk)) {
250 assert(blk_get_aio_context(d->conf.blk) == s->ctx);
251 }
252}
253
254
255
256
257static int virtio_scsi_do_tmf(VirtIOSCSI *s, VirtIOSCSIReq *req)
258{
259 SCSIDevice *d = virtio_scsi_device_find(s, req->req.tmf.lun);
260 SCSIRequest *r, *next;
261 BusChild *kid;
262 int target;
263 int ret = 0;
264
265 virtio_scsi_ctx_check(s, d);
266
267 req->resp.tmf.response = VIRTIO_SCSI_S_OK;
268
269
270
271
272
273 req->req.tmf.subtype =
274 virtio_tswap32(VIRTIO_DEVICE(s), req->req.tmf.subtype);
275
276 switch (req->req.tmf.subtype) {
277 case VIRTIO_SCSI_T_TMF_ABORT_TASK:
278 case VIRTIO_SCSI_T_TMF_QUERY_TASK:
279 if (!d) {
280 goto fail;
281 }
282 if (d->lun != virtio_scsi_get_lun(req->req.tmf.lun)) {
283 goto incorrect_lun;
284 }
285 QTAILQ_FOREACH_SAFE(r, &d->requests, next, next) {
286 VirtIOSCSIReq *cmd_req = r->hba_private;
287 if (cmd_req && cmd_req->req.cmd.tag == req->req.tmf.tag) {
288 break;
289 }
290 }
291 if (r) {
292
293
294
295
296 assert(r->hba_private);
297 if (req->req.tmf.subtype == VIRTIO_SCSI_T_TMF_QUERY_TASK) {
298
299
300
301 req->resp.tmf.response = VIRTIO_SCSI_S_FUNCTION_SUCCEEDED;
302 } else {
303 VirtIOSCSICancelNotifier *notifier;
304
305 req->remaining = 1;
306 notifier = g_new(VirtIOSCSICancelNotifier, 1);
307 notifier->tmf_req = req;
308 notifier->notifier.notify = virtio_scsi_cancel_notify;
309 scsi_req_cancel_async(r, ¬ifier->notifier);
310 ret = -EINPROGRESS;
311 }
312 }
313 break;
314
315 case VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET:
316 if (!d) {
317 goto fail;
318 }
319 if (d->lun != virtio_scsi_get_lun(req->req.tmf.lun)) {
320 goto incorrect_lun;
321 }
322 s->resetting++;
323 qdev_reset_all(&d->qdev);
324 s->resetting--;
325 break;
326
327 case VIRTIO_SCSI_T_TMF_ABORT_TASK_SET:
328 case VIRTIO_SCSI_T_TMF_CLEAR_TASK_SET:
329 case VIRTIO_SCSI_T_TMF_QUERY_TASK_SET:
330 if (!d) {
331 goto fail;
332 }
333 if (d->lun != virtio_scsi_get_lun(req->req.tmf.lun)) {
334 goto incorrect_lun;
335 }
336
337
338
339
340
341
342 req->remaining = 1;
343 QTAILQ_FOREACH_SAFE(r, &d->requests, next, next) {
344 if (r->hba_private) {
345 if (req->req.tmf.subtype == VIRTIO_SCSI_T_TMF_QUERY_TASK_SET) {
346
347
348
349 req->resp.tmf.response = VIRTIO_SCSI_S_FUNCTION_SUCCEEDED;
350 break;
351 } else {
352 VirtIOSCSICancelNotifier *notifier;
353
354 req->remaining++;
355 notifier = g_new(VirtIOSCSICancelNotifier, 1);
356 notifier->notifier.notify = virtio_scsi_cancel_notify;
357 notifier->tmf_req = req;
358 scsi_req_cancel_async(r, ¬ifier->notifier);
359 }
360 }
361 }
362 if (--req->remaining > 0) {
363 ret = -EINPROGRESS;
364 }
365 break;
366
367 case VIRTIO_SCSI_T_TMF_I_T_NEXUS_RESET:
368 target = req->req.tmf.lun[1];
369 s->resetting++;
370 QTAILQ_FOREACH(kid, &s->bus.qbus.children, sibling) {
371 d = SCSI_DEVICE(kid->child);
372 if (d->channel == 0 && d->id == target) {
373 qdev_reset_all(&d->qdev);
374 }
375 }
376 s->resetting--;
377 break;
378
379 case VIRTIO_SCSI_T_TMF_CLEAR_ACA:
380 default:
381 req->resp.tmf.response = VIRTIO_SCSI_S_FUNCTION_REJECTED;
382 break;
383 }
384
385 return ret;
386
387incorrect_lun:
388 req->resp.tmf.response = VIRTIO_SCSI_S_INCORRECT_LUN;
389 return ret;
390
391fail:
392 req->resp.tmf.response = VIRTIO_SCSI_S_BAD_TARGET;
393 return ret;
394}
395
396static void virtio_scsi_handle_ctrl_req(VirtIOSCSI *s, VirtIOSCSIReq *req)
397{
398 VirtIODevice *vdev = (VirtIODevice *)s;
399 uint32_t type;
400 int r = 0;
401
402 if (iov_to_buf(req->elem.out_sg, req->elem.out_num, 0,
403 &type, sizeof(type)) < sizeof(type)) {
404 virtio_scsi_bad_req(req);
405 return;
406 }
407
408 virtio_tswap32s(vdev, &type);
409 if (type == VIRTIO_SCSI_T_TMF) {
410 if (virtio_scsi_parse_req(req, sizeof(VirtIOSCSICtrlTMFReq),
411 sizeof(VirtIOSCSICtrlTMFResp)) < 0) {
412 virtio_scsi_bad_req(req);
413 return;
414 } else {
415 r = virtio_scsi_do_tmf(s, req);
416 }
417
418 } else if (type == VIRTIO_SCSI_T_AN_QUERY ||
419 type == VIRTIO_SCSI_T_AN_SUBSCRIBE) {
420 if (virtio_scsi_parse_req(req, sizeof(VirtIOSCSICtrlANReq),
421 sizeof(VirtIOSCSICtrlANResp)) < 0) {
422 virtio_scsi_bad_req(req);
423 return;
424 } else {
425 req->resp.an.event_actual = 0;
426 req->resp.an.response = VIRTIO_SCSI_S_OK;
427 }
428 }
429 if (r == 0) {
430 virtio_scsi_complete_req(req);
431 } else {
432 assert(r == -EINPROGRESS);
433 }
434}
435
436bool virtio_scsi_handle_ctrl_vq(VirtIOSCSI *s, VirtQueue *vq)
437{
438 VirtIOSCSIReq *req;
439 bool progress = false;
440
441 while ((req = virtio_scsi_pop_req(s, vq))) {
442 progress = true;
443 virtio_scsi_handle_ctrl_req(s, req);
444 }
445 return progress;
446}
447
448static void virtio_scsi_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
449{
450 VirtIOSCSI *s = (VirtIOSCSI *)vdev;
451
452 if (s->ctx) {
453 virtio_device_start_ioeventfd(vdev);
454 if (!s->dataplane_fenced) {
455 return;
456 }
457 }
458 virtio_scsi_acquire(s);
459 virtio_scsi_handle_ctrl_vq(s, vq);
460 virtio_scsi_release(s);
461}
462
463static void virtio_scsi_complete_cmd_req(VirtIOSCSIReq *req)
464{
465
466
467
468 req->resp_size = sizeof(VirtIOSCSICmdResp);
469 virtio_scsi_complete_req(req);
470}
471
472static void virtio_scsi_command_complete(SCSIRequest *r, uint32_t status,
473 size_t resid)
474{
475 VirtIOSCSIReq *req = r->hba_private;
476 uint8_t sense[SCSI_SENSE_BUF_SIZE];
477 uint32_t sense_len;
478 VirtIODevice *vdev = VIRTIO_DEVICE(req->dev);
479
480 if (r->io_canceled) {
481 return;
482 }
483
484 req->resp.cmd.response = VIRTIO_SCSI_S_OK;
485 req->resp.cmd.status = status;
486 if (req->resp.cmd.status == GOOD) {
487 req->resp.cmd.resid = virtio_tswap32(vdev, resid);
488 } else {
489 req->resp.cmd.resid = 0;
490 sense_len = scsi_req_get_sense(r, sense, sizeof(sense));
491 sense_len = MIN(sense_len, req->resp_iov.size - sizeof(req->resp.cmd));
492 qemu_iovec_from_buf(&req->resp_iov, sizeof(req->resp.cmd),
493 sense, sense_len);
494 req->resp.cmd.sense_len = virtio_tswap32(vdev, sense_len);
495 }
496 virtio_scsi_complete_cmd_req(req);
497}
498
499static int virtio_scsi_parse_cdb(SCSIDevice *dev, SCSICommand *cmd,
500 uint8_t *buf, void *hba_private)
501{
502 VirtIOSCSIReq *req = hba_private;
503
504 if (cmd->len == 0) {
505 cmd->len = MIN(VIRTIO_SCSI_CDB_DEFAULT_SIZE, SCSI_CMD_BUF_SIZE);
506 memcpy(cmd->buf, buf, cmd->len);
507 }
508
509
510
511
512 cmd->xfer = req->qsgl.size;
513 cmd->mode = req->mode;
514 return 0;
515}
516
517static QEMUSGList *virtio_scsi_get_sg_list(SCSIRequest *r)
518{
519 VirtIOSCSIReq *req = r->hba_private;
520
521 return &req->qsgl;
522}
523
524static void virtio_scsi_request_cancelled(SCSIRequest *r)
525{
526 VirtIOSCSIReq *req = r->hba_private;
527
528 if (!req) {
529 return;
530 }
531 if (req->dev->resetting) {
532 req->resp.cmd.response = VIRTIO_SCSI_S_RESET;
533 } else {
534 req->resp.cmd.response = VIRTIO_SCSI_S_ABORTED;
535 }
536 virtio_scsi_complete_cmd_req(req);
537}
538
539static void virtio_scsi_fail_cmd_req(VirtIOSCSIReq *req)
540{
541 req->resp.cmd.response = VIRTIO_SCSI_S_FAILURE;
542 virtio_scsi_complete_cmd_req(req);
543}
544
545static int virtio_scsi_handle_cmd_req_prepare(VirtIOSCSI *s, VirtIOSCSIReq *req)
546{
547 VirtIOSCSICommon *vs = &s->parent_obj;
548 SCSIDevice *d;
549 int rc;
550
551 rc = virtio_scsi_parse_req(req, sizeof(VirtIOSCSICmdReq) + vs->cdb_size,
552 sizeof(VirtIOSCSICmdResp) + vs->sense_size);
553 if (rc < 0) {
554 if (rc == -ENOTSUP) {
555 virtio_scsi_fail_cmd_req(req);
556 return -ENOTSUP;
557 } else {
558 virtio_scsi_bad_req(req);
559 return -EINVAL;
560 }
561 }
562
563 d = virtio_scsi_device_find(s, req->req.cmd.lun);
564 if (!d) {
565 req->resp.cmd.response = VIRTIO_SCSI_S_BAD_TARGET;
566 virtio_scsi_complete_cmd_req(req);
567 return -ENOENT;
568 }
569 virtio_scsi_ctx_check(s, d);
570 req->sreq = scsi_req_new(d, req->req.cmd.tag,
571 virtio_scsi_get_lun(req->req.cmd.lun),
572 req->req.cmd.cdb, req);
573
574 if (req->sreq->cmd.mode != SCSI_XFER_NONE
575 && (req->sreq->cmd.mode != req->mode ||
576 req->sreq->cmd.xfer > req->qsgl.size)) {
577 req->resp.cmd.response = VIRTIO_SCSI_S_OVERRUN;
578 virtio_scsi_complete_cmd_req(req);
579 return -ENOBUFS;
580 }
581 scsi_req_ref(req->sreq);
582 blk_io_plug(d->conf.blk);
583 return 0;
584}
585
586static void virtio_scsi_handle_cmd_req_submit(VirtIOSCSI *s, VirtIOSCSIReq *req)
587{
588 SCSIRequest *sreq = req->sreq;
589 if (scsi_req_enqueue(sreq)) {
590 scsi_req_continue(sreq);
591 }
592 blk_io_unplug(sreq->dev->conf.blk);
593 scsi_req_unref(sreq);
594}
595
596bool virtio_scsi_handle_cmd_vq(VirtIOSCSI *s, VirtQueue *vq)
597{
598 VirtIOSCSIReq *req, *next;
599 int ret = 0;
600 bool progress = false;
601
602 QTAILQ_HEAD(, VirtIOSCSIReq) reqs = QTAILQ_HEAD_INITIALIZER(reqs);
603
604 do {
605 virtio_queue_set_notification(vq, 0);
606
607 while ((req = virtio_scsi_pop_req(s, vq))) {
608 progress = true;
609 ret = virtio_scsi_handle_cmd_req_prepare(s, req);
610 if (!ret) {
611 QTAILQ_INSERT_TAIL(&reqs, req, next);
612 } else if (ret == -EINVAL) {
613
614 while (!QTAILQ_EMPTY(&reqs)) {
615 req = QTAILQ_FIRST(&reqs);
616 QTAILQ_REMOVE(&reqs, req, next);
617 blk_io_unplug(req->sreq->dev->conf.blk);
618 scsi_req_unref(req->sreq);
619 virtqueue_detach_element(req->vq, &req->elem, 0);
620 virtio_scsi_free_req(req);
621 }
622 }
623 }
624
625 virtio_queue_set_notification(vq, 1);
626 } while (ret != -EINVAL && !virtio_queue_empty(vq));
627
628 QTAILQ_FOREACH_SAFE(req, &reqs, next, next) {
629 virtio_scsi_handle_cmd_req_submit(s, req);
630 }
631 return progress;
632}
633
634static void virtio_scsi_handle_cmd(VirtIODevice *vdev, VirtQueue *vq)
635{
636
637 VirtIOSCSI *s = (VirtIOSCSI *)vdev;
638
639 if (s->ctx) {
640 virtio_device_start_ioeventfd(vdev);
641 if (!s->dataplane_fenced) {
642 return;
643 }
644 }
645 virtio_scsi_acquire(s);
646 virtio_scsi_handle_cmd_vq(s, vq);
647 virtio_scsi_release(s);
648}
649
650static void virtio_scsi_get_config(VirtIODevice *vdev,
651 uint8_t *config)
652{
653 VirtIOSCSIConfig *scsiconf = (VirtIOSCSIConfig *)config;
654 VirtIOSCSICommon *s = VIRTIO_SCSI_COMMON(vdev);
655
656 virtio_stl_p(vdev, &scsiconf->num_queues, s->conf.num_queues);
657 virtio_stl_p(vdev, &scsiconf->seg_max, 128 - 2);
658 virtio_stl_p(vdev, &scsiconf->max_sectors, s->conf.max_sectors);
659 virtio_stl_p(vdev, &scsiconf->cmd_per_lun, s->conf.cmd_per_lun);
660 virtio_stl_p(vdev, &scsiconf->event_info_size, sizeof(VirtIOSCSIEvent));
661 virtio_stl_p(vdev, &scsiconf->sense_size, s->sense_size);
662 virtio_stl_p(vdev, &scsiconf->cdb_size, s->cdb_size);
663 virtio_stw_p(vdev, &scsiconf->max_channel, VIRTIO_SCSI_MAX_CHANNEL);
664 virtio_stw_p(vdev, &scsiconf->max_target, VIRTIO_SCSI_MAX_TARGET);
665 virtio_stl_p(vdev, &scsiconf->max_lun, VIRTIO_SCSI_MAX_LUN);
666}
667
668static void virtio_scsi_set_config(VirtIODevice *vdev,
669 const uint8_t *config)
670{
671 VirtIOSCSIConfig *scsiconf = (VirtIOSCSIConfig *)config;
672 VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
673
674 if ((uint32_t) virtio_ldl_p(vdev, &scsiconf->sense_size) >= 65536 ||
675 (uint32_t) virtio_ldl_p(vdev, &scsiconf->cdb_size) >= 256) {
676 virtio_error(vdev,
677 "bad data written to virtio-scsi configuration space");
678 return;
679 }
680
681 vs->sense_size = virtio_ldl_p(vdev, &scsiconf->sense_size);
682 vs->cdb_size = virtio_ldl_p(vdev, &scsiconf->cdb_size);
683}
684
685static uint64_t virtio_scsi_get_features(VirtIODevice *vdev,
686 uint64_t requested_features,
687 Error **errp)
688{
689 VirtIOSCSI *s = VIRTIO_SCSI(vdev);
690
691
692 requested_features |= s->host_features;
693 return requested_features;
694}
695
696static void virtio_scsi_reset(VirtIODevice *vdev)
697{
698 VirtIOSCSI *s = VIRTIO_SCSI(vdev);
699 VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
700
701 assert(!s->dataplane_started);
702 s->resetting++;
703 qbus_reset_all(BUS(&s->bus));
704 s->resetting--;
705
706 vs->sense_size = VIRTIO_SCSI_SENSE_DEFAULT_SIZE;
707 vs->cdb_size = VIRTIO_SCSI_CDB_DEFAULT_SIZE;
708 s->events_dropped = false;
709}
710
711void virtio_scsi_push_event(VirtIOSCSI *s, SCSIDevice *dev,
712 uint32_t event, uint32_t reason)
713{
714 VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);
715 VirtIOSCSIReq *req;
716 VirtIOSCSIEvent *evt;
717 VirtIODevice *vdev = VIRTIO_DEVICE(s);
718
719 if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
720 return;
721 }
722
723 req = virtio_scsi_pop_req(s, vs->event_vq);
724 if (!req) {
725 s->events_dropped = true;
726 return;
727 }
728
729 if (s->events_dropped) {
730 event |= VIRTIO_SCSI_T_EVENTS_MISSED;
731 s->events_dropped = false;
732 }
733
734 if (virtio_scsi_parse_req(req, 0, sizeof(VirtIOSCSIEvent))) {
735 virtio_scsi_bad_req(req);
736 return;
737 }
738
739 evt = &req->resp.event;
740 memset(evt, 0, sizeof(VirtIOSCSIEvent));
741 evt->event = virtio_tswap32(vdev, event);
742 evt->reason = virtio_tswap32(vdev, reason);
743 if (!dev) {
744 assert(event == VIRTIO_SCSI_T_EVENTS_MISSED);
745 } else {
746 evt->lun[0] = 1;
747 evt->lun[1] = dev->id;
748
749
750 if (dev->lun >= 256) {
751 evt->lun[2] = (dev->lun >> 8) | 0x40;
752 }
753 evt->lun[3] = dev->lun & 0xFF;
754 }
755 virtio_scsi_complete_req(req);
756}
757
758bool virtio_scsi_handle_event_vq(VirtIOSCSI *s, VirtQueue *vq)
759{
760 if (s->events_dropped) {
761 virtio_scsi_push_event(s, NULL, VIRTIO_SCSI_T_NO_EVENT, 0);
762 return true;
763 }
764 return false;
765}
766
767static void virtio_scsi_handle_event(VirtIODevice *vdev, VirtQueue *vq)
768{
769 VirtIOSCSI *s = VIRTIO_SCSI(vdev);
770
771 if (s->ctx) {
772 virtio_device_start_ioeventfd(vdev);
773 if (!s->dataplane_fenced) {
774 return;
775 }
776 }
777 virtio_scsi_acquire(s);
778 virtio_scsi_handle_event_vq(s, vq);
779 virtio_scsi_release(s);
780}
781
782static void virtio_scsi_change(SCSIBus *bus, SCSIDevice *dev, SCSISense sense)
783{
784 VirtIOSCSI *s = container_of(bus, VirtIOSCSI, bus);
785 VirtIODevice *vdev = VIRTIO_DEVICE(s);
786
787 if (virtio_vdev_has_feature(vdev, VIRTIO_SCSI_F_CHANGE) &&
788 dev->type != TYPE_ROM) {
789 virtio_scsi_acquire(s);
790 virtio_scsi_push_event(s, dev, VIRTIO_SCSI_T_PARAM_CHANGE,
791 sense.asc | (sense.ascq << 8));
792 virtio_scsi_release(s);
793 }
794}
795
796static void virtio_scsi_pre_hotplug(HotplugHandler *hotplug_dev,
797 DeviceState *dev, Error **errp)
798{
799 SCSIDevice *sd = SCSI_DEVICE(dev);
800 sd->hba_supports_iothread = true;
801}
802
803static void virtio_scsi_hotplug(HotplugHandler *hotplug_dev, DeviceState *dev,
804 Error **errp)
805{
806 VirtIODevice *vdev = VIRTIO_DEVICE(hotplug_dev);
807 VirtIOSCSI *s = VIRTIO_SCSI(vdev);
808 SCSIDevice *sd = SCSI_DEVICE(dev);
809 int ret;
810
811 if (s->ctx && !s->dataplane_fenced) {
812 if (blk_op_is_blocked(sd->conf.blk, BLOCK_OP_TYPE_DATAPLANE, errp)) {
813 return;
814 }
815 virtio_scsi_acquire(s);
816 ret = blk_set_aio_context(sd->conf.blk, s->ctx, errp);
817 virtio_scsi_release(s);
818 if (ret < 0) {
819 return;
820 }
821 }
822
823 if (virtio_vdev_has_feature(vdev, VIRTIO_SCSI_F_HOTPLUG)) {
824 virtio_scsi_acquire(s);
825 virtio_scsi_push_event(s, sd,
826 VIRTIO_SCSI_T_TRANSPORT_RESET,
827 VIRTIO_SCSI_EVT_RESET_RESCAN);
828 virtio_scsi_release(s);
829 }
830}
831
832static void virtio_scsi_hotunplug(HotplugHandler *hotplug_dev, DeviceState *dev,
833 Error **errp)
834{
835 VirtIODevice *vdev = VIRTIO_DEVICE(hotplug_dev);
836 VirtIOSCSI *s = VIRTIO_SCSI(vdev);
837 SCSIDevice *sd = SCSI_DEVICE(dev);
838 AioContext *ctx = s->ctx ?: qemu_get_aio_context();
839
840 if (virtio_vdev_has_feature(vdev, VIRTIO_SCSI_F_HOTPLUG)) {
841 virtio_scsi_acquire(s);
842 virtio_scsi_push_event(s, sd,
843 VIRTIO_SCSI_T_TRANSPORT_RESET,
844 VIRTIO_SCSI_EVT_RESET_REMOVED);
845 virtio_scsi_release(s);
846 }
847
848 aio_disable_external(ctx);
849 qdev_simple_device_unplug_cb(hotplug_dev, dev, errp);
850 aio_enable_external(ctx);
851
852 if (s->ctx) {
853 virtio_scsi_acquire(s);
854
855 blk_set_aio_context(sd->conf.blk, qemu_get_aio_context(), NULL);
856 virtio_scsi_release(s);
857 }
858}
859
860static struct SCSIBusInfo virtio_scsi_scsi_info = {
861 .tcq = true,
862 .max_channel = VIRTIO_SCSI_MAX_CHANNEL,
863 .max_target = VIRTIO_SCSI_MAX_TARGET,
864 .max_lun = VIRTIO_SCSI_MAX_LUN,
865
866 .complete = virtio_scsi_command_complete,
867 .cancel = virtio_scsi_request_cancelled,
868 .change = virtio_scsi_change,
869 .parse_cdb = virtio_scsi_parse_cdb,
870 .get_sg_list = virtio_scsi_get_sg_list,
871 .save_request = virtio_scsi_save_request,
872 .load_request = virtio_scsi_load_request,
873};
874
875void virtio_scsi_common_realize(DeviceState *dev,
876 VirtIOHandleOutput ctrl,
877 VirtIOHandleOutput evt,
878 VirtIOHandleOutput cmd,
879 Error **errp)
880{
881 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
882 VirtIOSCSICommon *s = VIRTIO_SCSI_COMMON(dev);
883 int i;
884
885 virtio_init(vdev, "virtio-scsi", VIRTIO_ID_SCSI,
886 sizeof(VirtIOSCSIConfig));
887
888 if (s->conf.num_queues == 0 ||
889 s->conf.num_queues > VIRTIO_QUEUE_MAX - 2) {
890 error_setg(errp, "Invalid number of queues (= %" PRIu32 "), "
891 "must be a positive integer less than %d.",
892 s->conf.num_queues, VIRTIO_QUEUE_MAX - 2);
893 virtio_cleanup(vdev);
894 return;
895 }
896 s->cmd_vqs = g_new0(VirtQueue *, s->conf.num_queues);
897 s->sense_size = VIRTIO_SCSI_SENSE_DEFAULT_SIZE;
898 s->cdb_size = VIRTIO_SCSI_CDB_DEFAULT_SIZE;
899
900 s->ctrl_vq = virtio_add_queue(vdev, s->conf.virtqueue_size, ctrl);
901 s->event_vq = virtio_add_queue(vdev, s->conf.virtqueue_size, evt);
902 for (i = 0; i < s->conf.num_queues; i++) {
903 s->cmd_vqs[i] = virtio_add_queue(vdev, s->conf.virtqueue_size, cmd);
904 }
905}
906
907static void virtio_scsi_device_realize(DeviceState *dev, Error **errp)
908{
909 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
910 VirtIOSCSI *s = VIRTIO_SCSI(dev);
911 Error *err = NULL;
912
913 virtio_scsi_common_realize(dev,
914 virtio_scsi_handle_ctrl,
915 virtio_scsi_handle_event,
916 virtio_scsi_handle_cmd,
917 &err);
918 if (err != NULL) {
919 error_propagate(errp, err);
920 return;
921 }
922
923 scsi_bus_new(&s->bus, sizeof(s->bus), dev,
924 &virtio_scsi_scsi_info, vdev->bus_name);
925
926 qbus_set_hotplug_handler(BUS(&s->bus), OBJECT(dev), &error_abort);
927
928 virtio_scsi_dataplane_setup(s, errp);
929}
930
931void virtio_scsi_common_unrealize(DeviceState *dev)
932{
933 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
934 VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(dev);
935
936 g_free(vs->cmd_vqs);
937 virtio_cleanup(vdev);
938}
939
940static void virtio_scsi_device_unrealize(DeviceState *dev, Error **errp)
941{
942 VirtIOSCSI *s = VIRTIO_SCSI(dev);
943
944 qbus_set_hotplug_handler(BUS(&s->bus), NULL, &error_abort);
945 virtio_scsi_common_unrealize(dev);
946}
947
948static Property virtio_scsi_properties[] = {
949 DEFINE_PROP_UINT32("num_queues", VirtIOSCSI, parent_obj.conf.num_queues, 1),
950 DEFINE_PROP_UINT32("virtqueue_size", VirtIOSCSI,
951 parent_obj.conf.virtqueue_size, 128),
952 DEFINE_PROP_UINT32("max_sectors", VirtIOSCSI, parent_obj.conf.max_sectors,
953 0xFFFF),
954 DEFINE_PROP_UINT32("cmd_per_lun", VirtIOSCSI, parent_obj.conf.cmd_per_lun,
955 128),
956 DEFINE_PROP_BIT("hotplug", VirtIOSCSI, host_features,
957 VIRTIO_SCSI_F_HOTPLUG, true),
958 DEFINE_PROP_BIT("param_change", VirtIOSCSI, host_features,
959 VIRTIO_SCSI_F_CHANGE, true),
960 DEFINE_PROP_LINK("iothread", VirtIOSCSI, parent_obj.conf.iothread,
961 TYPE_IOTHREAD, IOThread *),
962 DEFINE_PROP_END_OF_LIST(),
963};
964
965static const VMStateDescription vmstate_virtio_scsi = {
966 .name = "virtio-scsi",
967 .minimum_version_id = 1,
968 .version_id = 1,
969 .fields = (VMStateField[]) {
970 VMSTATE_VIRTIO_DEVICE,
971 VMSTATE_END_OF_LIST()
972 },
973};
974
975static void virtio_scsi_common_class_init(ObjectClass *klass, void *data)
976{
977 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
978 DeviceClass *dc = DEVICE_CLASS(klass);
979
980 vdc->get_config = virtio_scsi_get_config;
981 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
982}
983
984static void virtio_scsi_class_init(ObjectClass *klass, void *data)
985{
986 DeviceClass *dc = DEVICE_CLASS(klass);
987 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
988 HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(klass);
989
990 dc->props = virtio_scsi_properties;
991 dc->vmsd = &vmstate_virtio_scsi;
992 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
993 vdc->realize = virtio_scsi_device_realize;
994 vdc->unrealize = virtio_scsi_device_unrealize;
995 vdc->set_config = virtio_scsi_set_config;
996 vdc->get_features = virtio_scsi_get_features;
997 vdc->reset = virtio_scsi_reset;
998 vdc->start_ioeventfd = virtio_scsi_dataplane_start;
999 vdc->stop_ioeventfd = virtio_scsi_dataplane_stop;
1000 hc->pre_plug = virtio_scsi_pre_hotplug;
1001 hc->plug = virtio_scsi_hotplug;
1002 hc->unplug = virtio_scsi_hotunplug;
1003}
1004
1005static const TypeInfo virtio_scsi_common_info = {
1006 .name = TYPE_VIRTIO_SCSI_COMMON,
1007 .parent = TYPE_VIRTIO_DEVICE,
1008 .instance_size = sizeof(VirtIOSCSICommon),
1009 .abstract = true,
1010 .class_init = virtio_scsi_common_class_init,
1011};
1012
1013static const TypeInfo virtio_scsi_info = {
1014 .name = TYPE_VIRTIO_SCSI,
1015 .parent = TYPE_VIRTIO_SCSI_COMMON,
1016 .instance_size = sizeof(VirtIOSCSI),
1017 .class_init = virtio_scsi_class_init,
1018 .interfaces = (InterfaceInfo[]) {
1019 { TYPE_HOTPLUG_HANDLER },
1020 { }
1021 }
1022};
1023
1024static void virtio_register_types(void)
1025{
1026 type_register_static(&virtio_scsi_common_info);
1027 type_register_static(&virtio_scsi_info);
1028}
1029
1030type_init(virtio_register_types)
1031
