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