[PATCH v1 1/3] virtio-net: Using single MSIX IRQ for TX/RX Q pair

[PATCH v1 1/3] virtio-net: Using single MSIX IRQ for TX/RX Q pair

[Ravi Kerur]

Ported earlier patch from Jason Wang (dated 12/26/2014).

This patch tries to reduce the number of MSIX irqs required for
virtio-net by sharing a MSIX irq for each TX/RX queue pair through
channels. If transport support channel, about half of the MSIX irqs
were reduced.

Signed-off-by: Ravi Kerur <rkerur@gmail.com>
---
 drivers/net/virtio_net.c | 29 ++++++++++++++++++++++++++++-
 1 file changed, 28 insertions(+), 1 deletion(-)

diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index d8838ded..d705cce 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -72,6 +72,9 @@ struct send_queue {
 
 	/* Name of the send queue: output.$index */
 	char name[40];
+
+	/* Name of the channel, shared with irq. */
+	char channel_name[40];
 };
 
 /* Internal representation of a receive virtqueue */
@@ -1529,6 +1532,8 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
 	int ret = -ENOMEM;
 	int i, total_vqs;
 	const char **names;
+	const char **channel_names;
+	unsigned *channels;
 
 	/* We expect 1 RX virtqueue followed by 1 TX virtqueue, followed by
 	 * possible N-1 RX/TX queue pairs used in multiqueue mode, followed by
@@ -1548,6 +1553,17 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
 	if (!names)
 		goto err_names;
 
+	channel_names = kmalloc_array(vi->max_queue_pairs,
+				      sizeof(*channel_names),
+				      GFP_KERNEL);
+	if (!channel_names)
+		goto err_channel_names;
+
+	channels = kmalloc_array(total_vqs, sizeof(*channels),
+				 GFP_KERNEL);
+	if (!channels)
+		goto err_channels;
+
 	/* Parameters for control virtqueue, if any */
 	if (vi->has_cvq) {
 		callbacks[total_vqs - 1] = NULL;
@@ -1562,10 +1578,15 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
 		sprintf(vi->sq[i].name, "output.%d", i);
 		names[rxq2vq(i)] = vi->rq[i].name;
 		names[txq2vq(i)] = vi->sq[i].name;
+		sprintf(vi->sq[i].channel_name, "txrx.%d", i);
+		channel_names[i] = vi->sq[i].channel_name;
+		channels[rxq2vq(i)] = i;
+		channels[txq2vq(i)] = i;
 	}
 
 	ret = vi->vdev->config->find_vqs(vi->vdev, total_vqs, vqs, callbacks,
-					 names);
+					 names, channels, channel_names,
+					 vi->max_queue_pairs);
 	if (ret)
 		goto err_find;
 
@@ -1580,6 +1601,8 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
 		vi->sq[i].vq = vqs[txq2vq(i)];
 	}
 
+	kfree(channels);
+	kfree(channel_names);
 	kfree(names);
 	kfree(callbacks);
 	kfree(vqs);
@@ -1587,6 +1610,10 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
 	return 0;
 
 err_find:
+	kfree(channels);
+err_channels:
+	kfree(channel_names);
+err_channel_names:
 	kfree(names);
 err_names:
 	kfree(callbacks);
-- 
1.9.1

[PATCH v1 2/3] virtio: vp_find_vqs accept channel setting params

[Ravi Kerur]

Port earlier patch from Jason Wang (dated 12/26/2014).

This patch lets vp_find_vqs function accept channel parameters.
For the transports that do not support channel currently, all
the parameters are ignored. For the device that does not use channel,
it can simply pass NULL to transport.

Signed-off-by: Ravi Kerur <rkerur@gmail.com>
---
 drivers/block/virtio_blk.c             |  3 ++-
 drivers/char/virtio_console.c          |  3 ++-
 drivers/gpu/drm/virtio/virtgpu_kms.c   |  3 ++-
 drivers/misc/mic/card/mic_virtio.c     |  5 ++++-
 drivers/net/caif/caif_virtio.c         |  3 ++-
 drivers/remoteproc/remoteproc_virtio.c |  9 ++++++---
 drivers/rpmsg/virtio_rpmsg_bus.c       |  3 ++-
 drivers/s390/virtio/kvm_virtio.c       |  5 ++++-
 drivers/s390/virtio/virtio_ccw.c       |  5 ++++-
 drivers/scsi/virtio_scsi.c             |  3 ++-
 drivers/virtio/virtio_balloon.c        |  3 ++-
 drivers/virtio/virtio_input.c          |  3 ++-
 drivers/virtio/virtio_mmio.c           |  9 ++++++---
 drivers/virtio/virtio_pci_modern.c     |  8 ++++++--
 include/linux/virtio_config.h          | 11 +++++++++--
 15 files changed, 55 insertions(+), 21 deletions(-)

diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index e93899c..7fb70b3 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -418,7 +418,8 @@ static int init_vq(struct virtio_blk *vblk)
 	}
 
 	/* Discover virtqueues and write information to configuration.  */
-	err = vdev->config->find_vqs(vdev, num_vqs, vqs, callbacks, names);
+	err = vdev->config->find_vqs(vdev, num_vqs, vqs, callbacks, names,
+				     NULL, NULL, 0);
 	if (err)
 		goto err_find_vqs;
 
diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c
index d2406fe..b316820 100644
--- a/drivers/char/virtio_console.c
+++ b/drivers/char/virtio_console.c
@@ -1923,7 +1923,8 @@ static int init_vqs(struct ports_device *portdev)
 	/* Find the queues. */
 	err = portdev->vdev->config->find_vqs(portdev->vdev, nr_queues, vqs,
 					      io_callbacks,
-					      (const char **)io_names);
+					      (const char **)io_names,
+					      NULL, NULL, 0);
 	if (err)
 		goto free;
 
diff --git a/drivers/gpu/drm/virtio/virtgpu_kms.c b/drivers/gpu/drm/virtio/virtgpu_kms.c
index 782766c..4e521c2f 100644
--- a/drivers/gpu/drm/virtio/virtgpu_kms.c
+++ b/drivers/gpu/drm/virtio/virtgpu_kms.c
@@ -100,7 +100,8 @@ int virtio_gpu_driver_load(struct drm_device *dev, unsigned long flags)
 		  virtio_gpu_config_changed_work_func);
 
 	ret = vgdev->vdev->config->find_vqs(vgdev->vdev, 2, vqs,
-					    callbacks, names);
+					    callbacks, names,
+					    NULL, NULL, 0);
 	if (ret) {
 		DRM_ERROR("failed to find virt queues\n");
 		goto err_vqs;
diff --git a/drivers/misc/mic/card/mic_virtio.c b/drivers/misc/mic/card/mic_virtio.c
index e486a0c..09c3f85 100644
--- a/drivers/misc/mic/card/mic_virtio.c
+++ b/drivers/misc/mic/card/mic_virtio.c
@@ -311,7 +311,10 @@ unmap:
 static int mic_find_vqs(struct virtio_device *vdev, unsigned nvqs,
 			struct virtqueue *vqs[],
 			vq_callback_t *callbacks[],
-			const char *names[])
+			const char *names[],
+			unsigned channels[],
+			const char *channel_names[],
+			unsigned nchannels)
 {
 	struct mic_vdev *mvdev = to_micvdev(vdev);
 	struct mic_device_ctrl __iomem *dc = mvdev->dc;
diff --git a/drivers/net/caif/caif_virtio.c b/drivers/net/caif/caif_virtio.c
index b306210..150809d 100644
--- a/drivers/net/caif/caif_virtio.c
+++ b/drivers/net/caif/caif_virtio.c
@@ -679,7 +679,8 @@ static int cfv_probe(struct virtio_device *vdev)
 		goto err;
 
 	/* Get the TX virtio ring. This is a "guest side vring". */
-	err = vdev->config->find_vqs(vdev, 1, &cfv->vq_tx, &vq_cbs, &names);
+	err = vdev->config->find_vqs(vdev, 1, &cfv->vq_tx, &vq_cbs, &names,
+				     NULL, NULL, 0);
 	if (err)
 		goto err;
 
diff --git a/drivers/remoteproc/remoteproc_virtio.c b/drivers/remoteproc/remoteproc_virtio.c
index e1a1023..16b3532 100644
--- a/drivers/remoteproc/remoteproc_virtio.c
+++ b/drivers/remoteproc/remoteproc_virtio.c
@@ -145,9 +145,12 @@ static void rproc_virtio_del_vqs(struct virtio_device *vdev)
 }
 
 static int rproc_virtio_find_vqs(struct virtio_device *vdev, unsigned nvqs,
-		       struct virtqueue *vqs[],
-		       vq_callback_t *callbacks[],
-		       const char *names[])
+				 struct virtqueue *vqs[],
+				 vq_callback_t *callbacks[],
+				 const char *names[],
+				 unsigned channels[],
+				 const char *channel_names,
+				 unsigned nchannels)
 {
 	struct rproc *rproc = vdev_to_rproc(vdev);
 	int i, ret;
diff --git a/drivers/rpmsg/virtio_rpmsg_bus.c b/drivers/rpmsg/virtio_rpmsg_bus.c
index 73354ee..8421666 100644
--- a/drivers/rpmsg/virtio_rpmsg_bus.c
+++ b/drivers/rpmsg/virtio_rpmsg_bus.c
@@ -965,7 +965,8 @@ static int rpmsg_probe(struct virtio_device *vdev)
 	init_waitqueue_head(&vrp->sendq);
 
 	/* We expect two virtqueues, rx and tx (and in this order) */
-	err = vdev->config->find_vqs(vdev, 2, vqs, vq_cbs, names);
+	err = vdev->config->find_vqs(vdev, 2, vqs, vq_cbs, names,
+				     NULL, NULL, 0);
 	if (err)
 		goto free_vrp;
 
diff --git a/drivers/s390/virtio/kvm_virtio.c b/drivers/s390/virtio/kvm_virtio.c
index 53fb975..a60d5ae 100644
--- a/drivers/s390/virtio/kvm_virtio.c
+++ b/drivers/s390/virtio/kvm_virtio.c
@@ -255,7 +255,10 @@ static void kvm_del_vqs(struct virtio_device *vdev)
 static int kvm_find_vqs(struct virtio_device *vdev, unsigned nvqs,
 			struct virtqueue *vqs[],
 			vq_callback_t *callbacks[],
-			const char *names[])
+			const char *names[],
+			unsigned channels[],
+			const char *channel_names[],
+			unsigned nchannels)
 {
 	struct kvm_device *kdev = to_kvmdev(vdev);
 	int i;
diff --git a/drivers/s390/virtio/virtio_ccw.c b/drivers/s390/virtio/virtio_ccw.c
index e9fae30..4ed0463 100644
--- a/drivers/s390/virtio/virtio_ccw.c
+++ b/drivers/s390/virtio/virtio_ccw.c
@@ -626,7 +626,10 @@ out:
 static int virtio_ccw_find_vqs(struct virtio_device *vdev, unsigned nvqs,
 			       struct virtqueue *vqs[],
 			       vq_callback_t *callbacks[],
-			       const char *names[])
+			       const char *names[],
+			       unsigned channels[],
+			       const char *channel_names[],
+			       unsigned nchannels)
 {
 	struct virtio_ccw_device *vcdev = to_vc_device(vdev);
 	unsigned long *indicatorp = NULL;
diff --git a/drivers/scsi/virtio_scsi.c b/drivers/scsi/virtio_scsi.c
index 7dbbb29..06b54f6 100644
--- a/drivers/scsi/virtio_scsi.c
+++ b/drivers/scsi/virtio_scsi.c
@@ -919,7 +919,8 @@ static int virtscsi_init(struct virtio_device *vdev,
 	}
 
 	/* Discover virtqueues and write information to configuration.  */
-	err = vdev->config->find_vqs(vdev, num_vqs, vqs, callbacks, names);
+	err = vdev->config->find_vqs(vdev, num_vqs, vqs, callbacks, names,
+				     NULL, NULL, 0);
 	if (err)
 		goto out;
 
diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
index 7efc329..a1a5dbc 100644
--- a/drivers/virtio/virtio_balloon.c
+++ b/drivers/virtio/virtio_balloon.c
@@ -396,7 +396,8 @@ static int init_vqs(struct virtio_balloon *vb)
 	 * optionally stat.
 	 */
 	nvqs = virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ) ? 3 : 2;
