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

Pull networking fixes from David Miller:
 "Just a bunch of small fixes and tidy ups:

   1) Finish the "busy_poll" renames, from Eliezer Tamir.

   2) Fix RCU stalls in IFB driver, from Ding Tianhong.

   3) Linearize buffers properly in tun/macvtap zerocopy code.

   4) Don't crash on rmmod in vxlan, from Pravin B Shelar.

   5) Spinlock used before init in alx driver, from Maarten Lankhorst.

   6) A sparse warning fix in bnx2x broke TSO checksums, fix from Dmitry
      Kravkov.

   7) Dummy and ifb driver load failure paths can oops, fixes from Tan
      Xiaojun and Ding Tianhong.

   8) Correct MTU calculations in IP tunnels, from Alexander Duyck.

   9) Account all TCP retransmits in SNMP stats properly, from Yuchung
      Cheng.

  10) atl1e and via-rhine do not handle DMA mapping failures properly,
      from Neil Horman.

  11) Various equal-cost multipath route fixes in ipv6 from Hannes
      Frederic Sowa"

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net: (36 commits)
  ipv6: only static routes qualify for equal cost multipathing
  via-rhine: fix dma mapping errors
  atl1e: fix dma mapping warnings
  tcp: account all retransmit failures
  usb/net/r815x: fix cast to restricted __le32
  usb/net/r8152: fix integer overflow in expression
  net: access page->private by using page_private
  net: strict_strtoul is obsolete, use kstrtoul instead
  drivers/net/ieee802154: don't use devm_pinctrl_get_select_default() in probe
  drivers/net/ethernet/cadence: don't use devm_pinctrl_get_select_default() in probe
  drivers/net/can/c_can: don't use devm_pinctrl_get_select_default() in probe
  net/usb: add relative mii functions for r815x
  net/tipc: use %*phC to dump small buffers in hex form
  qlcnic: Adding Maintainers.
  gre: Fix MTU sizing check for gretap tunnels
  pkt_sched: sch_qfq: remove forward declaration of qfq_update_agg_ts
  pkt_sched: sch_qfq: improve efficiency of make_eligible
  gso: Update tunnel segmentation to support Tx checksum offload
  inet: fix spacing in assignment
  ifb: fix oops when loading the ifb failed
  ...

21 files changed, 170 insertions, 146 deletions

diff --git a/net/9p/trans_common.c b/net/9p/trans_common.c
index de8df957867d..2ee3879161b1 100644
--- a/net/9p/trans_common.c
+++ b/net/9p/trans_common.c
@@ -24,11 +24,11 @@
  */
 void p9_release_pages(struct page **pages, int nr_pages)
 {
-        int i = 0;
-        while (pages[i] && nr_pages--) {
-                put_page(pages[i]);
-                i++;
-        }
+        int i;
+
+        for (i = 0; i < nr_pages; i++)
+                if (pages[i])
+                        put_page(pages[i]);
 }
 EXPORT_SYMBOL(p9_release_pages);
 
diff --git a/net/core/datagram.c b/net/core/datagram.c
index 6e9ab31e457e..8ab48cd89559 100644
--- a/net/core/datagram.c
+++ b/net/core/datagram.c
@@ -56,7 +56,7 @@
 #include <net/sock.h>
 #include <net/tcp_states.h>
 #include <trace/events/skb.h>
