[NET]: Detect hardware rx checksum faults correctly

Here is the patch that introduces the generic skb_checksum_complete
which also checks for hardware RX checksum faults.  If that happens,
it'll call netdev_rx_csum_fault which currently prints out a stack
trace with the device name.  In future it can turn off RX checksum.

I've converted every spot under net/ that does RX checksum checks to
use skb_checksum_complete or __skb_checksum_complete with the
exceptions of:

* Those places where checksums are done bit by bit.  These will call
netdev_rx_csum_fault directly.

* The following have not been completely checked/converted:

ipmr
ip_vs
netfilter
dccp

This patch is based on patches and suggestions from Stephen Hemminger
and David S. Miller.

Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
Signed-off-by: David S. Miller <davem@davemloft.net>

19 files changed, 173 insertions, 134 deletions

diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index c6efce4a04a4..936f8b76114e 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -927,6 +927,13 @@ extern int		netdev_max_backlog;
 extern int              weight_p;
 extern int              netdev_set_master(struct net_device *dev, struct net_device *master);
 extern int skb_checksum_help(struct sk_buff *skb, int inward);
+#ifdef CONFIG_BUG
+extern void netdev_rx_csum_fault(struct net_device *dev);
+#else
+static inline void netdev_rx_csum_fault(struct net_device *dev)
+{
+}
+#endif
 /* rx skb timestamps */
 extern void             net_enable_timestamp(void);
 extern void             net_disable_timestamp(void);
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 83010231db99..0a8ea8b35816 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -1236,8 +1236,7 @@ extern unsigned int    datagram_poll(struct file *file, struct socket *sock,
 extern int             skb_copy_datagram_iovec(const struct sk_buff *from,
                                                int offset, struct iovec *to,
                                                int size);
-extern int             skb_copy_and_csum_datagram_iovec(const
-                                                        struct sk_buff *skb,
+extern int             skb_copy_and_csum_datagram_iovec(struct sk_buff *skb,
                                                         int hlen,
                                                         struct iovec *iov);
 extern void            skb_free_datagram(struct sock *sk, struct sk_buff *skb);
@@ -1305,6 +1304,30 @@ static inline void skb_set_timestamp(struct sk_buff *skb, const struct timeval *
 
 extern void __net_timestamp(struct sk_buff *skb);
 
+extern unsigned int __skb_checksum_complete(struct sk_buff *skb);
+
+/**
+ *      skb_checksum_complete - Calculate checksum of an entire packet
+ *      @skb: packet to process
+ *
+ *      This function calculates the checksum over the entire packet plus
+ *      the value of skb->csum.  The latter can be used to supply the
+ *      checksum of a pseudo header as used by TCP/UDP.  It returns the
+ *      checksum.
+ *
+ *      For protocols that contain complete checksums such as ICMP/TCP/UDP,
+ *      this function can be used to verify that checksum on received
+ *      packets.  In that case the function should return zero if the
+ *      checksum is correct.  In particular, this function will return zero
+ *      if skb->ip_summed is CHECKSUM_UNNECESSARY which indicates that the
+ *      hardware has already verified the correctness of the checksum.
+ */
+static inline unsigned int skb_checksum_complete(struct sk_buff *skb)
+{
+        return skb->ip_summed != CHECKSUM_UNNECESSARY &&
+                __skb_checksum_complete(skb);
+}
+
 #ifdef CONFIG_NETFILTER
 static inline void nf_conntrack_put(struct nf_conntrack *nfct)
 {
diff --git a/include/net/tcp.h b/include/net/tcp.h
index c24339c4e310..96cc3b434e40 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -27,6 +27,7 @@
 #include <linux/slab.h>
 #include <linux/cache.h>
 #include <linux/percpu.h>
+#include <linux/skbuff.h>
 
 #include <net/inet_connection_sock.h>
 #include <net/inet_timewait_sock.h>
@@ -852,7 +853,7 @@ static __inline__ u16 tcp_v4_check(struct tcphdr *th, int len,
 
 static __inline__ int __tcp_checksum_complete(struct sk_buff *skb)
 {
-        return (unsigned short)csum_fold(skb_checksum(skb, 0, skb->len, skb->csum));
+        return __skb_checksum_complete(skb);
 }
 
 static __inline__ int tcp_checksum_complete(struct sk_buff *skb)
diff --git a/net/core/datagram.c b/net/core/datagram.c
index d219435d086c..1bcfef51ac58 100644
--- a/net/core/datagram.c
+++ b/net/core/datagram.c
@@ -350,6 +350,20 @@ fault:
         return -EFAULT;
 }
 
+unsigned int __skb_checksum_complete(struct sk_buff *skb)
+{
+        unsigned int sum;
+
+        sum = (u16)csum_fold(skb_checksum(skb, 0, skb->len, skb->csum));
+        if (likely(!sum)) {
+                if (unlikely(skb->ip_summed == CHECKSUM_HW))
+                        netdev_rx_csum_fault(skb->dev);
+                skb->ip_summed = CHECKSUM_UNNECESSARY;
+        }
+        return sum;
+}
+EXPORT_SYMBOL(__skb_checksum_complete);
+
 /**
  *      skb_copy_and_csum_datagram_iovec - Copy and checkum skb to user iovec.
  *      @skb: skbuff
@@ -363,7 +377,7 @@ fault:
  *               -EFAULT - fault during copy. Beware, in this case iovec
  *                         can be modified!
  */
-int skb_copy_and_csum_datagram_iovec(const struct sk_buff *skb,
+int skb_copy_and_csum_datagram_iovec(struct sk_buff *skb,
                                      int hlen, struct iovec *iov)
 {
         unsigned int csum;
@@ -376,8 +390,7 @@ int skb_copy_and_csum_datagram_iovec(const struct sk_buff *skb,
                 iov++;
 
         if (iov->iov_len < chunk) {
-                if ((unsigned short)csum_fold(skb_checksum(skb, 0, chunk + hlen,
-                                                           skb->csum)))
+                if (__skb_checksum_complete(skb))
                         goto csum_error;
                 if (skb_copy_datagram_iovec(skb, hlen, iov, chunk))
                         goto fault;
@@ -388,6 +401,8 @@ int skb_copy_and_csum_datagram_iovec(const struct sk_buff *skb,
                         goto fault;
                 if ((unsigned short)csum_fold(csum))
                         goto csum_error;
+                if (unlikely(skb->ip_summed == CHECKSUM_HW))
+                        netdev_rx_csum_fault(skb->dev);
                 iov->iov_len -= chunk;
                 iov->iov_base += chunk;
         }
diff --git a/net/core/dev.c b/net/core/dev.c
index 8d1541595277..0b48e294aafe 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -1108,6 +1108,18 @@ out:
         return ret;
 }
 
+/* Take action when hardware reception checksum errors are detected. */
+#ifdef CONFIG_BUG
+void netdev_rx_csum_fault(struct net_device *dev)
+{
+        if (net_ratelimit()) {
+                printk(KERN_ERR "%s: hw csum failure.\n", dev->name);
+                dump_stack();
+        }
+}
+EXPORT_SYMBOL(netdev_rx_csum_fault);
+#endif
+
 #ifdef CONFIG_HIGHMEM
 /* Actually, we should eliminate this check as soon as we know, that:
  * 1. IOMMU is present and allows to map all the memory.
diff --git a/net/core/netpoll.c b/net/core/netpoll.c
index 802fe11efad0..49424a42a2c0 100644
--- a/net/core/netpoll.c
+++ b/net/core/netpoll.c
@@ -101,16 +101,20 @@ void netpoll_queue(struct sk_buff *skb)
 static int checksum_udp(struct sk_buff *skb, struct udphdr *uh,
                              unsigned short ulen, u32 saddr, u32 daddr)
 {
-        if (uh->check == 0)
+        unsigned int psum;
+
+        if (uh->check == 0 || skb->ip_summed == CHECKSUM_UNNECESSARY)
                 return 0;
 
-        if (skb->ip_summed == CHECKSUM_HW)
-                return csum_tcpudp_magic(
-                        saddr, daddr, ulen, IPPROTO_UDP, skb->csum);
+        psum = csum_tcpudp_nofold(saddr, daddr, ulen, IPPROTO_UDP, 0);
+
+        if (skb->ip_summed == CHECKSUM_HW &&
+            !(u16)csum_fold(csum_add(psum, skb->csum)))
+                return 0;
 
-        skb->csum = csum_tcpudp_nofold(saddr, daddr, ulen, IPPROTO_UDP, 0);
+        skb->csum = psum;
 
-        return csum_fold(skb_checksum(skb, 0, skb->len, skb->csum));
+        return __skb_checksum_complete(skb);
 }
 
 /*
@@ -489,7 +493,7 @@ int __netpoll_rx(struct sk_buff *skb)
 
         if (ulen != len)
                 goto out;
-        if (checksum_udp(skb, uh, ulen, iph->saddr, iph->daddr) < 0)
+        if (checksum_udp(skb, uh, ulen, iph->saddr, iph->daddr))
                 goto out;
         if (np->local_ip && np->local_ip != ntohl(iph->daddr))
                 goto out;
diff --git a/net/ipv4/icmp.c b/net/ipv4/icmp.c
index 175e093ec564..e3eceecd0496 100644
--- a/net/ipv4/icmp.c
+++ b/net/ipv4/icmp.c
@@ -934,11 +934,11 @@ int icmp_rcv(struct sk_buff *skb)
         case CHECKSUM_HW:
                 if (!(u16)csum_fold(skb->csum))
                         break;
-                LIMIT_NETDEBUG(KERN_DEBUG "icmp v4 hw csum failure\n");
+                /* fall through */
         case CHECKSUM_NONE:
-                if ((u16)csum_fold(skb_checksum(skb, 0, skb->len, 0)))
+                skb->csum = 0;
+                if (__skb_checksum_complete(skb))
                         goto error;
-        default:;
         }
 
         if (!pskb_pull(skb, sizeof(struct icmphdr)))
diff --git a/net/ipv4/igmp.c b/net/ipv4/igmp.c
index c6247fc84060..c04607b49212 100644
--- a/net/ipv4/igmp.c
+++ b/net/ipv4/igmp.c
@@ -872,11 +872,18 @@ int igmp_rcv(struct sk_buff *skb)
                 return 0;
         }
 
-        if (!pskb_may_pull(skb, sizeof(struct igmphdr)) || 
-            (u16)csum_fold(skb_checksum(skb, 0, len, 0))) {
-                in_dev_put(in_dev);
-                kfree_skb(skb);
-                return 0;
+        if (!pskb_may_pull(skb, sizeof(struct igmphdr)))
+                goto drop;
+
+        switch (skb->ip_summed) {
+        case CHECKSUM_HW:
+                if (!(u16)csum_fold(skb->csum))
+                        break;
+                /* fall through */
+        case CHECKSUM_NONE:
+                skb->csum = 0;
+                if (__skb_checksum_complete(skb))
+                        goto drop;
         }
 
         ih = skb->h.igmph;
@@ -906,6 +913,8 @@ int igmp_rcv(struct sk_buff *skb)
         default:
                 NETDEBUG(KERN_DEBUG "New IGMP type=%d, why we do not know about it?\n", ih->type);
         }
+
+drop:
         in_dev_put(in_dev);
         kfree_skb(skb);
         return 0;
diff --git a/net/ipv4/ip_gre.c b/net/ipv4/ip_gre.c
index 896ce3f8f53a..4e9c74b54b15 100644
--- a/net/ipv4/ip_gre.c
+++ b/net/ipv4/ip_gre.c
@@ -577,15 +577,16 @@ static int ipgre_rcv(struct sk_buff *skb)
                         goto drop_nolock;
 
                 if (flags&GRE_CSUM) {
-                        if (skb->ip_summed == CHECKSUM_HW) {
+                        switch (skb->ip_summed) {
+                        case CHECKSUM_HW:
                                 csum = (u16)csum_fold(skb->csum);
-                                if (csum)
-                                        skb->ip_summed = CHECKSUM_NONE;
-                        }
-                        if (skb->ip_summed == CHECKSUM_NONE) {
-                                skb->csum = skb_checksum(skb, 0, skb->len, 0);
+                                if (!csum)
+                                        break;
+                                /* fall through */
+                        case CHECKSUM_NONE:
+                                skb->csum = 0;
+                                csum = __skb_checksum_complete(skb);
                                 skb->ip_summed = CHECKSUM_HW;
-                                csum = (u16)csum_fold(skb->csum);
                         }
                         offset += 4;
                 }
diff --git a/net/ipv4/netfilter/ip_conntrack_proto_icmp.c b/net/ipv4/netfilter/ip_conntrack_proto_icmp.c
index 5198f3a1e2cd..e4d6b268e8c4 100644
--- a/net/ipv4/netfilter/ip_conntrack_proto_icmp.c
+++ b/net/ipv4/netfilter/ip_conntrack_proto_icmp.c
@@ -13,6 +13,7 @@
 #include <linux/in.h>
 #include <linux/icmp.h>
 #include <linux/seq_file.h>
+#include <linux/skbuff.h>
 #include <net/ip.h>
 #include <net/checksum.h>
 #include <linux/netfilter.h>
@@ -230,19 +231,15 @@ icmp_error(struct sk_buff *skb, enum ip_conntrack_info *ctinfo,
         case CHECKSUM_HW:
                 if (!(u16)csum_fold(skb->csum)) 
                         break;
-                if (LOG_INVALID(IPPROTO_ICMP))
-                        nf_log_packet(PF_INET, 0, skb, NULL, NULL, NULL,
-                                      "ip_ct_icmp: bad HW ICMP checksum ");
-                return -NF_ACCEPT;
+                /* fall through */
         case CHECKSUM_NONE:
-                if ((u16)csum_fold(skb_checksum(skb, 0, skb->len, 0))) {
+                skb->csum = 0;
+                if (__skb_checksum_complete(skb)) {
                         if (LOG_INVALID(IPPROTO_ICMP))
                                 nf_log_packet(PF_INET, 0, skb, NULL, NULL, NULL,
                                               "ip_ct_icmp: bad ICMP checksum ");
                         return -NF_ACCEPT;
                 }
-        default:
-                break;
         }
 
 checksum_skipped:
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index 634dabb558fd..ac1fcf5b4ebc 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -1110,24 +1110,18 @@ static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
 static int tcp_v4_checksum_init(struct sk_buff *skb)
 {
         if (skb->ip_summed == CHECKSUM_HW) {
-                skb->ip_summed = CHECKSUM_UNNECESSARY;
                 if (!tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr,
-                                  skb->nh.iph->daddr, skb->csum))
+                                  skb->nh.iph->daddr, skb->csum)) {
+                        skb->ip_summed = CHECKSUM_UNNECESSARY;
                         return 0;
-
-                LIMIT_NETDEBUG(KERN_DEBUG "hw tcp v4 csum failed\n");
-                skb->ip_summed = CHECKSUM_NONE;
+                }
         }
+
+        skb->csum = csum_tcpudp_nofold(skb->nh.iph->saddr, skb->nh.iph->daddr,
+                                       skb->len, IPPROTO_TCP, 0);
+
         if (skb->len <= 76) {
-                if (tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr,
-                                 skb->nh.iph->daddr,
-                                 skb_checksum(skb, 0, skb->len, 0)))
-                        return -1;
-                skb->ip_summed = CHECKSUM_UNNECESSARY;
-        } else {
-                skb->csum = ~tcp_v4_check(skb->h.th, skb->len,
-                                          skb->nh.iph->saddr,
-                                          skb->nh.iph->daddr, 0);
+                return __skb_checksum_complete(skb);
         }
         return 0;
 }
@@ -1219,7 +1213,7 @@ int tcp_v4_rcv(struct sk_buff *skb)
          * provided case of th->doff==0 is elimineted.
          * So, we defer the checks. */
         if ((skb->ip_summed != CHECKSUM_UNNECESSARY &&
-             tcp_v4_checksum_init(skb) < 0))
+             tcp_v4_checksum_init(skb)))
                 goto bad_packet;
 
         th = skb->h.th;
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index e0bd1013cb0d..2422a5f7195d 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -761,7 +761,7 @@ int udp_ioctl(struct sock *sk, int cmd, unsigned long arg)
 
 static __inline__ int __udp_checksum_complete(struct sk_buff *skb)
 {
-        return (unsigned short)csum_fold(skb_checksum(skb, 0, skb->len, skb->csum));
+        return __skb_checksum_complete(skb);
 }
 
 static __inline__ int udp_checksum_complete(struct sk_buff *skb)
@@ -1100,11 +1100,8 @@ static int udp_checksum_init(struct sk_buff *skb, struct udphdr *uh,
         if (uh->check == 0) {
                 skb->ip_summed = CHECKSUM_UNNECESSARY;
         } else if (skb->ip_summed == CHECKSUM_HW) {
-                skb->ip_summed = CHECKSUM_UNNECESSARY;
                 if (!udp_check(uh, ulen, saddr, daddr, skb->csum))
-                        return 0;
-                LIMIT_NETDEBUG(KERN_DEBUG "udp v4 hw csum failure.\n");
-                skb->ip_summed = CHECKSUM_NONE;
+                        skb->ip_summed = CHECKSUM_UNNECESSARY;
         }
         if (skb->ip_summed != CHECKSUM_UNNECESSARY)
                 skb->csum = csum_tcpudp_nofold(saddr, daddr, ulen, IPPROTO_UDP, 0);
diff --git a/net/ipv6/icmp.c b/net/ipv6/icmp.c
index 23e540365a14..1bdf0fb8bf8a 100644
--- a/net/ipv6/icmp.c
+++ b/net/ipv6/icmp.c
@@ -585,17 +585,16 @@ static int icmpv6_rcv(struct sk_buff **pskb, unsigned int *nhoffp)
         daddr = &skb->nh.ipv6h->daddr;
 
         /* Perform checksum. */
-        if (skb->ip_summed == CHECKSUM_HW) {
-                skb->ip_summed = CHECKSUM_UNNECESSARY;
-                if (csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
-                                    skb->csum)) {
-                        LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 hw checksum failed\n");
-                        skb->ip_summed = CHECKSUM_NONE;
-                }
-        }
-        if (skb->ip_summed == CHECKSUM_NONE) {
-                if (csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
-                                    skb_checksum(skb, 0, skb->len, 0))) {
+        switch (skb->ip_summed) {
+        case CHECKSUM_HW:
+                if (!csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
+                                     skb->csum))
+                        break;
+                /* fall through */
+        case CHECKSUM_NONE:
+                skb->csum = ~csum_ipv6_magic(saddr, daddr, skb->len,
+                                             IPPROTO_ICMPV6, 0);
+                if (__skb_checksum_complete(skb)) {
                         LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x > %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x]\n",
                                        NIP6(*saddr), NIP6(*daddr));
                         goto discard_it;
diff --git a/net/ipv6/raw.c b/net/ipv6/raw.c
index 651c79b41eeb..8e9628f1c4c5 100644
--- a/net/ipv6/raw.c
+++ b/net/ipv6/raw.c
@@ -298,13 +298,10 @@ void rawv6_err(struct sock *sk, struct sk_buff *skb,
 static inline int rawv6_rcv_skb(struct sock * sk, struct sk_buff * skb)
 {
         if ((raw6_sk(sk)->checksum || sk->sk_filter) && 
-            skb->ip_summed != CHECKSUM_UNNECESSARY) {
-                if ((unsigned short)csum_fold(skb_checksum(skb, 0, skb->len, skb->csum))) {
-                        /* FIXME: increment a raw6 drops counter here */
-                        kfree_skb(skb);
-                        return 0;
-                }
-                skb->ip_summed = CHECKSUM_UNNECESSARY;
+            skb_checksum_complete(skb)) {
+                /* FIXME: increment a raw6 drops counter here */
+                kfree_skb(skb);
+                return 0;
         }
 
         /* Charge it to the socket. */
@@ -337,32 +334,25 @@ int rawv6_rcv(struct sock *sk, struct sk_buff *skb)
         if (!rp->checksum)
                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 
-        if (skb->ip_summed != CHECKSUM_UNNECESSARY) {
-                if (skb->ip_summed == CHECKSUM_HW) {
-                        skb_postpull_rcsum(skb, skb->nh.raw,
-                                           skb->h.raw - skb->nh.raw);
+        if (skb->ip_summed == CHECKSUM_HW) {
+                skb_postpull_rcsum(skb, skb->nh.raw,
+                                   skb->h.raw - skb->nh.raw);
+                if (!csum_ipv6_magic(&skb->nh.ipv6h->saddr,
+                                     &skb->nh.ipv6h->daddr,
+                                     skb->len, inet->num, skb->csum))
                         skb->ip_summed = CHECKSUM_UNNECESSARY;
-                        if (csum_ipv6_magic(&skb->nh.ipv6h->saddr,
-                                            &skb->nh.ipv6h->daddr,
-                                            skb->len, inet->num, skb->csum)) {
-                                LIMIT_NETDEBUG(KERN_DEBUG "raw v6 hw csum failure.\n");
-                                skb->ip_summed = CHECKSUM_NONE;
-                        }
-                }
-                if (skb->ip_summed == CHECKSUM_NONE)
-                        skb->csum = ~csum_ipv6_magic(&skb->nh.ipv6h->saddr,
-                                                     &skb->nh.ipv6h->daddr,
-                                                     skb->len, inet->num, 0);
         }
+        if (skb->ip_summed != CHECKSUM_UNNECESSARY)
+                skb->csum = ~csum_ipv6_magic(&skb->nh.ipv6h->saddr,
+                                             &skb->nh.ipv6h->daddr,
+                                             skb->len, inet->num, 0);
 
         if (inet->hdrincl) {
-                if (skb->ip_summed != CHECKSUM_UNNECESSARY &&
-                    (unsigned short)csum_fold(skb_checksum(skb, 0, skb->len, skb->csum))) {
+                if (skb_checksum_complete(skb)) {
                         /* FIXME: increment a raw6 drops counter here */
                         kfree_skb(skb);
                         return 0;
                 }
-                skb->ip_summed = CHECKSUM_UNNECESSARY;
         }
 
         rawv6_rcv_skb(sk, skb);
@@ -407,7 +397,7 @@ static int rawv6_recvmsg(struct kiocb *iocb, struct sock *sk,
         if (skb->ip_summed==CHECKSUM_UNNECESSARY) {
                 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
         } else if (msg->msg_flags&MSG_TRUNC) {
-                if ((unsigned short)csum_fold(skb_checksum(skb, 0, skb->len, skb->csum)))
+                if (__skb_checksum_complete(skb))
                         goto csum_copy_err;
                 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
         } else {
diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index d746d3b27efb..62c0e5bd931c 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -1401,20 +1401,18 @@ out:
 static int tcp_v6_checksum_init(struct sk_buff *skb)
 {
         if (skb->ip_summed == CHECKSUM_HW) {
-                skb->ip_summed = CHECKSUM_UNNECESSARY;
                 if (!tcp_v6_check(skb->h.th,skb->len,&skb->nh.ipv6h->saddr,
-                                  &skb->nh.ipv6h->daddr,skb->csum))
+                                  &skb->nh.ipv6h->daddr,skb->csum)) {
+                        skb->ip_summed = CHECKSUM_UNNECESSARY;
                         return 0;
-                LIMIT_NETDEBUG(KERN_DEBUG "hw tcp v6 csum failed\n");
+                }
         }
+
+        skb->csum = ~tcp_v6_check(skb->h.th,skb->len,&skb->nh.ipv6h->saddr,
+                                  &skb->nh.ipv6h->daddr, 0);
+
         if (skb->len <= 76) {
-                if (tcp_v6_check(skb->h.th,skb->len,&skb->nh.ipv6h->saddr,
-                                 &skb->nh.ipv6h->daddr,skb_checksum(skb, 0, skb->len, 0)))
-                        return -1;
-                skb->ip_summed = CHECKSUM_UNNECESSARY;
-        } else {
-                skb->csum = ~tcp_v6_check(skb->h.th,skb->len,&skb->nh.ipv6h->saddr,
-                                          &skb->nh.ipv6h->daddr,0);
+                return __skb_checksum_complete(skb);
         }
         return 0;
 }
@@ -1575,7 +1573,7 @@ static int tcp_v6_rcv(struct sk_buff **pskb, unsigned int *nhoffp)
                 goto discard_it;
 
         if ((skb->ip_summed != CHECKSUM_UNNECESSARY &&
-             tcp_v6_checksum_init(skb) < 0))
+             tcp_v6_checksum_init(skb)))
                 goto bad_packet;
 
         th = skb->h.th;
diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c
index bf9519341fd3..e671153b47b2 100644
--- a/net/ipv6/udp.c
+++ b/net/ipv6/udp.c
@@ -248,7 +248,7 @@ try_again:
                 err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov,
                                               copied);
         } else if (msg->msg_flags&MSG_TRUNC) {
-                if ((unsigned short)csum_fold(skb_checksum(skb, 0, skb->len, skb->csum)))
+                if (__skb_checksum_complete(skb))
                         goto csum_copy_err;
                 err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov,
                                               copied);
@@ -363,13 +363,10 @@ static inline int udpv6_queue_rcv_skb(struct sock * sk, struct sk_buff *skb)
                 return -1;
         }
 