-	err = vb->vdev->config->find_vqs(vb->vdev, nvqs, vqs, callbacks, names);
+	err = vb->vdev->config->find_vqs(vb->vdev, nvqs, vqs, callbacks, names,
+					 NULL, NULL, 0);
 	if (err)
 		return err;
 
diff --git a/drivers/virtio/virtio_input.c b/drivers/virtio/virtio_input.c
index c96944b..5493235 100644
--- a/drivers/virtio/virtio_input.c
+++ b/drivers/virtio/virtio_input.c
@@ -173,7 +173,8 @@ static int virtinput_init_vqs(struct virtio_input *vi)
 	static const char *names[] = { "events", "status" };
 	int err;
 
-	err = vi->vdev->config->find_vqs(vi->vdev, 2, vqs, cbs, names);
+	err = vi->vdev->config->find_vqs(vi->vdev, 2, vqs, cbs, names,
+					 NULL, NULL, 0);
 	if (err)
 		return err;
 	vi->evt = vqs[0];
diff --git a/drivers/virtio/virtio_mmio.c b/drivers/virtio/virtio_mmio.c
index f499d9d..8c9be80 100644
--- a/drivers/virtio/virtio_mmio.c
+++ b/drivers/virtio/virtio_mmio.c
@@ -480,9 +480,12 @@ error_available:
 }
 
 static int vm_find_vqs(struct virtio_device *vdev, unsigned nvqs,
-		       struct virtqueue *vqs[],
-		       vq_callback_t *callbacks[],
-		       const char *names[])
+			struct virtqueue *vqs[],
+			vq_callback_t *callbacks[],
+			const char *names[],
+			unsigned channels[],
+			const char *channel_names[],
+			unsigned nchannels)
 {
 	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
 	unsigned int irq = platform_get_irq(vm_dev->pdev, 0);
diff --git a/drivers/virtio/virtio_pci_modern.c b/drivers/virtio/virtio_pci_modern.c
index 8e5cf19..c308983 100644
--- a/drivers/virtio/virtio_pci_modern.c
+++ b/drivers/virtio/virtio_pci_modern.c
@@ -418,11 +418,15 @@ err_new_queue:
 static int vp_modern_find_vqs(struct virtio_device *vdev, unsigned nvqs,
 			      struct virtqueue *vqs[],
 			      vq_callback_t *callbacks[],
-			      const char *names[])
+			      const char *names[],
+			      unsigned channels[],
+			      const char *channel_names[],
+			      unsigned nchannels)
 {
 	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
 	struct virtqueue *vq;
-	int rc = vp_find_vqs(vdev, nvqs, vqs, callbacks, names);
+	int rc = vp_find_vqs(vdev, nvqs, vqs, callbacks, names,
+			     NULL, NULL, 0);
 
 	if (rc)
 		return rc;
diff --git a/include/linux/virtio_config.h b/include/linux/virtio_config.h
index e5ce8ab..9c94a2f 100644
--- a/include/linux/virtio_config.h
+++ b/include/linux/virtio_config.h
@@ -41,6 +41,9 @@
  *		include a NULL entry for vqs that do not need a callback
  *	names: array of virtqueue names (mainly for debugging)
  *		include a NULL entry for vqs unused by driver
+ *	channels: array of channels each vq belong to
+ *	channel_names: names of channels
+ *	nchannels: number of channels
  *	Returns 0 on success or error status
  * @del_vqs: free virtqueues found by find_vqs().
  * @get_features: get the array of feature bits for this device.
@@ -70,7 +73,10 @@ struct virtio_config_ops {
 	int (*find_vqs)(struct virtio_device *, unsigned nvqs,
 			struct virtqueue *vqs[],
 			vq_callback_t *callbacks[],
-			const char *names[]);
+			const char *names[],
+			unsigned int channels[],
+			const char *channel_names,
+			unsigned nchannels);
 	void (*del_vqs)(struct virtio_device *);
 	u64 (*get_features)(struct virtio_device *vdev);
 	int (*finalize_features)(struct virtio_device *vdev);
@@ -156,7 +162,8 @@ struct virtqueue *virtio_find_single_vq(struct virtio_device *vdev,
 	vq_callback_t *callbacks[] = { c };
 	const char *names[] = { n };
 	struct virtqueue *vq;
-	int err = vdev->config->find_vqs(vdev, 1, &vq, callbacks, names);
+	int err = vdev->config->find_vqs(vdev, 1, &vq, callbacks, names,
+					 NULL, NULL, 0);
 	if (err < 0)
 		return ERR_PTR(err);
 	return vq;
-- 
1.9.1

[PATCH v1 3/3] virtio-pci: Introduce channels

[Ravi Kerur]

Port earlier patch from Jason Wang (dated 12/26/2014).

This patch introduces virtio pci channel which are virtqueue groups
that sharing a single MSIX irq. This can be used to reduce the irqs
needed by virtio device.

The channel are in fact a list of virtqueues, and vp_channel_interrupt()
was introduced to traverse the list. The current strategy was kept but
is converted to channel internally:

- per vq vectors was implemented through per vq channel
- sharing interrupts was implemented through a single channel for all
  virtqueues

This is done by letting vp_try_to_find_vqs() to accept the array of
channel names and the channels that each vq belongs to.

Signed-off-by: Ravi Kerur <rkerur@gmail.com>
---
 drivers/virtio/virtio_pci_common.c | 208 +++++++++++++++++++++++--------------
 drivers/virtio/virtio_pci_common.h |  23 ++--
 2 files changed, 146 insertions(+), 85 deletions(-)

diff --git a/drivers/virtio/virtio_pci_common.c b/drivers/virtio/virtio_pci_common.c
index 78f804a..5c0594e 100644
--- a/drivers/virtio/virtio_pci_common.c
+++ b/drivers/virtio/virtio_pci_common.c
@@ -76,6 +76,23 @@ static irqreturn_t vp_vring_interrupt(int irq, void *opaque)
 	return ret;
 }
 
+static irqreturn_t vp_channel_interrupt(int irq, void *opaque)
+{
+	struct virtio_pci_channel *vp_channel = opaque;
+	struct virtio_pci_vq_info *info;
+	irqreturn_t ret = IRQ_NONE;
+	unsigned long flags;
+
+	spin_lock_irqsave(&vp_channel->lock, flags);
+	list_for_each_entry(info, &vp_channel->virtqueues, node) {
+		if (vring_interrupt(irq, info->vq) == IRQ_HANDLED)
+			ret = IRQ_HANDLED;
+	}
+	spin_unlock_irqrestore(&vp_channel->lock, flags);
+
+	return ret;
+}
+
 /* A small wrapper to also acknowledge the interrupt when it's handled.
  * I really need an EIO hook for the vring so I can ack the interrupt once we
  * know that we'll be handling the IRQ but before we invoke the callback since
@@ -112,8 +129,12 @@ static void vp_free_vectors(struct virtio_device *vdev)
 		vp_dev->intx_enabled = 0;
 	}
 
-	for (i = 0; i < vp_dev->msix_used_vectors; ++i)
-		free_irq(vp_dev->msix_entries[i].vector, vp_dev);
+	if (vp_dev->msix_used_vectors)
+		free_irq(vp_dev->msix_entries[0].vector, vp_dev);
+
+	for (i = 1; i < vp_dev->msix_used_vectors; ++i)
+		free_irq(vp_dev->msix_entries[i].vector,
+			 &vp_dev->channels[i - 1]);
 
 	for (i = 0; i < vp_dev->msix_vectors; i++)
 		if (vp_dev->msix_affinity_masks[i])
@@ -137,8 +158,7 @@ static void vp_free_vectors(struct virtio_device *vdev)
 	vp_dev->msix_affinity_masks = NULL;
 }
 
-static int vp_request_msix_vectors(struct virtio_device *vdev, int nvectors,
-				   bool per_vq_vectors)
+static int vp_request_msix_vectors(struct virtio_device *vdev, int nvectors)
 {
 	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
 	const char *name = dev_name(&vp_dev->vdev.dev);
@@ -175,8 +195,8 @@ static int vp_request_msix_vectors(struct virtio_device *vdev, int nvectors,
 	vp_dev->msix_enabled = 1;
 
 	/* Set the vector used for configuration */
-	v = vp_dev->msix_used_vectors;
-	snprintf(vp_dev->msix_names[v], sizeof *vp_dev->msix_names,
+	v = 0;
+	snprintf(vp_dev->msix_names[0], sizeof(*vp_dev->msix_names),
 		 "%s-config", name);
 	err = request_irq(vp_dev->msix_entries[v].vector,
 			  vp_config_changed, 0, vp_dev->msix_names[v],
@@ -192,18 +212,6 @@ static int vp_request_msix_vectors(struct virtio_device *vdev, int nvectors,
 		goto error;
 	}
 
-	if (!per_vq_vectors) {
-		/* Shared vector for all VQs */
-		v = vp_dev->msix_used_vectors;
-		snprintf(vp_dev->msix_names[v], sizeof *vp_dev->msix_names,
-			 "%s-virtqueues", name);
-		err = request_irq(vp_dev->msix_entries[v].vector,
-				  vp_vring_interrupt, 0, vp_dev->msix_names[v],
-				  vp_dev);
-		if (err)
-			goto error;
-		++vp_dev->msix_used_vectors;
-	}
 	return 0;
 error:
 	vp_free_vectors(vdev);
@@ -228,6 +236,7 @@ static struct virtqueue *vp_setup_vq(struct virtio_device *vdev, unsigned index,
 				     u16 msix_vec)
 {
 	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+	struct virtio_pci_channel *vp_channel;
 	struct virtio_pci_vq_info *info = kmalloc(sizeof *info, GFP_KERNEL);
 	struct virtqueue *vq;
 	unsigned long flags;
@@ -242,9 +251,16 @@ static struct virtqueue *vp_setup_vq(struct virtio_device *vdev, unsigned index,
 
 	info->vq = vq;
 	if (callback) {
-		spin_lock_irqsave(&vp_dev->lock, flags);
-		list_add(&info->node, &vp_dev->virtqueues);
-		spin_unlock_irqrestore(&vp_dev->lock, flags);
+		if (msix_vec != VIRTIO_MSI_NO_VECTOR) {
+			vp_channel = &vp_dev->channels[msix_vec - 1];
+			spin_lock_irqsave(&vp_channel->lock, flags);
+			list_add(&info->node, &vp_channel->virtqueues);
+			spin_unlock_irqrestore(&vp_channel->lock, flags);
+		} else {
+			spin_lock_irqsave(&vp_dev->lock, flags);
+			list_add(&info->node, &vp_dev->virtqueues);
+			spin_unlock_irqrestore(&vp_dev->lock, flags);
+		}
 	} else {
 		INIT_LIST_HEAD(&info->node);
 	}
@@ -257,15 +273,17 @@ out_info:
 	return vq;
 }
 
-static void vp_del_vq(struct virtqueue *vq)
+static void vp_del_vq(struct virtqueue *vq,
+		      struct virtio_pci_channel *channel)
 {
 	struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev);
 	struct virtio_pci_vq_info *info = vp_dev->vqs[vq->index];
+	spinlock_t *lock = channel ? &channel->lock : &vp_dev->lock;
 	unsigned long flags;
 
-	spin_lock_irqsave(&vp_dev->lock, flags);
+	spin_lock_irqsave(lock, flags);
 	list_del(&info->node);
-	spin_unlock_irqrestore(&vp_dev->lock, flags);
+	spin_unlock_irqrestore(lock, flags);
 
 	vp_dev->del_vq(info);
 	kfree(info);
@@ -275,95 +293,103 @@ static void vp_del_vq(struct virtqueue *vq)
 void vp_del_vqs(struct virtio_device *vdev)
 {
 	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+	struct virtio_pci_vq_info *info, *ninfo;
+	struct virtio_pci_channel *channel;
 	struct virtqueue *vq, *n;
-	struct virtio_pci_vq_info *info;
+	int i;
 
-	list_for_each_entry_safe(vq, n, &vdev->vqs, list) {
-		info = vp_dev->vqs[vq->index];
-		if (vp_dev->per_vq_vectors &&
-			info->msix_vector != VIRTIO_MSI_NO_VECTOR)
-			free_irq(vp_dev->msix_entries[info->msix_vector].vector,
-				 vq);
-		vp_del_vq(vq);
+	if (vp_dev->nchannels) {
+		for (i = 0; i < vp_dev->nchannels; i++) {
+			channel = &vp_dev->channels[i];
+			list_for_each_entry_safe(info, ninfo,
+						&channel->virtqueues, node) {
+				vp_del_vq(info->vq, channel);
+			}
+		}
+	} else {
+		list_for_each_entry_safe(vq, n, &vdev->vqs, list) {
+			vp_del_vq(vq, NULL);
+		}
 	}
-	vp_dev->per_vq_vectors = false;
+
+	vp_dev->nchannels = 0;
 
 	vp_free_vectors(vdev);
 	kfree(vp_dev->vqs);
 	vp_dev->vqs = NULL;
+	kfree(vp_dev->channels);
 }
 
 static int vp_try_to_find_vqs(struct virtio_device *vdev, unsigned nvqs,
 			      struct virtqueue *vqs[],
 			      vq_callback_t *callbacks[],
 			      const char *names[],
-			      bool use_msix,
-			      bool per_vq_vectors)
+			      unsigned *channels,
+			      const char *channel_names[],
+			      unsigned nchannels)
 {
 	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
 	u16 msix_vec;
-	int i, err, nvectors, allocated_vectors;
+	int i, err = 0;
 
 	vp_dev->vqs = kmalloc(nvqs * sizeof *vp_dev->vqs, GFP_KERNEL);
 	if (!vp_dev->vqs)
 		return -ENOMEM;
 
-	if (!use_msix) {
+	if (nchannels) {
+		vp_dev->channels = kmalloc(nchannels *
+					   sizeof(*vp_dev->channels),
+					   GFP_KERNEL);
+		if (!vp_dev->channels)
+			goto error_find;
+	}
+	vp_dev->nchannels = nchannels;
+
+	for (i = 0; i < nchannels; i++) {
+		spin_lock_init(&vp_dev->channels[i].lock);
+		INIT_LIST_HEAD(&vp_dev->channels[i].virtqueues);
+	}
+
+	if (!nchannels) {
 		/* Old style: one normal interrupt for change and all vqs. */
 		err = vp_request_intx(vdev);
 		if (err)
 			goto error_find;
 	} else {
-		if (per_vq_vectors) {
-			/* Best option: one for change interrupt, one per vq. */
-			nvectors = 1;
-			for (i = 0; i < nvqs; ++i)
-				if (callbacks[i])
-					++nvectors;
-		} else {
-			/* Second best: one for change, shared for all vqs. */
-			nvectors = 2;
-		}
+		err = vp_request_msix_vectors(vdev, nchannels + 1);
+		if (err)
+			goto error_find;
+	}
+
+	for (i = 0; i < nchannels; i++) {
+		snprintf(vp_dev->msix_names[i + 1],
+			sizeof(*vp_dev->msix_names),
+			"%s-%s",
+			dev_name(&vp_dev->vdev.dev), channel_names[i]);
+		err = request_irq(vp_dev->msix_entries[i + 1].vector,
+				vp_channel_interrupt, 0,
+				vp_dev->msix_names[i + 1],
+				&vp_dev->channels[i]);
 
-		err = vp_request_msix_vectors(vdev, nvectors, per_vq_vectors);
 		if (err)
 			goto error_find;
+		++vp_dev->msix_used_vectors;
 	}
 
-	vp_dev->per_vq_vectors = per_vq_vectors;
-	allocated_vectors = vp_dev->msix_used_vectors;
 	for (i = 0; i < nvqs; ++i) {
 		if (!names[i]) {
 			vqs[i] = NULL;
 			continue;
 		} else if (!callbacks[i] || !vp_dev->msix_enabled)
 			msix_vec = VIRTIO_MSI_NO_VECTOR;
-		else if (vp_dev->per_vq_vectors)
-			msix_vec = allocated_vectors++;
 		else
-			msix_vec = VP_MSIX_VQ_VECTOR;
+			msix_vec = channels[i] + 1;
 		vqs[i] = vp_setup_vq(vdev, i, callbacks[i], names[i], msix_vec);
 		if (IS_ERR(vqs[i])) {
 			err = PTR_ERR(vqs[i]);
 			goto error_find;
 		}
 
-		if (!vp_dev->per_vq_vectors || msix_vec == VIRTIO_MSI_NO_VECTOR)
-			continue;
-
-		/* allocate per-vq irq if available and necessary */
-		snprintf(vp_dev->msix_names[msix_vec],
-			 sizeof *vp_dev->msix_names,
-			 "%s-%s",
-			 dev_name(&vp_dev->vdev.dev), names[i]);
-		err = request_irq(vp_dev->msix_entries[msix_vec].vector,
-				  vring_interrupt, 0,
-				  vp_dev->msix_names[msix_vec],
-				  vqs[i]);
-		if (err) {
-			vp_del_vq(vqs[i]);
-			goto error_find;
-		}
 	}
 	return 0;
 
@@ -376,22 +402,48 @@ error_find:
 int vp_find_vqs(struct virtio_device *vdev, unsigned nvqs,
 		struct virtqueue *vqs[],
 		vq_callback_t *callbacks[],
-		const char *names[])
+		const char *names[],
+		unsigned channels[],
+		const char *channel_names[],
+		unsigned nchannels)
 {
-	int err;
+	int err, i;
+	const char *cnames[] = {"virtqueues"};
+
+	if (nchannels) {
+		/* Try channel settings */
+		err = vp_try_to_find_vqs(vdev, nvqs, vqs, callbacks, names,
+					 channels, channel_names, nchannels);
+		if (!err)
+			return 0;
+	}
+
+	channels = kmalloc_array(nvqs, sizeof(unsigned), GFP_KERNEL);
+	if (!channels)
+		return -ENOMEM;
 
 	/* Try MSI-X with one vector per queue. */
-	err = vp_try_to_find_vqs(vdev, nvqs, vqs, callbacks, names, true, true);
+	for (i = 0; i < nvqs; i++)
+		channels[i] = i;
+	err = vp_try_to_find_vqs(vdev, nvqs, vqs, callbacks, names, channels,
+				 names, nvqs);
 	if (!err)
-		return 0;
+		goto out;
+
 	/* Fallback: MSI-X with one vector for config, one shared for queues. */
-	err = vp_try_to_find_vqs(vdev, nvqs, vqs, callbacks, names,
-				 true, false);
+	for (i = 0; i < nvqs; i++)
+		channels[i] = 0;
+	err = vp_try_to_find_vqs(vdev, nvqs, vqs, callbacks, names, channels,
+				 cnames, 1);
 	if (!err)
-		return 0;
+		goto out;
+
 	/* Finally fall back to regular interrupts. */
-	return vp_try_to_find_vqs(vdev, nvqs, vqs, callbacks, names,
-				  false, false);
+	err = vp_try_to_find_vqs(vdev, nvqs, vqs, callbacks, names,
+				NULL, NULL, 0);
+out:
+	kfree(channels);
+	return err;
 }
 
 const char *vp_bus_name(struct virtio_device *vdev)
diff --git a/drivers/virtio/virtio_pci_common.h b/drivers/virtio/virtio_pci_common.h
index b976d96..e8a739d 100644
--- a/drivers/virtio/virtio_pci_common.h
+++ b/drivers/virtio/virtio_pci_common.h
@@ -48,6 +48,11 @@ struct virtio_pci_vq_info {
 	unsigned msix_vector;
 };
 
+struct virtio_pci_channel {
+	spinlock_t lock;
+	struct list_head virtqueues;
+};
+
 /* Our device structure */
 struct virtio_pci_device {
 	struct virtio_device vdev;
@@ -88,6 +93,10 @@ struct virtio_pci_device {
 	/* array of all queues for house-keeping */
 	struct virtio_pci_vq_info **vqs;
 
+	/* array of channels */
+	struct virtio_pci_channel *channels;
+	unsigned nchannels;
+
 	/* MSI-X support */
 	int msix_enabled;
 	int intx_enabled;
@@ -98,12 +107,9 @@ struct virtio_pci_device {
 	char (*msix_names)[256];
 	/* Number of available vectors */
 	unsigned msix_vectors;
-	/* Vectors allocated, excluding per-vq vectors if any */
+	/* Vectors allocated */
 	unsigned msix_used_vectors;
 
-	/* Whether we have vector per vq */
-	bool per_vq_vectors;
-
 	struct virtqueue *(*setup_vq)(struct virtio_pci_device *vp_dev,
 				      struct virtio_pci_vq_info *info,
 				      unsigned idx,
@@ -137,9 +143,12 @@ bool vp_notify(struct virtqueue *vq);
 void vp_del_vqs(struct virtio_device *vdev);
 /* the config->find_vqs() implementation */
 int vp_find_vqs(struct virtio_device *vdev, unsigned nvqs,
-		       struct virtqueue *vqs[],
-		       vq_callback_t *callbacks[],
-		       const char *names[]);
+		struct virtqueue *vqs[],
+		vq_callback_t *callbacks[],
+		const char *names[],
+		unsigned channels[],
+		const char *channel_names[],
+		unsigned nchannels);
 const char *vp_bus_name(struct virtio_device *vdev);
 
 /* Setup the affinity for a virtqueue:
-- 
1.9.1

Re: [PATCH v1 2/3] virtio: vp_find_vqs accept channel setting params

[kbuild test robot]

[-- Attachment #1: Type: text/plain, Size: 2879 bytes --]

Hi Ravi,

[auto build test WARNING on char-misc/char-misc-next -- if it's inappropriate base, please suggest rules for selecting the more suitable base]

url:    https://github.com/0day-ci/linux/commits/Ravi-Kerur/virtio-net-Using-single-MSIX-IRQ-for-TX-RX-Q-pair/20151027-015503
config: x86_64-randconfig-x015-201543 (attached as .config)
reproduce:
        # save the attached .config to linux build tree
        make ARCH=x86_64 

All warnings (new ones prefixed by >>):

>> drivers/virtio/virtio_mmio.c:524:14: warning: initialization from incompatible pointer type [-Wincompatible-pointer-types]
     .find_vqs = vm_find_vqs,
                 ^
   drivers/virtio/virtio_mmio.c:524:14: note: (near initialization for 'virtio_mmio_config_ops.find_vqs')

vim +524 drivers/virtio/virtio_mmio.c

edfd52e6 Pawel Moll         2011-10-24  508  }
edfd52e6 Pawel Moll         2011-10-24  509  
66846048 Rick Jones         2011-11-14  510  static const char *vm_bus_name(struct virtio_device *vdev)
66846048 Rick Jones         2011-11-14  511  {
66846048 Rick Jones         2011-11-14  512  	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
edfd52e6 Pawel Moll         2011-10-24  513  
66846048 Rick Jones         2011-11-14  514  	return vm_dev->pdev->name;
66846048 Rick Jones         2011-11-14  515  }
edfd52e6 Pawel Moll         2011-10-24  516  
93503932 Stephen Hemminger  2013-02-10  517  static const struct virtio_config_ops virtio_mmio_config_ops = {
edfd52e6 Pawel Moll         2011-10-24  518  	.get		= vm_get,
edfd52e6 Pawel Moll         2011-10-24  519  	.set		= vm_set,
87e7bf14 Michael S. Tsirkin 2015-03-12  520  	.generation	= vm_generation,
edfd52e6 Pawel Moll         2011-10-24  521  	.get_status	= vm_get_status,
edfd52e6 Pawel Moll         2011-10-24  522  	.set_status	= vm_set_status,
edfd52e6 Pawel Moll         2011-10-24  523  	.reset		= vm_reset,
edfd52e6 Pawel Moll         2011-10-24 @524  	.find_vqs	= vm_find_vqs,
edfd52e6 Pawel Moll         2011-10-24  525  	.del_vqs	= vm_del_vqs,
edfd52e6 Pawel Moll         2011-10-24  526  	.get_features	= vm_get_features,
edfd52e6 Pawel Moll         2011-10-24  527  	.finalize_features = vm_finalize_features,
66846048 Rick Jones         2011-11-14  528  	.bus_name	= vm_bus_name,
edfd52e6 Pawel Moll         2011-10-24  529  };
edfd52e6 Pawel Moll         2011-10-24  530  
edfd52e6 Pawel Moll         2011-10-24  531  
edfd52e6 Pawel Moll         2011-10-24  532  

:::::: The code at line 524 was first introduced by commit
:::::: edfd52e6367270c90f3fd7cc302b375ffa89f91e virtio: Add platform bus driver for memory mapped virtio device

:::::: TO: Pawel Moll <pawel.moll@arm.com>
:::::: CC: Rusty Russell <rusty@rustcorp.com.au>

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

[-- Attachment #2: .config.gz --]
[-- Type: application/octet-stream, Size: 17898 bytes --]

Re: [PATCH v1 2/3] virtio: vp_find_vqs accept channel setting params

[kbuild test robot]

[-- Attachment #1: Type: text/plain, Size: 4205 bytes --]

Hi Ravi,

[auto build test ERROR on char-misc/char-misc-next -- if it's inappropriate base, please suggest rules for selecting the more suitable base]

url:    https://github.com/0day-ci/linux/commits/Ravi-Kerur/virtio-net-Using-single-MSIX-IRQ-for-TX-RX-Q-pair/20151027-015503
config: x86_64-randconfig-x016-201543 (attached as .config)
reproduce:
        # save the attached .config to linux build tree
        make ARCH=x86_64 

Note: the linux-review/Ravi-Kerur/virtio-net-Using-single-MSIX-IRQ-for-TX-RX-Q-pair/20151027-015503 HEAD 69781953042f14dfe510f90e63b4366d729daf9e builds fine.
      It only hurts bisectibility.

All error/warnings (new ones prefixed by >>):

>> drivers/misc/mic/card/mic_virtio.c:372:14: warning: initialization from incompatible pointer type [-Wincompatible-pointer-types]
     .find_vqs = mic_find_vqs,
                 ^
   drivers/misc/mic/card/mic_virtio.c:372:14: note: (near initialization for 'mic_vq_config_ops.find_vqs')
--
   drivers/virtio/virtio_pci_modern.c: In function 'vp_modern_find_vqs':
>> drivers/virtio/virtio_pci_modern.c:428:11: error: too many arguments to function 'vp_find_vqs'
     int rc = vp_find_vqs(vdev, nvqs, vqs, callbacks, names,
              ^
   In file included from drivers/virtio/virtio_pci_modern.c:21:0:
   drivers/virtio/virtio_pci_common.h:139:5: note: declared here
    int vp_find_vqs(struct virtio_device *vdev, unsigned nvqs,
        ^
   drivers/virtio/virtio_pci_modern.c: At top level:
>> drivers/virtio/virtio_pci_modern.c:474:14: warning: initialization from incompatible pointer type [-Wincompatible-pointer-types]
     .find_vqs = vp_modern_find_vqs,
                 ^
   drivers/virtio/virtio_pci_modern.c:474:14: note: (near initialization for 'virtio_pci_config_nodev_ops.find_vqs')
   drivers/virtio/virtio_pci_modern.c:489:14: warning: initialization from incompatible pointer type [-Wincompatible-pointer-types]
     .find_vqs = vp_modern_find_vqs,
                 ^
   drivers/virtio/virtio_pci_modern.c:489:14: note: (near initialization for 'virtio_pci_config_ops.find_vqs')

vim +/vp_find_vqs +428 drivers/virtio/virtio_pci_modern.c

   422				      unsigned channels[],
   423				      const char *channel_names[],
   424				      unsigned nchannels)
   425	{
   426		struct virtio_pci_device *vp_dev = to_vp_device(vdev);
   427		struct virtqueue *vq;
 > 428		int rc = vp_find_vqs(vdev, nvqs, vqs, callbacks, names,
   429				     NULL, NULL, 0);
   430	
   431		if (rc)
   432			return rc;
   433	
   434		/* Select and activate all queues. Has to be done last: once we do
   435		 * this, there's no way to go back except reset.
   436		 */
   437		list_for_each_entry(vq, &vdev->vqs, list) {
   438			vp_iowrite16(vq->index, &vp_dev->common->queue_select);
   439			vp_iowrite16(1, &vp_dev->common->queue_enable);
   440		}
   441	
   442		return 0;
   443	}
   444	
   445	static void del_vq(struct virtio_pci_vq_info *info)
   446	{
   447		struct virtqueue *vq = info->vq;
   448		struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev);
   449	
   450		vp_iowrite16(vq->index, &vp_dev->common->queue_select);
   451	
   452		if (vp_dev->msix_enabled) {
   453			vp_iowrite16(VIRTIO_MSI_NO_VECTOR,
   454				     &vp_dev->common->queue_msix_vector);
   455			/* Flush the write out to device */
   456			vp_ioread16(&vp_dev->common->queue_msix_vector);
   457		}
   458	
   459		if (!vp_dev->notify_base)
   460			pci_iounmap(vp_dev->pci_dev, (void __force __iomem *)vq->priv);
   461	
   462		vring_del_virtqueue(vq);
   463	
   464		free_pages_exact(info->queue, vring_pci_size(info->num));
   465	}
   466	
   467	static const struct virtio_config_ops virtio_pci_config_nodev_ops = {
   468		.get		= NULL,
   469		.set		= NULL,
   470		.generation	= vp_generation,
   471		.get_status	= vp_get_status,
   472		.set_status	= vp_set_status,
   473		.reset		= vp_reset,
 > 474		.find_vqs	= vp_modern_find_vqs,
   475		.del_vqs	= vp_del_vqs,
   476		.get_features	= vp_get_features,
   477		.finalize_features = vp_finalize_features,

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

[-- Attachment #2: .config.gz --]
[-- Type: application/octet-stream, Size: 22770 bytes --]

Re: [PATCH v1 1/3] virtio-net: Using single MSIX IRQ for TX/RX Q pair

[Jason Wang]

On 10/27/2015 01:52 AM, Ravi Kerur wrote:
> Ported earlier patch from Jason Wang (dated 12/26/2014).
>
> This patch tries to reduce the number of MSIX irqs required for
> virtio-net by sharing a MSIX irq for each TX/RX queue pair through
> channels. If transport support channel, about half of the MSIX irqs
> were reduced.
>
> Signed-off-by: Ravi Kerur <rkerur@gmail.com>
> ---
>  drivers/net/virtio_net.c | 29 ++++++++++++++++++++++++++++-
>  1 file changed, 28 insertions(+), 1 deletion(-)

Thanks for the patches. Some minor comments:

- If there's no big changes of the code, better keep my sign-offs :)
- Rusty does not like the name "channels", so better rename it to
"virtqueue groups"
- Build bot reports some compiling issues, this need to be fixed in next
version.
- The order of patches in this series is reversed, pach 1/3 should be
3/3. And better to have a cover letter to describe the motivation and
changes since last series. (You can do this through git format-patch
--cover)
- Michale's comment about unnecessary wakeup of tx queue needs to be
addressed, otherwise, we may get unnecessary tx interrupts.
- Some benchmarks is needed to make sure there's no performance regression.

> diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
> index d8838ded..d705cce 100644
> --- a/drivers/net/virtio_net.c
> +++ b/drivers/net/virtio_net.c
> @@ -72,6 +72,9 @@ struct send_queue {
>  
>  	/* Name of the send queue: output.$index */
>  	char name[40];
> +
> +	/* Name of the channel, shared with irq. */
> +	char channel_name[40];
>  };
>  
>  /* Internal representation of a receive virtqueue */
> @@ -1529,6 +1532,8 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>  	int ret = -ENOMEM;
>  	int i, total_vqs;
>  	const char **names;
> +	const char **channel_names;
> +	unsigned *channels;
>  
>  	/* We expect 1 RX virtqueue followed by 1 TX virtqueue, followed by
>  	 * possible N-1 RX/TX queue pairs used in multiqueue mode, followed by
> @@ -1548,6 +1553,17 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>  	if (!names)
>  		goto err_names;
>  
> +	channel_names = kmalloc_array(vi->max_queue_pairs,
> +				      sizeof(*channel_names),
> +				      GFP_KERNEL);
> +	if (!channel_names)
> +		goto err_channel_names;
> +
> +	channels = kmalloc_array(total_vqs, sizeof(*channels),
> +				 GFP_KERNEL);
> +	if (!channels)
> +		goto err_channels;
> +
>  	/* Parameters for control virtqueue, if any */
>  	if (vi->has_cvq) {
>  		callbacks[total_vqs - 1] = NULL;
> @@ -1562,10 +1578,15 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>  		sprintf(vi->sq[i].name, "output.%d", i);
>  		names[rxq2vq(i)] = vi->rq[i].name;
>  		names[txq2vq(i)] = vi->sq[i].name;
> +		sprintf(vi->sq[i].channel_name, "txrx.%d", i);
> +		channel_names[i] = vi->sq[i].channel_name;
> +		channels[rxq2vq(i)] = i;
> +		channels[txq2vq(i)] = i;
>  	}
>  
>  	ret = vi->vdev->config->find_vqs(vi->vdev, total_vqs, vqs, callbacks,
> -					 names);
> +					 names, channels, channel_names,
> +					 vi->max_queue_pairs);
>  	if (ret)
>  		goto err_find;
>  
> @@ -1580,6 +1601,8 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>  		vi->sq[i].vq = vqs[txq2vq(i)];
>  	}
>  
> +	kfree(channels);
> +	kfree(channel_names);
>  	kfree(names);
>  	kfree(callbacks);
>  	kfree(vqs);
> @@ -1587,6 +1610,10 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>  	return 0;
>  
>  err_find:
> +	kfree(channels);
> +err_channels:
> +	kfree(channel_names);
> +err_channel_names:
>  	kfree(names);
>  err_names:
>  	kfree(callbacks);

Re: [PATCH v1 1/3] virtio-net: Using single MSIX IRQ for TX/RX Q pair

[Michael S. Tsirkin]

On Mon, Oct 26, 2015 at 10:52:47AM -0700, Ravi Kerur wrote:
> Ported earlier patch from Jason Wang (dated 12/26/2014).
> 
> This patch tries to reduce the number of MSIX irqs required for
> virtio-net by sharing a MSIX irq for each TX/RX queue pair through
> channels. If transport support channel, about half of the MSIX irqs
> were reduced.
> 
> Signed-off-by: Ravi Kerur <rkerur@gmail.com>

Why bother BTW? Looks like this is adding a bunch of overhead
on data path - to what end?

Maybe you have a huge number of these devices ... but in that case, how
about sharing the config interrupt instead?
That's only possible if host supports VIRTIO_1
(so we can detect config interrupt by reading the ISR).



> ---
>  drivers/net/virtio_net.c | 29 ++++++++++++++++++++++++++++-
>  1 file changed, 28 insertions(+), 1 deletion(-)
> 
> diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
> index d8838ded..d705cce 100644
> --- a/drivers/net/virtio_net.c
> +++ b/drivers/net/virtio_net.c
> @@ -72,6 +72,9 @@ struct send_queue {
>  
>  	/* Name of the send queue: output.$index */
>  	char name[40];
> +
> +	/* Name of the channel, shared with irq. */
> +	char channel_name[40];
>  };
>  
>  /* Internal representation of a receive virtqueue */
> @@ -1529,6 +1532,8 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>  	int ret = -ENOMEM;
>  	int i, total_vqs;
>  	const char **names;
> +	const char **channel_names;
> +	unsigned *channels;
>  
>  	/* We expect 1 RX virtqueue followed by 1 TX virtqueue, followed by
>  	 * possible N-1 RX/TX queue pairs used in multiqueue mode, followed by
> @@ -1548,6 +1553,17 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>  	if (!names)
>  		goto err_names;
>  
> +	channel_names = kmalloc_array(vi->max_queue_pairs,
> +				      sizeof(*channel_names),
> +				      GFP_KERNEL);
> +	if (!channel_names)
> +		goto err_channel_names;
> +
> +	channels = kmalloc_array(total_vqs, sizeof(*channels),
> +				 GFP_KERNEL);
> +	if (!channels)
> +		goto err_channels;
> +
>  	/* Parameters for control virtqueue, if any */
>  	if (vi->has_cvq) {
>  		callbacks[total_vqs - 1] = NULL;
> @@ -1562,10 +1578,15 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>  		sprintf(vi->sq[i].name, "output.%d", i);
>  		names[rxq2vq(i)] = vi->rq[i].name;
>  		names[txq2vq(i)] = vi->sq[i].name;
> +		sprintf(vi->sq[i].channel_name, "txrx.%d", i);
> +		channel_names[i] = vi->sq[i].channel_name;
> +		channels[rxq2vq(i)] = i;
> +		channels[txq2vq(i)] = i;
>  	}
>  
>  	ret = vi->vdev->config->find_vqs(vi->vdev, total_vqs, vqs, callbacks,
> -					 names);
> +					 names, channels, channel_names,
> +					 vi->max_queue_pairs);
>  	if (ret)
>  		goto err_find;
>  
> @@ -1580,6 +1601,8 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>  		vi->sq[i].vq = vqs[txq2vq(i)];
>  	}
>  
> +	kfree(channels);
> +	kfree(channel_names);
>  	kfree(names);
>  	kfree(callbacks);
>  	kfree(vqs);
> @@ -1587,6 +1610,10 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>  	return 0;
>  
>  err_find:
> +	kfree(channels);
> +err_channels:
> +	kfree(channel_names);
> +err_channel_names:
>  	kfree(names);
>  err_names:
>  	kfree(callbacks);
> -- 
> 1.9.1

Re: [PATCH v1 1/3] virtio-net: Using single MSIX IRQ for TX/RX Q pair

[Ravi Kerur]

On 10/26/2015 10:11 PM, Jason Wang wrote:
> 
> 
> On 10/27/2015 01:52 AM, Ravi Kerur wrote:
>> Ported earlier patch from Jason Wang (dated 12/26/2014).
>>
>> This patch tries to reduce the number of MSIX irqs required for
>> virtio-net by sharing a MSIX irq for each TX/RX queue pair through
>> channels. If transport support channel, about half of the MSIX irqs
>> were reduced.
>>
>> Signed-off-by: Ravi Kerur <rkerur@gmail.com>
>> ---
>>  drivers/net/virtio_net.c | 29 ++++++++++++++++++++++++++++-
>>  1 file changed, 28 insertions(+), 1 deletion(-)
> 
> Thanks for the patches. Some minor comments:
> 
> - If there's no big changes of the code, better keep my sign-offs :)

Sorry for that. Will fix it in 'v2'

> - Rusty does not like the name "channels", so better rename it to
> "virtqueue groups"
> - Build bot reports some compiling issues, this need to be fixed in next
> version.

I saw build failure email, it was reported against 2nd patch. All 3 patches need to be applied for successful build. Will look into it and fix any issues.

> - The order of patches in this series is reversed, pach 1/3 should be
> 3/3. And better to have a cover letter to describe the motivation and
> changes since last series. (You can do this through git format-patch
> --cover)
> - Michale's comment about unnecessary wakeup of tx queue needs to be
> addressed, otherwise, we may get unnecessary tx interrupts.

I am working on it, will take care of above comments as well in 'v2'

> - Some benchmarks is needed to make sure there's no performance regression.
> 
>> diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
>> index d8838ded..d705cce 100644
>> --- a/drivers/net/virtio_net.c
>> +++ b/drivers/net/virtio_net.c
>> @@ -72,6 +72,9 @@ struct send_queue {
>>  
>>  	/* Name of the send queue: output.$index */
>>  	char name[40];
>> +
>> +	/* Name of the channel, shared with irq. */
>> +	char channel_name[40];
>>  };
>>  
>>  /* Internal representation of a receive virtqueue */
>> @@ -1529,6 +1532,8 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>  	int ret = -ENOMEM;
>>  	int i, total_vqs;
>>  	const char **names;
>> +	const char **channel_names;
>> +	unsigned *channels;
>>  
>>  	/* We expect 1 RX virtqueue followed by 1 TX virtqueue, followed by
>>  	 * possible N-1 RX/TX queue pairs used in multiqueue mode, followed by
>> @@ -1548,6 +1553,17 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>  	if (!names)
>>  		goto err_names;
>>  
>> +	channel_names = kmalloc_array(vi->max_queue_pairs,
>> +				      sizeof(*channel_names),
>> +				      GFP_KERNEL);
>> +	if (!channel_names)
>> +		goto err_channel_names;
>> +
>> +	channels = kmalloc_array(total_vqs, sizeof(*channels),
>> +				 GFP_KERNEL);
>> +	if (!channels)
>> +		goto err_channels;
>> +
>>  	/* Parameters for control virtqueue, if any */
>>  	if (vi->has_cvq) {
>>  		callbacks[total_vqs - 1] = NULL;
>> @@ -1562,10 +1578,15 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>  		sprintf(vi->sq[i].name, "output.%d", i);
>>  		names[rxq2vq(i)] = vi->rq[i].name;
>>  		names[txq2vq(i)] = vi->sq[i].name;
>> +		sprintf(vi->sq[i].channel_name, "txrx.%d", i);
>> +		channel_names[i] = vi->sq[i].channel_name;
>> +		channels[rxq2vq(i)] = i;
>> +		channels[txq2vq(i)] = i;
>>  	}
>>  
>>  	ret = vi->vdev->config->find_vqs(vi->vdev, total_vqs, vqs, callbacks,
>> -					 names);
>> +					 names, channels, channel_names,
>> +					 vi->max_queue_pairs);
>>  	if (ret)
>>  		goto err_find;
>>  
>> @@ -1580,6 +1601,8 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>  		vi->sq[i].vq = vqs[txq2vq(i)];
>>  	}
>>  
>> +	kfree(channels);
>> +	kfree(channel_names);
>>  	kfree(names);
>>  	kfree(callbacks);
>>  	kfree(vqs);
>> @@ -1587,6 +1610,10 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>  	return 0;
>>  
>>  err_find:
>> +	kfree(channels);
>> +err_channels:
>> +	kfree(channel_names);
>> +err_channel_names:
>>  	kfree(names);
>>  err_names:
>>  	kfree(callbacks);
> 

Re: [PATCH v1 1/3] virtio-net: Using single MSIX IRQ for TX/RX Q pair

[Ravi Kerur]

On 10/27/2015 1:38 AM, Michael S. Tsirkin wrote:
> On Mon, Oct 26, 2015 at 10:52:47AM -0700, Ravi Kerur wrote:
>> Ported earlier patch from Jason Wang (dated 12/26/2014).
>>
>> This patch tries to reduce the number of MSIX irqs required for
>> virtio-net by sharing a MSIX irq for each TX/RX queue pair through
>> channels. If transport support channel, about half of the MSIX irqs
>> were reduced.
>>
>> Signed-off-by: Ravi Kerur <rkerur@gmail.com>
> 
> Why bother BTW? Looks like this is adding a bunch of overhead
> on data path - to what end?
> 
> Maybe you have a huge number of these devices ... but in that case, how
> about sharing the config interrupt instead?
> That's only possible if host supports VIRTIO_1
> (so we can detect config interrupt by reading the ISR).

For my clarification, are you suggesting this as an additional changes for config interrupts or rework existing patch?
> 
> 
> 
>> ---
>>  drivers/net/virtio_net.c | 29 ++++++++++++++++++++++++++++-
>>  1 file changed, 28 insertions(+), 1 deletion(-)
>>
>> diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
>> index d8838ded..d705cce 100644
>> --- a/drivers/net/virtio_net.c
>> +++ b/drivers/net/virtio_net.c
>> @@ -72,6 +72,9 @@ struct send_queue {
>>  
>>  	/* Name of the send queue: output.$index */
>>  	char name[40];
>> +
>> +	/* Name of the channel, shared with irq. */
>> +	char channel_name[40];
>>  };
>>  
>>  /* Internal representation of a receive virtqueue */
>> @@ -1529,6 +1532,8 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>  	int ret = -ENOMEM;
>>  	int i, total_vqs;
>>  	const char **names;
>> +	const char **channel_names;
>> +	unsigned *channels;
>>  
>>  	/* We expect 1 RX virtqueue followed by 1 TX virtqueue, followed by
>>  	 * possible N-1 RX/TX queue pairs used in multiqueue mode, followed by
>> @@ -1548,6 +1553,17 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>  	if (!names)
>>  		goto err_names;
>>  
>> +	channel_names = kmalloc_array(vi->max_queue_pairs,
>> +				      sizeof(*channel_names),
>> +				      GFP_KERNEL);
>> +	if (!channel_names)
>> +		goto err_channel_names;
>> +
>> +	channels = kmalloc_array(total_vqs, sizeof(*channels),
>> +				 GFP_KERNEL);
>> +	if (!channels)
>> +		goto err_channels;
>> +
>>  	/* Parameters for control virtqueue, if any */
>>  	if (vi->has_cvq) {
>>  		callbacks[total_vqs - 1] = NULL;
>> @@ -1562,10 +1578,15 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>  		sprintf(vi->sq[i].name, "output.%d", i);
>>  		names[rxq2vq(i)] = vi->rq[i].name;
>>  		names[txq2vq(i)] = vi->sq[i].name;
>> +		sprintf(vi->sq[i].channel_name, "txrx.%d", i);
>> +		channel_names[i] = vi->sq[i].channel_name;
>> +		channels[rxq2vq(i)] = i;
>> +		channels[txq2vq(i)] = i;
>>  	}
>>  
>>  	ret = vi->vdev->config->find_vqs(vi->vdev, total_vqs, vqs, callbacks,
>> -					 names);
>> +					 names, channels, channel_names,
>> +					 vi->max_queue_pairs);
>>  	if (ret)
>>  		goto err_find;
>>  
>> @@ -1580,6 +1601,8 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>  		vi->sq[i].vq = vqs[txq2vq(i)];
>>  	}
>>  
>> +	kfree(channels);
>> +	kfree(channel_names);
>>  	kfree(names);
>>  	kfree(callbacks);
>>  	kfree(vqs);
>> @@ -1587,6 +1610,10 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>  	return 0;
>>  
>>  err_find:
>> +	kfree(channels);
>> +err_channels:
>> +	kfree(channel_names);
>> +err_channel_names:
>>  	kfree(names);
>>  err_names:
>>  	kfree(callbacks);
>> -- 
>> 1.9.1

