Merge branch 'linus' into timers/urgent

Get upstream changes so we can apply fixes against them

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

4 files changed, 172 insertions, 39 deletions

diff --git a/drivers/net/xen-netback/common.h b/drivers/net/xen-netback/common.h
index 9d7f1723dd8f..8a4d77ee9c5b 100644
--- a/drivers/net/xen-netback/common.h
+++ b/drivers/net/xen-netback/common.h
@@ -57,8 +57,12 @@ struct xenvif {
 
         u8               fe_dev_addr[6];
 
-        /* Physical parameters of the comms window. */
-        unsigned int     irq;
+        /* When feature-split-event-channels = 0, tx_irq = rx_irq. */
+        unsigned int tx_irq;
+        unsigned int rx_irq;
+        /* Only used when feature-split-event-channels = 1 */
+        char tx_irq_name[IFNAMSIZ+4]; /* DEVNAME-tx */
+        char rx_irq_name[IFNAMSIZ+4]; /* DEVNAME-rx */
 
         /* List of frontends to notify after a batch of frames sent. */
         struct list_head notify_list;
@@ -113,13 +117,15 @@ struct xenvif *xenvif_alloc(struct device *parent,
                             unsigned int handle);
 
 int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref,
-                   unsigned long rx_ring_ref, unsigned int evtchn);
+                   unsigned long rx_ring_ref, unsigned int tx_evtchn,
+                   unsigned int rx_evtchn);
 void xenvif_disconnect(struct xenvif *vif);
 
 void xenvif_get(struct xenvif *vif);
 void xenvif_put(struct xenvif *vif);
 
 int xenvif_xenbus_init(void);
+void xenvif_xenbus_fini(void);
 
 int xenvif_schedulable(struct xenvif *vif);
 
@@ -157,4 +163,6 @@ void xenvif_carrier_off(struct xenvif *vif);
 /* Returns number of ring slots required to send an skb to the frontend */
 unsigned int xen_netbk_count_skb_slots(struct xenvif *vif, struct sk_buff *skb);
 
+extern bool separate_tx_rx_irq;
+
 #endif /* __XEN_NETBACK__COMMON_H__ */
diff --git a/drivers/net/xen-netback/interface.c b/drivers/net/xen-netback/interface.c
index d98414168485..087d2db0389d 100644
--- a/drivers/net/xen-netback/interface.c
+++ b/drivers/net/xen-netback/interface.c
@@ -60,21 +60,39 @@ static int xenvif_rx_schedulable(struct xenvif *vif)
         return xenvif_schedulable(vif) && !xen_netbk_rx_ring_full(vif);
 }
 
