1 files changed, 163 insertions, 56 deletions

diff --git a/drivers/net/xen-netback/interface.c b/drivers/net/xen-netback/interface.c
index d98414168485..01bb854c7f62 100644
--- a/drivers/net/xen-netback/interface.c
+++ b/drivers/net/xen-netback/interface.c
@@ -30,6 +30,7 @@
 
 #include "common.h"
 
+#include <linux/kthread.h>
 #include <linux/ethtool.h>
 #include <linux/rtnetlink.h>
 #include <linux/if_vlan.h>
@@ -38,50 +39,93 @@
 #include <asm/xen/hypercall.h>
 
 #define XENVIF_QUEUE_LENGTH 32
+#define XENVIF_NAPI_WEIGHT  64
 
-void xenvif_get(struct xenvif *vif)
+int xenvif_schedulable(struct xenvif *vif)
 {
-        atomic_inc(&vif->refcnt);
+        return netif_running(vif->dev) && netif_carrier_ok(vif->dev);
 }
 
-void xenvif_put(struct xenvif *vif)
+static int xenvif_rx_schedulable(struct xenvif *vif)
 {
-        if (atomic_dec_and_test(&vif->refcnt))
-                wake_up(&vif->waiting_to_free);
+        return xenvif_schedulable(vif) && !xenvif_rx_ring_full(vif);
 }
 
-int xenvif_schedulable(struct xenvif *vif)
+static irqreturn_t xenvif_tx_interrupt(int irq, void *dev_id)
 {
-        return netif_running(vif->dev) && netif_carrier_ok(vif->dev);
+        struct xenvif *vif = dev_id;
+
+        if (RING_HAS_UNCONSUMED_REQUESTS(&vif->tx))
+                napi_schedule(&vif->napi);
+
+        return IRQ_HANDLED;
 }
 
-static int xenvif_rx_schedulable(struct xenvif *vif)
+static int xenvif_poll(struct napi_struct *napi, int budget)
 {
-        return xenvif_schedulable(vif) && !xen_netbk_rx_ring_full(vif);
+        struct xenvif *vif = container_of(napi, struct xenvif, napi);
+        int work_done;
+
+        work_done = xenvif_tx_action(vif, budget);
+
+        if (work_done < budget) {
+                int more_to_do = 0;
+                unsigned long flags;
+
+                /* It is necessary to disable IRQ before calling
+                 * RING_HAS_UNCONSUMED_REQUESTS. Otherwise we might
+                 * lose event from the frontend.
+                 *
+                 * Consider:
+                 *   RING_HAS_UNCONSUMED_REQUESTS
+                 *   <frontend generates event to trigger napi_schedule>
+                 *   __napi_complete
+                 *
+                 * This handler is still in scheduled state so the
+                 * event has no effect at all. After __napi_complete
+                 * this handler is descheduled and cannot get
+                 * scheduled again. We lose event in this case and the ring
+                 * will be completely stalled.
+                 */
+
+                local_irq_save(flags);
+
+                RING_FINAL_CHECK_FOR_REQUESTS(&vif->tx, more_to_do);
+                if (!more_to_do)
+                        __napi_complete(napi);
+
+                local_irq_restore(flags);
+        }
+
+        return work_done;
 }
 
-static irqreturn_t xenvif_interrupt(int irq, void *dev_id)
+static irqreturn_t xenvif_rx_interrupt(int irq, void *dev_id)
 {
         struct xenvif *vif = dev_id;
 
-        if (vif->netbk == NULL)
-                return IRQ_NONE;
-
-        xen_netbk_schedule_xenvif(vif);
-
         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);
 
         BUG_ON(skb->dev != dev);
 
-        if (vif->netbk == NULL)
+        /* Drop the packet if vif is not ready */
+        if (vif->task == NULL)
                 goto drop;
 
         /* Drop the packet if the target domain has no receive buffers. */
@@ -89,13 +133,12 @@ static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 goto drop;
 
         /* Reserve ring slots for the worst-case number of fragments. */
-        vif->rx_req_cons_peek += xen_netbk_count_skb_slots(vif, skb);
-        xenvif_get(vif);
+        vif->rx_req_cons_peek += xenvif_count_skb_slots(vif, skb);
 
-        if (vif->can_queue && xen_netbk_must_stop_queue(vif))
+        if (vif->can_queue && xenvif_must_stop_queue(vif))
                 netif_stop_queue(dev);
 
-        xen_netbk_queue_tx_skb(vif, skb);
+        xenvif_queue_tx_skb(vif, skb);
 
         return NETDEV_TX_OK;
 
@@ -105,11 +148,6 @@ static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev)
         return NETDEV_TX_OK;
 }
 
-void xenvif_receive_skb(struct xenvif *vif, struct sk_buff *skb)
-{
-        netif_rx_ni(skb);
-}
-
 void xenvif_notify_tx_completion(struct xenvif *vif)
 {
         if (netif_queue_stopped(vif->dev) && xenvif_rx_schedulable(vif))
@@ -124,17 +162,20 @@ 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);
-        xen_netbk_check_rx_xenvif(vif);
+        napi_enable(&vif->napi);
+        enable_irq(vif->tx_irq);
+        if (vif->tx_irq != vif->rx_irq)
+                enable_irq(vif->rx_irq);
+        xenvif_check_rx_xenvif(vif);
 }
 
 static void xenvif_down(struct xenvif *vif)
 {
-        disable_irq(vif->irq);
+        napi_disable(&vif->napi);
+        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);
 }
 
 static int xenvif_open(struct net_device *dev)