Re: [PATCH v1 1/3] virtio-net: Using single MSIX IRQ for TX/RX Q pair

[Jason Wang]

On 10/27/2015 04:38 PM, Michael S. Tsirkin wrote:
> On Mon, Oct 26, 2015 at 10:52:47AM -0700, Ravi Kerur wrote:
>> Ported earlier patch from Jason Wang (dated 12/26/2014).
>>
>> This patch tries to reduce the number of MSIX irqs required for
>> virtio-net by sharing a MSIX irq for each TX/RX queue pair through
>> channels. If transport support channel, about half of the MSIX irqs
>> were reduced.
>>
>> Signed-off-by: Ravi Kerur <rkerur@gmail.com>
> Why bother BTW? 

The reason is we want to save the number of interrupt vectors used.
Booting a guest with 256 queues with current driver will result all
tx/rx queues shares a single vector. This is suboptimal. With this
series, half could be saved. And more complex policy could be applied on
top (e.g limit the number of vectors used by driver).

> Looks like this is adding a bunch of overhead
> on data path - to what end?

I agree some benchmark is needed for this.

> Maybe you have a huge number of these devices ... but in that case, how
> about sharing the config interrupt instead?
> That's only possible if host supports VIRTIO_1
> (so we can detect config interrupt by reading the ISR).
>
>
>
>> ---
>>  drivers/net/virtio_net.c | 29 ++++++++++++++++++++++++++++-
>>  1 file changed, 28 insertions(+), 1 deletion(-)
>>
>> diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
>> index d8838ded..d705cce 100644
>> --- a/drivers/net/virtio_net.c
>> +++ b/drivers/net/virtio_net.c
>> @@ -72,6 +72,9 @@ struct send_queue {
>>  
>>  	/* Name of the send queue: output.$index */
>>  	char name[40];
>> +
>> +	/* Name of the channel, shared with irq. */
>> +	char channel_name[40];
>>  };
>>  
>>  /* Internal representation of a receive virtqueue */
>> @@ -1529,6 +1532,8 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>  	int ret = -ENOMEM;
>>  	int i, total_vqs;
>>  	const char **names;
>> +	const char **channel_names;
>> +	unsigned *channels;
>>  
>>  	/* We expect 1 RX virtqueue followed by 1 TX virtqueue, followed by
>>  	 * possible N-1 RX/TX queue pairs used in multiqueue mode, followed by
>> @@ -1548,6 +1553,17 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>  	if (!names)
>>  		goto err_names;
>>  
>> +	channel_names = kmalloc_array(vi->max_queue_pairs,
>> +				      sizeof(*channel_names),
>> +				      GFP_KERNEL);
>> +	if (!channel_names)
>> +		goto err_channel_names;
>> +
>> +	channels = kmalloc_array(total_vqs, sizeof(*channels),
>> +				 GFP_KERNEL);
>> +	if (!channels)
>> +		goto err_channels;
>> +
>>  	/* Parameters for control virtqueue, if any */
>>  	if (vi->has_cvq) {
>>  		callbacks[total_vqs - 1] = NULL;
>> @@ -1562,10 +1578,15 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>  		sprintf(vi->sq[i].name, "output.%d", i);
>>  		names[rxq2vq(i)] = vi->rq[i].name;
>>  		names[txq2vq(i)] = vi->sq[i].name;
>> +		sprintf(vi->sq[i].channel_name, "txrx.%d", i);
>> +		channel_names[i] = vi->sq[i].channel_name;
>> +		channels[rxq2vq(i)] = i;
>> +		channels[txq2vq(i)] = i;
>>  	}
>>  
>>  	ret = vi->vdev->config->find_vqs(vi->vdev, total_vqs, vqs, callbacks,
>> -					 names);
>> +					 names, channels, channel_names,
>> +					 vi->max_queue_pairs);
>>  	if (ret)
>>  		goto err_find;
>>  
>> @@ -1580,6 +1601,8 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>  		vi->sq[i].vq = vqs[txq2vq(i)];
>>  	}
>>  
>> +	kfree(channels);
>> +	kfree(channel_names);
>>  	kfree(names);
>>  	kfree(callbacks);
>>  	kfree(vqs);
>> @@ -1587,6 +1610,10 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>  	return 0;
>>  
>>  err_find:
>> +	kfree(channels);
>> +err_channels:
>> +	kfree(channel_names);
>> +err_channel_names:
>>  	kfree(names);
>>  err_names:
>>  	kfree(callbacks);
>> -- 
>> 1.9.1

