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