@@ -250,11 +291,12 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid,
         struct net_device *dev;
         struct xenvif *vif;
         char name[IFNAMSIZ] = {};
+        int i;
 
         snprintf(name, IFNAMSIZ - 1, "vif%u.%u", domid, handle);
         dev = alloc_netdev(sizeof(struct xenvif), name, ether_setup);
         if (dev == NULL) {
-                pr_warn("Could not allocate netdev\n");
+                pr_warn("Could not allocate netdev for %s\n", name);
                 return ERR_PTR(-ENOMEM);
         }
 
@@ -263,14 +305,9 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid,
         vif = netdev_priv(dev);
         vif->domid  = domid;
         vif->handle = handle;
-        vif->netbk  = NULL;
         vif->can_sg = 1;
         vif->csum = 1;
-        atomic_set(&vif->refcnt, 1);
-        init_waitqueue_head(&vif->waiting_to_free);
         vif->dev = dev;
-        INIT_LIST_HEAD(&vif->schedule_list);
-        INIT_LIST_HEAD(&vif->notify_list);
 
         vif->credit_bytes = vif->remaining_credit = ~0UL;
         vif->credit_usec  = 0UL;
@@ -285,6 +322,16 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid,
 
         dev->tx_queue_len = XENVIF_QUEUE_LENGTH;
 
+        skb_queue_head_init(&vif->rx_queue);
+        skb_queue_head_init(&vif->tx_queue);
+
+        vif->pending_cons = 0;
+        vif->pending_prod = MAX_PENDING_REQS;
+        for (i = 0; i < MAX_PENDING_REQS; i++)
+                vif->pending_ring[i] = i;
+        for (i = 0; i < MAX_PENDING_REQS; i++)
+                vif->mmap_pages[i] = NULL;
+
         /*
          * Initialise a dummy MAC address. We choose the numerically
          * largest non-broadcast address to prevent the address getting
@@ -294,6 +341,8 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid,
         memset(dev->dev_addr, 0xFF, ETH_ALEN);
         dev->dev_addr[0] &= ~0x01;
 
+        netif_napi_add(dev, &vif->napi, xenvif_poll, XENVIF_NAPI_WEIGHT);
+
         netif_carrier_off(dev);
 
         err = register_netdev(dev);
@@ -304,31 +353,66 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid,
         }
 
         netdev_dbg(dev, "Successfully created xenvif\n");
+
+        __module_get(THIS_MODULE);
+
         return vif;
 }
 
 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;
 
-        err = xen_netbk_map_frontend_rings(vif, tx_ring_ref, rx_ring_ref);
+        err = xenvif_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);
+        init_waitqueue_head(&vif->wq);
+        vif->task = kthread_create(xenvif_kthread,
+                                   (void *)vif, "%s", vif->dev->name);
+        if (IS_ERR(vif->task)) {
+                pr_warn("Could not allocate kthread for %s\n", vif->dev->name);
+                err = PTR_ERR(vif->task);
+                goto err_rx_unbind;
+        }
 
         rtnl_lock();
         if (!vif->can_sg && vif->dev->mtu > ETH_DATA_LEN)
@@ -339,10 +423,20 @@ int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref,
                 xenvif_up(vif);
         rtnl_unlock();
 
+        wake_up_process(vif->task);
+
         return 0;
+
+err_rx_unbind:
+        unbind_from_irqhandler(vif->rx_irq, vif);
+        vif->rx_irq = 0;
+err_tx_unbind:
+        unbind_from_irqhandler(vif->tx_irq, vif);
+        vif->tx_irq = 0;
 err_unmap:
-        xen_netbk_unmap_frontend_rings(vif);
+        xenvif_unmap_frontend_rings(vif);
 err:
+        module_put(THIS_MODULE);
         return err;
 }
 
@@ -355,7 +449,6 @@ void xenvif_carrier_off(struct xenvif *vif)
         if (netif_running(dev))
                 xenvif_down(vif);
         rtnl_unlock();
-        xenvif_put(vif);
 }
 
 void xenvif_disconnect(struct xenvif *vif)
@@ -363,15 +456,29 @@ void xenvif_disconnect(struct xenvif *vif)
         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->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->tx_irq = 0;
+        }
 
-        if (vif->irq)
-                unbind_from_irqhandler(vif->irq, vif);
+        if (vif->task)
+                kthread_stop(vif->task);
 
-        unregister_netdev(vif->dev);
+        xenvif_unmap_frontend_rings(vif);
+}
 
-        xen_netbk_unmap_frontend_rings(vif);
+void xenvif_free(struct xenvif *vif)
+{
+        netif_napi_del(&vif->napi);
+
+        unregister_netdev(vif->dev);
 
         free_netdev(vif->dev);
+
+        module_put(THIS_MODULE);
 }