1 files changed, 48 insertions, 69 deletions

diff --git a/drivers/net/xen-netback/interface.c b/drivers/net/xen-netback/interface.c
index 852da34b8961..bfd10cb9c8de 100644
--- a/drivers/net/xen-netback/interface.c
+++ b/drivers/net/xen-netback/interface.c
@@ -55,7 +55,8 @@ static inline void xenvif_stop_queue(struct xenvif_queue *queue)
 
 int xenvif_schedulable(struct xenvif *vif)
 {
-        return netif_running(vif->dev) && netif_carrier_ok(vif->dev);
+        return netif_running(vif->dev) &&
+                test_bit(VIF_STATUS_CONNECTED, &vif->status);
 }
 
 static irqreturn_t xenvif_tx_interrupt(int irq, void *dev_id)
@@ -96,13 +97,22 @@ int xenvif_poll(struct napi_struct *napi, int budget)
 static irqreturn_t xenvif_rx_interrupt(int irq, void *dev_id)
 {
         struct xenvif_queue *queue = dev_id;
+        struct netdev_queue *net_queue =
+                netdev_get_tx_queue(queue->vif->dev, queue->id);
 
+        /* QUEUE_STATUS_RX_PURGE_EVENT is only set if either QDisc was off OR
+         * the carrier went down and this queue was previously blocked
+         */
+        if (unlikely(netif_tx_queue_stopped(net_queue) ||
+                     (!netif_carrier_ok(queue->vif->dev) &&
+                      test_bit(QUEUE_STATUS_RX_STALLED, &queue->status))))
+                set_bit(QUEUE_STATUS_RX_PURGE_EVENT, &queue->status);
         xenvif_kick_thread(queue);
 
         return IRQ_HANDLED;
 }
 
-static irqreturn_t xenvif_interrupt(int irq, void *dev_id)
+irqreturn_t xenvif_interrupt(int irq, void *dev_id)
 {
         xenvif_tx_interrupt(irq, dev_id);
         xenvif_rx_interrupt(irq, dev_id);
@@ -124,45 +134,22 @@ void xenvif_wake_queue(struct xenvif_queue *queue)
         netif_tx_wake_queue(netdev_get_tx_queue(dev, id));
 }
 
-/* Callback to wake the queue and drain it on timeout */
-static void xenvif_wake_queue_callback(unsigned long data)
+/* Callback to wake the queue's thread and turn the carrier off on timeout */
+static void xenvif_rx_stalled(unsigned long data)
 {
         struct xenvif_queue *queue = (struct xenvif_queue *)data;
 
         if (xenvif_queue_stopped(queue)) {
-                netdev_err(queue->vif->dev, "draining TX queue\n");
-                queue->rx_queue_purge = true;
+                set_bit(QUEUE_STATUS_RX_PURGE_EVENT, &queue->status);
                 xenvif_kick_thread(queue);
-                xenvif_wake_queue(queue);
         }
 }
 
-static u16 xenvif_select_queue(struct net_device *dev, struct sk_buff *skb,
-                               void *accel_priv, select_queue_fallback_t fallback)
-{
-        unsigned int num_queues = dev->real_num_tx_queues;
-        u32 hash;
-        u16 queue_index;
-
-        /* First, check if there is only one queue to optimise the
-         * single-queue or old frontend scenario.
-         */
-        if (num_queues == 1) {
-                queue_index = 0;
-        } else {
-                /* Use skb_get_hash to obtain an L4 hash if available */
-                hash = skb_get_hash(skb);
-                queue_index = hash % num_queues;
-        }
-
-        return queue_index;
-}
-
 static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
         struct xenvif *vif = netdev_priv(dev);
         struct xenvif_queue *queue = NULL;
-        unsigned int num_queues = dev->real_num_tx_queues;
+        unsigned int num_queues = vif->num_queues;
         u16 index;
         int min_slots_needed;
 
@@ -203,11 +190,11 @@ static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev)
          * drain.
          */
         if (!xenvif_rx_ring_slots_available(queue, min_slots_needed)) {
-                queue->wake_queue.function = xenvif_wake_queue_callback;
-                queue->wake_queue.data = (unsigned long)queue;
+                queue->rx_stalled.function = xenvif_rx_stalled;
+                queue->rx_stalled.data = (unsigned long)queue;
                 xenvif_stop_queue(queue);
-                mod_timer(&queue->wake_queue,
-                        jiffies + rx_drain_timeout_jiffies);
+                mod_timer(&queue->rx_stalled,
+                          jiffies + rx_drain_timeout_jiffies);
         }
 
         skb_queue_tail(&queue->rx_queue, skb);