-#include <net/ll_poll.h>
+#include <net/busy_poll.h>
 
 /*
  *      Is a socket 'connection oriented' ?
diff --git a/net/core/dev.c b/net/core/dev.c
index 560dafd83adf..a3d8d44cb7f4 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -2481,10 +2481,10 @@ static int dev_gso_segment(struct sk_buff *skb, netdev_features_t features)
 }
 
 static netdev_features_t harmonize_features(struct sk_buff *skb,
-        __be16 protocol, netdev_features_t features)
+        netdev_features_t features)
 {
         if (skb->ip_summed != CHECKSUM_NONE &&
-            !can_checksum_protocol(features, protocol)) {
+            !can_checksum_protocol(features, skb_network_protocol(skb))) {
                 features &= ~NETIF_F_ALL_CSUM;
         } else if (illegal_highdma(skb->dev, skb)) {
                 features &= ~NETIF_F_SG;
@@ -2505,20 +2505,18 @@ netdev_features_t netif_skb_features(struct sk_buff *skb)
                 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
                 protocol = veh->h_vlan_encapsulated_proto;
         } else if (!vlan_tx_tag_present(skb)) {
-                return harmonize_features(skb, protocol, features);
+                return harmonize_features(skb, features);
         }
 
         features &= (skb->dev->vlan_features | NETIF_F_HW_VLAN_CTAG_TX |
                                                NETIF_F_HW_VLAN_STAG_TX);
 
-        if (protocol != htons(ETH_P_8021Q) && protocol != htons(ETH_P_8021AD)) {
-                return harmonize_features(skb, protocol, features);
-        } else {
+        if (protocol == htons(ETH_P_8021Q) || protocol == htons(ETH_P_8021AD))
                 features &= NETIF_F_SG | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST |
                                 NETIF_F_GEN_CSUM | NETIF_F_HW_VLAN_CTAG_TX |
                                 NETIF_F_HW_VLAN_STAG_TX;
-                return harmonize_features(skb, protocol, features);
-        }
+
+        return harmonize_features(skb, features);
 }
 EXPORT_SYMBOL(netif_skb_features);
 
diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index 724bb7cb173f..20e02d2605ec 100644
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -824,7 +824,7 @@ int skb_copy_ubufs(struct sk_buff *skb, gfp_t gfp_mask)
                 page = alloc_page(gfp_mask);
                 if (!page) {
                         while (head) {
-                                struct page *next = (struct page *)head->private;
+                                struct page *next = (struct page *)page_private(head);
                                 put_page(head);
                                 head = next;
                         }
@@ -834,7 +834,7 @@ int skb_copy_ubufs(struct sk_buff *skb, gfp_t gfp_mask)
                 memcpy(page_address(page),
                        vaddr + f->page_offset, skb_frag_size(f));
                 kunmap_atomic(vaddr);
-                page->private = (unsigned long)head;
+                set_page_private(page, (unsigned long)head);
                 head = page;
         }
 
@@ -848,7 +848,7 @@ int skb_copy_ubufs(struct sk_buff *skb, gfp_t gfp_mask)
         for (i = num_frags - 1; i >= 0; i--) {
                 __skb_fill_page_desc(skb, i, head, 0,
                                      skb_shinfo(skb)->frags[i].size);
-                head = (struct page *)head->private;
+                head = (struct page *)page_private(head);
         }
 
         skb_shinfo(skb)->tx_flags &= ~SKBTX_DEV_ZEROCOPY;
diff --git a/net/core/sock.c b/net/core/sock.c
index ab06b719f5b1..548d716c5f62 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -139,7 +139,7 @@
 #include <net/tcp.h>
 #endif
 
-#include <net/ll_poll.h>
+#include <net/busy_poll.h>
 
 static DEFINE_MUTEX(proto_list_mutex);
 static LIST_HEAD(proto_list);
@@ -901,7 +901,7 @@ set_rcvbuf:
                 break;
 
 #ifdef CONFIG_NET_LL_RX_POLL
-        case SO_LL:
+        case SO_BUSY_POLL:
                 /* allow unprivileged users to decrease the value */
                 if ((val > sk->sk_ll_usec) && !capable(CAP_NET_ADMIN))
                         ret = -EPERM;
