virtio_blk: allow re-reading config space at runtime (7a7c924c) · Commits · 戴 / test

drivers/block/virtio_blk.c

+78 −10

Original line number	Diff line number	Diff line
		@@ -6,10 +6,12 @@
		#include <linux/virtio.h>
		#include <linux/virtio_blk.h>
		#include <linux/scatterlist.h>
		#include <linux/string_helpers.h>

		#define PART_BITS 4

		static int major, index;
		struct workqueue_struct *virtblk_wq;

		struct virtio_blk
		{
		@@ -26,6 +28,9 @@ struct virtio_blk

		mempool_t *pool;

		/* Process context for config space updates */
		struct work_struct config_work;

		/* What host tells us, plus 2 for header & tailer. */
		unsigned int sg_elems;

		@@ -291,6 +296,46 @@ static ssize_t virtblk_serial_show(struct device *dev,
		}
		DEVICE_ATTR(serial, S_IRUGO, virtblk_serial_show, NULL);

		static void virtblk_config_changed_work(struct work_struct *work)
		{
		struct virtio_blk *vblk =
		container_of(work, struct virtio_blk, config_work);
		struct virtio_device *vdev = vblk->vdev;
		struct request_queue *q = vblk->disk->queue;
		char cap_str_2[10], cap_str_10[10];
		u64 capacity, size;

		/* Host must always specify the capacity. */
		vdev->config->get(vdev, offsetof(struct virtio_blk_config, capacity),
		&capacity, sizeof(capacity));

		/* If capacity is too big, truncate with warning. */
		if ((sector_t)capacity != capacity) {
		dev_warn(&vdev->dev, "Capacity %llu too large: truncating\n",
		(unsigned long long)capacity);
		capacity = (sector_t)-1;
		}

		size = capacity * queue_logical_block_size(q);
		string_get_size(size, STRING_UNITS_2, cap_str_2, sizeof(cap_str_2));
		string_get_size(size, STRING_UNITS_10, cap_str_10, sizeof(cap_str_10));

		dev_notice(&vdev->dev,
		"new size: %llu %d-byte logical blocks (%s/%s)\n",
		(unsigned long long)capacity,
		queue_logical_block_size(q),
		cap_str_10, cap_str_2);

		set_capacity(vblk->disk, capacity);
		}

		static void virtblk_config_changed(struct virtio_device *vdev)
		{
		struct virtio_blk *vblk = vdev->priv;

		queue_work(virtblk_wq, &vblk->config_work);
		}

		static int __devinit virtblk_probe(struct virtio_device *vdev)
		{
		struct virtio_blk *vblk;
		@@ -327,6 +372,7 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
		vblk->vdev = vdev;
		vblk->sg_elems = sg_elems;
		sg_init_table(vblk->sg, vblk->sg_elems);
		INIT_WORK(&vblk->config_work, virtblk_config_changed_work);

		/* We expect one virtqueue, for output. */
		vblk->vq = virtio_find_single_vq(vdev, blk_done, "requests");
		@@ -477,6 +523,8 @@ static void __devexit virtblk_remove(struct virtio_device *vdev)
		{
		struct virtio_blk *vblk = vdev->priv;

		flush_work(&vblk->config_work);

		/* Nothing should be pending. */
		BUG_ON(!list_empty(&vblk->reqs));

		@@ -515,20 +563,40 @@ static struct virtio_driver __refdata virtio_blk = {
		.id_table = id_table,
		.probe = virtblk_probe,
		.remove = __devexit_p(virtblk_remove),
		.config_changed = virtblk_config_changed,
		};

		static int __init init(void)
		{
		int error;

		virtblk_wq = alloc_workqueue("virtio-blk", 0, 0);
		if (!virtblk_wq)
		return -ENOMEM;

		major = register_blkdev(0, "virtblk");
		if (major < 0)
		return major;
		return register_virtio_driver(&virtio_blk);
		if (major < 0) {
		error = major;
		goto out_destroy_workqueue;
		}

		error = register_virtio_driver(&virtio_blk);
		if (error)
		goto out_unregister_blkdev;
		return 0;

		out_unregister_blkdev:
		unregister_blkdev(major, "virtblk");
		out_destroy_workqueue:
		destroy_workqueue(virtblk_wq);
		return error;
		}

		static void __exit fini(void)
		{
		unregister_blkdev(major, "virtblk");
		unregister_virtio_driver(&virtio_blk);
		destroy_workqueue(virtblk_wq);
		}
		module_init(init);
		module_exit(fini);

Admin message