Re: [PATCH v1 1/3] virtio-net: Using single MSIX IRQ for TX/RX Q pair

[Michael S. Tsirkin]

On Wed, Oct 28, 2015 at 11:13:39AM +0800, Jason Wang wrote:
> 
> 
> On 10/27/2015 04:38 PM, Michael S. Tsirkin wrote:
> > On Mon, Oct 26, 2015 at 10:52:47AM -0700, Ravi Kerur wrote:
> >> Ported earlier patch from Jason Wang (dated 12/26/2014).
> >>
> >> This patch tries to reduce the number of MSIX irqs required for
> >> virtio-net by sharing a MSIX irq for each TX/RX queue pair through
> >> channels. If transport support channel, about half of the MSIX irqs
> >> were reduced.
> >>
> >> Signed-off-by: Ravi Kerur <rkerur@gmail.com>
> > Why bother BTW? 
> 
> The reason is we want to save the number of interrupt vectors used.
> Booting a guest with 256 queues with current driver will result all
> tx/rx queues shares a single vector. This is suboptimal.

With a single CPU? But what configures so many queues? Why do it?

> With this
> series, half could be saved.

At cost of e.g. inability to balance the interrupts.

> And more complex policy could be applied on
> top (e.g limit the number of vectors used by driver).

If that's the motivation, I'd like to see a draft of that more complex
policy first.

