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

Commit 4d272f90 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'virtio-next-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux 

Pull virtio fixes from Rusty Russell:
 "Not entirely surprising: the ongoing QEMU work on virtio 1.0 has
  revealed more minor issues with our virtio 1.0 drivers just introduced
  in the kernel.

  (I would normally use my fixes branch for this, but there were a batch
  of them...)"

* tag 'virtio-next-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux:
  virtio_mmio: fix access width for mmio
  uapi/virtio_scsi: allow overriding CDB/SENSE size
  virtio_mmio: generation support
  virtio_rpmsg: set DRIVER_OK before using device
  9p/trans_virtio: fix hot-unplug
  virtio-balloon: do not call blocking ops when !TASK_RUNNING
  virtio_blk: fix comment for virtio 1.0
  virtio_blk: typo fix
  virtio_balloon: set DRIVER_OK before using device
  virtio_console: avoid config access from irq
  virtio_console: init work unconditionally
parents 2fc67756 704a0b5f

drivers/char/virtio_console.c

+18 −1
Original line number Diff line number Diff line
@@ -142,6 +142,7 @@ struct ports_device { 
	 * notification

	 */

	struct work_struct control_work;

	struct work_struct config_work;



	struct list_head ports;
@@ -1837,10 +1838,21 @@ static void config_intr(struct virtio_device *vdev) 


	portdev = vdev->priv;



	if (!use_multiport(portdev))

		schedule_work(&portdev->config_work);

}



static void config_work_handler(struct work_struct *work)