-static irqreturn_t xenvif_interrupt(int irq, void *dev_id)
+static irqreturn_t xenvif_tx_interrupt(int irq, void *dev_id)
 {
         struct xenvif *vif = dev_id;
 
         if (vif->netbk == NULL)
-                return IRQ_NONE;
+                return IRQ_HANDLED;
 
         xen_netbk_schedule_xenvif(vif);
 
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t xenvif_rx_interrupt(int irq, void *dev_id)
+{
+        struct xenvif *vif = dev_id;
+
+        if (vif->netbk == NULL)
+                return IRQ_HANDLED;
+
         if (xenvif_rx_schedulable(vif))
                 netif_wake_queue(vif->dev);
 
         return IRQ_HANDLED;
 }
 
+static irqreturn_t xenvif_interrupt(int irq, void *dev_id)
+{
+        xenvif_tx_interrupt(irq, dev_id);
+        xenvif_rx_interrupt(irq, dev_id);
+
+        return IRQ_HANDLED;
+}
+
 static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
         struct xenvif *vif = netdev_priv(dev);
@@ -125,13 +143,17 @@ static struct net_device_stats *xenvif_get_stats(struct net_device *dev)
 static void xenvif_up(struct xenvif *vif)
 {
         xen_netbk_add_xenvif(vif);
-        enable_irq(vif->irq);
+        enable_irq(vif->tx_irq);
+        if (vif->tx_irq != vif->rx_irq)
+                enable_irq(vif->rx_irq);
         xen_netbk_check_rx_xenvif(vif);
 }
 
 static void xenvif_down(struct xenvif *vif)
 {
-        disable_irq(vif->irq);
+        disable_irq(vif->tx_irq);
+        if (vif->tx_irq != vif->rx_irq)
+                disable_irq(vif->rx_irq);
         del_timer_sync(&vif->credit_timeout);
         xen_netbk_deschedule_xenvif(vif);
         xen_netbk_remove_xenvif(vif);
@@ -308,25 +330,52 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid,
 }
 
 int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref,
-                   unsigned long rx_ring_ref, unsigned int evtchn)
+                   unsigned long rx_ring_ref, unsigned int tx_evtchn,
+                   unsigned int rx_evtchn)
 {
         int err = -ENOMEM;
 
         /* Already connected through? */
-        if (vif->irq)
+        if (vif->tx_irq)
                 return 0;
 
+        __module_get(THIS_MODULE);
+
         err = xen_netbk_map_frontend_rings(vif, tx_ring_ref, rx_ring_ref);
         if (err < 0)
                 goto err;
 
-        err = bind_interdomain_evtchn_to_irqhandler(
-                vif->domid, evtchn, xenvif_interrupt, 0,
-                vif->dev->name, vif);
-        if (err < 0)
-                goto err_unmap;
-        vif->irq = err;
-        disable_irq(vif->irq);
+        if (tx_evtchn == rx_evtchn) {
+                /* feature-split-event-channels == 0 */
+                err = bind_interdomain_evtchn_to_irqhandler(
+                        vif->domid, tx_evtchn, xenvif_interrupt, 0,
+                        vif->dev->name, vif);
+                if (err < 0)
+                        goto err_unmap;
+                vif->tx_irq = vif->rx_irq = err;
+                disable_irq(vif->tx_irq);
+        } else {
+                /* feature-split-event-channels == 1 */
+                snprintf(vif->tx_irq_name, sizeof(vif->tx_irq_name),
+                         "%s-tx", vif->dev->name);
+                err = bind_interdomain_evtchn_to_irqhandler(
+                        vif->domid, tx_evtchn, xenvif_tx_interrupt, 0,
+                        vif->tx_irq_name, vif);
+                if (err < 0)
+                        goto err_unmap;
+                vif->tx_irq = err;
+                disable_irq(vif->tx_irq);
+
+                snprintf(vif->rx_irq_name, sizeof(vif->rx_irq_name),
+                         "%s-rx", vif->dev->name);
+                err = bind_interdomain_evtchn_to_irqhandler(
+                        vif->domid, rx_evtchn, xenvif_rx_interrupt, 0,
+                        vif->rx_irq_name, vif);
+                if (err < 0)
+                        goto err_tx_unbind;
+                vif->rx_irq = err;
+                disable_irq(vif->rx_irq);
+        }
 
         xenvif_get(vif);
 
@@ -340,9 +389,13 @@ int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref,
         rtnl_unlock();
 
         return 0;
+err_tx_unbind:
+        unbind_from_irqhandler(vif->tx_irq, vif);
+        vif->tx_irq = 0;
 err_unmap:
         xen_netbk_unmap_frontend_rings(vif);
 err:
+        module_put(THIS_MODULE);
         return err;
 }
 
@@ -360,18 +413,37 @@ void xenvif_carrier_off(struct xenvif *vif)
 
 void xenvif_disconnect(struct xenvif *vif)
 {
+        /* Disconnect funtion might get called by generic framework
+         * even before vif connects, so we need to check if we really
+         * need to do a module_put.
+         */
+        int need_module_put = 0;
+
         if (netif_carrier_ok(vif->dev))
                 xenvif_carrier_off(vif);
 
         atomic_dec(&vif->refcnt);
         wait_event(vif->waiting_to_free, atomic_read(&vif->refcnt) == 0);
 
-        if (vif->irq)
-                unbind_from_irqhandler(vif->irq, vif);
+        if (vif->tx_irq) {
+                if (vif->tx_irq == vif->rx_irq)
+                        unbind_from_irqhandler(vif->tx_irq, vif);
+                else {
+                        unbind_from_irqhandler(vif->tx_irq, vif);
+                        unbind_from_irqhandler(vif->rx_irq, vif);
+                }
+                /* vif->irq is valid, we had a module_get in
+                 * xenvif_connect.
+                 */
+                need_module_put = 1;
+        }
 
         unregister_netdev(vif->dev);
 
         xen_netbk_unmap_frontend_rings(vif);
 
         free_netdev(vif->dev);
+
+        if (need_module_put)
+                module_put(THIS_MODULE);
 }
diff --git a/drivers/net/xen-netback/netback.c b/drivers/net/xen-netback/netback.c
index 8c20935d72c9..64828de25d9a 100644
--- a/drivers/net/xen-netback/netback.c
+++ b/drivers/net/xen-netback/netback.c
@@ -47,6 +47,13 @@
 #include <asm/xen/hypercall.h>
 #include <asm/xen/page.h>
 