> > Looks like this is adding a bunch of overhead
> > on data path - to what end?
> 
> I agree some benchmark is needed for this.
> 
> > Maybe you have a huge number of these devices ... but in that case, how
> > about sharing the config interrupt instead?
> > That's only possible if host supports VIRTIO_1
> > (so we can detect config interrupt by reading the ISR).
> >
> >
> >
> >> ---
> >>  drivers/net/virtio_net.c | 29 ++++++++++++++++++++++++++++-
> >>  1 file changed, 28 insertions(+), 1 deletion(-)
> >>
> >> diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
> >> index d8838ded..d705cce 100644
> >> --- a/drivers/net/virtio_net.c
> >> +++ b/drivers/net/virtio_net.c
> >> @@ -72,6 +72,9 @@ struct send_queue {
> >>  
> >>  	/* Name of the send queue: output.$index */
> >>  	char name[40];
> >> +
> >> +	/* Name of the channel, shared with irq. */
> >> +	char channel_name[40];
> >>  };
> >>  
> >>  /* Internal representation of a receive virtqueue */
> >> @@ -1529,6 +1532,8 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
> >>  	int ret = -ENOMEM;
> >>  	int i, total_vqs;
> >>  	const char **names;
> >> +	const char **channel_names;
> >> +	unsigned *channels;
> >>  
> >>  	/* We expect 1 RX virtqueue followed by 1 TX virtqueue, followed by
> >>  	 * possible N-1 RX/TX queue pairs used in multiqueue mode, followed by
> >> @@ -1548,6 +1553,17 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
> >>  	if (!names)
> >>  		goto err_names;
> >>  
> >> +	channel_names = kmalloc_array(vi->max_queue_pairs,
> >> +				      sizeof(*channel_names),
> >> +				      GFP_KERNEL);
> >> +	if (!channel_names)
> >> +		goto err_channel_names;
> >> +
> >> +	channels = kmalloc_array(total_vqs, sizeof(*channels),
> >> +				 GFP_KERNEL);
> >> +	if (!channels)
> >> +		goto err_channels;
> >> +
> >>  	/* Parameters for control virtqueue, if any */
> >>  	if (vi->has_cvq) {
> >>  		callbacks[total_vqs - 1] = NULL;
> >> @@ -1562,10 +1578,15 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
> >>  		sprintf(vi->sq[i].name, "output.%d", i);
> >>  		names[rxq2vq(i)] = vi->rq[i].name;
> >>  		names[txq2vq(i)] = vi->sq[i].name;
> >> +		sprintf(vi->sq[i].channel_name, "txrx.%d", i);
> >> +		channel_names[i] = vi->sq[i].channel_name;
> >> +		channels[rxq2vq(i)] = i;
> >> +		channels[txq2vq(i)] = i;
> >>  	}
> >>  
> >>  	ret = vi->vdev->config->find_vqs(vi->vdev, total_vqs, vqs, callbacks,
> >> -					 names);
> >> +					 names, channels, channel_names,
> >> +					 vi->max_queue_pairs);
> >>  	if (ret)
> >>  		goto err_find;
> >>  
> >> @@ -1580,6 +1601,8 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
> >>  		vi->sq[i].vq = vqs[txq2vq(i)];
> >>  	}
> >>  
> >> +	kfree(channels);
> >> +	kfree(channel_names);
> >>  	kfree(names);
> >>  	kfree(callbacks);
> >>  	kfree(vqs);
> >> @@ -1587,6 +1610,10 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
> >>  	return 0;
> >>  
> >>  err_find:
> >> +	kfree(channels);
> >> +err_channels:
> >> +	kfree(channel_names);
> >> +err_channel_names:
> >>  	kfree(names);
> >>  err_names:
> >>  	kfree(callbacks);
> >> -- 
> >> 1.9.1