@@ -1171,7 +1171,7 @@ int sock_getsockopt(struct socket *sock, int level, int optname,
                 break;
 
 #ifdef CONFIG_NET_LL_RX_POLL
-        case SO_LL:
+        case SO_BUSY_POLL:
                 v.val = sk->sk_ll_usec;
                 break;
 #endif
@@ -2294,7 +2294,7 @@ void sock_init_data(struct socket *sock, struct sock *sk)
 
 #ifdef CONFIG_NET_LL_RX_POLL
         sk->sk_napi_id          =       0;
-        sk->sk_ll_usec          =       sysctl_net_ll_read;
+        sk->sk_ll_usec          =       sysctl_net_busy_read;
 #endif
 
         /*
diff --git a/net/core/sysctl_net_core.c b/net/core/sysctl_net_core.c
index afc677eadd93..660968616637 100644
--- a/net/core/sysctl_net_core.c
+++ b/net/core/sysctl_net_core.c
@@ -19,7 +19,7 @@
 #include <net/ip.h>
 #include <net/sock.h>
 #include <net/net_ratelimit.h>
-#include <net/ll_poll.h>
+#include <net/busy_poll.h>
 
 static int one = 1;
 
@@ -300,15 +300,15 @@ static struct ctl_table net_core_table[] = {
 #endif /* CONFIG_NET_FLOW_LIMIT */
 #ifdef CONFIG_NET_LL_RX_POLL
         {
-                .procname       = "low_latency_poll",
-                .data           = &sysctl_net_ll_poll,
+                .procname       = "busy_poll",
+                .data           = &sysctl_net_busy_poll,
                 .maxlen         = sizeof(unsigned int),
                 .mode           = 0644,
                 .proc_handler   = proc_dointvec
         },
         {
-                .procname       = "low_latency_read",
-                .data           = &sysctl_net_ll_read,
+                .procname       = "busy_read",
+                .data           = &sysctl_net_busy_read,
                 .maxlen         = sizeof(unsigned int),
                 .mode           = 0644,
                 .proc_handler   = proc_dointvec
diff --git a/net/dns_resolver/dns_key.c b/net/dns_resolver/dns_key.c
index 0a69d0757795..f347a2ca7d7e 100644
--- a/net/dns_resolver/dns_key.c
+++ b/net/dns_resolver/dns_key.c
@@ -118,7 +118,7 @@ dns_resolver_instantiate(struct key *key, struct key_preparsed_payload *prep)
                                 if (opt_vlen <= 0)
                                         goto bad_option_value;
 
-                                ret = strict_strtoul(eq, 10, &derrno);
+                                ret = kstrtoul(eq, 10, &derrno);
                                 if (ret < 0)
                                         goto bad_option_value;
 
diff --git a/net/ipv4/gre_offload.c b/net/ipv4/gre_offload.c
index 775d5b532ece..55e6bfb3a289 100644
--- a/net/ipv4/gre_offload.c
+++ b/net/ipv4/gre_offload.c
@@ -100,6 +100,9 @@ static struct sk_buff *gre_gso_segment(struct sk_buff *skb,
                 }
                 __skb_push(skb, tnl_hlen - ghl);
 
+                skb_reset_inner_headers(skb);
+                skb->encapsulation = 1;
+
                 skb_reset_mac_header(skb);
                 skb_set_network_header(skb, mac_len);
                 skb->mac_len = mac_len;
diff --git a/net/ipv4/inet_hashtables.c b/net/ipv4/inet_hashtables.c
index 6af375afeeef..7bd8983dbfcf 100644
--- a/net/ipv4/inet_hashtables.c
+++ b/net/ipv4/inet_hashtables.c
@@ -467,7 +467,7 @@ void inet_unhash(struct sock *sk)
                 lock = inet_ehash_lockp(hashinfo, sk->sk_hash);
 
         spin_lock_bh(lock);
-        done =__sk_nulls_del_node_init_rcu(sk);
+        done = __sk_nulls_del_node_init_rcu(sk);
         if (done)
                 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
         spin_unlock_bh(lock);
diff --git a/net/ipv4/ip_tunnel.c b/net/ipv4/ip_tunnel.c
index 945734b2f209..ca1cb2d5f6e2 100644
--- a/net/ipv4/ip_tunnel.c
+++ b/net/ipv4/ip_tunnel.c
@@ -476,7 +476,7 @@ static int tnl_update_pmtu(struct net_device *dev, struct sk_buff *skb,
                             struct rtable *rt, __be16 df)
 {
         struct ip_tunnel *tunnel = netdev_priv(dev);
-        int pkt_size = skb->len - tunnel->hlen;
+        int pkt_size = skb->len - tunnel->hlen - dev->hard_header_len;
         int mtu;
 
         if (df)
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index 15cbfa94bd8e..5423223e93c2 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -279,7 +279,7 @@
 
 #include <asm/uaccess.h>
 #include <asm/ioctls.h>
-#include <net/ll_poll.h>
+#include <net/busy_poll.h>
 
 int sysctl_tcp_fin_timeout __read_mostly = TCP_FIN_TIMEOUT;
 
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index 35675e46aff8..b299da5ff499 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -75,7 +75,7 @@
 #include <net/netdma.h>
 #include <net/secure_seq.h>
 #include <net/tcp_memcontrol.h>
-#include <net/ll_poll.h>
+#include <net/busy_poll.h>
 
 #include <linux/inet.h>
 #include <linux/ipv6.h>
@@ -1994,7 +1994,7 @@ process:
         if (sk_filter(sk, skb))
                 goto discard_and_relse;
 
-        sk_mark_ll(sk, skb);
+        sk_mark_napi_id(sk, skb);
         skb->dev = NULL;
 
         bh_lock_sock_nested(sk);
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 3d609490f118..92fde8d1aa82 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -2407,6 +2407,8 @@ int tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb)
                  * see tcp_input.c tcp_sacktag_write_queue().
                  */
                 TCP_SKB_CB(skb)->ack_seq = tp->snd_nxt;
+        } else {
+                NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPRETRANSFAIL);
         }
         return err;
 }