{

	struct ports_device *portdev;



	portdev = container_of(work, struct ports_device, control_work);

	if (!use_multiport(portdev)) {

		struct virtio_device *vdev;

		struct port *port;

		u16 rows, cols;



		vdev = portdev->vdev;

		virtio_cread(vdev, struct virtio_console_config, cols, &cols);

		virtio_cread(vdev, struct virtio_console_config, rows, &rows);
@@ -2040,12 +2052,14 @@ static int virtcons_probe(struct virtio_device *vdev) 


	virtio_device_ready(portdev->vdev);



	INIT_WORK(&portdev->config_work, &config_work_handler);

	INIT_WORK(&portdev->control_work, &control_work_handler);



	if (multiport) {

		unsigned int nr_added_bufs;



		spin_lock_init(&portdev->c_ivq_lock);

		spin_lock_init(&portdev->c_ovq_lock);

		INIT_WORK(&portdev->control_work, &control_work_handler);



		nr_added_bufs = fill_queue(portdev->c_ivq,

					   &portdev->c_ivq_lock);
@@ -2113,6 +2127,8 @@ static void virtcons_remove(struct virtio_device *vdev) 
	/* Finish up work that's lined up */

	if (use_multiport(portdev))

		cancel_work_sync(&portdev->control_work);

	else

		cancel_work_sync(&portdev->config_work);



	list_for_each_entry_safe(port, port2, &portdev->ports, list)

		unplug_port(port);
@@ -2164,6 +2180,7 @@ static int virtcons_freeze(struct virtio_device *vdev) 


	virtqueue_disable_cb(portdev->c_ivq);

	cancel_work_sync(&portdev->control_work);

	cancel_work_sync(&portdev->config_work);

	/*

	 * Once more: if control_work_handler() was running, it would

	 * enable the cb as the last step.

drivers/rpmsg/virtio_rpmsg_bus.c

+16 −1
Original line number Diff line number Diff line
@@ -951,6 +951,7 @@ static int rpmsg_probe(struct virtio_device *vdev) 
	void *bufs_va;

	int err = 0, i;

	size_t total_buf_space;

	bool notify;



	vrp = kzalloc(sizeof(*vrp), GFP_KERNEL);

	if (!vrp)
@@ -1030,8 +1031,22 @@ static int rpmsg_probe(struct virtio_device *vdev) 
		}

	}



	/*

	 * Prepare to kick but don't notify yet - we can't do this before

	 * device is ready.

	 */

	notify = virtqueue_kick_prepare(vrp->rvq);



	/* From this point on, we can notify and get callbacks. */

	virtio_device_ready(vdev);



	/* tell the remote processor it can start sending messages */

	virtqueue_kick(vrp->rvq);

	/*

	 * this might be concurrent with callbacks, but we are only

	 * doing notify, not a full kick here, so that's ok.

	 */

	if (notify)

		virtqueue_notify(vrp->rvq);



	dev_info(&vdev->dev, "rpmsg host is online\n");

drivers/virtio/virtio_balloon.c

+16 −5
Original line number Diff line number Diff line
@@ -29,6 +29,7 @@ 
#include <linux/module.h>

#include <linux/balloon_compaction.h>

#include <linux/oom.h>

#include <linux/wait.h>



/*

 * Balloon device works in 4K page units.  So each page is pointed to by
@@ -334,17 +335,25 @@ static int virtballoon_oom_notify(struct notifier_block *self, 
static int balloon(void *_vballoon)

{

	struct virtio_balloon *vb = _vballoon;

	DEFINE_WAIT_FUNC(wait, woken_wake_function);



	set_freezable();

	while (!kthread_should_stop()) {

		s64 diff;



		try_to_freeze();

		wait_event_interruptible(vb->config_change,

					 (diff = towards_target(vb)) != 0

					 || vb->need_stats_update

					 || kthread_should_stop()

					 || freezing(current));



		add_wait_queue(&vb->config_change, &wait);

		for (;;) {

			if ((diff = towards_target(vb)) != 0 ||

			    vb->need_stats_update ||

			    kthread_should_stop() ||

			    freezing(current))

				break;

			wait_woken(&wait, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);

		}

		remove_wait_queue(&vb->config_change, &wait);



		if (vb->need_stats_update)

			stats_handle_request(vb);

		if (diff > 0)
@@ -499,6 +508,8 @@ static int virtballoon_probe(struct virtio_device *vdev) 
	if (err < 0)

		goto out_oom_notify;



	virtio_device_ready(vdev);



	vb->thread = kthread_run(balloon, vb, "vballoon");

	if (IS_ERR(vb->thread)) {

		err = PTR_ERR(vb->thread);

drivers/virtio/virtio_mmio.c

+82 −8
Original line number Diff line number Diff line
@@ -156,22 +156,95 @@ static void vm_get(struct virtio_device *vdev, unsigned offset, 
		   void *buf, unsigned len)

{

	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);

	void __iomem *base = vm_dev->base + VIRTIO_MMIO_CONFIG;

	u8 b;

	__le16 w;

	__le32 l;



	if (vm_dev->version == 1) {

		u8 *ptr = buf;

		int i;



		for (i = 0; i < len; i++)

		ptr[i] = readb(vm_dev->base + VIRTIO_MMIO_CONFIG + offset + i);

			ptr[i] = readb(base + offset + i);

		return;

	}



	switch (len) {

	case 1:

		b = readb(base + offset);

		memcpy(buf, &b, sizeof b);

		break;

	case 2:

		w = cpu_to_le16(readw(base + offset));

		memcpy(buf, &w, sizeof w);

		break;

	case 4:

		l = cpu_to_le32(readl(base + offset));

		memcpy(buf, &l, sizeof l);

		break;

	case 8:

		l = cpu_to_le32(readl(base + offset));

		memcpy(buf, &l, sizeof l);

		l = cpu_to_le32(ioread32(base + offset + sizeof l));

		memcpy(buf + sizeof l, &l, sizeof l);

		break;

	default:

		BUG();

	}

}



static void vm_set(struct virtio_device *vdev, unsigned offset,

		   const void *buf, unsigned len)

{

	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);

	void __iomem *base = vm_dev->base + VIRTIO_MMIO_CONFIG;

	u8 b;

	__le16 w;

	__le32 l;



	if (vm_dev->version == 1) {

		const u8 *ptr = buf;

		int i;



		for (i = 0; i < len; i++)

		writeb(ptr[i], vm_dev->base + VIRTIO_MMIO_CONFIG + offset + i);

			writeb(ptr[i], base + offset + i);



		return;

	}



	switch (len) {

	case 1:

		memcpy(&b, buf, sizeof b);

		writeb(b, base + offset);

		break;

	case 2:

		memcpy(&w, buf, sizeof w);

		writew(le16_to_cpu(w), base + offset);

		break;

	case 4:

		memcpy(&l, buf, sizeof l);

		writel(le32_to_cpu(l), base + offset);

		break;

	case 8:

		memcpy(&l, buf, sizeof l);

		writel(le32_to_cpu(l), base + offset);

		memcpy(&l, buf + sizeof l, sizeof l);

		writel(le32_to_cpu(l), base + offset + sizeof l);

		break;

	default:

		BUG();

	}

}



static u32 vm_generation(struct virtio_device *vdev)

{

	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);



	if (vm_dev->version == 1)

		return 0;

	else

		return readl(vm_dev->base + VIRTIO_MMIO_CONFIG_GENERATION);

}



static u8 vm_get_status(struct virtio_device *vdev)
@@ -440,6 +513,7 @@ static const char *vm_bus_name(struct virtio_device *vdev) 
static const struct virtio_config_ops virtio_mmio_config_ops = {

	.get		= vm_get,

	.set		= vm_set,

	.generation	= vm_generation,

	.get_status	= vm_get_status,

	.set_status	= vm_set_status,

	.reset		= vm_reset,

include/uapi/linux/virtio_blk.h

+6 −2
Original line number Diff line number Diff line
@@ -60,7 +60,7 @@ struct virtio_blk_config { 
	__u32 size_max;

	/* The maximum number of segments (if VIRTIO_BLK_F_SEG_MAX) */

	__u32 seg_max;

	/* geometry the device (if VIRTIO_BLK_F_GEOMETRY) */

	/* geometry of the device (if VIRTIO_BLK_F_GEOMETRY) */

	struct virtio_blk_geometry {

		__u16 cylinders;

		__u8 heads;
@@ -119,7 +119,11 @@ struct virtio_blk_config { 
#define VIRTIO_BLK_T_BARRIER	0x80000000

#endif /* !VIRTIO_BLK_NO_LEGACY */



/* This is the first element of the read scatter-gather list. */

/*

 * This comes first in the read scatter-gather list.

 * For legacy virtio, if VIRTIO_F_ANY_LAYOUT is not negotiated,

 * this is the first element of the read scatter-gather list.

 */

struct virtio_blk_outhdr {

	/* VIRTIO_BLK_T* */

	__virtio32 type;