1 files changed, 97 insertions, 62 deletions

diff --git a/drivers/net/xen-netback/interface.c b/drivers/net/xen-netback/interface.c
index 087d2db0389d..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,17 +39,7 @@
 #include <asm/xen/hypercall.h>
 
 #define XENVIF_QUEUE_LENGTH 32
-
-void xenvif_get(struct xenvif *vif)
-{
-        atomic_inc(&vif->refcnt);
-}
-
-void xenvif_put(struct xenvif *vif)
-{
-        if (atomic_dec_and_test(&vif->refcnt))
-                wake_up(&vif->waiting_to_free);
-}
+#define XENVIF_NAPI_WEIGHT  64
 
 int xenvif_schedulable(struct xenvif *vif)
 {
@@ -57,28 +48,62 @@ int xenvif_schedulable(struct xenvif *vif)
 
 static int xenvif_rx_schedulable(struct xenvif *vif)
 {
-        return xenvif_schedulable(vif) && !xen_netbk_rx_ring_full(vif);
+        return xenvif_schedulable(vif) && !xenvif_rx_ring_full(vif);
 }
 
 static irqreturn_t xenvif_tx_interrupt(int irq, void *dev_id)
 {
         struct xenvif *vif = dev_id;
 
-        if (vif->netbk == NULL)
-                return IRQ_HANDLED;
-
-        xen_netbk_schedule_xenvif(vif);
+        if (RING_HAS_UNCONSUMED_REQUESTS(&vif->tx))
+                napi_schedule(&vif->napi);
 
         return IRQ_HANDLED;
 }
 
+static int xenvif_poll(struct napi_struct *napi, int budget)
+{
+        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_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);
 
@@ -99,7 +124,8 @@ static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *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. */
@@ -107,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;
 
@@ -123,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))
@@ -142,21 +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);
+        napi_enable(&vif->napi);
         enable_irq(vif->tx_irq);
         if (vif->tx_irq != vif->rx_irq)
                 enable_irq(vif->rx_irq);
-        xen_netbk_check_rx_xenvif(vif);
+        xenvif_check_rx_xenvif(vif);
 }
 
 static void xenvif_down(struct xenvif *vif)
 {
+        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)
@@ -272,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);
         }
 
@@ -285,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;
@@ -307,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
@@ -316,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);
@@ -326,6 +353,9 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid,
         }
 
         netdev_dbg(dev, "Successfully created xenvif\n");
+
+        __module_get(THIS_MODULE);
+
         return vif;
 }
 
@@ -339,9 +369,7 @@ int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref,
         if (vif->tx_irq)
                 return 0;
 
-        __module_get(THIS_MODULE);
-
-        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;
 
@@ -377,7 +405,14 @@ int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref,
                 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)
@@ -388,12 +423,18 @@ 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;
@@ -408,23 +449,13 @@ 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)
 {
-        /* 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->tx_irq) {
                 if (vif->tx_irq == vif->rx_irq)
                         unbind_from_irqhandler(vif->tx_irq, vif);
@@ -432,18 +463,22 @@ void xenvif_disconnect(struct xenvif *vif)
                         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;
+                vif->tx_irq = 0;
         }
 
-        unregister_netdev(vif->dev);
+        if (vif->task)
+                kthread_stop(vif->task);
+
+        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);
 
-        if (need_module_put)
-                module_put(THIS_MODULE);
+        module_put(THIS_MODULE);
 }