@@ -2528,10 +2530,9 @@ begin_fwd:
                 if (sacked & (TCPCB_SACKED_ACKED|TCPCB_SACKED_RETRANS))
                         continue;
 
-                if (tcp_retransmit_skb(sk, skb)) {
-                        NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPRETRANSFAIL);
+                if (tcp_retransmit_skb(sk, skb))
                         return;
-                }
+
                 NET_INC_STATS_BH(sock_net(sk), mib_idx);
 
                 if (tcp_in_cwnd_reduction(sk))
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index 6b270e53c207..766e6bab9113 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -109,7 +109,7 @@
 #include <trace/events/udp.h>
 #include <linux/static_key.h>
 #include <trace/events/skb.h>
-#include <net/ll_poll.h>
+#include <net/busy_poll.h>
 #include "udp_impl.h"
 
 struct udp_table udp_table __read_mostly;
@@ -1713,7 +1713,7 @@ int __udp4_lib_rcv(struct sk_buff *skb, struct udp_table *udptable,
         if (sk != NULL) {
                 int ret;
 
-                sk_mark_ll(sk, skb);
+                sk_mark_napi_id(sk, skb);
                 ret = udp_queue_rcv_skb(sk, skb);
                 sock_put(sk);
 
@@ -2323,6 +2323,9 @@ struct sk_buff *skb_udp_tunnel_segment(struct sk_buff *skb,
                 struct udphdr *uh;
                 int udp_offset = outer_hlen - tnl_hlen;
 
+                skb_reset_inner_headers(skb);
+                skb->encapsulation = 1;
+
                 skb->mac_len = mac_len;
 
                 skb_push(skb, outer_hlen);
@@ -2345,7 +2348,6 @@ struct sk_buff *skb_udp_tunnel_segment(struct sk_buff *skb,
                                 uh->check = CSUM_MANGLED_0;
 
                 }
-                skb->ip_summed = CHECKSUM_NONE;
                 skb->protocol = protocol;
         } while ((skb = skb->next));
 out:
diff --git a/net/ipv6/ip6_fib.c b/net/ipv6/ip6_fib.c
index 192dd1a0e188..5fc9c7a68d8d 100644
--- a/net/ipv6/ip6_fib.c
+++ b/net/ipv6/ip6_fib.c
@@ -632,6 +632,12 @@ insert_above:
         return ln;
 }
 
+static inline bool rt6_qualify_for_ecmp(struct rt6_info *rt)
+{
+        return (rt->rt6i_flags & (RTF_GATEWAY|RTF_ADDRCONF|RTF_DYNAMIC)) ==
+               RTF_GATEWAY;
+}
+
 /*
  *      Insert routing information in a node.
  */
@@ -646,6 +652,7 @@ static int fib6_add_rt2node(struct fib6_node *fn, struct rt6_info *rt,
         int add = (!info->nlh ||
                    (info->nlh->nlmsg_flags & NLM_F_CREATE));
         int found = 0;
+        bool rt_can_ecmp = rt6_qualify_for_ecmp(rt);
 
         ins = &fn->leaf;
 
@@ -691,9 +698,8 @@ static int fib6_add_rt2node(struct fib6_node *fn, struct rt6_info *rt,
                          * To avoid long list, we only had siblings if the
                          * route have a gateway.
                          */
-                        if (rt->rt6i_flags & RTF_GATEWAY &&
-                            !(rt->rt6i_flags & RTF_EXPIRES) &&
-                            !(iter->rt6i_flags & RTF_EXPIRES))
+                        if (rt_can_ecmp &&
+                            rt6_qualify_for_ecmp(iter))
                                 rt->rt6i_nsiblings++;
                 }
 
@@ -715,7 +721,8 @@ static int fib6_add_rt2node(struct fib6_node *fn, struct rt6_info *rt,
                 /* Find the first route that have the same metric */
                 sibling = fn->leaf;
                 while (sibling) {
-                        if (sibling->rt6i_metric == rt->rt6i_metric) {
+                        if (sibling->rt6i_metric == rt->rt6i_metric &&
+                            rt6_qualify_for_ecmp(sibling)) {
                                 list_add_tail(&rt->rt6i_siblings,
                                               &sibling->rt6i_siblings);
                                 break;
diff --git a/net/ipv6/route.c b/net/ipv6/route.c
index bd5fd7054031..a8c891aa2464 100644
--- a/net/ipv6/route.c
+++ b/net/ipv6/route.c
@@ -65,6 +65,12 @@
 #include <linux/sysctl.h>
 #endif
 
+enum rt6_nud_state {
+        RT6_NUD_FAIL_HARD = -2,
+        RT6_NUD_FAIL_SOFT = -1,
+        RT6_NUD_SUCCEED = 1
+};
+
 static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
                                     const struct in6_addr *dest);
 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
@@ -531,28 +537,29 @@ static inline int rt6_check_dev(struct rt6_info *rt, int oif)
         return 0;
 }
 
-static inline bool rt6_check_neigh(struct rt6_info *rt)
+static inline enum rt6_nud_state rt6_check_neigh(struct rt6_info *rt)
 {
         struct neighbour *neigh;
-        bool ret = false;
+        enum rt6_nud_state ret = RT6_NUD_FAIL_HARD;
 
         if (rt->rt6i_flags & RTF_NONEXTHOP ||
             !(rt->rt6i_flags & RTF_GATEWAY))
-                return true;
+                return RT6_NUD_SUCCEED;
 
         rcu_read_lock_bh();
         neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
         if (neigh) {
                 read_lock(&neigh->lock);
                 if (neigh->nud_state & NUD_VALID)
-                        ret = true;
+                        ret = RT6_NUD_SUCCEED;
 #ifdef CONFIG_IPV6_ROUTER_PREF
                 else if (!(neigh->nud_state & NUD_FAILED))
-                        ret = true;
+                        ret = RT6_NUD_SUCCEED;
 #endif
                 read_unlock(&neigh->lock);
-        } else if (IS_ENABLED(CONFIG_IPV6_ROUTER_PREF)) {
-                ret = true;
+        } else {
+                ret = IS_ENABLED(CONFIG_IPV6_ROUTER_PREF) ?
+                      RT6_NUD_SUCCEED : RT6_NUD_FAIL_SOFT;
         }
         rcu_read_unlock_bh();
 
@@ -566,43 +573,52 @@ static int rt6_score_route(struct rt6_info *rt, int oif,
 
         m = rt6_check_dev(rt, oif);
         if (!m && (strict & RT6_LOOKUP_F_IFACE))
-                return -1;
+                return RT6_NUD_FAIL_HARD;
 #ifdef CONFIG_IPV6_ROUTER_PREF
         m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
 #endif
-        if (!rt6_check_neigh(rt) && (strict & RT6_LOOKUP_F_REACHABLE))
-                return -1;
+        if (strict & RT6_LOOKUP_F_REACHABLE) {
+                int n = rt6_check_neigh(rt);
+                if (n < 0)
+                        return n;
+        }
         return m;
 }
 
 static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
-                                   int *mpri, struct rt6_info *match)
+                                   int *mpri, struct rt6_info *match,
+                                   bool *do_rr)
 {
         int m;
+        bool match_do_rr = false;
 
         if (rt6_check_expired(rt))
                 goto out;
 
         m = rt6_score_route(rt, oif, strict);
-        if (m < 0)
+        if (m == RT6_NUD_FAIL_SOFT && !IS_ENABLED(CONFIG_IPV6_ROUTER_PREF)) {
+                match_do_rr = true;
+                m = 0; /* lowest valid score */
+        } else if (m < 0) {
                 goto out;
+        }
+
+        if (strict & RT6_LOOKUP_F_REACHABLE)
+                rt6_probe(rt);
 
         if (m > *mpri) {
-                if (strict & RT6_LOOKUP_F_REACHABLE)
-                        rt6_probe(match);
+                *do_rr = match_do_rr;
                 *mpri = m;
                 match = rt;
-        } else if (strict & RT6_LOOKUP_F_REACHABLE) {
-                rt6_probe(rt);
         }
-
 out:
         return match;
 }
 
 static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
                                      struct rt6_info *rr_head,
-                                     u32 metric, int oif, int strict)
+                                     u32 metric, int oif, int strict,
+                                     bool *do_rr)
 {
         struct rt6_info *rt, *match;
         int mpri = -1;
@@ -610,10 +626,10 @@ static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
         match = NULL;
         for (rt = rr_head; rt && rt->rt6i_metric == metric;
              rt = rt->dst.rt6_next)
-                match = find_match(rt, oif, strict, &mpri, match);
+                match = find_match(rt, oif, strict, &mpri, match, do_rr);
         for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
              rt = rt->dst.rt6_next)
-                match = find_match(rt, oif, strict, &mpri, match);
+                match = find_match(rt, oif, strict, &mpri, match, do_rr);
 
         return match;
 }
