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