hw/scsi/virtio-scsi-dataplane.c

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