@@ -622,15 +638,16 @@ static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
 {
         struct rt6_info *match, *rt0;
         struct net *net;
+        bool do_rr = false;
 
         rt0 = fn->rr_ptr;
         if (!rt0)
                 fn->rr_ptr = rt0 = fn->leaf;
 
-        match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict);
+        match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict,
+                             &do_rr);
 
-        if (!match &&
-            (strict & RT6_LOOKUP_F_REACHABLE)) {
+        if (do_rr) {
                 struct rt6_info *next = rt0->dst.rt6_next;
 
                 /* no entries matched; do round-robin */
@@ -1080,10 +1097,13 @@ static void ip6_link_failure(struct sk_buff *skb)
 
         rt = (struct rt6_info *) skb_dst(skb);
         if (rt) {
-                if (rt->rt6i_flags & RTF_CACHE)
-                        rt6_update_expires(rt, 0);
-                else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
+                if (rt->rt6i_flags & RTF_CACHE) {
+                        dst_hold(&rt->dst);
+                        if (ip6_del_rt(rt))
+                                dst_free(&rt->dst);
+                } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT)) {
                         rt->rt6i_node->fn_sernum = -1;
+                }
         }
 }
 
diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index 5cffa5c3e6b8..6e1649d58533 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -63,7 +63,7 @@
 #include <net/inet_common.h>
 #include <net/secure_seq.h>
 #include <net/tcp_memcontrol.h>