Re: [PATCH v1 1/3] virtio-net: Using single MSIX IRQ for TX/RX Q pair

[Jason Wang]

On 10/28/2015 03:21 PM, Michael S. Tsirkin wrote:
> On Wed, Oct 28, 2015 at 11:13:39AM +0800, Jason Wang wrote:
>>
>> On 10/27/2015 04:38 PM, Michael S. Tsirkin wrote:
>>> On Mon, Oct 26, 2015 at 10:52:47AM -0700, Ravi Kerur wrote:
>>>> Ported earlier patch from Jason Wang (dated 12/26/2014).
>>>>
>>>> This patch tries to reduce the number of MSIX irqs required for
>>>> virtio-net by sharing a MSIX irq for each TX/RX queue pair through
>>>> channels. If transport support channel, about half of the MSIX irqs
>>>> were reduced.
>>>>
>>>> Signed-off-by: Ravi Kerur <rkerur@gmail.com>
>>> Why bother BTW? 
>> The reason is we want to save the number of interrupt vectors used.
>> Booting a guest with 256 queues with current driver will result all
>> tx/rx queues shares a single vector. This is suboptimal.
> With a single CPU? 

Even for smp guests. Or you want a per-cpu interrupt?

> But what configures so many queues? Why do it?

Something like cpu hot add.

