Merge branch 'virtio-next' of git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux (dc92b1f9) · Commits · 戴 / test

arch/s390/Kconfig

+0 −1

Original line number	Diff line number	Diff line
		@@ -656,7 +656,6 @@ config S390_GUEST
		depends on 64BIT && EXPERIMENTAL
		select VIRTUALIZATION
		select VIRTIO
		select VIRTIO_RING
		select VIRTIO_CONSOLE
		help
		Enabling this option adds support for virtio based paravirtual device

arch/x86/lguest/Kconfig

+0 −1

Original line number	Diff line number	Diff line
		@@ -4,7 +4,6 @@ config LGUEST_GUEST
		depends on X86_32
		select VIRTUALIZATION
		select VIRTIO
		select VIRTIO_RING
		select VIRTIO_CONSOLE
		help
		Lguest is a tiny in-kernel hypervisor. Selecting this will

drivers/block/virtio_blk.c

+269 −37

Original line number	Diff line number	Diff line
		@@ -14,6 +14,9 @@

		#define PART_BITS 4

		static bool use_bio;
		module_param(use_bio, bool, S_IRUGO);

		static int major;
		static DEFINE_IDA(vd_index_ida);

		@@ -23,6 +26,7 @@ struct virtio_blk
		{
		struct virtio_device *vdev;
		struct virtqueue *vq;
		wait_queue_head_t queue_wait;

		/* The disk structure for the kernel. */
		struct gendisk *disk;
		@@ -51,53 +55,244 @@ struct virtio_blk
		struct virtblk_req
		{
		struct request *req;
		struct bio *bio;
		struct virtio_blk_outhdr out_hdr;
		struct virtio_scsi_inhdr in_hdr;
		struct work_struct work;
		struct virtio_blk *vblk;
		int flags;
		u8 status;
		struct scatterlist sg[];
		};

		static void blk_done(struct virtqueue *vq)
		{
		struct virtio_blk *vblk = vq->vdev->priv;
		struct virtblk_req *vbr;
		unsigned int len;
		unsigned long flags;

		spin_lock_irqsave(vblk->disk->queue->queue_lock, flags);
		while ((vbr = virtqueue_get_buf(vblk->vq, &len)) != NULL) {
		int error;
		enum {
		VBLK_IS_FLUSH = 1,
		VBLK_REQ_FLUSH = 2,
		VBLK_REQ_DATA = 4,
		VBLK_REQ_FUA = 8,
		};

		static inline int virtblk_result(struct virtblk_req *vbr)
		{
		switch (vbr->status) {
		case VIRTIO_BLK_S_OK:
		error = 0;
		break;
		return 0;
		case VIRTIO_BLK_S_UNSUPP:
		error = -ENOTTY;
		break;
		return -ENOTTY;
		default:
		error = -EIO;
		break;
		return -EIO;
		}
		}

		switch (vbr->req->cmd_type) {
		case REQ_TYPE_BLOCK_PC:
		vbr->req->resid_len = vbr->in_hdr.residual;
		vbr->req->sense_len = vbr->in_hdr.sense_len;
		vbr->req->errors = vbr->in_hdr.errors;
		break;
		case REQ_TYPE_SPECIAL:
		vbr->req->errors = (error != 0);
		break;
		default:
		static inline struct virtblk_req virtblk_alloc_req(struct virtio_blk vblk,
		gfp_t gfp_mask)
		{
		struct virtblk_req *vbr;

		vbr = mempool_alloc(vblk->pool, gfp_mask);
		if (!vbr)
		return NULL;

		vbr->vblk = vblk;
		if (use_bio)
		sg_init_table(vbr->sg, vblk->sg_elems);

		return vbr;
		}

		static void virtblk_add_buf_wait(struct virtio_blk *vblk,
		struct virtblk_req *vbr,
		unsigned long out,
		unsigned long in)
		{
		DEFINE_WAIT(wait);

		for (;;) {
		prepare_to_wait_exclusive(&vblk->queue_wait, &wait,
		TASK_UNINTERRUPTIBLE);

		spin_lock_irq(vblk->disk->queue->queue_lock);
		if (virtqueue_add_buf(vblk->vq, vbr->sg, out, in, vbr,
		GFP_ATOMIC) < 0) {
		spin_unlock_irq(vblk->disk->queue->queue_lock);
		io_schedule();
		} else {
		virtqueue_kick(vblk->vq);
		spin_unlock_irq(vblk->disk->queue->queue_lock);
		break;
		}

		__blk_end_request_all(vbr->req, error);
		}

		finish_wait(&vblk->queue_wait, &wait);
		}

		static inline void virtblk_add_req(struct virtblk_req *vbr,
		unsigned int out, unsigned int in)
		{
		struct virtio_blk *vblk = vbr->vblk;

		spin_lock_irq(vblk->disk->queue->queue_lock);
		if (unlikely(virtqueue_add_buf(vblk->vq, vbr->sg, out, in, vbr,
		GFP_ATOMIC) < 0)) {
		spin_unlock_irq(vblk->disk->queue->queue_lock);
		virtblk_add_buf_wait(vblk, vbr, out, in);
		return;
		}
		virtqueue_kick(vblk->vq);
		spin_unlock_irq(vblk->disk->queue->queue_lock);
		}

		static int virtblk_bio_send_flush(struct virtblk_req *vbr)
		{
		unsigned int out = 0, in = 0;

		vbr->flags \|= VBLK_IS_FLUSH;
		vbr->out_hdr.type = VIRTIO_BLK_T_FLUSH;
		vbr->out_hdr.sector = 0;
		vbr->out_hdr.ioprio = 0;
		sg_set_buf(&vbr->sg[out++], &vbr->out_hdr, sizeof(vbr->out_hdr));
		sg_set_buf(&vbr->sg[out + in++], &vbr->status, sizeof(vbr->status));

		virtblk_add_req(vbr, out, in);

		return 0;
		}

		static int virtblk_bio_send_data(struct virtblk_req *vbr)
		{
		struct virtio_blk *vblk = vbr->vblk;
		unsigned int num, out = 0, in = 0;
		struct bio *bio = vbr->bio;

		vbr->flags &= ~VBLK_IS_FLUSH;
		vbr->out_hdr.type = 0;
		vbr->out_hdr.sector = bio->bi_sector;
		vbr->out_hdr.ioprio = bio_prio(bio);

		sg_set_buf(&vbr->sg[out++], &vbr->out_hdr, sizeof(vbr->out_hdr));

		num = blk_bio_map_sg(vblk->disk->queue, bio, vbr->sg + out);

		sg_set_buf(&vbr->sg[num + out + in++], &vbr->status,
		sizeof(vbr->status));

		if (num) {
		if (bio->bi_rw & REQ_WRITE) {
		vbr->out_hdr.type \|= VIRTIO_BLK_T_OUT;
		out += num;
		} else {
		vbr->out_hdr.type \|= VIRTIO_BLK_T_IN;
		in += num;
		}
		}

		virtblk_add_req(vbr, out, in);

		return 0;
		}

		static void virtblk_bio_send_data_work(struct work_struct *work)
		{
		struct virtblk_req *vbr;

		vbr = container_of(work, struct virtblk_req, work);

		virtblk_bio_send_data(vbr);
		}

		static void virtblk_bio_send_flush_work(struct work_struct *work)
		{
		struct virtblk_req *vbr;

		vbr = container_of(work, struct virtblk_req, work);

		virtblk_bio_send_flush(vbr);
		}

		static inline void virtblk_request_done(struct virtblk_req *vbr)
		{
		struct virtio_blk *vblk = vbr->vblk;
		struct request *req = vbr->req;
		int error = virtblk_result(vbr);

		if (req->cmd_type == REQ_TYPE_BLOCK_PC) {
		req->resid_len = vbr->in_hdr.residual;
		req->sense_len = vbr->in_hdr.sense_len;
		req->errors = vbr->in_hdr.errors;
		} else if (req->cmd_type == REQ_TYPE_SPECIAL) {
		req->errors = (error != 0);
		}

		__blk_end_request_all(req, error);
		mempool_free(vbr, vblk->pool);
		}

		static inline void virtblk_bio_flush_done(struct virtblk_req *vbr)
		{
		struct virtio_blk *vblk = vbr->vblk;

		if (vbr->flags & VBLK_REQ_DATA) {
		/* Send out the actual write data */
		INIT_WORK(&vbr->work, virtblk_bio_send_data_work);
		queue_work(virtblk_wq, &vbr->work);
		} else {
		bio_endio(vbr->bio, virtblk_result(vbr));
		mempool_free(vbr, vblk->pool);
		}
		}

		static inline void virtblk_bio_data_done(struct virtblk_req *vbr)
		{
		struct virtio_blk *vblk = vbr->vblk;

		if (unlikely(vbr->flags & VBLK_REQ_FUA)) {
		/* Send out a flush before end the bio */
		vbr->flags &= ~VBLK_REQ_DATA;
		INIT_WORK(&vbr->work, virtblk_bio_send_flush_work);
		queue_work(virtblk_wq, &vbr->work);
		} else {
		bio_endio(vbr->bio, virtblk_result(vbr));
		mempool_free(vbr, vblk->pool);
		}
		}

		static inline void virtblk_bio_done(struct virtblk_req *vbr)
		{
		if (unlikely(vbr->flags & VBLK_IS_FLUSH))
		virtblk_bio_flush_done(vbr);
		else
		virtblk_bio_data_done(vbr);
		}

		static void virtblk_done(struct virtqueue *vq)
		{
		struct virtio_blk *vblk = vq->vdev->priv;
		bool bio_done = false, req_done = false;
		struct virtblk_req *vbr;
		unsigned long flags;
		unsigned int len;

		spin_lock_irqsave(vblk->disk->queue->queue_lock, flags);
		do {
		virtqueue_disable_cb(vq);
		while ((vbr = virtqueue_get_buf(vblk->vq, &len)) != NULL) {
		if (vbr->bio) {
		virtblk_bio_done(vbr);
		bio_done = true;
		} else {
		virtblk_request_done(vbr);
		req_done = true;
		}
		}
		} while (!virtqueue_enable_cb(vq));
		/* In case queue is stopped waiting for more buffers. */
		if (req_done)
		blk_start_queue(vblk->disk->queue);
		spin_unlock_irqrestore(vblk->disk->queue->queue_lock, flags);

		if (bio_done)
		wake_up(&vblk->queue_wait);
		}

		static bool do_req(struct request_queue q, struct virtio_blk vblk,
		@@ -106,13 +301,13 @@ static bool do_req(struct request_queue q, struct virtio_blk vblk,
		unsigned long num, out = 0, in = 0;
		struct virtblk_req *vbr;

		vbr = mempool_alloc(vblk->pool, GFP_ATOMIC);
		vbr = virtblk_alloc_req(vblk, GFP_ATOMIC);
		if (!vbr)
		/* When another request finishes we'll try again. */
		return false;

		vbr->req = req;

		vbr->bio = NULL;
		if (req->cmd_flags & REQ_FLUSH) {
		vbr->out_hdr.type = VIRTIO_BLK_T_FLUSH;
		vbr->out_hdr.sector = 0;
		@@ -172,7 +367,8 @@ static bool do_req(struct request_queue q, struct virtio_blk vblk,
		}
		}

		if (virtqueue_add_buf(vblk->vq, vblk->sg, out, in, vbr, GFP_ATOMIC)<0) {
		if (virtqueue_add_buf(vblk->vq, vblk->sg, out, in, vbr,
		GFP_ATOMIC) < 0) {
		mempool_free(vbr, vblk->pool);
		return false;
		}
		@@ -180,7 +376,7 @@ static bool do_req(struct request_queue q, struct virtio_blk vblk,
		return true;
		}

		static void do_virtblk_request(struct request_queue *q)
		static void virtblk_request(struct request_queue *q)
		{
		struct virtio_blk *vblk = q->queuedata;
		struct request *req;
		@@ -203,6 +399,34 @@ static void do_virtblk_request(struct request_queue *q)
		virtqueue_kick(vblk->vq);
		}

		static void virtblk_make_request(struct request_queue q, struct bio bio)
		{
		struct virtio_blk *vblk = q->queuedata;
		struct virtblk_req *vbr;

		BUG_ON(bio->bi_phys_segments + 2 > vblk->sg_elems);

		vbr = virtblk_alloc_req(vblk, GFP_NOIO);
		if (!vbr) {
		bio_endio(bio, -ENOMEM);
		return;
		}

		vbr->bio = bio;
		vbr->flags = 0;
		if (bio->bi_rw & REQ_FLUSH)
		vbr->flags \|= VBLK_REQ_FLUSH;
		if (bio->bi_rw & REQ_FUA)
		vbr->flags \|= VBLK_REQ_FUA;
		if (bio->bi_size)
		vbr->flags \|= VBLK_REQ_DATA;

		if (unlikely(vbr->flags & VBLK_REQ_FLUSH))
		virtblk_bio_send_flush(vbr);
		else
		virtblk_bio_send_data(vbr);
		}

		/* return id (s/n) string for disk to id_str
		*/
		static int virtblk_get_id(struct gendisk disk, char id_str)
		@@ -360,7 +584,7 @@ static int init_vq(struct virtio_blk *vblk)
		int err = 0;

		/* We expect one virtqueue, for output. */
		vblk->vq = virtio_find_single_vq(vblk->vdev, blk_done, "requests");
		vblk->vq = virtio_find_single_vq(vblk->vdev, virtblk_done, "requests");
		if (IS_ERR(vblk->vq))
		err = PTR_ERR(vblk->vq);

		@@ -477,6 +701,8 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
		struct virtio_blk *vblk;
		struct request_queue *q;
		int err, index;
		int pool_size;

		u64 cap;
		u32 v, blk_size, sg_elems, opt_io_size;
		u16 min_io_size;
		@@ -506,10 +732,12 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
		goto out_free_index;
		}

		init_waitqueue_head(&vblk->queue_wait);
		vblk->vdev = vdev;
		vblk->sg_elems = sg_elems;
		sg_init_table(vblk->sg, vblk->sg_elems);
		mutex_init(&vblk->config_lock);

		INIT_WORK(&vblk->config_work, virtblk_config_changed_work);
		vblk->config_enable = true;

		@@ -517,7 +745,10 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
		if (err)
		goto out_free_vblk;

		vblk->pool = mempool_create_kmalloc_pool(1,sizeof(struct virtblk_req));
		pool_size = sizeof(struct virtblk_req);
		if (use_bio)
		pool_size += sizeof(struct scatterlist) * sg_elems;
		vblk->pool = mempool_create_kmalloc_pool(1, pool_size);
		if (!vblk->pool) {
		err = -ENOMEM;
		goto out_free_vq;
		@@ -530,12 +761,14 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
		goto out_mempool;
		}

		q = vblk->disk->queue = blk_init_queue(do_virtblk_request, NULL);
		q = vblk->disk->queue = blk_init_queue(virtblk_request, NULL);
		if (!q) {
		err = -ENOMEM;
		goto out_put_disk;
		}

		if (use_bio)
		blk_queue_make_request(q, virtblk_make_request);
		q->queuedata = vblk;

		virtblk_name_format("vd", index, vblk->disk->disk_name, DISK_NAME_LEN);
		@@ -620,7 +853,6 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
		if (!err && opt_io_size)
		blk_queue_io_opt(q, blk_size * opt_io_size);


		add_disk(vblk->disk);
		err = device_create_file(disk_to_dev(vblk->disk), &dev_attr_serial);
		if (err)

drivers/char/virtio_console.c

+178 −20

Original line number	Diff line number	Diff line
		@@ -24,6 +24,8 @@
		#include <linux/err.h>
		#include <linux/freezer.h>
		#include <linux/fs.h>
		#include <linux/splice.h>
		#include <linux/pagemap.h>
		#include <linux/init.h>
		#include <linux/list.h>
		#include <linux/poll.h>
		@@ -474,26 +476,53 @@ static ssize_t send_control_msg(struct port *port, unsigned int event,
		return 0;
		}

		struct buffer_token {
		union {
		void *buf;
		struct scatterlist *sg;
		} u;
		/* If sgpages == 0 then buf is used, else sg is used */
		unsigned int sgpages;
		};

		static void reclaim_sg_pages(struct scatterlist *sg, unsigned int nrpages)
		{
		int i;
		struct page *page;

		for (i = 0; i < nrpages; i++) {
		page = sg_page(&sg[i]);
		if (!page)
		break;
		put_page(page);
		}
		kfree(sg);
		}

		/* Callers must take the port->outvq_lock */
		static void reclaim_consumed_buffers(struct port *port)
		{
		void *buf;
		struct buffer_token *tok;
		unsigned int len;

		if (!port->portdev) {
		/* Device has been unplugged. vqs are already gone. */
		return;
		}
		while ((buf = virtqueue_get_buf(port->out_vq, &len))) {
		kfree(buf);
		while ((tok = virtqueue_get_buf(port->out_vq, &len))) {
		if (tok->sgpages)
		reclaim_sg_pages(tok->u.sg, tok->sgpages);
		else
		kfree(tok->u.buf);
		kfree(tok);
		port->outvq_full = false;
		}
		}

		static ssize_t send_buf(struct port port, void in_buf, size_t in_count,
		bool nonblock)
		static ssize_t __send_to_port(struct port port, struct scatterlist sg,
		int nents, size_t in_count,
		struct buffer_token *tok, bool nonblock)
		{
		struct scatterlist sg[1];
		struct virtqueue *out_vq;
		ssize_t ret;
		unsigned long flags;
		@@ -505,8 +534,7 @@ static ssize_t send_buf(struct port port, void in_buf, size_t in_count,

		reclaim_consumed_buffers(port);

		sg_init_one(sg, in_buf, in_count);
		ret = virtqueue_add_buf(out_vq, sg, 1, 0, in_buf, GFP_ATOMIC);
		ret = virtqueue_add_buf(out_vq, sg, nents, 0, tok, GFP_ATOMIC);

		/* Tell Host to go! */
		virtqueue_kick(out_vq);
		@@ -544,6 +572,37 @@ done:
		return in_count;
		}

		static ssize_t send_buf(struct port port, void in_buf, size_t in_count,
		bool nonblock)
		{
		struct scatterlist sg[1];
		struct buffer_token *tok;

		tok = kmalloc(sizeof(*tok), GFP_ATOMIC);
		if (!tok)
		return -ENOMEM;
		tok->sgpages = 0;
		tok->u.buf = in_buf;

		sg_init_one(sg, in_buf, in_count);

		return __send_to_port(port, sg, 1, in_count, tok, nonblock);
		}

		static ssize_t send_pages(struct port port, struct scatterlist sg, int nents,
		size_t in_count, bool nonblock)
		{
		struct buffer_token *tok;

		tok = kmalloc(sizeof(*tok), GFP_ATOMIC);
		if (!tok)
		return -ENOMEM;
		tok->sgpages = nents;
		tok->u.sg = sg;

		return __send_to_port(port, sg, nents, in_count, tok, nonblock);
		}

		/*
		* Give out the data that's requested from the buffer that we have
		* queued up.
		@@ -665,6 +724,26 @@ static ssize_t port_fops_read(struct file filp, char __user ubuf,
		return fill_readbuf(port, ubuf, count, true);
		}

		static int wait_port_writable(struct port *port, bool nonblock)
		{
		int ret;

		if (will_write_block(port)) {
		if (nonblock)
		return -EAGAIN;

		ret = wait_event_freezable(port->waitqueue,
		!will_write_block(port));
		if (ret < 0)
		return ret;
		}
		/* Port got hot-unplugged. */
		if (!port->guest_connected)
		return -ENODEV;

		return 0;
		}

		static ssize_t port_fops_write(struct file filp, const char __user ubuf,
		size_t count, loff_t *offp)
		{
		@@ -681,18 +760,9 @@ static ssize_t port_fops_write(struct file filp, const char __user ubuf,

		nonblock = filp->f_flags & O_NONBLOCK;

		if (will_write_block(port)) {
		if (nonblock)
		return -EAGAIN;

		ret = wait_event_freezable(port->waitqueue,
		!will_write_block(port));
		ret = wait_port_writable(port, nonblock);
		if (ret < 0)
		return ret;
		}
		/* Port got hot-unplugged. */
		if (!port->guest_connected)
		return -ENODEV;

		count = min((size_t)(32 * 1024), count);

		@@ -725,6 +795,93 @@ out:
		return ret;
		}

		struct sg_list {
		unsigned int n;
		unsigned int size;
		size_t len;
		struct scatterlist *sg;
		};

		static int pipe_to_sg(struct pipe_inode_info pipe, struct pipe_buffer buf,
		struct splice_desc *sd)
		{
		struct sg_list *sgl = sd->u.data;
		unsigned int offset, len;

		if (sgl->n == sgl->size)
		return 0;

		/* Try lock this page */
		if (buf->ops->steal(pipe, buf) == 0) {
		/* Get reference and unlock page for moving */
		get_page(buf->page);
		unlock_page(buf->page);

		len = min(buf->len, sd->len);
		sg_set_page(&(sgl->sg[sgl->n]), buf->page, len, buf->offset);
		} else {
		/* Failback to copying a page */
		struct page *page = alloc_page(GFP_KERNEL);
		char *src = buf->ops->map(pipe, buf, 1);
		char *dst;

		if (!page)
		return -ENOMEM;
		dst = kmap(page);

		offset = sd->pos & ~PAGE_MASK;

		len = sd->len;
		if (len + offset > PAGE_SIZE)
		len = PAGE_SIZE - offset;

		memcpy(dst + offset, src + buf->offset, len);

		kunmap(page);
		buf->ops->unmap(pipe, buf, src);

		sg_set_page(&(sgl->sg[sgl->n]), page, len, offset);
		}
		sgl->n++;
		sgl->len += len;

		return len;
		}

		/* Faster zero-copy write by splicing */
		static ssize_t port_fops_splice_write(struct pipe_inode_info *pipe,
		struct file filp, loff_t ppos,
		size_t len, unsigned int flags)
		{
		struct port *port = filp->private_data;
		struct sg_list sgl;
		ssize_t ret;
		struct splice_desc sd = {
		.total_len = len,
		.flags = flags,
		.pos = *ppos,
		.u.data = &sgl,
		};

		ret = wait_port_writable(port, filp->f_flags & O_NONBLOCK);
		if (ret < 0)
		return ret;

		sgl.n = 0;
		sgl.len = 0;
		sgl.size = pipe->nrbufs;
		sgl.sg = kmalloc(sizeof(struct scatterlist) * sgl.size, GFP_KERNEL);
		if (unlikely(!sgl.sg))
		return -ENOMEM;

		sg_init_table(sgl.sg, sgl.size);
		ret = __splice_from_pipe(pipe, &sd, pipe_to_sg);
		if (likely(ret > 0))
		ret = send_pages(port, sgl.sg, sgl.n, sgl.len, true);

		return ret;
		}

		static unsigned int port_fops_poll(struct file filp, poll_table wait)
		{
		struct port *port;
		@@ -856,6 +1013,7 @@ static const struct file_operations port_fops = {
		.open = port_fops_open,
		.read = port_fops_read,
		.write = port_fops_write,
		.splice_write = port_fops_splice_write,
		.poll = port_fops_poll,
		.release = port_fops_release,
		.fasync = port_fops_fasync,

drivers/lguest/lguest_device.c

+4 −1

Original line number	Diff line number	Diff line
		@@ -263,6 +263,9 @@ static struct virtqueue lg_find_vq(struct virtio_device vdev,
		struct virtqueue *vq;
		int err;

		if (!name)
		return NULL;

		/* We must have this many virtqueues. */
		if (index >= ldev->desc->num_vq)
		return ERR_PTR(-ENOENT);
		@@ -296,7 +299,7 @@ static struct virtqueue lg_find_vq(struct virtio_device vdev,
		* to 'true': the host just a(nother) SMP CPU, so we only need inter-cpu
		* barriers.
		*/
		vq = vring_new_virtqueue(lvq->config.num, LGUEST_VRING_ALIGN, vdev,
		vq = vring_new_virtqueue(index, lvq->config.num, LGUEST_VRING_ALIGN, vdev,
		true, lvq->pages, lg_notify, callback, name);
		if (!vq) {
		err = -ENOMEM;

Admin message