-#include <net/ll_poll.h>
+#include <net/busy_poll.h>
 
 #include <asm/uaccess.h>
 
@@ -1499,7 +1499,7 @@ process:
         if (sk_filter(sk, skb))
                 goto discard_and_relse;
 
-        sk_mark_ll(sk, skb);
+        sk_mark_napi_id(sk, skb);
         skb->dev = NULL;
 
         bh_lock_sock_nested(sk);
diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c
index b6f31437a1f8..f4058150262b 100644
--- a/net/ipv6/udp.c
+++ b/net/ipv6/udp.c
@@ -46,7 +46,7 @@
 #include <net/ip6_checksum.h>
 #include <net/xfrm.h>
 #include <net/inet6_hashtables.h>
-#include <net/ll_poll.h>
+#include <net/busy_poll.h>
 
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
@@ -844,7 +844,7 @@ int __udp6_lib_rcv(struct sk_buff *skb, struct udp_table *udptable,
         if (sk != NULL) {
                 int ret;
 
-                sk_mark_ll(sk, skb);
+                sk_mark_napi_id(sk, skb);
                 ret = udpv6_queue_rcv_skb(sk, skb);
                 sock_put(sk);
 
diff --git a/net/sched/sch_qfq.c b/net/sched/sch_qfq.c
index 7c195d972bf0..a7ab323849b6 100644
--- a/net/sched/sch_qfq.c
+++ b/net/sched/sch_qfq.c
@@ -821,7 +821,14 @@ static void qfq_make_eligible(struct qfq_sched *q)
         unsigned long old_vslot = q->oldV >> q->min_slot_shift;
 
         if (vslot != old_vslot) {
-                unsigned long mask = (1ULL << fls(vslot ^ old_vslot)) - 1;
+                unsigned long mask;
+                int last_flip_pos = fls(vslot ^ old_vslot);
+
+                if (last_flip_pos > 31) /* higher than the number of groups */
+                        mask = ~0UL;    /* make all groups eligible */
+                else
+                        mask = (1UL << last_flip_pos) - 1;
+
                 qfq_move_groups(q, mask, IR, ER);
                 qfq_move_groups(q, mask, IB, EB);
         }
@@ -1003,9 +1010,61 @@ static inline void charge_actual_service(struct qfq_aggregate *agg)
         agg->F = agg->S + (u64)service_received * agg->inv_w;
 }
 
-static inline void qfq_update_agg_ts(struct qfq_sched *q,
-                                     struct qfq_aggregate *agg,
-                                     enum update_reason reason);
+/* Assign a reasonable start time for a new aggregate in group i.
+ * Admissible values for \hat(F) are multiples of \sigma_i
+ * no greater than V+\sigma_i . Larger values mean that
+ * we had a wraparound so we consider the timestamp to be stale.
+ *
+ * If F is not stale and F >= V then we set S = F.
+ * Otherwise we should assign S = V, but this may violate
+ * the ordering in EB (see [2]). So, if we have groups in ER,
+ * set S to the F_j of the first group j which would be blocking us.
+ * We are guaranteed not to move S backward because
+ * otherwise our group i would still be blocked.
+ */
+static void qfq_update_start(struct qfq_sched *q, struct qfq_aggregate *agg)
+{
+        unsigned long mask;
+        u64 limit, roundedF;
+        int slot_shift = agg->grp->slot_shift;
+
+        roundedF = qfq_round_down(agg->F, slot_shift);
+        limit = qfq_round_down(q->V, slot_shift) + (1ULL << slot_shift);
+
+        if (!qfq_gt(agg->F, q->V) || qfq_gt(roundedF, limit)) {
+                /* timestamp was stale */
+                mask = mask_from(q->bitmaps[ER], agg->grp->index);
+                if (mask) {
+                        struct qfq_group *next = qfq_ffs(q, mask);
+                        if (qfq_gt(roundedF, next->F)) {
+                                if (qfq_gt(limit, next->F))
+                                        agg->S = next->F;
+                                else /* preserve timestamp correctness */
+                                        agg->S = limit;
+                                return;
+                        }
+                }
+                agg->S = q->V;
+        } else  /* timestamp is not stale */
+                agg->S = agg->F;
+}
+
+/* Update the timestamps of agg before scheduling/rescheduling it for
+ * service.  In particular, assign to agg->F its maximum possible
+ * value, i.e., the virtual finish time with which the aggregate
+ * should be labeled if it used all its budget once in service.
+ */
+static inline void
+qfq_update_agg_ts(struct qfq_sched *q,
+                    struct qfq_aggregate *agg, enum update_reason reason)
+{
+        if (reason != requeue)
+                qfq_update_start(q, agg);
+        else /* just charge agg for the service received */
+                agg->S = agg->F;
+
+        agg->F = agg->S + (u64)agg->budgetmax * agg->inv_w;
+}
 
 static void qfq_schedule_agg(struct qfq_sched *q, struct qfq_aggregate *agg);
 
@@ -1128,66 +1187,6 @@ static struct qfq_aggregate *qfq_choose_next_agg(struct qfq_sched *q)
         return agg;
 }
 
