hw/block/dataplane/virtio-blk.c

   1 /*
   2  * Dedicated thread for virtio-blk I/O processing
   3  *
   4  * Copyright 2012 IBM, Corp.
   5  * Copyright 2012 Red Hat, Inc. and/or its affiliates
   6  *
   7  * Authors:
   8  *   Stefan Hajnoczi <[email protected]>
   9  *
  10  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  11  * See the COPYING file in the top-level directory.
  12  *
  13  */
  14
  15 #include "trace.h"
  16 #include "qemu/iov.h"
  17 #include "qemu/thread.h"
  18 #include "qemu/error-report.h"
  19 #include "hw/virtio/dataplane/vring.h"
  20 #include "block/block.h"
  21 #include "hw/virtio/virtio-blk.h"
  22 #include "virtio-blk.h"
  23 #include "block/aio.h"
  24 #include "hw/virtio/virtio-bus.h"
  25 #include "qom/object_interfaces.h"
  26
  27 struct VirtIOBlockDataPlane {
  28     bool started;
  29     bool starting;
  30     bool stopping;
  31     bool disabled;
  32
  33     VirtIOBlkConf *blk;
  34
  35     VirtIODevice *vdev;
  36     Vring vring;                    /* virtqueue vring */
  37     EventNotifier *guest_notifier;  /* irq */
  38     QEMUBH *bh;                     /* bh for guest notification */
  39
  40     /* Note that these EventNotifiers are assigned by value.  This is
  41      * fine as long as you do not call event_notifier_cleanup on them
  42      * (because you don't own the file descriptor or handle; you just
  43      * use it).
  44      */
  45     IOThread *iothread;
  46     IOThread internal_iothread_obj;
  47     AioContext *ctx;
  48     EventNotifier host_notifier;    /* doorbell */
  49
  50     /* Operation blocker on BDS */
  51     Error *blocker;
  52     void (*saved_complete_request)(struct VirtIOBlockReq *req,
  53                                    unsigned char status);
  54 };
  55
  56 /* Raise an interrupt to signal guest, if necessary */
  57 static void notify_guest(VirtIOBlockDataPlane *s)
  58 {
  59     if (!vring_should_notify(s->vdev, &s->vring)) {
  60         return;
  61     }
  62
  63     event_notifier_set(s->guest_notifier);
  64 }
  65
  66 static void notify_guest_bh(void *opaque)
  67 {
  68     VirtIOBlockDataPlane *s = opaque;
  69
  70     notify_guest(s);
  71 }
  72
  73 static void complete_request_vring(VirtIOBlockReq *req, unsigned char status)
  74 {
  75     VirtIOBlockDataPlane *s = req->dev->dataplane;
  76     stb_p(&req->in->status, status);
  77
  78     vring_push(&req->dev->dataplane->vring, &req->elem,
  79                req->qiov.size + sizeof(*req->in));
  80
  81     /* Suppress notification to guest by BH and its scheduled
  82      * flag because requests are completed as a batch after io
  83      * plug & unplug is introduced, and the BH can still be
  84      * executed in dataplane aio context even after it is
  85      * stopped, so needn't worry about notification loss with BH.
  86      */
  87     qemu_bh_schedule(s->bh);
  88 }
  89
  90 static void handle_notify(EventNotifier *e)
  91 {
  92     VirtIOBlockDataPlane *s = container_of(e, VirtIOBlockDataPlane,
  93                                            host_notifier);
  94     VirtIOBlock *vblk = VIRTIO_BLK(s->vdev);
  95
  96     event_notifier_test_and_clear(&s->host_notifier);
  97     bdrv_io_plug(s->blk->conf.bs);
  98     for (;;) {
  99         MultiReqBuffer mrb = {
 100             .num_writes = 0,
 101         };
 102         int ret;
 103
 104         /* Disable guest->host notifies to avoid unnecessary vmexits */
 105         vring_disable_notification(s->vdev, &s->vring);
 106
 107         for (;;) {
 108             VirtIOBlockReq *req = virtio_blk_alloc_request(vblk);
 109
 110             ret = vring_pop(s->vdev, &s->vring, &req->elem);
 111             if (ret < 0) {
 112                 virtio_blk_free_request(req);
 113                 break; /* no more requests */
 114             }
 115
 116             trace_virtio_blk_data_plane_process_request(s, req->elem.out_num,
 117                                                         req->elem.in_num,
 118                                                         req->elem.index);
 119
 120             virtio_blk_handle_request(req, &mrb);
 121         }
 122
 123         virtio_submit_multiwrite(s->blk->conf.bs, &mrb);
 124
 125         if (likely(ret == -EAGAIN)) { /* vring emptied */
 126             /* Re-enable guest->host notifies and stop processing the vring.
 127              * But if the guest has snuck in more descriptors, keep processing.
 128              */
 129             if (vring_enable_notification(s->vdev, &s->vring)) {
 130                 break;
 131             }
 132         } else { /* fatal error */
 133             break;
 134         }
 135     }
 136     bdrv_io_unplug(s->blk->conf.bs);
 137 }
 138
 139 /* Context: QEMU global mutex held */
 140 void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *blk,
 141                                   VirtIOBlockDataPlane **dataplane,
 142                                   Error **errp)
 143 {
 144     VirtIOBlockDataPlane *s;
 145     Error *local_err = NULL;
 146     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
 147     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
 148
 149     *dataplane = NULL;
 150
 151     if (!blk->data_plane && !blk->iothread) {
 152         return;
 153     }
 154
 155     /* Don't try if transport does not support notifiers. */
 156     if (!k->set_guest_notifiers || !k->set_host_notifier) {
 157         error_setg(errp,
 158                    "device is incompatible with x-data-plane "
 159                    "(transport does not support notifiers)");
 160         return;
 161     }
 162
 163     /* If dataplane is (re-)enabled while the guest is running there could be
 164      * block jobs that can conflict.
 165      */
 166     if (bdrv_op_is_blocked(blk->conf.bs, BLOCK_OP_TYPE_DATAPLANE, &local_err)) {
 167         error_report("cannot start dataplane thread: %s",
 168                       error_get_pretty(local_err));
 169         error_free(local_err);
 170         return;
 171     }
 172
 173     s = g_new0(VirtIOBlockDataPlane, 1);
 174     s->vdev = vdev;
 175     s->blk = blk;
 176
 177     if (blk->iothread) {
 178         s->iothread = blk->iothread;
 179         object_ref(OBJECT(s->iothread));
 180     } else {
 181         /* Create per-device IOThread if none specified.  This is for
 182          * x-data-plane option compatibility.  If x-data-plane is removed we
 183          * can drop this.
 184          */
 185         object_initialize(&s->internal_iothread_obj,
 186                           sizeof(s->internal_iothread_obj),
 187                           TYPE_IOTHREAD);
 188         user_creatable_complete(OBJECT(&s->internal_iothread_obj), &error_abort);
 189         s->iothread = &s->internal_iothread_obj;
 190     }
 191     s->ctx = iothread_get_aio_context(s->iothread);
 192     s->bh = aio_bh_new(s->ctx, notify_guest_bh, s);
 193
 194     error_setg(&s->blocker, "block device is in use by data plane");
 195     bdrv_op_block_all(blk->conf.bs, s->blocker);
 196     bdrv_op_unblock(blk->conf.bs, BLOCK_OP_TYPE_RESIZE, s->blocker);
 197     bdrv_op_unblock(blk->conf.bs, BLOCK_OP_TYPE_DRIVE_DEL, s->blocker);
 198
 199     *dataplane = s;
 200 }
 201
 202 /* Context: QEMU global mutex held */
 203 void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s)
 204 {
 205     if (!s) {
 206         return;
 207     }
 208
 209     virtio_blk_data_plane_stop(s);
 210     bdrv_op_unblock_all(s->blk->conf.bs, s->blocker);
 211     error_free(s->blocker);
 212     object_unref(OBJECT(s->iothread));
 213     qemu_bh_delete(s->bh);
 214     g_free(s);
 215 }
 216
 217 /* Context: QEMU global mutex held */
 218 void virtio_blk_data_plane_start(VirtIOBlockDataPlane *s)
 219 {
 220     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s->vdev)));
 221     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
 222     VirtIOBlock *vblk = VIRTIO_BLK(s->vdev);
 223     VirtQueue *vq;
 224     int r;
 225
 226     if (s->started || s->disabled) {
 227         return;
 228     }
 229
 230     if (s->starting) {
 231         return;
 232     }
 233
 234     s->starting = true;
 235
 236     vq = virtio_get_queue(s->vdev, 0);
 237     if (!vring_setup(&s->vring, s->vdev, 0)) {
 238         goto fail_vring;
 239     }
 240
 241     /* Set up guest notifier (irq) */
 242     r = k->set_guest_notifiers(qbus->parent, 1, true);
 243     if (r != 0) {
 244         fprintf(stderr, "virtio-blk failed to set guest notifier (%d), "
 245                 "ensure -enable-kvm is set\n", r);
 246         goto fail_guest_notifiers;
 247     }
 248     s->guest_notifier = virtio_queue_get_guest_notifier(vq);
 249
 250     /* Set up virtqueue notify */
 251     r = k->set_host_notifier(qbus->parent, 0, true);
 252     if (r != 0) {
 253         fprintf(stderr, "virtio-blk failed to set host notifier (%d)\n", r);
 254         goto fail_host_notifier;
 255     }
 256     s->host_notifier = *virtio_queue_get_host_notifier(vq);
 257
 258     s->saved_complete_request = vblk->complete_request;
 259     vblk->complete_request = complete_request_vring;
 260
 261     s->starting = false;
 262     s->started = true;
 263     trace_virtio_blk_data_plane_start(s);
 264
 265     bdrv_set_aio_context(s->blk->conf.bs, s->ctx);
 266
 267     /* Kick right away to begin processing requests already in vring */
 268     event_notifier_set(virtio_queue_get_host_notifier(vq));
 269
 270     /* Get this show started by hooking up our callbacks */
 271     aio_context_acquire(s->ctx);
 272     aio_set_event_notifier(s->ctx, &s->host_notifier, handle_notify);
 273     aio_context_release(s->ctx);
 274     return;
 275
 276   fail_host_notifier:
 277     k->set_guest_notifiers(qbus->parent, 1, false);
 278   fail_guest_notifiers:
 279     vring_teardown(&s->vring, s->vdev, 0);
 280     s->disabled = true;
 281   fail_vring:
 282     s->starting = false;
 283 }
 284
 285 /* Context: QEMU global mutex held */
 286 void virtio_blk_data_plane_stop(VirtIOBlockDataPlane *s)
 287 {
 288     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s->vdev)));
 289     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
 290     VirtIOBlock *vblk = VIRTIO_BLK(s->vdev);
 291
 292
 293     /* Better luck next time. */
 294     if (s->disabled) {
 295         s->disabled = false;
 296         return;
 297     }
 298     if (!s->started || s->stopping) {
 299         return;
 300     }
 301     s->stopping = true;
 302     vblk->complete_request = s->saved_complete_request;
 303     trace_virtio_blk_data_plane_stop(s);
 304
 305     aio_context_acquire(s->ctx);
 306
 307     /* Stop notifications for new requests from guest */
 308     aio_set_event_notifier(s->ctx, &s->host_notifier, NULL);
 309
 310     /* Drain and switch bs back to the QEMU main loop */
 311     bdrv_set_aio_context(s->blk->conf.bs, qemu_get_aio_context());
 312
 313     aio_context_release(s->ctx);
 314
 315     /* Sync vring state back to virtqueue so that non-dataplane request
 316      * processing can continue when we disable the host notifier below.
 317      */
 318     vring_teardown(&s->vring, s->vdev, 0);
 319
 320     k->set_host_notifier(qbus->parent, 0, false);
 321
 322     /* Clean up guest notifier (irq) */
 323     k->set_guest_notifiers(qbus->parent, 1, false);
 324
 325     s->started = false;
 326     s->stopping = false;
 327 }