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 "hw/virtio/virtio-scsi.h"
15 #include "qemu/error-report.h"
16 #include "sysemu/block-backend.h"
17 #include <hw/scsi/scsi.h>
18 #include <block/scsi.h>
19 #include <hw/virtio/virtio-bus.h>
20 #include "hw/virtio/virtio-access.h"
21 #include "stdio.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 VirtIOSCSIVring *virtio_scsi_vring_init(VirtIOSCSI *s,
42                                                VirtQueue *vq,
43                                                EventNotifierHandler *handler,
44                                                int n)
45 {
46     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s)));
47     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
48     VirtIOSCSIVring *r;
49     int rc;
50 
51     /* Set up virtqueue notify */
52     rc = k->set_host_notifier(qbus->parent, n, true);
53     if (rc != 0) {
54         fprintf(stderr, "virtio-scsi: Failed to set host notifier (%d)\n",
55                 rc);
56         s->dataplane_fenced = true;
57         return NULL;
58     }
59 
60     r = g_slice_new(VirtIOSCSIVring);
61     r->host_notifier = *virtio_queue_get_host_notifier(vq);
62     r->guest_notifier = *virtio_queue_get_guest_notifier(vq);
63     aio_set_event_notifier(s->ctx, &r->host_notifier, handler);
64 
65     r->parent = s;
66 
67     if (!vring_setup(&r->vring, VIRTIO_DEVICE(s), n)) {
68         fprintf(stderr, "virtio-scsi: VRing setup failed\n");
69         goto fail_vring;
70     }
71     return r;
72 
73 fail_vring:
74     aio_set_event_notifier(s->ctx, &r->host_notifier, NULL);
75     k->set_host_notifier(qbus->parent, n, false);
76     g_slice_free(VirtIOSCSIVring, r);
77     return NULL;
78 }
79 
80 VirtIOSCSIReq *virtio_scsi_pop_req_vring(VirtIOSCSI *s,
81                                          VirtIOSCSIVring *vring)
82 {
83     VirtIOSCSIReq *req = virtio_scsi_init_req(s, NULL);
84     int r;
85 
86     req->vring = vring;
87     r = vring_pop((VirtIODevice *)s, &vring->vring, &req->elem);
88     if (r < 0) {
89         virtio_scsi_free_req(req);
90         req = NULL;
91     }
92     return req;
93 }
94 
95 void virtio_scsi_vring_push_notify(VirtIOSCSIReq *req)
96 {
97     VirtIODevice *vdev = VIRTIO_DEVICE(req->vring->parent);
98 
99     vring_push(vdev, &req->vring->vring, &req->elem,
100                req->qsgl.size + req->resp_iov.size);
101 
102     if (vring_should_notify(vdev, &req->vring->vring)) {
103         event_notifier_set(&req->vring->guest_notifier);
104     }
105 }
106 
107 static void virtio_scsi_iothread_handle_ctrl(EventNotifier *notifier)
108 {
109     VirtIOSCSIVring *vring = container_of(notifier,
110                                           VirtIOSCSIVring, host_notifier);
111     VirtIOSCSI *s = VIRTIO_SCSI(vring->parent);
112     VirtIOSCSIReq *req;
113 
114     event_notifier_test_and_clear(notifier);
115     while ((req = virtio_scsi_pop_req_vring(s, vring))) {
116         virtio_scsi_handle_ctrl_req(s, req);
117     }
118 }
119 
120 static void virtio_scsi_iothread_handle_event(EventNotifier *notifier)
121 {
122     VirtIOSCSIVring *vring = container_of(notifier,
123                                           VirtIOSCSIVring, host_notifier);
124     VirtIOSCSI *s = vring->parent;
125     VirtIODevice *vdev = VIRTIO_DEVICE(s);
126 
127     event_notifier_test_and_clear(notifier);
128 
129     if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
130         return;
131     }
132 
133     if (s->events_dropped) {
134         virtio_scsi_push_event(s, NULL, VIRTIO_SCSI_T_NO_EVENT, 0);
135     }
136 }
137 
138 static void virtio_scsi_iothread_handle_cmd(EventNotifier *notifier)
139 {
140     VirtIOSCSIVring *vring = container_of(notifier,
141                                           VirtIOSCSIVring, host_notifier);
142     VirtIOSCSI *s = (VirtIOSCSI *)vring->parent;
143     VirtIOSCSIReq *req, *next;
144     QTAILQ_HEAD(, VirtIOSCSIReq) reqs = QTAILQ_HEAD_INITIALIZER(reqs);
145 
146     event_notifier_test_and_clear(notifier);
147     while ((req = virtio_scsi_pop_req_vring(s, vring))) {
148         if (virtio_scsi_handle_cmd_req_prepare(s, req)) {
149             QTAILQ_INSERT_TAIL(&reqs, req, next);
150         }
151     }
152 
153     QTAILQ_FOREACH_SAFE(req, &reqs, next, next) {
154         virtio_scsi_handle_cmd_req_submit(s, req);
155     }
156 }
157 
158 /* assumes s->ctx held */
159 static void virtio_scsi_clear_aio(VirtIOSCSI *s)
160 {
161     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);
162     int i;
163 
164     if (s->ctrl_vring) {
165         aio_set_event_notifier(s->ctx, &s->ctrl_vring->host_notifier, NULL);
166     }
167     if (s->event_vring) {
168         aio_set_event_notifier(s->ctx, &s->event_vring->host_notifier, NULL);
169     }
170     if (s->cmd_vrings) {
171         for (i = 0; i < vs->conf.num_queues && s->cmd_vrings[i]; i++) {
172             aio_set_event_notifier(s->ctx, &s->cmd_vrings[i]->host_notifier, NULL);
173         }
174     }
175 }
176 
177 static void virtio_scsi_vring_teardown(VirtIOSCSI *s)
178 {
179     VirtIODevice *vdev = VIRTIO_DEVICE(s);
180     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);
181     int i;
182 
183     if (s->ctrl_vring) {
184         vring_teardown(&s->ctrl_vring->vring, vdev, 0);
185         g_slice_free(VirtIOSCSIVring, s->ctrl_vring);
186         s->ctrl_vring = NULL;
187     }
188     if (s->event_vring) {
189         vring_teardown(&s->event_vring->vring, vdev, 1);
190         g_slice_free(VirtIOSCSIVring, s->event_vring);
191         s->event_vring = NULL;
192     }
193     if (s->cmd_vrings) {
194         for (i = 0; i < vs->conf.num_queues && s->cmd_vrings[i]; i++) {
195             vring_teardown(&s->cmd_vrings[i]->vring, vdev, 2 + i);
196             g_slice_free(VirtIOSCSIVring, s->cmd_vrings[i]);
197             s->cmd_vrings[i] = NULL;
198         }
199         free(s->cmd_vrings);
200         s->cmd_vrings = NULL;
201     }
202 }
203 
204 /* Context: QEMU global mutex held */
205 void virtio_scsi_dataplane_start(VirtIOSCSI *s)
206 {
207     int i;
208     int rc;
209     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s)));
210     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
211     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);
212 
213     if (s->dataplane_started ||
214         s->dataplane_starting ||
215         s->dataplane_fenced ||
216         s->ctx != iothread_get_aio_context(vs->conf.iothread)) {
217         return;
218     }
219 
220     s->dataplane_starting = true;
221 
222     /* Set up guest notifier (irq) */
223     rc = k->set_guest_notifiers(qbus->parent, vs->conf.num_queues + 2, true);
224     if (rc != 0) {
225         fprintf(stderr, "virtio-scsi: Failed to set guest notifiers (%d), "
226                 "ensure -enable-kvm is set\n", rc);
227         s->dataplane_fenced = true;
228         goto fail_guest_notifiers;
229     }
230 
231     aio_context_acquire(s->ctx);
232     s->ctrl_vring = virtio_scsi_vring_init(s, vs->ctrl_vq,
233                                            virtio_scsi_iothread_handle_ctrl,
234                                            0);
235     if (!s->ctrl_vring) {
236         goto fail_vrings;
237     }
238     s->event_vring = virtio_scsi_vring_init(s, vs->event_vq,
239                                             virtio_scsi_iothread_handle_event,
240                                             1);
241     if (!s->event_vring) {
242         goto fail_vrings;
243     }
244     s->cmd_vrings = g_new(VirtIOSCSIVring *, vs->conf.num_queues);
245     for (i = 0; i < vs->conf.num_queues; i++) {
246         s->cmd_vrings[i] =
247             virtio_scsi_vring_init(s, vs->cmd_vqs[i],
248                                    virtio_scsi_iothread_handle_cmd,
249                                    i + 2);
250         if (!s->cmd_vrings[i]) {
251             goto fail_vrings;
252         }
253     }
254 
255     s->dataplane_starting = false;
256     s->dataplane_started = true;
257     aio_context_release(s->ctx);
258     return;
259 
260 fail_vrings:
261     virtio_scsi_clear_aio(s);
262     aio_context_release(s->ctx);
263     virtio_scsi_vring_teardown(s);
264     for (i = 0; i < vs->conf.num_queues + 2; i++) {
265         k->set_host_notifier(qbus->parent, i, false);
266     }
267     k->set_guest_notifiers(qbus->parent, vs->conf.num_queues + 2, false);
268 fail_guest_notifiers:
269     s->dataplane_starting = false;
270 }
271 
272 /* Context: QEMU global mutex held */
273 void virtio_scsi_dataplane_stop(VirtIOSCSI *s)
274 {
275     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s)));
276     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
277     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);
278     int i;
279 
280     /* Better luck next time. */
281     if (s->dataplane_fenced) {
282         s->dataplane_fenced = false;
283         return;
284     }
285     if (!s->dataplane_started || s->dataplane_stopping) {
286         return;
287     }
288     s->dataplane_stopping = true;
289     assert(s->ctx == iothread_get_aio_context(vs->conf.iothread));
290 
291     aio_context_acquire(s->ctx);
292 
293     aio_set_event_notifier(s->ctx, &s->ctrl_vring->host_notifier, NULL);
294     aio_set_event_notifier(s->ctx, &s->event_vring->host_notifier, NULL);
295     for (i = 0; i < vs->conf.num_queues; i++) {
296         aio_set_event_notifier(s->ctx, &s->cmd_vrings[i]->host_notifier, NULL);
297     }
298 
299     blk_drain_all(); /* ensure there are no in-flight requests */
300 
301     aio_context_release(s->ctx);
302 
303     /* Sync vring state back to virtqueue so that non-dataplane request
304      * processing can continue when we disable the host notifier below.
305      */
306     virtio_scsi_vring_teardown(s);
307 
308     for (i = 0; i < vs->conf.num_queues + 2; i++) {
309         k->set_host_notifier(qbus->parent, i, false);
310     }
311 
312     /* Clean up guest notifier (irq) */
313     k->set_guest_notifiers(qbus->parent, vs->conf.num_queues + 2, false);
314     s->dataplane_stopping = false;
315     s->dataplane_started = false;
316 }
317