-/*
- * Assign a reasonable start time for a new aggregate in group i.
- * Admissible values for \hat(F) are multiples of \sigma_i
- * no greater than V+\sigma_i . Larger values mean that
- * we had a wraparound so we consider the timestamp to be stale.
- *
- * If F is not stale and F >= V then we set S = F.
- * Otherwise we should assign S = V, but this may violate
- * the ordering in EB (see [2]). So, if we have groups in ER,
- * set S to the F_j of the first group j which would be blocking us.
- * We are guaranteed not to move S backward because
- * otherwise our group i would still be blocked.
- */
-static void qfq_update_start(struct qfq_sched *q, struct qfq_aggregate *agg)
-{
-        unsigned long mask;
-        u64 limit, roundedF;
-        int slot_shift = agg->grp->slot_shift;
-
-        roundedF = qfq_round_down(agg->F, slot_shift);
-        limit = qfq_round_down(q->V, slot_shift) + (1ULL << slot_shift);
-
-        if (!qfq_gt(agg->F, q->V) || qfq_gt(roundedF, limit)) {
-                /* timestamp was stale */
-                mask = mask_from(q->bitmaps[ER], agg->grp->index);
-                if (mask) {
-                        struct qfq_group *next = qfq_ffs(q, mask);
-                        if (qfq_gt(roundedF, next->F)) {
-                                if (qfq_gt(limit, next->F))
-                                        agg->S = next->F;
-                                else /* preserve timestamp correctness */
-                                        agg->S = limit;
-                                return;
-                        }
-                }
-                agg->S = q->V;
-        } else  /* timestamp is not stale */
-                agg->S = agg->F;
-}
-
-/*
- * Update the timestamps of agg before scheduling/rescheduling it for
- * service.  In particular, assign to agg->F its maximum possible
- * value, i.e., the virtual finish time with which the aggregate
- * should be labeled if it used all its budget once in service.
- */
-static inline void
-qfq_update_agg_ts(struct qfq_sched *q,
-                    struct qfq_aggregate *agg, enum update_reason reason)
-{
-        if (reason != requeue)
-                qfq_update_start(q, agg);
-        else /* just charge agg for the service received */
-                agg->S = agg->F;
-
-        agg->F = agg->S + (u64)agg->budgetmax * agg->inv_w;
-}
-
-static void qfq_schedule_agg(struct qfq_sched *, struct qfq_aggregate *);
-
 static int qfq_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 {
         struct qfq_sched *q = qdisc_priv(sch);
diff --git a/net/socket.c b/net/socket.c
index 45afa648364a..829b460acb87 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -104,11 +104,11 @@
 #include <linux/route.h>
 #include <linux/sockios.h>
 #include <linux/atalk.h>
-#include <net/ll_poll.h>
+#include <net/busy_poll.h>
 
 #ifdef CONFIG_NET_LL_RX_POLL
-unsigned int sysctl_net_ll_read __read_mostly;
-unsigned int sysctl_net_ll_poll __read_mostly;
+unsigned int sysctl_net_busy_read __read_mostly;
+unsigned int sysctl_net_busy_poll __read_mostly;
 #endif
 
 static int sock_no_open(struct inode *irrelevant, struct file *dontcare);
diff --git a/net/tipc/ib_media.c b/net/tipc/ib_media.c
index ad2e1ec4117e..9934a32bfa87 100644
--- a/net/tipc/ib_media.c
+++ b/net/tipc/ib_media.c
@@ -292,13 +292,7 @@ static int ib_addr2str(struct tipc_media_addr *a, char *str_buf, int str_size)
         if (str_size < 60)      /* 60 = 19 * strlen("xx:") + strlen("xx\0") */
                 return 1;
 
-        sprintf(str_buf, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:"
-                         "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
-                a->value[0], a->value[1], a->value[2], a->value[3],
-                a->value[4], a->value[5], a->value[6], a->value[7],
-                a->value[8], a->value[9], a->value[10], a->value[11],
-                a->value[12], a->value[13], a->value[14], a->value[15],
-                a->value[16], a->value[17], a->value[18], a->value[19]);
+        sprintf(str_buf, "%20phC", a->value);
 
         return 0;
 }