26 files changed, 167 insertions, 268 deletions

diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c
index 6d6dd345bc4d..211c0cc6c3d3 100644
--- a/net/ipv4/af_inet.c
+++ b/net/ipv4/af_inet.c
@@ -1476,22 +1476,20 @@ int inet_ctl_sock_create(struct sock **sk, unsigned short family,
 }
 EXPORT_SYMBOL_GPL(inet_ctl_sock_create);
 
-unsigned long snmp_fold_field(void __percpu *mib[], int offt)
+unsigned long snmp_fold_field(void __percpu *mib, int offt)
 {
         unsigned long res = 0;
-        int i, j;
+        int i;
 
-        for_each_possible_cpu(i) {
-                for (j = 0; j < SNMP_ARRAY_SZ; j++)
-                        res += *(((unsigned long *) per_cpu_ptr(mib[j], i)) + offt);
-        }
+        for_each_possible_cpu(i)
+                res += *(((unsigned long *) per_cpu_ptr(mib, i)) + offt);
         return res;
 }
 EXPORT_SYMBOL_GPL(snmp_fold_field);
 
 #if BITS_PER_LONG==32
 
-u64 snmp_fold_field64(void __percpu *mib[], int offt, size_t syncp_offset)
+u64 snmp_fold_field64(void __percpu *mib, int offt, size_t syncp_offset)
 {
         u64 res = 0;
         int cpu;
@@ -1502,7 +1500,7 @@ u64 snmp_fold_field64(void __percpu *mib[], int offt, size_t syncp_offset)
                 u64 v;
                 unsigned int start;
 
-                bhptr = per_cpu_ptr(mib[0], cpu);
+                bhptr = per_cpu_ptr(mib, cpu);
                 syncp = (struct u64_stats_sync *)(bhptr + syncp_offset);
                 do {
                         start = u64_stats_fetch_begin_irq(syncp);
@@ -1516,25 +1514,6 @@ u64 snmp_fold_field64(void __percpu *mib[], int offt, size_t syncp_offset)
 EXPORT_SYMBOL_GPL(snmp_fold_field64);
 #endif
 
-int snmp_mib_init(void __percpu *ptr[2], size_t mibsize, size_t align)
-{
-        BUG_ON(ptr == NULL);
-        ptr[0] = __alloc_percpu(mibsize, align);
-        if (!ptr[0])
-                return -ENOMEM;
-
-#if SNMP_ARRAY_SZ == 2
-        ptr[1] = __alloc_percpu(mibsize, align);
-        if (!ptr[1]) {
-                free_percpu(ptr[0]);
-                ptr[0] = NULL;
-                return -ENOMEM;
-        }
-#endif
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snmp_mib_init);
-
 #ifdef CONFIG_IP_MULTICAST
 static const struct net_protocol igmp_protocol = {
         .handler =      igmp_rcv,
@@ -1570,40 +1549,30 @@ static __net_init int ipv4_mib_init_net(struct net *net)
 {
         int i;
 
-        if (snmp_mib_init((void __percpu **)net->mib.tcp_statistics,
-                          sizeof(struct tcp_mib),
-                          __alignof__(struct tcp_mib)) < 0)
+        net->mib.tcp_statistics = alloc_percpu(struct tcp_mib);
+        if (!net->mib.tcp_statistics)
                 goto err_tcp_mib;
-        if (snmp_mib_init((void __percpu **)net->mib.ip_statistics,
-                          sizeof(struct ipstats_mib),
-                          __alignof__(struct ipstats_mib)) < 0)
+        net->mib.ip_statistics = alloc_percpu(struct ipstats_mib);
+        if (!net->mib.ip_statistics)
                 goto err_ip_mib;
 
         for_each_possible_cpu(i) {
                 struct ipstats_mib *af_inet_stats;
-                af_inet_stats = per_cpu_ptr(net->mib.ip_statistics[0], i);
+                af_inet_stats = per_cpu_ptr(net->mib.ip_statistics, i);
                 u64_stats_init(&af_inet_stats->syncp);
-#if SNMP_ARRAY_SZ == 2
-                af_inet_stats = per_cpu_ptr(net->mib.ip_statistics[1], i);
-                u64_stats_init(&af_inet_stats->syncp);
-#endif
         }
 
-        if (snmp_mib_init((void __percpu **)net->mib.net_statistics,
-                          sizeof(struct linux_mib),
-                          __alignof__(struct linux_mib)) < 0)
+        net->mib.net_statistics = alloc_percpu(struct linux_mib);
+        if (!net->mib.net_statistics)
                 goto err_net_mib;
-        if (snmp_mib_init((void __percpu **)net->mib.udp_statistics,
-                          sizeof(struct udp_mib),
-                          __alignof__(struct udp_mib)) < 0)
+        net->mib.udp_statistics = alloc_percpu(struct udp_mib);
+        if (!net->mib.udp_statistics)
                 goto err_udp_mib;
-        if (snmp_mib_init((void __percpu **)net->mib.udplite_statistics,
-                          sizeof(struct udp_mib),
-                          __alignof__(struct udp_mib)) < 0)
+        net->mib.udplite_statistics = alloc_percpu(struct udp_mib);
+        if (!net->mib.udplite_statistics)
                 goto err_udplite_mib;
-        if (snmp_mib_init((void __percpu **)net->mib.icmp_statistics,
-                          sizeof(struct icmp_mib),
-                          __alignof__(struct icmp_mib)) < 0)
+        net->mib.icmp_statistics = alloc_percpu(struct icmp_mib);
+        if (!net->mib.icmp_statistics)
                 goto err_icmp_mib;
         net->mib.icmpmsg_statistics = kzalloc(sizeof(struct icmpmsg_mib),
                                               GFP_KERNEL);
@@ -1614,17 +1583,17 @@ static __net_init int ipv4_mib_init_net(struct net *net)
         return 0;
 
 err_icmpmsg_mib:
-        snmp_mib_free((void __percpu **)net->mib.icmp_statistics);
+        free_percpu(net->mib.icmp_statistics);
 err_icmp_mib:
-        snmp_mib_free((void __percpu **)net->mib.udplite_statistics);
+        free_percpu(net->mib.udplite_statistics);
 err_udplite_mib:
-        snmp_mib_free((void __percpu **)net->mib.udp_statistics);
+        free_percpu(net->mib.udp_statistics);
 err_udp_mib:
-        snmp_mib_free((void __percpu **)net->mib.net_statistics);
+        free_percpu(net->mib.net_statistics);
 err_net_mib:
-        snmp_mib_free((void __percpu **)net->mib.ip_statistics);
+        free_percpu(net->mib.ip_statistics);
 err_ip_mib:
-        snmp_mib_free((void __percpu **)net->mib.tcp_statistics);
+        free_percpu(net->mib.tcp_statistics);
 err_tcp_mib:
         return -ENOMEM;
 }
@@ -1632,12 +1601,12 @@ err_tcp_mib:
 static __net_exit void ipv4_mib_exit_net(struct net *net)
 {
         kfree(net->mib.icmpmsg_statistics);
-        snmp_mib_free((void __percpu **)net->mib.icmp_statistics);
-        snmp_mib_free((void __percpu **)net->mib.udplite_statistics);
-        snmp_mib_free((void __percpu **)net->mib.udp_statistics);
-        snmp_mib_free((void __percpu **)net->mib.net_statistics);
-        snmp_mib_free((void __percpu **)net->mib.ip_statistics);
-        snmp_mib_free((void __percpu **)net->mib.tcp_statistics);
+        free_percpu(net->mib.icmp_statistics);
+        free_percpu(net->mib.udplite_statistics);
+        free_percpu(net->mib.udp_statistics);
+        free_percpu(net->mib.net_statistics);
+        free_percpu(net->mib.ip_statistics);
+        free_percpu(net->mib.tcp_statistics);
 }
 
 static __net_initdata struct pernet_operations ipv4_mib_ops = {
diff --git a/net/ipv4/devinet.c b/net/ipv4/devinet.c
index bdbf68bb2e2d..78692e46b64f 100644
--- a/net/ipv4/devinet.c
+++ b/net/ipv4/devinet.c
@@ -106,7 +106,6 @@ static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = {
 #define IN4_ADDR_HSIZE          (1U << IN4_ADDR_HSIZE_SHIFT)
 
 static struct hlist_head inet_addr_lst[IN4_ADDR_HSIZE];
-static DEFINE_SPINLOCK(inet_addr_hash_lock);
 
 static u32 inet_addr_hash(struct net *net, __be32 addr)
 {
@@ -119,16 +118,14 @@ static void inet_hash_insert(struct net *net, struct in_ifaddr *ifa)
 {
         u32 hash = inet_addr_hash(net, ifa->ifa_local);
 
-        spin_lock(&inet_addr_hash_lock);
+        ASSERT_RTNL();
         hlist_add_head_rcu(&ifa->hash, &inet_addr_lst[hash]);
-        spin_unlock(&inet_addr_hash_lock);
 }
 
 static void inet_hash_remove(struct in_ifaddr *ifa)
 {
-        spin_lock(&inet_addr_hash_lock);
+        ASSERT_RTNL();
         hlist_del_init_rcu(&ifa->hash);
-        spin_unlock(&inet_addr_hash_lock);
 }
 
 /**
diff --git a/net/ipv4/gre_demux.c b/net/ipv4/gre_demux.c
index 250be7421ab3..fbfd829f4049 100644
--- a/net/ipv4/gre_demux.c
+++ b/net/ipv4/gre_demux.c
@@ -93,28 +93,6 @@ void gre_build_header(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
 }
 EXPORT_SYMBOL_GPL(gre_build_header);
 
-static __sum16 check_checksum(struct sk_buff *skb)
-{
-        __sum16 csum = 0;
-
-        switch (skb->ip_summed) {
-        case CHECKSUM_COMPLETE:
-                csum = csum_fold(skb->csum);
-
-                if (!csum)
-                        break;
-                /* Fall through. */
-
-        case CHECKSUM_NONE:
-                skb->csum = 0;
-                csum = __skb_checksum_complete(skb);
-                skb->ip_summed = CHECKSUM_COMPLETE;
-                break;
-        }
-
-        return csum;
-}
-
 static int parse_gre_header(struct sk_buff *skb, struct tnl_ptk_info *tpi,
                             bool *csum_err)
 {
@@ -141,7 +119,7 @@ static int parse_gre_header(struct sk_buff *skb, struct tnl_ptk_info *tpi,
 
         options = (__be32 *)(greh + 1);
         if (greh->flags & GRE_CSUM) {
-                if (check_checksum(skb)) {
+                if (skb_checksum_simple_validate(skb)) {
                         *csum_err = true;
                         return -EINVAL;
                 }
diff --git a/net/ipv4/icmp.c b/net/ipv4/icmp.c
index 0134663fdbce..fe52666dc43c 100644
--- a/net/ipv4/icmp.c
+++ b/net/ipv4/icmp.c
@@ -908,16 +908,8 @@ int icmp_rcv(struct sk_buff *skb)
 
         ICMP_INC_STATS_BH(net, ICMP_MIB_INMSGS);
 
-        switch (skb->ip_summed) {
-        case CHECKSUM_COMPLETE:
-                if (!csum_fold(skb->csum))
-                        break;
-                /* fall through */
-        case CHECKSUM_NONE:
-                skb->csum = 0;
-                if (__skb_checksum_complete(skb))
-                        goto csum_error;
-        }
+        if (skb_checksum_simple_validate(skb))
+                goto csum_error;
 
         if (!pskb_pull(skb, sizeof(*icmph)))
                 goto error;
diff --git a/net/ipv4/igmp.c b/net/ipv4/igmp.c
index 97e4d1655d26..17d34e3c2ac3 100644
--- a/net/ipv4/igmp.c
+++ b/net/ipv4/igmp.c
@@ -988,16 +988,8 @@ int igmp_rcv(struct sk_buff *skb)
         if (!pskb_may_pull(skb, sizeof(struct igmphdr)))
                 goto drop;
 
-        switch (skb->ip_summed) {
-        case CHECKSUM_COMPLETE:
-                if (!csum_fold(skb->csum))
-                        break;
-                /* fall through */
-        case CHECKSUM_NONE:
-                skb->csum = 0;
-                if (__skb_checksum_complete(skb))
-                        goto drop;
-        }
+        if (skb_checksum_simple_validate(skb))
+                goto drop;
 
         ih = igmp_hdr(skb);
         switch (ih->type) {
diff --git a/net/ipv4/inetpeer.c b/net/ipv4/inetpeer.c
index 48f424465112..c98cf141f4ed 100644
--- a/net/ipv4/inetpeer.c
+++ b/net/ipv4/inetpeer.c
@@ -120,7 +120,7 @@ int inet_peer_maxttl __read_mostly = 10 * 60 * HZ;	/* usual time to live: 10 min
 static void inetpeer_gc_worker(struct work_struct *work)
 {
         struct inet_peer *p, *n, *c;
-        LIST_HEAD(list);
+        struct list_head list;
 
         spin_lock_bh(&gc_lock);
         list_replace_init(&gc_list, &list);
diff --git a/net/ipv4/ip_gre.c b/net/ipv4/ip_gre.c
index 94213c891565..c5a557a06a31 100644
--- a/net/ipv4/ip_gre.c
+++ b/net/ipv4/ip_gre.c
@@ -410,7 +410,7 @@ static int ipgre_open(struct net_device *dev)
                 struct flowi4 fl4;
                 struct rtable *rt;
 
-                rt = ip_route_output_gre(dev_net(dev), &fl4,
+                rt = ip_route_output_gre(t->net, &fl4,
                                          t->parms.iph.daddr,
                                          t->parms.iph.saddr,
                                          t->parms.o_key,
@@ -434,7 +434,7 @@ static int ipgre_close(struct net_device *dev)
 
         if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
                 struct in_device *in_dev;
-                in_dev = inetdev_by_index(dev_net(dev), t->mlink);
+                in_dev = inetdev_by_index(t->net, t->mlink);
                 if (in_dev)
                         ip_mc_dec_group(in_dev, t->parms.iph.daddr);
         }
@@ -478,7 +478,7 @@ static void __gre_tunnel_init(struct net_device *dev)
         dev->needed_headroom    = LL_MAX_HEADER + sizeof(struct iphdr) + 4;
         dev->mtu                = ETH_DATA_LEN - sizeof(struct iphdr) - 4;
 
-        dev->features           |= NETIF_F_NETNS_LOCAL | GRE_FEATURES;
+        dev->features           |= GRE_FEATURES;
         dev->hw_features        |= GRE_FEATURES;
 
         if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
diff --git a/net/ipv4/ip_options.c b/net/ipv4/ip_options.c
index f4ab72e19af9..5e7aecea05cd 100644
--- a/net/ipv4/ip_options.c
+++ b/net/ipv4/ip_options.c
@@ -364,7 +364,7 @@ int ip_options_compile(struct net *net,
                         }
                         if (optptr[2] <= optlen) {
                                 unsigned char *timeptr = NULL;
-                                if (optptr[2]+3 > optptr[1]) {
+                                if (optptr[2]+3 > optlen) {
                                         pp_ptr = optptr + 2;
                                         goto error;
                                 }
@@ -376,7 +376,7 @@ int ip_options_compile(struct net *net,
                                         optptr[2] += 4;
                                         break;
                                 case IPOPT_TS_TSANDADDR:
-                                        if (optptr[2]+7 > optptr[1]) {
+                                        if (optptr[2]+7 > optlen) {
                                                 pp_ptr = optptr + 2;
                                                 goto error;
                                         }
@@ -390,7 +390,7 @@ int ip_options_compile(struct net *net,
                                         optptr[2] += 8;
                                         break;
                                 case IPOPT_TS_PRESPEC:
-                                        if (optptr[2]+7 > optptr[1]) {
+                                        if (optptr[2]+7 > optlen) {
                                                 pp_ptr = optptr + 2;
                                                 goto error;
                                         }
diff --git a/net/ipv4/proc.c b/net/ipv4/proc.c
index ad737fad6d8b..ae0af9386f7c 100644
--- a/net/ipv4/proc.c
+++ b/net/ipv4/proc.c
@@ -345,15 +345,15 @@ static void icmp_put(struct seq_file *seq)
         for (i = 0; icmpmibmap[i].name != NULL; i++)
                 seq_printf(seq, " Out%s", icmpmibmap[i].name);
         seq_printf(seq, "\nIcmp: %lu %lu %lu",
-                snmp_fold_field((void __percpu **) net->mib.icmp_statistics, ICMP_MIB_INMSGS),
-                snmp_fold_field((void __percpu **) net->mib.icmp_statistics, ICMP_MIB_INERRORS),
-                snmp_fold_field((void __percpu **) net->mib.icmp_statistics, ICMP_MIB_CSUMERRORS));
+                snmp_fold_field(net->mib.icmp_statistics, ICMP_MIB_INMSGS),
+                snmp_fold_field(net->mib.icmp_statistics, ICMP_MIB_INERRORS),
+                snmp_fold_field(net->mib.icmp_statistics, ICMP_MIB_CSUMERRORS));
         for (i = 0; icmpmibmap[i].name != NULL; i++)
                 seq_printf(seq, " %lu",
                            atomic_long_read(ptr + icmpmibmap[i].index));
         seq_printf(seq, " %lu %lu",
-                snmp_fold_field((void __percpu **) net->mib.icmp_statistics, ICMP_MIB_OUTMSGS),
-                snmp_fold_field((void __percpu **) net->mib.icmp_statistics, ICMP_MIB_OUTERRORS));
+                snmp_fold_field(net->mib.icmp_statistics, ICMP_MIB_OUTMSGS),
+                snmp_fold_field(net->mib.icmp_statistics, ICMP_MIB_OUTERRORS));
         for (i = 0; icmpmibmap[i].name != NULL; i++)
                 seq_printf(seq, " %lu",
                            atomic_long_read(ptr + (icmpmibmap[i].index | 0x100)));
@@ -379,7 +379,7 @@ static int snmp_seq_show(struct seq_file *seq, void *v)
         BUILD_BUG_ON(offsetof(struct ipstats_mib, mibs) != 0);
         for (i = 0; snmp4_ipstats_list[i].name != NULL; i++)
                 seq_printf(seq, " %llu",
-                           snmp_fold_field64((void __percpu **)net->mib.ip_statistics,
+                           snmp_fold_field64(net->mib.ip_statistics,
                                              snmp4_ipstats_list[i].entry,
                                              offsetof(struct ipstats_mib, syncp)));
 
@@ -395,11 +395,11 @@ static int snmp_seq_show(struct seq_file *seq, void *v)
                 /* MaxConn field is signed, RFC 2012 */
                 if (snmp4_tcp_list[i].entry == TCP_MIB_MAXCONN)
                         seq_printf(seq, " %ld",
-                                   snmp_fold_field((void __percpu **)net->mib.tcp_statistics,
+                                   snmp_fold_field(net->mib.tcp_statistics,
                                                    snmp4_tcp_list[i].entry));
                 else
                         seq_printf(seq, " %lu",
-                                   snmp_fold_field((void __percpu **)net->mib.tcp_statistics,
+                                   snmp_fold_field(net->mib.tcp_statistics,
                                                    snmp4_tcp_list[i].entry));
         }
 
@@ -410,7 +410,7 @@ static int snmp_seq_show(struct seq_file *seq, void *v)
         seq_puts(seq, "\nUdp:");
         for (i = 0; snmp4_udp_list[i].name != NULL; i++)
                 seq_printf(seq, " %lu",
-                           snmp_fold_field((void __percpu **)net->mib.udp_statistics,
+                           snmp_fold_field(net->mib.udp_statistics,
                                            snmp4_udp_list[i].entry));
 
         /* the UDP and UDP-Lite MIBs are the same */
@@ -421,7 +421,7 @@ static int snmp_seq_show(struct seq_file *seq, void *v)
         seq_puts(seq, "\nUdpLite:");
         for (i = 0; snmp4_udp_list[i].name != NULL; i++)
                 seq_printf(seq, " %lu",
-                           snmp_fold_field((void __percpu **)net->mib.udplite_statistics,
+                           snmp_fold_field(net->mib.udplite_statistics,
                                            snmp4_udp_list[i].entry));
 
         seq_putc(seq, '\n');
@@ -458,7 +458,7 @@ static int netstat_seq_show(struct seq_file *seq, void *v)
         seq_puts(seq, "\nTcpExt:");
         for (i = 0; snmp4_net_list[i].name != NULL; i++)
                 seq_printf(seq, " %lu",
-                           snmp_fold_field((void __percpu **)net->mib.net_statistics,
+                           snmp_fold_field(net->mib.net_statistics,
                                            snmp4_net_list[i].entry));
 
         seq_puts(seq, "\nIpExt:");
@@ -468,7 +468,7 @@ static int netstat_seq_show(struct seq_file *seq, void *v)
         seq_puts(seq, "\nIpExt:");
         for (i = 0; snmp4_ipextstats_list[i].name != NULL; i++)
                 seq_printf(seq, " %llu",
-                           snmp_fold_field64((void __percpu **)net->mib.ip_statistics,
+                           snmp_fold_field64(net->mib.ip_statistics,
                                              snmp4_ipextstats_list[i].entry,
                                              offsetof(struct ipstats_mib, syncp)));
 
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index 4bd6d52eeffb..eb1dde37e678 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -2916,6 +2916,14 @@ static int do_tcp_getsockopt(struct sock *sk, int level,
         case TCP_USER_TIMEOUT:
                 val = jiffies_to_msecs(icsk->icsk_user_timeout);
                 break;
+
+        case TCP_FASTOPEN:
+                if (icsk->icsk_accept_queue.fastopenq != NULL)
+                        val = icsk->icsk_accept_queue.fastopenq->max_qlen;
+                else
+                        val = 0;
+                break;
+
         case TCP_TIMESTAMP:
                 val = tcp_time_stamp + tp->tsoffset;
                 break;
diff --git a/net/ipv4/tcp_bic.c b/net/ipv4/tcp_bic.c
index 821846fb0a7e..d5de69bc04f5 100644
--- a/net/ipv4/tcp_bic.c
+++ b/net/ipv4/tcp_bic.c
@@ -140,13 +140,12 @@ static inline void bictcp_update(struct bictcp *ca, u32 cwnd)
                 ca->cnt = 1;
 }
 
-static void bictcp_cong_avoid(struct sock *sk, u32 ack, u32 acked,
-                              u32 in_flight)
+static void bictcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         struct bictcp *ca = inet_csk_ca(sk);
 
-        if (!tcp_is_cwnd_limited(sk, in_flight))
+        if (!tcp_is_cwnd_limited(sk))
                 return;
 
         if (tp->snd_cwnd <= tp->snd_ssthresh)
diff --git a/net/ipv4/tcp_cong.c b/net/ipv4/tcp_cong.c
index 2b9464c93b88..7b09d8b49fa5 100644
--- a/net/ipv4/tcp_cong.c
+++ b/net/ipv4/tcp_cong.c
@@ -276,26 +276,6 @@ int tcp_set_congestion_control(struct sock *sk, const char *name)
         return err;
 }
 
-/* RFC2861 Check whether we are limited by application or congestion window
- * This is the inverse of cwnd check in tcp_tso_should_defer
- */
-bool tcp_is_cwnd_limited(const struct sock *sk, u32 in_flight)
-{
-        const struct tcp_sock *tp = tcp_sk(sk);
-        u32 left;
-
-        if (in_flight >= tp->snd_cwnd)
-                return true;
-
-        left = tp->snd_cwnd - in_flight;
-        if (sk_can_gso(sk) &&
-            left * sysctl_tcp_tso_win_divisor < tp->snd_cwnd &&
-            left < tp->xmit_size_goal_segs)
-                return true;
-        return left <= tcp_max_tso_deferred_mss(tp);
-}
-EXPORT_SYMBOL_GPL(tcp_is_cwnd_limited);
-
 /* Slow start is used when congestion window is no greater than the slow start
  * threshold. We base on RFC2581 and also handle stretch ACKs properly.
  * We do not implement RFC3465 Appropriate Byte Counting (ABC) per se but
@@ -337,11 +317,11 @@ EXPORT_SYMBOL_GPL(tcp_cong_avoid_ai);
 /* This is Jacobson's slow start and congestion avoidance.
  * SIGCOMM '88, p. 328.
  */
-void tcp_reno_cong_avoid(struct sock *sk, u32 ack, u32 acked, u32 in_flight)
+void tcp_reno_cong_avoid(struct sock *sk, u32 ack, u32 acked)
 {
         struct tcp_sock *tp = tcp_sk(sk);
 
-        if (!tcp_is_cwnd_limited(sk, in_flight))
+        if (!tcp_is_cwnd_limited(sk))
                 return;
 
         /* In "safe" area, increase. */
diff --git a/net/ipv4/tcp_cubic.c b/net/ipv4/tcp_cubic.c
index b4f1b29b08bd..a9bd8a4828a9 100644
--- a/net/ipv4/tcp_cubic.c
+++ b/net/ipv4/tcp_cubic.c
@@ -304,13 +304,12 @@ static inline void bictcp_update(struct bictcp *ca, u32 cwnd)
                 ca->cnt = 1;
 }
 
-static void bictcp_cong_avoid(struct sock *sk, u32 ack, u32 acked,
-                              u32 in_flight)
+static void bictcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         struct bictcp *ca = inet_csk_ca(sk);
 
-        if (!tcp_is_cwnd_limited(sk, in_flight))
+        if (!tcp_is_cwnd_limited(sk))
                 return;
 
         if (tp->snd_cwnd <= tp->snd_ssthresh) {
diff --git a/net/ipv4/tcp_highspeed.c b/net/ipv4/tcp_highspeed.c
index 8b9e7bad77c0..1c4908280d92 100644
--- a/net/ipv4/tcp_highspeed.c
+++ b/net/ipv4/tcp_highspeed.c
@@ -109,12 +109,12 @@ static void hstcp_init(struct sock *sk)
         tp->snd_cwnd_clamp = min_t(u32, tp->snd_cwnd_clamp, 0xffffffff/128);
 }
 
-static void hstcp_cong_avoid(struct sock *sk, u32 ack, u32 acked, u32 in_flight)
+static void hstcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         struct hstcp *ca = inet_csk_ca(sk);
 
-        if (!tcp_is_cwnd_limited(sk, in_flight))
+        if (!tcp_is_cwnd_limited(sk))
                 return;
 
         if (tp->snd_cwnd <= tp->snd_ssthresh)
diff --git a/net/ipv4/tcp_htcp.c b/net/ipv4/tcp_htcp.c
index 4a194acfd923..031361311a8b 100644
--- a/net/ipv4/tcp_htcp.c
+++ b/net/ipv4/tcp_htcp.c
@@ -227,12 +227,12 @@ static u32 htcp_recalc_ssthresh(struct sock *sk)
         return max((tp->snd_cwnd * ca->beta) >> 7, 2U);
 }
 
-static void htcp_cong_avoid(struct sock *sk, u32 ack, u32 acked, u32 in_flight)
+static void htcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         struct htcp *ca = inet_csk_ca(sk);
 
-        if (!tcp_is_cwnd_limited(sk, in_flight))
+        if (!tcp_is_cwnd_limited(sk))
                 return;
 
         if (tp->snd_cwnd <= tp->snd_ssthresh)
diff --git a/net/ipv4/tcp_hybla.c b/net/ipv4/tcp_hybla.c
index a15a799bf768..d8f8f05a4951 100644
--- a/net/ipv4/tcp_hybla.c
+++ b/net/ipv4/tcp_hybla.c
@@ -87,8 +87,7 @@ static inline u32 hybla_fraction(u32 odds)
  *     o Give cwnd a new value based on the model proposed
  *     o remember increments <1
  */
-static void hybla_cong_avoid(struct sock *sk, u32 ack, u32 acked,
-                             u32 in_flight)
+static void hybla_cong_avoid(struct sock *sk, u32 ack, u32 acked)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         struct hybla *ca = inet_csk_ca(sk);
@@ -101,11 +100,11 @@ static void hybla_cong_avoid(struct sock *sk, u32 ack, u32 acked,
                 ca->minrtt_us = tp->srtt_us;
         }
 
-        if (!tcp_is_cwnd_limited(sk, in_flight))
+        if (!tcp_is_cwnd_limited(sk))
                 return;
 
         if (!ca->hybla_en) {
-                tcp_reno_cong_avoid(sk, ack, acked, in_flight);
+                tcp_reno_cong_avoid(sk, ack, acked);
                 return;
         }
 
diff --git a/net/ipv4/tcp_illinois.c b/net/ipv4/tcp_illinois.c
index 863d105e3015..5999b3972e64 100644
--- a/net/ipv4/tcp_illinois.c
+++ b/net/ipv4/tcp_illinois.c
@@ -255,8 +255,7 @@ static void tcp_illinois_state(struct sock *sk, u8 new_state)
 /*
  * Increase window in response to successful acknowledgment.
  */
-static void tcp_illinois_cong_avoid(struct sock *sk, u32 ack, u32 acked,
-                                    u32 in_flight)
+static void tcp_illinois_cong_avoid(struct sock *sk, u32 ack, u32 acked)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         struct illinois *ca = inet_csk_ca(sk);
@@ -265,7 +264,7 @@ static void tcp_illinois_cong_avoid(struct sock *sk, u32 ack, u32 acked,
                 update_params(sk);
 
         /* RFC2861 only increase cwnd if fully utilized */
-        if (!tcp_is_cwnd_limited(sk, in_flight))
+        if (!tcp_is_cwnd_limited(sk))
                 return;
 
         /* In slow start */
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index d6b46eb2f94c..350b2072f0ab 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -2938,10 +2938,11 @@ static void tcp_synack_rtt_meas(struct sock *sk, const u32 synack_stamp)
                 tcp_ack_update_rtt(sk, FLAG_SYN_ACKED, seq_rtt_us, -1L);
 }
 
-static void tcp_cong_avoid(struct sock *sk, u32 ack, u32 acked, u32 in_flight)
+static void tcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
 {
         const struct inet_connection_sock *icsk = inet_csk(sk);
-        icsk->icsk_ca_ops->cong_avoid(sk, ack, acked, in_flight);
+
+        icsk->icsk_ca_ops->cong_avoid(sk, ack, acked);
         tcp_sk(sk)->snd_cwnd_stamp = tcp_time_stamp;
 }
 
@@ -3364,7 +3365,6 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
         u32 ack_seq = TCP_SKB_CB(skb)->seq;
         u32 ack = TCP_SKB_CB(skb)->ack_seq;
         bool is_dupack = false;
-        u32 prior_in_flight;
         u32 prior_fackets;
         int prior_packets = tp->packets_out;
         const int prior_unsacked = tp->packets_out - tp->sacked_out;
@@ -3397,7 +3397,6 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
                 flag |= FLAG_SND_UNA_ADVANCED;
 
         prior_fackets = tp->fackets_out;
-        prior_in_flight = tcp_packets_in_flight(tp);
 
         /* ts_recent update must be made after we are sure that the packet
          * is in window.
@@ -3452,7 +3451,7 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
 
         /* Advance cwnd if state allows */
         if (tcp_may_raise_cwnd(sk, flag))
-                tcp_cong_avoid(sk, ack, acked, prior_in_flight);
+                tcp_cong_avoid(sk, ack, acked);
 
         if (tcp_ack_is_dubious(sk, flag)) {
                 is_dupack = !(flag & (FLAG_SND_UNA_ADVANCED | FLAG_NOT_DUP));
@@ -4703,28 +4702,6 @@ static int tcp_prune_queue(struct sock *sk)
         return -1;
 }
 
-/* RFC2861, slow part. Adjust cwnd, after it was not full during one rto.
- * As additional protections, we do not touch cwnd in retransmission phases,
- * and if application hit its sndbuf limit recently.
- */
-void tcp_cwnd_application_limited(struct sock *sk)
-{
-        struct tcp_sock *tp = tcp_sk(sk);
-
-        if (inet_csk(sk)->icsk_ca_state == TCP_CA_Open &&
-            sk->sk_socket && !test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
-                /* Limited by application or receiver window. */
-                u32 init_win = tcp_init_cwnd(tp, __sk_dst_get(sk));
-                u32 win_used = max(tp->snd_cwnd_used, init_win);
-                if (win_used < tp->snd_cwnd) {
-                        tp->snd_ssthresh = tcp_current_ssthresh(sk);
-                        tp->snd_cwnd = (tp->snd_cwnd + win_used) >> 1;
-                }
-                tp->snd_cwnd_used = 0;
-        }
-        tp->snd_cwnd_stamp = tcp_time_stamp;
-}
-
 static bool tcp_should_expand_sndbuf(const struct sock *sk)
 {
         const struct tcp_sock *tp = tcp_sk(sk);
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index 438f3b95143d..ad166dcc278f 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -1744,28 +1744,6 @@ static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
         return sk;
 }
 
-static __sum16 tcp_v4_checksum_init(struct sk_buff *skb)
-{
-        const struct iphdr *iph = ip_hdr(skb);
-
-        if (skb->ip_summed == CHECKSUM_COMPLETE) {
-                if (!tcp_v4_check(skb->len, iph->saddr,
-                                  iph->daddr, skb->csum)) {
-                        skb->ip_summed = CHECKSUM_UNNECESSARY;
-                        return 0;
-                }
-        }
-
-        skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
-                                       skb->len, IPPROTO_TCP, 0);
-
-        if (skb->len <= 76) {
-                return __skb_checksum_complete(skb);
-        }
-        return 0;
-}
-
-
 /* The socket must have it's spinlock held when we get
  * here.
  *
@@ -1960,7 +1938,8 @@ int tcp_v4_rcv(struct sk_buff *skb)
          * Packet length and doff are validated by header prediction,
          * provided case of th->doff==0 is eliminated.
          * So, we defer the checks. */
-        if (!skb_csum_unnecessary(skb) && tcp_v4_checksum_init(skb))
+
+        if (skb_checksum_init(skb, IPPROTO_TCP, inet_compute_pseudo))
                 goto csum_error;
 
         th = tcp_hdr(skb);
diff --git a/net/ipv4/tcp_lp.c b/net/ipv4/tcp_lp.c
index c9aecae31327..1e70fa8fa793 100644
--- a/net/ipv4/tcp_lp.c
+++ b/net/ipv4/tcp_lp.c
@@ -115,13 +115,12 @@ static void tcp_lp_init(struct sock *sk)
  * Will only call newReno CA when away from inference.
  * From TCP-LP's paper, this will be handled in additive increasement.
  */
-static void tcp_lp_cong_avoid(struct sock *sk, u32 ack, u32 acked,
-                              u32 in_flight)
+static void tcp_lp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
 {
         struct lp *lp = inet_csk_ca(sk);
 
         if (!(lp->flag & LP_WITHIN_INF))
-                tcp_reno_cong_avoid(sk, ack, acked, in_flight);
+                tcp_reno_cong_avoid(sk, ack, acked);
 }
 
 /**
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 12d6016bdd9a..694711a140d4 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -878,15 +878,8 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,
         BUG_ON(!skb || !tcp_skb_pcount(skb));
 
         if (clone_it) {
-                const struct sk_buff *fclone = skb + 1;
-
                 skb_mstamp_get(&skb->skb_mstamp);
 
-                if (unlikely(skb->fclone == SKB_FCLONE_ORIG &&
-                             fclone->fclone == SKB_FCLONE_CLONE))
-                        NET_INC_STATS(sock_net(sk),
-                                      LINUX_MIB_TCPSPURIOUS_RTX_HOSTQUEUES);
-
                 if (unlikely(skb_cloned(skb)))
                         skb = pskb_copy(skb, gfp_mask);
                 else
@@ -1387,12 +1380,35 @@ unsigned int tcp_current_mss(struct sock *sk)
         return mss_now;
 }
 
-/* Congestion window validation. (RFC2861) */
-static void tcp_cwnd_validate(struct sock *sk)
+/* RFC2861, slow part. Adjust cwnd, after it was not full during one rto.
+ * As additional protections, we do not touch cwnd in retransmission phases,
+ * and if application hit its sndbuf limit recently.
+ */
+static void tcp_cwnd_application_limited(struct sock *sk)
 {
         struct tcp_sock *tp = tcp_sk(sk);
 
-        if (tp->packets_out >= tp->snd_cwnd) {
+        if (inet_csk(sk)->icsk_ca_state == TCP_CA_Open &&
+            sk->sk_socket && !test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
+                /* Limited by application or receiver window. */
+                u32 init_win = tcp_init_cwnd(tp, __sk_dst_get(sk));
+                u32 win_used = max(tp->snd_cwnd_used, init_win);
+                if (win_used < tp->snd_cwnd) {
+                        tp->snd_ssthresh = tcp_current_ssthresh(sk);
+                        tp->snd_cwnd = (tp->snd_cwnd + win_used) >> 1;
+                }
+                tp->snd_cwnd_used = 0;
+        }
+        tp->snd_cwnd_stamp = tcp_time_stamp;
+}
+
+static void tcp_cwnd_validate(struct sock *sk, u32 unsent_segs)
+{
+        struct tcp_sock *tp = tcp_sk(sk);
+
+        tp->lsnd_pending = tp->packets_out + unsent_segs;
+
+        if (tcp_is_cwnd_limited(sk)) {
                 /* Network is feed fully. */
                 tp->snd_cwnd_used = 0;
                 tp->snd_cwnd_stamp = tcp_time_stamp;
@@ -1865,7 +1881,7 @@ static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle,
 {
         struct tcp_sock *tp = tcp_sk(sk);
         struct sk_buff *skb;
-        unsigned int tso_segs, sent_pkts;
+        unsigned int tso_segs, sent_pkts, unsent_segs = 0;
         int cwnd_quota;
         int result;
 
@@ -1909,7 +1925,7 @@ static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle,
                                 break;
                 } else {
                         if (!push_one && tcp_tso_should_defer(sk, skb))
-                                break;
+                                goto compute_unsent_segs;
                 }
 
                 /* TCP Small Queues :
@@ -1934,8 +1950,14 @@ static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle,
                          * there is no smp_mb__after_set_bit() yet
                          */
                         smp_mb__after_clear_bit();
-                        if (atomic_read(&sk->sk_wmem_alloc) > limit)
+                        if (atomic_read(&sk->sk_wmem_alloc) > limit) {
+                                u32 unsent_bytes;
+
+compute_unsent_segs:
+                                unsent_bytes = tp->write_seq - tp->snd_nxt;
+                                unsent_segs = DIV_ROUND_UP(unsent_bytes, mss_now);
                                 break;
+                        }
                 }
 
                 limit = mss_now;
@@ -1975,7 +1997,7 @@ repair:
                 /* Send one loss probe per tail loss episode. */
                 if (push_one != 2)
                         tcp_schedule_loss_probe(sk);
-                tcp_cwnd_validate(sk);
+                tcp_cwnd_validate(sk, unsent_segs);
                 return false;
         }
         return (push_one == 2) || (!tp->packets_out && tcp_send_head(sk));
@@ -2039,6 +2061,25 @@ bool tcp_schedule_loss_probe(struct sock *sk)
         return true;
 }
 
+/* Thanks to skb fast clones, we can detect if a prior transmit of
+ * a packet is still in a qdisc or driver queue.
+ * In this case, there is very little point doing a retransmit !
+ * Note: This is called from BH context only.
+ */
+static bool skb_still_in_host_queue(const struct sock *sk,
+                                    const struct sk_buff *skb)
+{
+        const struct sk_buff *fclone = skb + 1;
+
+        if (unlikely(skb->fclone == SKB_FCLONE_ORIG &&
+                     fclone->fclone == SKB_FCLONE_CLONE)) {
+                NET_INC_STATS_BH(sock_net(sk),
+                                 LINUX_MIB_TCPSPURIOUS_RTX_HOSTQUEUES);
+                return true;
+        }
+        return false;
+}
+
 /* When probe timeout (PTO) fires, send a new segment if one exists, else
  * retransmit the last segment.
  */
@@ -2064,6 +2105,9 @@ void tcp_send_loss_probe(struct sock *sk)
         if (WARN_ON(!skb))
                 goto rearm_timer;
 
+        if (skb_still_in_host_queue(sk, skb))
+                goto rearm_timer;
+
         pcount = tcp_skb_pcount(skb);
         if (WARN_ON(!pcount))
                 goto rearm_timer;
@@ -2385,6 +2429,9 @@ int __tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb)
             min(sk->sk_wmem_queued + (sk->sk_wmem_queued >> 2), sk->sk_sndbuf))
                 return -EAGAIN;
 
+        if (skb_still_in_host_queue(sk, skb))
+                return -EBUSY;
+
         if (before(TCP_SKB_CB(skb)->seq, tp->snd_una)) {
                 if (before(TCP_SKB_CB(skb)->end_seq, tp->snd_una))
                         BUG();
@@ -2478,7 +2525,7 @@ 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 {
+        } else if (err != -EBUSY) {
                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPRETRANSFAIL);
         }
         return err;
diff --git a/net/ipv4/tcp_scalable.c b/net/ipv4/tcp_scalable.c
index 0ac50836da4d..8250949b8853 100644
--- a/net/ipv4/tcp_scalable.c
+++ b/net/ipv4/tcp_scalable.c
@@ -15,12 +15,11 @@
 #define TCP_SCALABLE_AI_CNT     50U
 #define TCP_SCALABLE_MD_SCALE   3
 
-static void tcp_scalable_cong_avoid(struct sock *sk, u32 ack, u32 acked,
-                                    u32 in_flight)
+static void tcp_scalable_cong_avoid(struct sock *sk, u32 ack, u32 acked)
 {
         struct tcp_sock *tp = tcp_sk(sk);
 
-        if (!tcp_is_cwnd_limited(sk, in_flight))
+        if (!tcp_is_cwnd_limited(sk))
                 return;
 
         if (tp->snd_cwnd <= tp->snd_ssthresh)
diff --git a/net/ipv4/tcp_vegas.c b/net/ipv4/tcp_vegas.c
index 48539fff6357..9a5e05f27f4f 100644
--- a/net/ipv4/tcp_vegas.c
+++ b/net/ipv4/tcp_vegas.c
@@ -163,14 +163,13 @@ static inline u32 tcp_vegas_ssthresh(struct tcp_sock *tp)
         return  min(tp->snd_ssthresh, tp->snd_cwnd-1);
 }
 
-static void tcp_vegas_cong_avoid(struct sock *sk, u32 ack, u32 acked,
-                                 u32 in_flight)
+static void tcp_vegas_cong_avoid(struct sock *sk, u32 ack, u32 acked)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         struct vegas *vegas = inet_csk_ca(sk);
 
         if (!vegas->doing_vegas_now) {
-                tcp_reno_cong_avoid(sk, ack, acked, in_flight);
+                tcp_reno_cong_avoid(sk, ack, acked);
                 return;
         }
 
@@ -195,7 +194,7 @@ static void tcp_vegas_cong_avoid(struct sock *sk, u32 ack, u32 acked,
                         /* We don't have enough RTT samples to do the Vegas
                          * calculation, so we'll behave like Reno.
                          */
-                        tcp_reno_cong_avoid(sk, ack, acked, in_flight);
+                        tcp_reno_cong_avoid(sk, ack, acked);
                 } else {
                         u32 rtt, diff;
                         u64 target_cwnd;
diff --git a/net/ipv4/tcp_veno.c b/net/ipv4/tcp_veno.c
index 1b8e28fcd7e1..27b9825753d1 100644
--- a/net/ipv4/tcp_veno.c
+++ b/net/ipv4/tcp_veno.c
@@ -114,19 +114,18 @@ static void tcp_veno_cwnd_event(struct sock *sk, enum tcp_ca_event event)
                 tcp_veno_init(sk);
 }
 
-static void tcp_veno_cong_avoid(struct sock *sk, u32 ack, u32 acked,
-                                u32 in_flight)
+static void tcp_veno_cong_avoid(struct sock *sk, u32 ack, u32 acked)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         struct veno *veno = inet_csk_ca(sk);
 
         if (!veno->doing_veno_now) {
-                tcp_reno_cong_avoid(sk, ack, acked, in_flight);
+                tcp_reno_cong_avoid(sk, ack, acked);
                 return;
         }
 
         /* limited by applications */
-        if (!tcp_is_cwnd_limited(sk, in_flight))
+        if (!tcp_is_cwnd_limited(sk))
                 return;
 
         /* We do the Veno calculations only if we got enough rtt samples */
@@ -134,7 +133,7 @@ static void tcp_veno_cong_avoid(struct sock *sk, u32 ack, u32 acked,
                 /* We don't have enough rtt samples to do the Veno
                  * calculation, so we'll behave like Reno.
                  */
-                tcp_reno_cong_avoid(sk, ack, acked, in_flight);
+                tcp_reno_cong_avoid(sk, ack, acked);
         } else {
                 u64 target_cwnd;
                 u32 rtt;
diff --git a/net/ipv4/tcp_yeah.c b/net/ipv4/tcp_yeah.c
index 5ede0e727945..599b79b8eac0 100644
--- a/net/ipv4/tcp_yeah.c
+++ b/net/ipv4/tcp_yeah.c
@@ -69,13 +69,12 @@ static void tcp_yeah_pkts_acked(struct sock *sk, u32 pkts_acked, s32 rtt_us)
         tcp_vegas_pkts_acked(sk, pkts_acked, rtt_us);
 }
 
-static void tcp_yeah_cong_avoid(struct sock *sk, u32 ack, u32 acked,
-                                u32 in_flight)
+static void tcp_yeah_cong_avoid(struct sock *sk, u32 ack, u32 acked)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         struct yeah *yeah = inet_csk_ca(sk);
 
-        if (!tcp_is_cwnd_limited(sk, in_flight))
+        if (!tcp_is_cwnd_limited(sk))
                 return;
 
         if (tp->snd_cwnd <= tp->snd_ssthresh)
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index 4468e1adc094..54ea0a3a48f1 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -1495,6 +1495,10 @@ int udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
                 if (skb->len > sizeof(struct udphdr) && encap_rcv != NULL) {
                         int ret;
 
+                        /* Verify checksum before giving to encap */
+                        if (udp_lib_checksum_complete(skb))
+                                goto csum_error;
+
                         ret = encap_rcv(sk, skb);
                         if (ret <= 0) {
                                 UDP_INC_STATS_BH(sock_net(sk),
@@ -1672,7 +1676,6 @@ static int __udp4_lib_mcast_deliver(struct net *net, struct sk_buff *skb,
 static inline int udp4_csum_init(struct sk_buff *skb, struct udphdr *uh,
                                  int proto)
 {
-        const struct iphdr *iph;
         int err;
 
         UDP_SKB_CB(skb)->partial_cov = 0;
@@ -1684,22 +1687,8 @@ static inline int udp4_csum_init(struct sk_buff *skb, struct udphdr *uh,
                         return err;
         }
 
-        iph = ip_hdr(skb);
-        if (uh->check == 0) {
-                skb->ip_summed = CHECKSUM_UNNECESSARY;
-        } else if (skb->ip_summed == CHECKSUM_COMPLETE) {
-                if (!csum_tcpudp_magic(iph->saddr, iph->daddr, skb->len,
-                                      proto, skb->csum))
-                        skb->ip_summed = CHECKSUM_UNNECESSARY;
-        }
-        if (!skb_csum_unnecessary(skb))
-                skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
-                                               skb->len, proto, 0);
-        /* Probably, we should checksum udp header (it should be in cache
-         * in any case) and data in tiny packets (< rx copybreak).
-         */
-
-        return 0;
+        return skb_checksum_init_zero_check(skb, proto, uh->check,
+                                            inet_compute_pseudo);
 }
 
 /*