xen-netback: split event channels support for Xen backend driver

Netback and netfront only use one event channel to do TX / RX notification,
which may cause unnecessary wake-up of processing routines. This patch adds a
new feature called feature-split-event-channels to netback, enabling it to
handle TX and RX events separately.

Netback will use tx_irq to notify guest for TX completion, rx_irq for RX
notification.

If frontend doesn't support this feature, tx_irq equals to rx_irq.

Signed-off-by: Wei Liu <wei.liu2@citrix.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 34 insertions, 7 deletions

diff --git a/drivers/net/xen-netback/xenbus.c b/drivers/net/xen-netback/xenbus.c
index d230c145660c..04bd860d16a9 100644
--- a/drivers/net/xen-netback/xenbus.c
+++ b/drivers/net/xen-netback/xenbus.c
@@ -122,6 +122,16 @@ static int netback_probe(struct xenbus_device *dev,
                 goto fail;
         }
 
+        /*
+         * Split event channels support, this is optional so it is not
+         * put inside the above loop.
+         */
+        err = xenbus_printf(XBT_NIL, dev->nodename,
+                            "feature-split-event-channels",
+                            "%u", separate_tx_rx_irq);
+        if (err)
+                pr_debug("Error writing feature-split-event-channels");
+
         err = xenbus_switch_state(dev, XenbusStateInitWait);
         if (err)
                 goto fail;
@@ -393,21 +403,36 @@ static int connect_rings(struct backend_info *be)
         struct xenvif *vif = be->vif;
         struct xenbus_device *dev = be->dev;
         unsigned long tx_ring_ref, rx_ring_ref;
-        unsigned int evtchn, rx_copy;
+        unsigned int tx_evtchn, rx_evtchn, rx_copy;
         int err;
         int val;
 
         err = xenbus_gather(XBT_NIL, dev->otherend,
                             "tx-ring-ref", "%lu", &tx_ring_ref,
-                            "rx-ring-ref", "%lu", &rx_ring_ref,
-                            "event-channel", "%u", &evtchn, NULL);
+                            "rx-ring-ref", "%lu", &rx_ring_ref, NULL);
         if (err) {
                 xenbus_dev_fatal(dev, err,
-                                 "reading %s/ring-ref and event-channel",
+                                 "reading %s/ring-ref",
                                  dev->otherend);
                 return err;
         }
 
+        /* Try split event channels first, then single event channel. */
+        err = xenbus_gather(XBT_NIL, dev->otherend,
+                            "event-channel-tx", "%u", &tx_evtchn,
+                            "event-channel-rx", "%u", &rx_evtchn, NULL);
+        if (err < 0) {
+                err = xenbus_scanf(XBT_NIL, dev->otherend,
+                                   "event-channel", "%u", &tx_evtchn);
+                if (err < 0) {
+                        xenbus_dev_fatal(dev, err,
+                                         "reading %s/event-channel(-tx/rx)",
+                                         dev->otherend);
+                        return err;
+                }
+                rx_evtchn = tx_evtchn;
+        }
+
         err = xenbus_scanf(XBT_NIL, dev->otherend, "request-rx-copy", "%u",
                            &rx_copy);
         if (err == -ENOENT) {
@@ -454,11 +479,13 @@ static int connect_rings(struct backend_info *be)
         vif->csum = !val;
 
         /* Map the shared frame, irq etc. */
-        err = xenvif_connect(vif, tx_ring_ref, rx_ring_ref, evtchn);
+        err = xenvif_connect(vif, tx_ring_ref, rx_ring_ref,
+                             tx_evtchn, rx_evtchn);
         if (err) {
                 xenbus_dev_fatal(dev, err,
-                                 "mapping shared-frames %lu/%lu port %u",
-                                 tx_ring_ref, rx_ring_ref, evtchn);
+                                 "mapping shared-frames %lu/%lu port tx %u rx %u",
+                                 tx_ring_ref, rx_ring_ref,
+                                 tx_evtchn, rx_evtchn);
                 return err;
         }
         return 0;