Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6e5aa7ef authored by Rusty Russell's avatar Rusty Russell
Browse files

virtio: reset function 



A reset function solves three problems:

1) It allows us to renegotiate features, eg. if we want to upgrade a
   guest driver without rebooting the guest.

2) It gives us a clean way of shutting down virtqueues: after a reset,
   we know that the buffers won't be used by the host, and

3) It helps the guest recover from messed-up drivers.

So we remove the ->shutdown hook, and the only way we now remove
feature bits is via reset.

We leave it to the driver to do the reset before it deletes queues:
the balloon driver, for example, needs to chat to the host in its
remove function.

Signed-off-by: default avatarRusty Russell <rusty@rustcorp.com.au>
parent b3369c1f

Documentation/lguest/lguest.c

+52 −10
Original line number Diff line number Diff line
@@ -193,6 +193,13 @@ static void *_convert(struct iovec *iov, size_t size, size_t align, 
#define le32_to_cpu(v32) (v32)

#define le64_to_cpu(v64) (v64)



/* The device virtqueue descriptors are followed by feature bitmasks. */

static u8 *get_feature_bits(struct device *dev)

{

	return (u8 *)(dev->desc + 1)

		+ dev->desc->num_vq * sizeof(struct lguest_vqconfig);

}



/*L:100 The Launcher code itself takes us out into userspace, that scary place

 * where pointers run wild and free!  Unfortunately, like most userspace

 * programs, it's quite boring (which is why everyone likes to hack on the
@@ -914,23 +921,60 @@ static void enable_fd(int fd, struct virtqueue *vq) 
	write(waker_fd, &vq->dev->fd, sizeof(vq->dev->fd));

}



/* Resetting a device is fairly easy. */

static void reset_device(struct device *dev)

{

	struct virtqueue *vq;



	verbose("Resetting device %s\n", dev->name);

	/* Clear the status. */

	dev->desc->status = 0;



	/* Clear any features they've acked. */

	memset(get_feature_bits(dev) + dev->desc->feature_len, 0,

	       dev->desc->feature_len);



	/* Zero out the virtqueues. */

	for (vq = dev->vq; vq; vq = vq->next) {

		memset(vq->vring.desc, 0,

		       vring_size(vq->config.num, getpagesize()));

		vq->last_avail_idx = 0;

	}

}



/* This is the generic routine we call when the Guest uses LHCALL_NOTIFY. */

static void handle_output(int fd, unsigned long addr)

{

	struct device *i;

	struct virtqueue *vq;



	/* Check each virtqueue. */

	/* Check each device and virtqueue. */

	for (i = devices.dev; i; i = i->next) {

		/* Notifications to device descriptors reset the device. */

		if (from_guest_phys(addr) == i->desc) {

			reset_device(i);

			return;

		}



		/* Notifications to virtqueues mean output has occurred. */

		for (vq = i->vq; vq; vq = vq->next) {

			if (vq->config.pfn == addr/getpagesize()) {

			if (vq->config.pfn != addr/getpagesize())

				continue;



			/* Guest should acknowledge (and set features!)  before

			 * using the device. */

			if (i->desc->status == 0) {

				warnx("%s gave early output", i->name);

				return;

			}



			if (strcmp(vq->dev->name, "console") != 0)

				verbose("Output to %s\n", vq->dev->name);

			if (vq->handle_output)

				vq->handle_output(fd, vq);

			return;

		}

	}

	}



	/* Early console write is done using notify on a nul-terminated string

	 * in Guest memory. */
@@ -1074,10 +1118,11 @@ static void add_virtqueue(struct device *dev, unsigned int num_descs, 
		vq->vring.used->flags = VRING_USED_F_NO_NOTIFY;

}



/* The virtqueue descriptors are followed by feature bytes. */

/* The first half of the feature bitmask is for us to advertise features.  The

 * second half if for the Guest to accept features. */

static void add_feature(struct device *dev, unsigned bit)

{

	u8 *features;

	u8 *features = get_feature_bits(dev);



	/* We can't extend the feature bits once we've added config bytes */

	if (dev->desc->feature_len <= bit / CHAR_BIT) {
@@ -1085,9 +1130,6 @@ static void add_feature(struct device *dev, unsigned bit) 
		dev->desc->feature_len = (bit / CHAR_BIT) + 1;

	}



	features = (u8 *)(dev->desc + 1)

		+ dev->desc->num_vq * sizeof(struct lguest_vqconfig);



	features[bit / CHAR_BIT] |= (1 << (bit % CHAR_BIT));

}

drivers/block/virtio_blk.c

+5 −1
Original line number Diff line number Diff line
@@ -264,12 +264,16 @@ static void virtblk_remove(struct virtio_device *vdev) 
	struct virtio_blk *vblk = vdev->priv;

	int major = vblk->disk->major;



	/* Nothing should be pending. */

	BUG_ON(!list_empty(&vblk->reqs));



	/* Stop all the virtqueues. */

	vdev->config->reset(vdev);



	blk_cleanup_queue(vblk->disk->queue);

	put_disk(vblk->disk);

	unregister_blkdev(major, "virtblk");

	mempool_destroy(vblk->pool);

	/* There should be nothing in the queue now, so no need to shutdown */

	vdev->config->del_vq(vblk->vq);

	kfree(vblk);

}

drivers/lguest/lguest_device.c

+13 −1
Original line number Diff line number Diff line
@@ -54,7 +54,7 @@ struct lguest_device { 
 *

 * The configuration information for a device consists of one or more

 * virtqueues, a feature bitmaks, and some configuration bytes.  The

 * configuration bytes don't really matter to us: the Launcher set them up, and

 * configuration bytes don't really matter to us: the Launcher sets them up, and

 * the driver will look at them during setup.

 *

 * A convenient routine to return the device's virtqueue config array:
@@ -139,9 +139,20 @@ static u8 lg_get_status(struct virtio_device *vdev) 


static void lg_set_status(struct virtio_device *vdev, u8 status)

{

	BUG_ON(!status);

	to_lgdev(vdev)->desc->status = status;

}



/* To reset the device, we (ab)use the NOTIFY hypercall, with the descriptor

 * address of the device.  The Host will zero the status and all the

 * features. */

static void lg_reset(struct virtio_device *vdev)

{

	unsigned long offset = (void *)to_lgdev(vdev)->desc - lguest_devices;



	hcall(LHCALL_NOTIFY, (max_pfn<<PAGE_SHIFT) + offset, 0, 0);

}



/*

 * Virtqueues

 *
@@ -279,6 +290,7 @@ static struct virtio_config_ops lguest_config_ops = { 
	.set = lg_set,

	.get_status = lg_get_status,

	.set_status = lg_set_status,

	.reset = lg_reset,

	.find_vq = lg_find_vq,

	.del_vq = lg_del_vq,

};

drivers/net/virtio_net.c

+3 −2
Original line number Diff line number Diff line
@@ -390,13 +390,14 @@ static void virtnet_remove(struct virtio_device *vdev) 
	struct virtnet_info *vi = vdev->priv;

	struct sk_buff *skb;



	/* Stop all the virtqueues. */

	vdev->config->reset(vdev);



	/* Free our skbs in send and recv queues, if any. */

	vi->rvq->vq_ops->shutdown(vi->rvq);

	while ((skb = __skb_dequeue(&vi->recv)) != NULL) {

		kfree_skb(skb);

		vi->num--;

	}

	vi->svq->vq_ops->shutdown(vi->svq);

	while ((skb = __skb_dequeue(&vi->send)) != NULL)

		kfree_skb(skb);

drivers/virtio/virtio.c

+10 −2
Original line number Diff line number Diff line
@@ -102,9 +102,13 @@ static int virtio_dev_remove(struct device *_d) 
	struct virtio_driver *drv = container_of(dev->dev.driver,

						 struct virtio_driver, driver);



	dev->config->set_status(dev, dev->config->get_status(dev)

				& ~VIRTIO_CONFIG_S_DRIVER);

	drv->remove(dev);



	/* Driver should have reset device. */

	BUG_ON(dev->config->get_status(dev));



	/* Acknowledge the device's existence again. */

	add_status(dev, VIRTIO_CONFIG_S_ACKNOWLEDGE);

	return 0;

}
@@ -130,6 +134,10 @@ int register_virtio_device(struct virtio_device *dev) 
	dev->dev.bus = &virtio_bus;

	sprintf(dev->dev.bus_id, "%u", dev->index);



	/* We always start by resetting the device, in case a previous

	 * driver messed it up.  This also tests that code path a little. */

	dev->config->reset(dev);



	/* Acknowledge that we've seen the device. */

	add_status(dev, VIRTIO_CONFIG_S_ACKNOWLEDGE);