+/* Provide an option to disable split event channels at load time as
+ * event channels are limited resource. Split event channels are
+ * enabled by default.
+ */
+bool separate_tx_rx_irq = 1;
+module_param(separate_tx_rx_irq, bool, 0644);
+
 /*
  * This is the maximum slots a skb can have. If a guest sends a skb
  * which exceeds this limit it is considered malicious.
@@ -783,7 +790,7 @@ static void xen_netbk_rx_action(struct xen_netbk *netbk)
         }
 
         list_for_each_entry_safe(vif, tmp, &notify, notify_list) {
-                notify_remote_via_irq(vif->irq);
+                notify_remote_via_irq(vif->rx_irq);
                 list_del_init(&vif->notify_list);
                 xenvif_put(vif);
         }
@@ -1763,7 +1770,7 @@ static void make_tx_response(struct xenvif *vif,
         vif->tx.rsp_prod_pvt = ++i;
         RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&vif->tx, notify);
         if (notify)
-                notify_remote_via_irq(vif->irq);
+                notify_remote_via_irq(vif->tx_irq);
 }
 
 static struct xen_netif_rx_response *make_rx_response(struct xenvif *vif,
@@ -1883,9 +1890,8 @@ static int __init netback_init(void)
                 return -ENODEV;
 
         if (fatal_skb_slots < XEN_NETBK_LEGACY_SLOTS_MAX) {
-                printk(KERN_INFO
-                       "xen-netback: fatal_skb_slots too small (%d), bump it to XEN_NETBK_LEGACY_SLOTS_MAX (%d)\n",
-                       fatal_skb_slots, XEN_NETBK_LEGACY_SLOTS_MAX);
+                pr_info("fatal_skb_slots too small (%d), bump it to XEN_NETBK_LEGACY_SLOTS_MAX (%d)\n",
+                        fatal_skb_slots, XEN_NETBK_LEGACY_SLOTS_MAX);
                 fatal_skb_slots = XEN_NETBK_LEGACY_SLOTS_MAX;
         }
 
@@ -1914,7 +1920,7 @@ static int __init netback_init(void)
                                              "netback/%u", group);
 
                 if (IS_ERR(netbk->task)) {
-                        printk(KERN_ALERT "kthread_create() fails at netback\n");
+                        pr_alert("kthread_create() fails at netback\n");
                         del_timer(&netbk->net_timer);
                         rc = PTR_ERR(netbk->task);
                         goto failed_init;
@@ -1940,10 +1946,6 @@ static int __init netback_init(void)
 failed_init:
         while (--group >= 0) {
                 struct xen_netbk *netbk = &xen_netbk[group];
-                for (i = 0; i < MAX_PENDING_REQS; i++) {
-                        if (netbk->mmap_pages[i])
-                                __free_page(netbk->mmap_pages[i]);
-                }
                 del_timer(&netbk->net_timer);
                 kthread_stop(netbk->task);
         }
@@ -1954,5 +1956,25 @@ failed_init:
 
 module_init(netback_init);
 
+static void __exit netback_fini(void)
+{
+        int i, j;
+
+        xenvif_xenbus_fini();
+
+        for (i = 0; i < xen_netbk_group_nr; i++) {
+                struct xen_netbk *netbk = &xen_netbk[i];
+                del_timer_sync(&netbk->net_timer);
+                kthread_stop(netbk->task);
+                for (j = 0; j < MAX_PENDING_REQS; j++) {
+                        if (netbk->mmap_pages[j])
+                                __free_page(netbk->mmap_pages[j]);
+                }
+        }
+
+        vfree(xen_netbk);
+}
+module_exit(netback_fini);
+
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_ALIAS("xen-backend:vif");
diff --git a/drivers/net/xen-netback/xenbus.c b/drivers/net/xen-netback/xenbus.c
index 410018c4c528..1fe48fe364ed 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\n");
+
         err = xenbus_switch_state(dev, XenbusStateInitWait);
         if (err)
                 goto fail;
@@ -135,7 +145,7 @@ abort_transaction:
         xenbus_transaction_end(xbt, 1);
         xenbus_dev_fatal(dev, err, "%s", message);
 fail:
-        pr_debug("failed");
+        pr_debug("failed\n");
         netback_remove(dev);
         return err;
 }
@@ -218,15 +228,14 @@ static void frontend_changed(struct xenbus_device *dev,
 {
         struct backend_info *be = dev_get_drvdata(&dev->dev);
 
-        pr_debug("frontend state %s", xenbus_strstate(frontend_state));
+        pr_debug("frontend state %s\n", xenbus_strstate(frontend_state));
 
         be->frontend_state = frontend_state;
 
         switch (frontend_state) {
         case XenbusStateInitialising:
                 if (dev->state == XenbusStateClosed) {
-                        printk(KERN_INFO "%s: %s: prepare for reconnect\n",
-                               __func__, dev->nodename);
+                        pr_info("%s: prepare for reconnect\n", dev->nodename);
                         xenbus_switch_state(dev, XenbusStateInitWait);
                 }
                 break;
@@ -393,21 +402,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 +478,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;
@@ -485,3 +511,8 @@ int xenvif_xenbus_init(void)
 {
         return xenbus_register_backend(&netback_driver);
 }
+
+void xenvif_xenbus_fini(void)
+{
+        return xenbus_unregister_driver(&netback_driver);
+}