@@ -225,7 +212,7 @@ static struct net_device_stats *xenvif_get_stats(struct net_device *dev)
 {
         struct xenvif *vif = netdev_priv(dev);
         struct xenvif_queue *queue = NULL;
-        unsigned int num_queues = dev->real_num_tx_queues;
+        unsigned int num_queues = vif->num_queues;
         unsigned long rx_bytes = 0;
         unsigned long rx_packets = 0;
         unsigned long tx_bytes = 0;
@@ -256,7 +243,7 @@ out:
 static void xenvif_up(struct xenvif *vif)
 {
         struct xenvif_queue *queue = NULL;
-        unsigned int num_queues = vif->dev->real_num_tx_queues;
+        unsigned int num_queues = vif->num_queues;
         unsigned int queue_index;
 
         for (queue_index = 0; queue_index < num_queues; ++queue_index) {
@@ -272,7 +259,7 @@ static void xenvif_up(struct xenvif *vif)
 static void xenvif_down(struct xenvif *vif)
 {
         struct xenvif_queue *queue = NULL;
-        unsigned int num_queues = vif->dev->real_num_tx_queues;
+        unsigned int num_queues = vif->num_queues;
         unsigned int queue_index;
 
         for (queue_index = 0; queue_index < num_queues; ++queue_index) {
@@ -288,7 +275,7 @@ static void xenvif_down(struct xenvif *vif)
 static int xenvif_open(struct net_device *dev)
 {
         struct xenvif *vif = netdev_priv(dev);
-        if (netif_carrier_ok(dev))
+        if (test_bit(VIF_STATUS_CONNECTED, &vif->status))
                 xenvif_up(vif);
         netif_tx_start_all_queues(dev);
         return 0;
@@ -297,7 +284,7 @@ static int xenvif_open(struct net_device *dev)
 static int xenvif_close(struct net_device *dev)
 {
         struct xenvif *vif = netdev_priv(dev);
-        if (netif_carrier_ok(dev))
+        if (test_bit(VIF_STATUS_CONNECTED, &vif->status))
                 xenvif_down(vif);
         netif_tx_stop_all_queues(dev);
         return 0;
@@ -379,7 +366,7 @@ static void xenvif_get_ethtool_stats(struct net_device *dev,
                                      struct ethtool_stats *stats, u64 * data)
 {
         struct xenvif *vif = netdev_priv(dev);
-        unsigned int num_queues = dev->real_num_tx_queues;
+        unsigned int num_queues = vif->num_queues;
         int i;
         unsigned int queue_index;
         struct xenvif_stats *vif_stats;
@@ -424,7 +411,6 @@ static const struct net_device_ops xenvif_netdev_ops = {
         .ndo_fix_features = xenvif_fix_features,
         .ndo_set_mac_address = eth_mac_addr,
         .ndo_validate_addr   = eth_validate_addr,
-        .ndo_select_queue = xenvif_select_queue,
 };
 
 struct xenvif *xenvif_alloc(struct device *parent, domid_t domid,
@@ -438,10 +424,10 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid,
         snprintf(name, IFNAMSIZ - 1, "vif%u.%u", domid, handle);
         /* Allocate a netdev with the max. supported number of queues.
          * When the guest selects the desired number, it will be updated
-         * via netif_set_real_num_tx_queues().
+         * via netif_set_real_num_*_queues().
          */
-        dev = alloc_netdev_mq(sizeof(struct xenvif), name, ether_setup,
-                              xenvif_max_queues);
+        dev = alloc_netdev_mq(sizeof(struct xenvif), name, NET_NAME_UNKNOWN,
+                              ether_setup, xenvif_max_queues);
         if (dev == NULL) {
                 pr_warn("Could not allocate netdev for %s\n", name);
                 return ERR_PTR(-ENOMEM);
@@ -458,11 +444,9 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid,
         vif->dev = dev;
         vif->disabled = false;
 
-        /* Start out with no queues. The call below does not require
-         * rtnl_lock() as it happens before register_netdev().
-         */
+        /* Start out with no queues. */
         vif->queues = NULL;
-        netif_set_real_num_tx_queues(dev, 0);
+        vif->num_queues = 0;
 
         dev->netdev_ops = &xenvif_netdev_ops;
         dev->hw_features = NETIF_F_SG |
@@ -538,7 +522,7 @@ int xenvif_init_queue(struct xenvif_queue *queue)
                 queue->grant_tx_handle[i] = NETBACK_INVALID_HANDLE;
         }
 
-        init_timer(&queue->wake_queue);
+        init_timer(&queue->rx_stalled);
 
         netif_napi_add(queue->vif->dev, &queue->napi, xenvif_poll,
                         XENVIF_NAPI_WEIGHT);
@@ -552,6 +536,7 @@ void xenvif_carrier_on(struct xenvif *vif)
         if (!vif->can_sg && vif->dev->mtu > ETH_DATA_LEN)
                 dev_set_mtu(vif->dev, ETH_DATA_LEN);
         netdev_update_features(vif->dev);
+        set_bit(VIF_STATUS_CONNECTED, &vif->status);
         netif_carrier_on(vif->dev);
         if (netif_running(vif->dev))
                 xenvif_up(vif);
@@ -649,9 +634,11 @@ void xenvif_carrier_off(struct xenvif *vif)
         struct net_device *dev = vif->dev;
 
         rtnl_lock();
-        netif_carrier_off(dev); /* discard queued packets */
-        if (netif_running(dev))
-                xenvif_down(vif);
+        if (test_and_clear_bit(VIF_STATUS_CONNECTED, &vif->status)) {
+                netif_carrier_off(dev); /* discard queued packets */
+                if (netif_running(dev))
+                        xenvif_down(vif);
+        }
         rtnl_unlock();
 }
 
@@ -677,17 +664,16 @@ static void xenvif_wait_unmap_timeout(struct xenvif_queue *queue,
 void xenvif_disconnect(struct xenvif *vif)
 {
         struct xenvif_queue *queue = NULL;
-        unsigned int num_queues = vif->dev->real_num_tx_queues;
+        unsigned int num_queues = vif->num_queues;
         unsigned int queue_index;
 
-        if (netif_carrier_ok(vif->dev))
-                xenvif_carrier_off(vif);
+        xenvif_carrier_off(vif);
 
         for (queue_index = 0; queue_index < num_queues; ++queue_index) {
                 queue = &vif->queues[queue_index];
 
                 if (queue->task) {
-                        del_timer_sync(&queue->wake_queue);
+                        del_timer_sync(&queue->rx_stalled);
                         kthread_stop(queue->task);
                         queue->task = NULL;
                 }
@@ -724,21 +710,17 @@ void xenvif_deinit_queue(struct xenvif_queue *queue)
 void xenvif_free(struct xenvif *vif)
 {
         struct xenvif_queue *queue = NULL;
-        unsigned int num_queues = vif->dev->real_num_tx_queues;
+        unsigned int num_queues = vif->num_queues;
         unsigned int queue_index;
         /* Here we want to avoid timeout messages if an skb can be legitimately
          * stuck somewhere else. Realistically this could be an another vif's
          * internal or QDisc queue. That another vif also has this
-         * rx_drain_timeout_msecs timeout, but the timer only ditches the
-         * internal queue. After that, the QDisc queue can put in worst case
-         * XEN_NETIF_RX_RING_SIZE / MAX_SKB_FRAGS skbs into that another vif's
-         * internal queue, so we need several rounds of such timeouts until we
-         * can be sure that no another vif should have skb's from us. We are
-         * not sending more skb's, so newly stuck packets are not interesting
-         * for us here.
+         * rx_drain_timeout_msecs timeout, so give it time to drain out.
+         * Although if that other guest wakes up just before its timeout happens
+         * and takes only one skb from QDisc, it can hold onto other skbs for a
+         * longer period.
          */
-        unsigned int worst_case_skb_lifetime = (rx_drain_timeout_msecs/1000) *
-                DIV_ROUND_UP(XENVIF_QUEUE_LENGTH, (XEN_NETIF_RX_RING_SIZE / MAX_SKB_FRAGS));
+        unsigned int worst_case_skb_lifetime = (rx_drain_timeout_msecs/1000);
 
         unregister_netdev(vif->dev);
 
@@ -748,12 +730,9 @@ void xenvif_free(struct xenvif *vif)
                 xenvif_deinit_queue(queue);
         }
 
-        /* Free the array of queues. The call below does not require
-         * rtnl_lock() because it happens after unregister_netdev().
-         */
-        netif_set_real_num_tx_queues(vif->dev, 0);
         vfree(vif->queues);
         vif->queues = NULL;
+        vif->num_queues = 0;
 
         free_netdev(vif->dev);