>
>> With this
>> series, half could be saved.
> At cost of e.g. inability to balance the interrupts.

Didn't follow. Btw, most psychical cards shares irq with tx/rx queue pair.

>
>> And more complex policy could be applied on
>> top (e.g limit the number of vectors used by driver).
> If that's the motivation, I'd like to see a draft of that more complex
> policy first.

How about something like:

1) Driver provides a min and max number of vectors it needs.
2) Virtio pci can then use pci_enable_msix_range() and return the actual
number of vectors to driver.
3) Then driver can divide the virtqueues into different groups

>
>>> Looks like this is adding a bunch of overhead
>>> on data path - to what end?
>> I agree some benchmark is needed for this.
>>
>>> Maybe you have a huge number of these devices ... but in that case, how
>>> about sharing the config interrupt instead?
>>> That's only possible if host supports VIRTIO_1
>>> (so we can detect config interrupt by reading the ISR).
>>>
>>>
>>>
>>>> ---
>>>>  drivers/net/virtio_net.c | 29 ++++++++++++++++++++++++++++-
>>>>  1 file changed, 28 insertions(+), 1 deletion(-)
>>>>
>>>> diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
>>>> index d8838ded..d705cce 100644
>>>> --- a/drivers/net/virtio_net.c
>>>> +++ b/drivers/net/virtio_net.c
>>>> @@ -72,6 +72,9 @@ struct send_queue {
>>>>  
>>>>  	/* Name of the send queue: output.$index */
>>>>  	char name[40];
>>>> +
>>>> +	/* Name of the channel, shared with irq. */
>>>> +	char channel_name[40];
>>>>  };
>>>>  
>>>>  /* Internal representation of a receive virtqueue */
>>>> @@ -1529,6 +1532,8 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>>>  	int ret = -ENOMEM;
>>>>  	int i, total_vqs;
>>>>  	const char **names;
>>>> +	const char **channel_names;
>>>> +	unsigned *channels;
>>>>  
>>>>  	/* We expect 1 RX virtqueue followed by 1 TX virtqueue, followed by
>>>>  	 * possible N-1 RX/TX queue pairs used in multiqueue mode, followed by
>>>> @@ -1548,6 +1553,17 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>>>  	if (!names)
>>>>  		goto err_names;
>>>>  
>>>> +	channel_names = kmalloc_array(vi->max_queue_pairs,
>>>> +				      sizeof(*channel_names),
>>>> +				      GFP_KERNEL);
>>>> +	if (!channel_names)
>>>> +		goto err_channel_names;
>>>> +
>>>> +	channels = kmalloc_array(total_vqs, sizeof(*channels),
>>>> +				 GFP_KERNEL);
>>>> +	if (!channels)
>>>> +		goto err_channels;
>>>> +
>>>>  	/* Parameters for control virtqueue, if any */
>>>>  	if (vi->has_cvq) {
>>>>  		callbacks[total_vqs - 1] = NULL;
>>>> @@ -1562,10 +1578,15 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>>>  		sprintf(vi->sq[i].name, "output.%d", i);
>>>>  		names[rxq2vq(i)] = vi->rq[i].name;
>>>>  		names[txq2vq(i)] = vi->sq[i].name;
>>>> +		sprintf(vi->sq[i].channel_name, "txrx.%d", i);
>>>> +		channel_names[i] = vi->sq[i].channel_name;
>>>> +		channels[rxq2vq(i)] = i;
>>>> +		channels[txq2vq(i)] = i;
>>>>  	}
>>>>  
>>>>  	ret = vi->vdev->config->find_vqs(vi->vdev, total_vqs, vqs, callbacks,
>>>> -					 names);
>>>> +					 names, channels, channel_names,
>>>> +					 vi->max_queue_pairs);
>>>>  	if (ret)
>>>>  		goto err_find;
>>>>  
>>>> @@ -1580,6 +1601,8 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>>>  		vi->sq[i].vq = vqs[txq2vq(i)];
>>>>  	}
>>>>  
>>>> +	kfree(channels);
>>>> +	kfree(channel_names);
>>>>  	kfree(names);
>>>>  	kfree(callbacks);
>>>>  	kfree(vqs);
>>>> @@ -1587,6 +1610,10 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
>>>>  	return 0;
>>>>  
>>>>  err_find:
>>>> +	kfree(channels);
>>>> +err_channels:
>>>> +	kfree(channel_names);
>>>> +err_channel_names:
>>>>  	kfree(names);
>>>>  err_names:
>>>>  	kfree(callbacks);
>>>> -- 
>>>> 1.9.1