Patched in Tegra support.

1 files changed, 35 insertions, 26 deletions

diff --git a/net/sched/sch_generic.c b/net/sched/sch_generic.c
index 5d81a447851..69fca279880 100644
--- a/net/sched/sch_generic.c
+++ b/net/sched/sch_generic.c
@@ -53,19 +53,20 @@ static inline int dev_requeue_skb(struct sk_buff *skb, struct Qdisc *q)
 static inline struct sk_buff *dequeue_skb(struct Qdisc *q)
 {
         struct sk_buff *skb = q->gso_skb;
-        const struct netdev_queue *txq = q->dev_queue;
 
         if (unlikely(skb)) {
+                struct net_device *dev = qdisc_dev(q);
+                struct netdev_queue *txq;
+
                 /* check the reason of requeuing without tx lock first */
-                txq = netdev_get_tx_queue(txq->dev, skb_get_queue_mapping(skb));
-                if (!netif_xmit_frozen_or_stopped(txq)) {
+                txq = netdev_get_tx_queue(dev, skb_get_queue_mapping(skb));
+                if (!netif_tx_queue_frozen_or_stopped(txq)) {
                         q->gso_skb = NULL;
                         q->q.qlen--;
                 } else
                         skb = NULL;
         } else {
-                if (!(q->flags & TCQ_F_ONETXQUEUE) || !netif_xmit_frozen_or_stopped(txq))
-                        skb = q->dequeue(q);
+                skb = q->dequeue(q);
         }
 
         return skb;
@@ -85,8 +86,9 @@ static inline int handle_dev_cpu_collision(struct sk_buff *skb,
                  * deadloop is detected. Return OK to try the next skb.
                  */
                 kfree_skb(skb);
-                net_warn_ratelimited("Dead loop on netdevice %s, fix it urgently!\n",
-                                     dev_queue->dev->name);
+                if (net_ratelimit())
+                        pr_warning("Dead loop on netdevice %s, fix it urgently!\n",
+                                   dev_queue->dev->name);
                 ret = qdisc_qlen(q);
         } else {
                 /*
@@ -119,7 +121,7 @@ int sch_direct_xmit(struct sk_buff *skb, struct Qdisc *q,
         spin_unlock(root_lock);
 
         HARD_TX_LOCK(dev, txq, smp_processor_id());
-        if (!netif_xmit_frozen_or_stopped(txq))
+        if (!netif_tx_queue_frozen_or_stopped(txq))
                 ret = dev_hard_start_xmit(skb, dev, txq);
 
         HARD_TX_UNLOCK(dev, txq);
@@ -134,14 +136,14 @@ int sch_direct_xmit(struct sk_buff *skb, struct Qdisc *q,
                 ret = handle_dev_cpu_collision(skb, txq, q);
         } else {
                 /* Driver returned NETDEV_TX_BUSY - requeue skb */
-                if (unlikely(ret != NETDEV_TX_BUSY))
-                        net_warn_ratelimited("BUG %s code %d qlen %d\n",
-                                             dev->name, ret, q->q.qlen);
+                if (unlikely (ret != NETDEV_TX_BUSY && net_ratelimit()))
+                        pr_warning("BUG %s code %d qlen %d\n",
+                                   dev->name, ret, q->q.qlen);
 
                 ret = dev_requeue_skb(skb, q);
         }
 
-        if (ret && netif_xmit_frozen_or_stopped(txq))
+        if (ret && netif_tx_queue_frozen_or_stopped(txq))
                 ret = 0;
 
         return ret;
@@ -240,11 +242,10 @@ static void dev_watchdog(unsigned long arg)
                                  * old device drivers set dev->trans_start
                                  */
                                 trans_start = txq->trans_start ? : dev->trans_start;
-                                if (netif_xmit_stopped(txq) &&
+                                if (netif_tx_queue_stopped(txq) &&
                                     time_after(jiffies, (trans_start +
                                                          dev->watchdog_timeo))) {
                                         some_queue_timedout = 1;
-                                        txq->trans_timeout++;
                                         break;
                                 }
                         }
@@ -323,6 +324,24 @@ void netif_carrier_off(struct net_device *dev)
 }
 EXPORT_SYMBOL(netif_carrier_off);
 
+/**
+ *      netif_notify_peers - notify network peers about existence of @dev
+ *      @dev: network device
+ *
+ * Generate traffic such that interested network peers are aware of
+ * @dev, such as by generating a gratuitous ARP. This may be used when
+ * a device wants to inform the rest of the network about some sort of
+ * reconfiguration such as a failover event or virtual machine
+ * migration.
+ */
+void netif_notify_peers(struct net_device *dev)
+{
+        rtnl_lock();
+        call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, dev);
+        rtnl_unlock();
+}
+EXPORT_SYMBOL(netif_notify_peers);
+
 /* "NOOP" scheduler: the best scheduler, recommended for all interfaces
    under all circumstances. It is difficult to invent anything faster or
    cheaper.
@@ -492,8 +511,7 @@ static int pfifo_fast_dump(struct Qdisc *qdisc, struct sk_buff *skb)
         struct tc_prio_qopt opt = { .bands = PFIFO_FAST_BANDS };
 
         memcpy(&opt.priomap, prio2band, TC_PRIO_MAX + 1);
-        if (nla_put(skb, TCA_OPTIONS, sizeof(opt), &opt))
-                goto nla_put_failure;
+        NLA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
         return skb->len;
 
 nla_put_failure:
@@ -526,8 +544,6 @@ struct Qdisc_ops pfifo_fast_ops __read_mostly = {
 };
 EXPORT_SYMBOL(pfifo_fast_ops);
 
-static struct lock_class_key qdisc_tx_busylock;
-
 struct Qdisc *qdisc_alloc(struct netdev_queue *dev_queue,
                           struct Qdisc_ops *ops)
 {
@@ -535,7 +551,6 @@ struct Qdisc *qdisc_alloc(struct netdev_queue *dev_queue,
         struct Qdisc *sch;
         unsigned int size = QDISC_ALIGN(sizeof(*sch)) + ops->priv_size;
         int err = -ENOBUFS;
-        struct net_device *dev = dev_queue->dev;
 
         p = kzalloc_node(size, GFP_KERNEL,
                          netdev_queue_numa_node_read(dev_queue));
@@ -555,16 +570,12 @@ struct Qdisc *qdisc_alloc(struct netdev_queue *dev_queue,
         }
         INIT_LIST_HEAD(&sch->list);
         skb_queue_head_init(&sch->q);
-
         spin_lock_init(&sch->busylock);
-        lockdep_set_class(&sch->busylock,
-                          dev->qdisc_tx_busylock ?: &qdisc_tx_busylock);
-
         sch->ops = ops;
         sch->enqueue = ops->enqueue;
         sch->dequeue = ops->dequeue;
         sch->dev_queue = dev_queue;
-        dev_hold(dev);
+        dev_hold(qdisc_dev(sch));
         atomic_set(&sch->refcnt, 1);
 
         return sch;
@@ -685,8 +696,6 @@ static void attach_one_default_qdisc(struct net_device *dev,
                         netdev_info(dev, "activation failed\n");
                         return;
                 }
-                if (!netif_is_multiqueue(dev))
-                        qdisc->flags |= TCQ_F_ONETXQUEUE;
         }
         dev_queue->qdisc_sleeping = qdisc;
 }