hw/block/dataplane/virtio-blk.c - qemu-android - Git at Google

 /*
  * Dedicated thread for virtio-blk I/O processing
  *
  * Copyright 2012 IBM, Corp.
  * Copyright 2012 Red Hat, Inc. and/or its affiliates
  *
  * Authors:
  *   Stefan Hajnoczi <stefanha@redhat.com>
  *
  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  * See the COPYING file in the top-level directory.
  *
  */

 #include "trace.h"
 #include "qemu/iov.h"
 #include "qemu/thread.h"
 #include "qemu/error-report.h"
 #include "hw/virtio/dataplane/vring.h"
 #include "sysemu/block-backend.h"
 #include "hw/virtio/virtio-blk.h"
 #include "virtio-blk.h"
 #include "block/aio.h"
 #include "hw/virtio/virtio-bus.h"
 #include "qom/object_interfaces.h"

 struct VirtIOBlockDataPlane {
     bool started;
     bool starting;
     bool stopping;
     bool disabled;

     VirtIOBlkConf *conf;

     VirtIODevice *vdev;
     Vring vring;                    /* virtqueue vring */
     EventNotifier *guest_notifier;  /* irq */
     QEMUBH *bh;                     /* bh for guest notification */

     /* Note that these EventNotifiers are assigned by value.  This is
      * fine as long as you do not call event_notifier_cleanup on them
      * (because you don't own the file descriptor or handle; you just
      * use it).
      */
     IOThread *iothread;
     IOThread internal_iothread_obj;
     AioContext *ctx;
     EventNotifier host_notifier;    /* doorbell */

     /* Operation blocker on BDS */
     Error *blocker;
     void (*saved_complete_request)(struct VirtIOBlockReq *req,
                                    unsigned char status);
 };

 /* Raise an interrupt to signal guest, if necessary */
 static void notify_guest(VirtIOBlockDataPlane *s)
 {
     if (!vring_should_notify(s->vdev, &s->vring)) {
         return;
     }

     event_notifier_set(s->guest_notifier);
 }

 static void notify_guest_bh(void *opaque)
 {
     VirtIOBlockDataPlane *s = opaque;

     notify_guest(s);
 }

 static void complete_request_vring(VirtIOBlockReq *req, unsigned char status)
 {
     VirtIOBlockDataPlane *s = req->dev->dataplane;
     stb_p(&req->in->status, status);

     vring_push(&req->dev->dataplane->vring, &req->elem,
                req->qiov.size + sizeof(*req->in));

     /* Suppress notification to guest by BH and its scheduled
      * flag because requests are completed as a batch after io
      * plug & unplug is introduced, and the BH can still be
      * executed in dataplane aio context even after it is
      * stopped, so needn't worry about notification loss with BH.
      */
     qemu_bh_schedule(s->bh);
 }

 static void handle_notify(EventNotifier *e)
 {
     VirtIOBlockDataPlane *s = container_of(e, VirtIOBlockDataPlane,
                                            host_notifier);
     VirtIOBlock *vblk = VIRTIO_BLK(s->vdev);

     event_notifier_test_and_clear(&s->host_notifier);
     blk_io_plug(s->conf->conf.blk);
     for (;;) {
         MultiReqBuffer mrb = {
             .num_writes = 0,
         };
         int ret;

         /* Disable guest->host notifies to avoid unnecessary vmexits */
         vring_disable_notification(s->vdev, &s->vring);

         for (;;) {
             VirtIOBlockReq *req = virtio_blk_alloc_request(vblk);

             ret = vring_pop(s->vdev, &s->vring, &req->elem);
             if (ret < 0) {
                 virtio_blk_free_request(req);
                 break; /* no more requests */
             }

             trace_virtio_blk_data_plane_process_request(s, req->elem.out_num,
                                                         req->elem.in_num,
                                                         req->elem.index);

             virtio_blk_handle_request(req, &mrb);
         }

         virtio_submit_multiwrite(s->conf->conf.blk, &mrb);

         if (likely(ret == -EAGAIN)) { /* vring emptied */
             /* Re-enable guest->host notifies and stop processing the vring.
              * But if the guest has snuck in more descriptors, keep processing.
              */
             if (vring_enable_notification(s->vdev, &s->vring)) {
                 break;
             }
         } else { /* fatal error */
             break;
         }
     }
     blk_io_unplug(s->conf->conf.blk);
 }

 /* Context: QEMU global mutex held */
 void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *conf,
                                   VirtIOBlockDataPlane **dataplane,
                                   Error **errp)
 {
     VirtIOBlockDataPlane *s;
     Error *local_err = NULL;
     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);

     *dataplane = NULL;

     if (!conf->data_plane && !conf->iothread) {
         return;
     }

     /* Don't try if transport does not support notifiers. */
     if (!k->set_guest_notifiers || !k->set_host_notifier) {
         error_setg(errp,
                    "device is incompatible with x-data-plane "
                    "(transport does not support notifiers)");
         return;
     }

     /* If dataplane is (re-)enabled while the guest is running there could be
      * block jobs that can conflict.
      */
     if (blk_op_is_blocked(conf->conf.blk, BLOCK_OP_TYPE_DATAPLANE,
                           &local_err)) {
         error_setg(errp, "cannot start dataplane thread: %s",
                    error_get_pretty(local_err));
         error_free(local_err);
         return;
     }

     s = g_new0(VirtIOBlockDataPlane, 1);
     s->vdev = vdev;
     s->conf = conf;

     if (conf->iothread) {
         s->iothread = conf->iothread;
         object_ref(OBJECT(s->iothread));
     } else {
         /* Create per-device IOThread if none specified.  This is for
          * x-data-plane option compatibility.  If x-data-plane is removed we
          * can drop this.
          */
         object_initialize(&s->internal_iothread_obj,
                           sizeof(s->internal_iothread_obj),
                           TYPE_IOTHREAD);
         user_creatable_complete(OBJECT(&s->internal_iothread_obj), &error_abort);
         s->iothread = &s->internal_iothread_obj;
     }
     s->ctx = iothread_get_aio_context(s->iothread);
     s->bh = aio_bh_new(s->ctx, notify_guest_bh, s);

     error_setg(&s->blocker, "block device is in use by data plane");
     blk_op_block_all(conf->conf.blk, s->blocker);
     blk_op_unblock(conf->conf.blk, BLOCK_OP_TYPE_RESIZE, s->blocker);
     blk_op_unblock(conf->conf.blk, BLOCK_OP_TYPE_DRIVE_DEL, s->blocker);
     blk_op_unblock(conf->conf.blk, BLOCK_OP_TYPE_BACKUP_SOURCE, s->blocker);
     blk_op_unblock(conf->conf.blk, BLOCK_OP_TYPE_COMMIT, s->blocker);
     blk_op_unblock(conf->conf.blk, BLOCK_OP_TYPE_MIRROR, s->blocker);
     blk_op_unblock(conf->conf.blk, BLOCK_OP_TYPE_STREAM, s->blocker);
     blk_op_unblock(conf->conf.blk, BLOCK_OP_TYPE_REPLACE, s->blocker);

     *dataplane = s;
 }

 /* Context: QEMU global mutex held */
 void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s)
 {
     if (!s) {
         return;
     }

     virtio_blk_data_plane_stop(s);
     blk_op_unblock_all(s->conf->conf.blk, s->blocker);
     error_free(s->blocker);
     object_unref(OBJECT(s->iothread));
     qemu_bh_delete(s->bh);
     g_free(s);
 }

 /* Context: QEMU global mutex held */
 void virtio_blk_data_plane_start(VirtIOBlockDataPlane *s)
 {
     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s->vdev)));
     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
     VirtIOBlock *vblk = VIRTIO_BLK(s->vdev);
     VirtQueue *vq;
     int r;

     if (s->started || s->disabled) {
         return;
     }

     if (s->starting) {
         return;
     }

     s->starting = true;

     vq = virtio_get_queue(s->vdev, 0);
     if (!vring_setup(&s->vring, s->vdev, 0)) {
         goto fail_vring;
     }

     /* Set up guest notifier (irq) */
     r = k->set_guest_notifiers(qbus->parent, 1, true);
     if (r != 0) {
         fprintf(stderr, "virtio-blk failed to set guest notifier (%d), "
                 "ensure -enable-kvm is set\n", r);
         goto fail_guest_notifiers;
     }
     s->guest_notifier = virtio_queue_get_guest_notifier(vq);

     /* Set up virtqueue notify */
     r = k->set_host_notifier(qbus->parent, 0, true);
     if (r != 0) {
         fprintf(stderr, "virtio-blk failed to set host notifier (%d)\n", r);
         goto fail_host_notifier;
     }
     s->host_notifier = *virtio_queue_get_host_notifier(vq);

     s->saved_complete_request = vblk->complete_request;
     vblk->complete_request = complete_request_vring;

     s->starting = false;
     s->started = true;
     trace_virtio_blk_data_plane_start(s);

     blk_set_aio_context(s->conf->conf.blk, s->ctx);

     /* Kick right away to begin processing requests already in vring */
     event_notifier_set(virtio_queue_get_host_notifier(vq));

     /* Get this show started by hooking up our callbacks */
     aio_context_acquire(s->ctx);
     aio_set_event_notifier(s->ctx, &s->host_notifier, handle_notify);
     aio_context_release(s->ctx);
     return;

   fail_host_notifier:
     k->set_guest_notifiers(qbus->parent, 1, false);
   fail_guest_notifiers:
     vring_teardown(&s->vring, s->vdev, 0);
     s->disabled = true;
   fail_vring:
     s->starting = false;
 }

 /* Context: QEMU global mutex held */
 void virtio_blk_data_plane_stop(VirtIOBlockDataPlane *s)
 {
     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s->vdev)));
     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
     VirtIOBlock *vblk = VIRTIO_BLK(s->vdev);


     /* Better luck next time. */
     if (s->disabled) {
         s->disabled = false;
         return;
     }
     if (!s->started || s->stopping) {
         return;
     }
     s->stopping = true;
     vblk->complete_request = s->saved_complete_request;
     trace_virtio_blk_data_plane_stop(s);

     aio_context_acquire(s->ctx);

     /* Stop notifications for new requests from guest */
     aio_set_event_notifier(s->ctx, &s->host_notifier, NULL);

     /* Drain and switch bs back to the QEMU main loop */
     blk_set_aio_context(s->conf->conf.blk, qemu_get_aio_context());

     aio_context_release(s->ctx);

     /* Sync vring state back to virtqueue so that non-dataplane request
      * processing can continue when we disable the host notifier below.
      */
     vring_teardown(&s->vring, s->vdev, 0);

     k->set_host_notifier(qbus->parent, 0, false);

     /* Clean up guest notifier (irq) */
     k->set_guest_notifiers(qbus->parent, 1, false);

     s->started = false;
     s->stopping = false;
 }
	/*
	* Dedicated thread for virtio-blk I/O processing
	*
	* Copyright 2012 IBM, Corp.
	* Copyright 2012 Red Hat, Inc. and/or its affiliates
	*
	* Authors:
	* Stefan Hajnoczi <stefanha@redhat.com>
	*
	* This work is licensed under the terms of the GNU GPL, version 2 or later.
	* See the COPYING file in the top-level directory.
	*
	*/

	#include "trace.h"
	#include "qemu/iov.h"
	#include "qemu/thread.h"
	#include "qemu/error-report.h"
	#include "hw/virtio/dataplane/vring.h"
	#include "sysemu/block-backend.h"
	#include "hw/virtio/virtio-blk.h"
	#include "virtio-blk.h"
	#include "block/aio.h"
	#include "hw/virtio/virtio-bus.h"
	#include "qom/object_interfaces.h"

	struct VirtIOBlockDataPlane {
	bool started;
	bool starting;
	bool stopping;
	bool disabled;

	VirtIOBlkConf *conf;

	VirtIODevice *vdev;
	Vring vring; /* virtqueue vring */
	EventNotifier guest_notifier; / irq */
	QEMUBH bh; / bh for guest notification */

	/* Note that these EventNotifiers are assigned by value. This is
	* fine as long as you do not call event_notifier_cleanup on them
	* (because you don't own the file descriptor or handle; you just
	* use it).
	*/
	IOThread *iothread;
	IOThread internal_iothread_obj;
	AioContext *ctx;
	EventNotifier host_notifier; /* doorbell */

	/* Operation blocker on BDS */
	Error *blocker;
	void (saved_complete_request)(struct VirtIOBlockReq req,
	unsigned char status);
	};

	/* Raise an interrupt to signal guest, if necessary */
	static void notify_guest(VirtIOBlockDataPlane *s)
	{
	if (!vring_should_notify(s->vdev, &s->vring)) {
	return;
	}

	event_notifier_set(s->guest_notifier);
	}

	static void notify_guest_bh(void *opaque)
	{
	VirtIOBlockDataPlane *s = opaque;

	notify_guest(s);
	}

	static void complete_request_vring(VirtIOBlockReq *req, unsigned char status)
	{
	VirtIOBlockDataPlane *s = req->dev->dataplane;
	stb_p(&req->in->status, status);

	vring_push(&req->dev->dataplane->vring, &req->elem,
	req->qiov.size + sizeof(*req->in));

	/* Suppress notification to guest by BH and its scheduled
	* flag because requests are completed as a batch after io
	* plug & unplug is introduced, and the BH can still be
	* executed in dataplane aio context even after it is
	* stopped, so needn't worry about notification loss with BH.
	*/
	qemu_bh_schedule(s->bh);
	}

	static void handle_notify(EventNotifier *e)
	{
	VirtIOBlockDataPlane *s = container_of(e, VirtIOBlockDataPlane,
	host_notifier);
	VirtIOBlock *vblk = VIRTIO_BLK(s->vdev);

	event_notifier_test_and_clear(&s->host_notifier);
	blk_io_plug(s->conf->conf.blk);
	for (;;) {
	MultiReqBuffer mrb = {
	.num_writes = 0,
	};
	int ret;

	/* Disable guest->host notifies to avoid unnecessary vmexits */
	vring_disable_notification(s->vdev, &s->vring);

	for (;;) {
	VirtIOBlockReq *req = virtio_blk_alloc_request(vblk);

	ret = vring_pop(s->vdev, &s->vring, &req->elem);
	if (ret < 0) {
	virtio_blk_free_request(req);
	break; /* no more requests */
	}

	trace_virtio_blk_data_plane_process_request(s, req->elem.out_num,
	req->elem.in_num,
	req->elem.index);

	virtio_blk_handle_request(req, &mrb);
	}

	virtio_submit_multiwrite(s->conf->conf.blk, &mrb);

	if (likely(ret == -EAGAIN)) { /* vring emptied */
	/* Re-enable guest->host notifies and stop processing the vring.
	* But if the guest has snuck in more descriptors, keep processing.
	*/
	if (vring_enable_notification(s->vdev, &s->vring)) {
	break;
	}
	} else { /* fatal error */
	break;
	}
	}
	blk_io_unplug(s->conf->conf.blk);
	}

	/* Context: QEMU global mutex held */
	void virtio_blk_data_plane_create(VirtIODevice vdev, VirtIOBlkConf conf,
	VirtIOBlockDataPlane **dataplane,
	Error **errp)
	{
	VirtIOBlockDataPlane *s;
	Error *local_err = NULL;
	BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
	VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);

	*dataplane = NULL;

	if (!conf->data_plane && !conf->iothread) {
	return;
	}

	/* Don't try if transport does not support notifiers. */
	if (!k->set_guest_notifiers \|\| !k->set_host_notifier) {
	error_setg(errp,
	"device is incompatible with x-data-plane "
	"(transport does not support notifiers)");
	return;
	}

	/* If dataplane is (re-)enabled while the guest is running there could be
	* block jobs that can conflict.
	*/
	if (blk_op_is_blocked(conf->conf.blk, BLOCK_OP_TYPE_DATAPLANE,
	&local_err)) {
	error_setg(errp, "cannot start dataplane thread: %s",
	error_get_pretty(local_err));
	error_free(local_err);
	return;
	}

	s = g_new0(VirtIOBlockDataPlane, 1);
	s->vdev = vdev;
	s->conf = conf;

	if (conf->iothread) {
	s->iothread = conf->iothread;
	object_ref(OBJECT(s->iothread));
	} else {
	/* Create per-device IOThread if none specified. This is for
	* x-data-plane option compatibility. If x-data-plane is removed we
	* can drop this.
	*/
	object_initialize(&s->internal_iothread_obj,
	sizeof(s->internal_iothread_obj),
	TYPE_IOTHREAD);
	user_creatable_complete(OBJECT(&s->internal_iothread_obj), &error_abort);
	s->iothread = &s->internal_iothread_obj;
	}
	s->ctx = iothread_get_aio_context(s->iothread);
	s->bh = aio_bh_new(s->ctx, notify_guest_bh, s);

	error_setg(&s->blocker, "block device is in use by data plane");
	blk_op_block_all(conf->conf.blk, s->blocker);
	blk_op_unblock(conf->conf.blk, BLOCK_OP_TYPE_RESIZE, s->blocker);
	blk_op_unblock(conf->conf.blk, BLOCK_OP_TYPE_DRIVE_DEL, s->blocker);
	blk_op_unblock(conf->conf.blk, BLOCK_OP_TYPE_BACKUP_SOURCE, s->blocker);
	blk_op_unblock(conf->conf.blk, BLOCK_OP_TYPE_COMMIT, s->blocker);
	blk_op_unblock(conf->conf.blk, BLOCK_OP_TYPE_MIRROR, s->blocker);
	blk_op_unblock(conf->conf.blk, BLOCK_OP_TYPE_STREAM, s->blocker);
	blk_op_unblock(conf->conf.blk, BLOCK_OP_TYPE_REPLACE, s->blocker);

	*dataplane = s;
	}

	/* Context: QEMU global mutex held */
	void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s)
	{
	if (!s) {
	return;
	}

	virtio_blk_data_plane_stop(s);
	blk_op_unblock_all(s->conf->conf.blk, s->blocker);
	error_free(s->blocker);
	object_unref(OBJECT(s->iothread));
	qemu_bh_delete(s->bh);
	g_free(s);
	}

	/* Context: QEMU global mutex held */
	void virtio_blk_data_plane_start(VirtIOBlockDataPlane *s)
	{
	BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s->vdev)));
	VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
	VirtIOBlock *vblk = VIRTIO_BLK(s->vdev);
	VirtQueue *vq;
	int r;

	if (s->started \|\| s->disabled) {
	return;
	}

	if (s->starting) {
	return;
	}

	s->starting = true;

	vq = virtio_get_queue(s->vdev, 0);
	if (!vring_setup(&s->vring, s->vdev, 0)) {
	goto fail_vring;
	}

	/* Set up guest notifier (irq) */
	r = k->set_guest_notifiers(qbus->parent, 1, true);
	if (r != 0) {
	fprintf(stderr, "virtio-blk failed to set guest notifier (%d), "
	"ensure -enable-kvm is set\n", r);
	goto fail_guest_notifiers;
	}
	s->guest_notifier = virtio_queue_get_guest_notifier(vq);

	/* Set up virtqueue notify */
	r = k->set_host_notifier(qbus->parent, 0, true);
	if (r != 0) {
	fprintf(stderr, "virtio-blk failed to set host notifier (%d)\n", r);
	goto fail_host_notifier;
	}
	s->host_notifier = *virtio_queue_get_host_notifier(vq);

	s->saved_complete_request = vblk->complete_request;
	vblk->complete_request = complete_request_vring;

	s->starting = false;
	s->started = true;
	trace_virtio_blk_data_plane_start(s);

	blk_set_aio_context(s->conf->conf.blk, s->ctx);

	/* Kick right away to begin processing requests already in vring */
	event_notifier_set(virtio_queue_get_host_notifier(vq));

	/* Get this show started by hooking up our callbacks */
	aio_context_acquire(s->ctx);
	aio_set_event_notifier(s->ctx, &s->host_notifier, handle_notify);
	aio_context_release(s->ctx);
	return;

	fail_host_notifier:
	k->set_guest_notifiers(qbus->parent, 1, false);
	fail_guest_notifiers:
	vring_teardown(&s->vring, s->vdev, 0);
	s->disabled = true;
	fail_vring:
	s->starting = false;
	}

	/* Context: QEMU global mutex held */
	void virtio_blk_data_plane_stop(VirtIOBlockDataPlane *s)
	{
	BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s->vdev)));
	VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
	VirtIOBlock *vblk = VIRTIO_BLK(s->vdev);


	/* Better luck next time. */
	if (s->disabled) {
	s->disabled = false;
	return;
	}
	if (!s->started \|\| s->stopping) {
	return;
	}
	s->stopping = true;
	vblk->complete_request = s->saved_complete_request;
	trace_virtio_blk_data_plane_stop(s);

	aio_context_acquire(s->ctx);

	/* Stop notifications for new requests from guest */
	aio_set_event_notifier(s->ctx, &s->host_notifier, NULL);

	/* Drain and switch bs back to the QEMU main loop */
	blk_set_aio_context(s->conf->conf.blk, qemu_get_aio_context());

	aio_context_release(s->ctx);

	/* Sync vring state back to virtqueue so that non-dataplane request
	* processing can continue when we disable the host notifier below.
	*/
	vring_teardown(&s->vring, s->vdev, 0);

	k->set_host_notifier(qbus->parent, 0, false);

	/* Clean up guest notifier (irq) */
	k->set_guest_notifiers(qbus->parent, 1, false);

	s->started = false;
	s->stopping = false;
	}