Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next

Pull networking updates from David Miller:
 "Highlights:

   1) Steady transitioning of the BPF instructure to a generic spot so
      all kernel subsystems can make use of it, from Alexei Starovoitov.

   2) SFC driver supports busy polling, from Alexandre Rames.

   3) Take advantage of hash table in UDP multicast delivery, from David
      Held.

   4) Lighten locking, in particular by getting rid of the LRU lists, in
      inet frag handling.  From Florian Westphal.

   5) Add support for various RFC6458 control messages in SCTP, from
      Geir Ola Vaagland.

   6) Allow to filter bridge forwarding database dumps by device, from
      Jamal Hadi Salim.

   7) virtio-net also now supports busy polling, from Jason Wang.

   8) Some low level optimization tweaks in pktgen from Jesper Dangaard
      Brouer.

   9) Add support for ipv6 address generation modes, so that userland
      can have some input into the process.  From Jiri Pirko.

  10) Consolidate common TCP connection request code in ipv4 and ipv6,
      from Octavian Purdila.

  11) New ARP packet logger in netfilter, from Pablo Neira Ayuso.

  12) Generic resizable RCU hash table, with intial users in netlink and
      nftables.  From Thomas Graf.

  13) Maintain a name assignment type so that userspace can see where a
      network device name came from (enumerated by kernel, assigned
      explicitly by userspace, etc.) From Tom Gundersen.

  14) Automatic flow label generation on transmit in ipv6, from Tom
      Herbert.

  15) New packet timestamping facilities from Willem de Bruijn, meant to
      assist in measuring latencies going into/out-of the packet
      scheduler, latency from TCP data transmission to ACK, etc"

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next: (1536 commits)
  cxgb4 : Disable recursive mailbox commands when enabling vi
  net: reduce USB network driver config options.
  tg3: Modify tg3_tso_bug() to handle multiple TX rings
  amd-xgbe: Perform phy connect/disconnect at dev open/stop
  amd-xgbe: Use dma_set_mask_and_coherent to set DMA mask
  net: sun4i-emac: fix memory leak on bad packet
  sctp: fix possible seqlock seadlock in sctp_packet_transmit()
  Revert "net: phy: Set the driver when registering an MDIO bus device"
  cxgb4vf: Turn off SGE RX/TX Callback Timers and interrupts in PCI shutdown routine
  team: Simplify return path of team_newlink
  bridge: Update outdated comment on promiscuous mode
  net-timestamp: ACK timestamp for bytestreams
  net-timestamp: TCP timestamping
  net-timestamp: SCHED timestamp on entering packet scheduler
  net-timestamp: add key to disambiguate concurrent datagrams
  net-timestamp: move timestamp flags out of sk_flags
  net-timestamp: extend SCM_TIMESTAMPING ancillary data struct
  cxgb4i : Move stray CPL definitions to cxgb4 driver
  tcp: reduce spurious retransmits due to transient SACK reneging
  qlcnic: Initialize dcbnl_ops before register_netdev
  ...

1 files changed, 42 insertions, 32 deletions

diff --git a/drivers/net/xen-netback/interface.c b/drivers/net/xen-netback/interface.c
index 9e97c7ca0ddd..48a55cda979b 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)
@@ -77,8 +78,12 @@ int xenvif_poll(struct napi_struct *napi, int budget)
         /* This vif is rogue, we pretend we've there is nothing to do
          * for this vif to deschedule it from NAPI. But this interface
          * will be turned off in thread context later.
+         * Also, if a guest doesn't post enough slots to receive data on one of
+         * its queues, the carrier goes down and NAPI is descheduled here so
+         * the guest can't send more packets until it's ready to receive.
          */
-        if (unlikely(queue->vif->disabled)) {
+        if (unlikely(queue->vif->disabled ||
+                     !netif_carrier_ok(queue->vif->dev))) {
                 napi_complete(napi);
                 return 0;
         }
@@ -96,13 +101,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,16 +138,14 @@ 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);
         }
 }
 
@@ -182,11 +194,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);
@@ -267,7 +279,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;
@@ -276,7 +288,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;
@@ -418,8 +430,8 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid,
          * When the guest selects the desired number, it will be updated
          * 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);
@@ -514,7 +526,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);
@@ -528,6 +540,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);
@@ -625,9 +638,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();
 }
 
@@ -656,14 +671,13 @@ void xenvif_disconnect(struct xenvif *vif)
         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;
                 }
@@ -705,16 +719,12 @@ void xenvif_free(struct xenvif *vif)
         /* 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);