-        if (skb->ip_summed != CHECKSUM_UNNECESSARY) {
-                if ((unsigned short)csum_fold(skb_checksum(skb, 0, skb->len, skb->csum))) {
-                        UDP6_INC_STATS_BH(UDP_MIB_INERRORS);
-                        kfree_skb(skb);
-                        return 0;
-                }
-                skb->ip_summed = CHECKSUM_UNNECESSARY;
+        if (skb_checksum_complete(skb)) {
+                UDP6_INC_STATS_BH(UDP_MIB_INERRORS);
+                kfree_skb(skb);
+                return 0;
         }
 
         if (sock_queue_rcv_skb(sk,skb)<0) {
@@ -491,13 +488,10 @@ static int udpv6_rcv(struct sk_buff **pskb, unsigned int *nhoffp)
                 uh = skb->h.uh;
         }
 
-        if (skb->ip_summed==CHECKSUM_HW) {
+        if (skb->ip_summed == CHECKSUM_HW &&
+            !csum_ipv6_magic(saddr, daddr, ulen, IPPROTO_UDP, skb->csum))
                 skb->ip_summed = CHECKSUM_UNNECESSARY;
-                if (csum_ipv6_magic(saddr, daddr, ulen, IPPROTO_UDP, skb->csum)) {
-                        LIMIT_NETDEBUG(KERN_DEBUG "udp v6 hw csum failure.\n");
-                        skb->ip_summed = CHECKSUM_NONE;
-                }
-        }
+
         if (skb->ip_summed != CHECKSUM_UNNECESSARY)
                 skb->csum = ~csum_ipv6_magic(saddr, daddr, ulen, IPPROTO_UDP, 0);
 
@@ -521,8 +515,7 @@ static int udpv6_rcv(struct sk_buff **pskb, unsigned int *nhoffp)
                 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
                         goto discard;
 
-                if (skb->ip_summed != CHECKSUM_UNNECESSARY &&
-                    (unsigned short)csum_fold(skb_checksum(skb, 0, skb->len, skb->csum)))
+                if (skb_checksum_complete(skb))
                         goto discard;
                 UDP6_INC_STATS_BH(UDP_MIB_NOPORTS);
 
diff --git a/net/rxrpc/transport.c b/net/rxrpc/transport.c
index 122c086ee2db..dbe6105e83a5 100644
--- a/net/rxrpc/transport.c
+++ b/net/rxrpc/transport.c
@@ -23,6 +23,7 @@
 #include <linux/in.h>
 #include <linux/in6.h>
 #include <linux/icmp.h>
+#include <linux/skbuff.h>
 #include <net/sock.h>
 #include <net/ip.h>
 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
@@ -475,15 +476,11 @@ void rxrpc_trans_receive_packet(struct rxrpc_transport *trans)
 
                 /* we'll probably need to checksum it (didn't call
                  * sock_recvmsg) */
-                if (pkt->ip_summed != CHECKSUM_UNNECESSARY) {
-                        if ((unsigned short)
-                            csum_fold(skb_checksum(pkt, 0, pkt->len,
-                                                   pkt->csum))) {
-                                kfree_skb(pkt);
-                                rxrpc_krxiod_queue_transport(trans);
-                                _leave(" CSUM failed");
-                                return;
-                        }
+                if (skb_checksum_complete(pkt)) {
+                        kfree_skb(pkt);
+                        rxrpc_krxiod_queue_transport(trans);
+                        _leave(" CSUM failed");
+                        return;
                 }
 
                 addr = pkt->nh.iph->saddr;
diff --git a/net/sunrpc/socklib.c b/net/sunrpc/socklib.c
index 8f97e90f36c8..eb330d4f66d6 100644
--- a/net/sunrpc/socklib.c
+++ b/net/sunrpc/socklib.c
@@ -6,6 +6,9 @@
  * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
  */
 
+#include <linux/compiler.h>
+#include <linux/netdevice.h>
+#include <linux/skbuff.h>
 #include <linux/types.h>
 #include <linux/pagemap.h>
 #include <linux/udp.h>
@@ -165,6 +168,8 @@ int csum_partial_copy_to_xdr(struct xdr_buf *xdr, struct sk_buff *skb)
                 return -1;
         if ((unsigned short)csum_fold(desc.csum))
                 return -1;
+        if (unlikely(skb->ip_summed == CHECKSUM_HW))
+                netdev_rx_csum_fault(skb->dev);
         return 0;
 no_checksum:
         if (xdr_partial_copy_from_skb(xdr, 0, &desc, skb_read_bits) < 0)
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index f16e7cdd6150..e50e7cf43737 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -623,12 +623,9 @@ svc_udp_recvfrom(struct svc_rqst *rqstp)
                 /* we can use it in-place */
                 rqstp->rq_arg.head[0].iov_base = skb->data + sizeof(struct udphdr);
                 rqstp->rq_arg.head[0].iov_len = len;
-                if (skb->ip_summed != CHECKSUM_UNNECESSARY) {
-                        if ((unsigned short)csum_fold(skb_checksum(skb, 0, skb->len, skb->csum))) {
-                                skb_free_datagram(svsk->sk_sk, skb);
-                                return 0;
-                        }
-                        skb->ip_summed = CHECKSUM_UNNECESSARY;
+                if (skb_checksum_complete(skb)) {
+                        skb_free_datagram(svsk->sk_sk, skb);
+                        return 0;
                 }
                 rqstp->rq_skbuff = skb;
         }