1 /*
2  * Virtio SCSI dataplane
3  *
4  * Copyright Red Hat, Inc. 2014
5  *
6  * Authors:
7  *   Fam Zheng <famz@redhat.com>
8  *
9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
10  * See the COPYING file in the top-level directory.
11  *
12  */
13 
14 #include "qemu/osdep.h"
15 #include "hw/virtio/virtio-scsi.h"
16 #include "qemu/error-report.h"
17 #include "sysemu/block-backend.h"
18 #include <hw/scsi/scsi.h>
19 #include <block/scsi.h>
20 #include <hw/virtio/virtio-bus.h>
21 #include "hw/virtio/virtio-access.h"
22 
23 /* Context: QEMU global mutex held */
24 void virtio_scsi_set_iothread(VirtIOSCSI *s, IOThread *iothread)
25 {
26     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s)));
27     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
28     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);
29 
30     assert(!s->ctx);
31     s->ctx = iothread_get_aio_context(vs->conf.iothread);
32 
33     /* Don't try if transport does not support notifiers. */
34     if (!k->set_guest_notifiers || !k->set_host_notifier) {
35         fprintf(stderr, "virtio-scsi: Failed to set iothread "
36                    "(transport does not support notifiers)");
37         exit(1);
38     }
39 }
40 
41 static void virtio_scsi_data_plane_handle_cmd(VirtIODevice *vdev,
42                                               VirtQueue *vq)
43 {
44     VirtIOSCSI *s = (VirtIOSCSI *)vdev;
45 
46     assert(s->ctx && s->dataplane_started);
47     virtio_scsi_handle_cmd_vq(s, vq);
48 }
49 
50 static void virtio_scsi_data_plane_handle_ctrl(VirtIODevice *vdev,
51                                                VirtQueue *vq)
52 {
53     VirtIOSCSI *s = VIRTIO_SCSI(vdev);
54 
55     assert(s->ctx && s->dataplane_started);
56     virtio_scsi_handle_ctrl_vq(s, vq);
57 }
58 
59 static void virtio_scsi_data_plane_handle_event(VirtIODevice *vdev,
60                                                 VirtQueue *vq)
61 {
62     VirtIOSCSI *s = VIRTIO_SCSI(vdev);
63 
64     assert(s->ctx && s->dataplane_started);
65     virtio_scsi_handle_event_vq(s, vq);
66 }
67 
68 static int virtio_scsi_vring_init(VirtIOSCSI *s, VirtQueue *vq, int n,
69                                   void (*fn)(VirtIODevice *vdev, VirtQueue *vq))
70 {
71     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s)));
72     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
73     int rc;
74 
75     /* Set up virtqueue notify */
76     rc = k->set_host_notifier(qbus->parent, n, true);
77     if (rc != 0) {
78         fprintf(stderr, "virtio-scsi: Failed to set host notifier (%d)\n",
79                 rc);
80         s->dataplane_fenced = true;
81         return rc;
82     }
83 
84     virtio_queue_aio_set_host_notifier_handler(vq, s->ctx, fn);
85     return 0;
86 }
87 
88 void virtio_scsi_dataplane_notify(VirtIODevice *vdev, VirtIOSCSIReq *req)
89 {
90     if (virtio_should_notify(vdev, req->vq)) {
91         event_notifier_set(virtio_queue_get_guest_notifier(req->vq));
92     }
93 }
94 
95 /* assumes s->ctx held */
96 static void virtio_scsi_clear_aio(VirtIOSCSI *s)
97 {
98     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);
99     int i;
100 
101     virtio_queue_aio_set_host_notifier_handler(vs->ctrl_vq, s->ctx, NULL);
102     virtio_queue_aio_set_host_notifier_handler(vs->event_vq, s->ctx, NULL);
103     for (i = 0; i < vs->conf.num_queues; i++) {
104         virtio_queue_aio_set_host_notifier_handler(vs->cmd_vqs[i], s->ctx, NULL);
105     }
106 }
107 
108 /* Context: QEMU global mutex held */
109 void virtio_scsi_dataplane_start(VirtIOSCSI *s)
110 {
111     int i;
112     int rc;
113     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s)));
114     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
115     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);
116 
117     if (s->dataplane_started ||
118         s->dataplane_starting ||
119         s->dataplane_fenced ||
120         s->ctx != iothread_get_aio_context(vs->conf.iothread)) {
121         return;
122     }
123 
124     s->dataplane_starting = true;
125 
126     /* Set up guest notifier (irq) */
127     rc = k->set_guest_notifiers(qbus->parent, vs->conf.num_queues + 2, true);
128     if (rc != 0) {
129         fprintf(stderr, "virtio-scsi: Failed to set guest notifiers (%d), "
130                 "ensure -enable-kvm is set\n", rc);
131         goto fail_guest_notifiers;
132     }
133 
134     aio_context_acquire(s->ctx);
135     rc = virtio_scsi_vring_init(s, vs->ctrl_vq, 0,
136                                 virtio_scsi_data_plane_handle_ctrl);
137     if (rc) {
138         goto fail_vrings;
139     }
140     rc = virtio_scsi_vring_init(s, vs->event_vq, 1,
141                                 virtio_scsi_data_plane_handle_event);
142     if (rc) {
143         goto fail_vrings;
144     }
145     for (i = 0; i < vs->conf.num_queues; i++) {
146         rc = virtio_scsi_vring_init(s, vs->cmd_vqs[i], i + 2,
147                                     virtio_scsi_data_plane_handle_cmd);
148         if (rc) {
149             goto fail_vrings;
150         }
151     }
152 
153     s->dataplane_starting = false;
154     s->dataplane_started = true;
155     aio_context_release(s->ctx);
156     return;
157 
158 fail_vrings:
159     virtio_scsi_clear_aio(s);
160     aio_context_release(s->ctx);
161     for (i = 0; i < vs->conf.num_queues + 2; i++) {
162         k->set_host_notifier(qbus->parent, i, false);
163     }
164     k->set_guest_notifiers(qbus->parent, vs->conf.num_queues + 2, false);
165 fail_guest_notifiers:
166     s->dataplane_fenced = true;
167     s->dataplane_starting = false;
168     s->dataplane_started = true;
169 }
170 
171 /* Context: QEMU global mutex held */
172 void virtio_scsi_dataplane_stop(VirtIOSCSI *s)
173 {
174     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s)));
175     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
176     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);
177     int i;
178 
179     if (!s->dataplane_started || s->dataplane_stopping) {
180         return;
181     }
182 
183     /* Better luck next time. */
184     if (s->dataplane_fenced) {
185         s->dataplane_fenced = false;
186         s->dataplane_started = false;
187         return;
188     }
189     s->dataplane_stopping = true;
190     assert(s->ctx == iothread_get_aio_context(vs->conf.iothread));
191 
192     aio_context_acquire(s->ctx);
193 
194     virtio_scsi_clear_aio(s);
195 
196     blk_drain_all(); /* ensure there are no in-flight requests */
197 
198     aio_context_release(s->ctx);
199 
200     for (i = 0; i < vs->conf.num_queues + 2; i++) {
201         k->set_host_notifier(qbus->parent, i, false);
202     }
203 
204     /* Clean up guest notifier (irq) */
205     k->set_guest_notifiers(qbus->parent, vs->conf.num_queues + 2, false);
206     s->dataplane_stopping = false;
207     s->dataplane_started = false;
208 }
209