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