net: skb_gro_checksum_* functions

Add skb_gro_checksum_validate, skb_gro_checksum_validate_zero_check,
and skb_gro_checksum_simple_validate, and __skb_gro_checksum_complete.
These are the cognates of the normal checksum functions but are used
in the gro_receive path and operate on GRO related fields in sk_buffs.

Signed-off-by: Tom Herbert <therbert@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 74 insertions, 2 deletions

diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 7e2b0b8b5cd7..eb73444e1bd0 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -1883,7 +1883,13 @@ struct napi_gro_cb {
         u16     proto;
 
         /* Used in udp_gro_receive */
-        u16     udp_mark;
+        u8      udp_mark:1;
+
+        /* GRO checksum is valid */
+        u8      csum_valid:1;
+
+        /* Number encapsulation layers crossed */
+        u8      encapsulation;
 
         /* used to support CHECKSUM_COMPLETE for tunneling protocols */
         __wsum  csum;
@@ -2154,11 +2160,77 @@ static inline void *skb_gro_network_header(struct sk_buff *skb)
 static inline void skb_gro_postpull_rcsum(struct sk_buff *skb,
                                         const void *start, unsigned int len)
 {
-        if (skb->ip_summed == CHECKSUM_COMPLETE)
+        if (NAPI_GRO_CB(skb)->csum_valid)
                 NAPI_GRO_CB(skb)->csum = csum_sub(NAPI_GRO_CB(skb)->csum,
                                                   csum_partial(start, len, 0));
 }
 
+/* GRO checksum functions. These are logical equivalents of the normal
+ * checksum functions (in skbuff.h) except that they operate on the GRO
+ * offsets and fields in sk_buff.
+ */
+
+__sum16 __skb_gro_checksum_complete(struct sk_buff *skb);
+
+static inline bool __skb_gro_checksum_validate_needed(struct sk_buff *skb,
+                                                      bool zero_okay,
+                                                      __sum16 check)
+{
+        return (skb->ip_summed != CHECKSUM_PARTIAL &&
+                (skb->ip_summed != CHECKSUM_UNNECESSARY ||
+                 (NAPI_GRO_CB(skb)->encapsulation > skb->encapsulation)) &&
+                (!zero_okay || check));
+}
+
+static inline __sum16 __skb_gro_checksum_validate_complete(struct sk_buff *skb,
+                                                           __wsum psum)
+{
+        if (NAPI_GRO_CB(skb)->csum_valid &&
+            !csum_fold(csum_add(psum, NAPI_GRO_CB(skb)->csum)))
+                return 0;
+
+        NAPI_GRO_CB(skb)->csum = psum;
+
+        return __skb_gro_checksum_complete(skb);
+}
+
+/* Update skb for CHECKSUM_UNNECESSARY when we verified a top level
+ * checksum or an encapsulated one during GRO. This saves work
+ * if we fallback to normal path with the packet.
+ */
+static inline void skb_gro_incr_csum_unnecessary(struct sk_buff *skb)
+{
+        if (skb->ip_summed == CHECKSUM_UNNECESSARY) {
+                if (NAPI_GRO_CB(skb)->encapsulation)
+                        skb->encapsulation = 1;
+        } else if (skb->ip_summed != CHECKSUM_PARTIAL) {
+                skb->ip_summed = CHECKSUM_UNNECESSARY;
+                skb->encapsulation = 0;
+        }
+}
+
+#define __skb_gro_checksum_validate(skb, proto, zero_okay, check,       \
+                                    compute_pseudo)                     \
+({                                                                      \
+        __sum16 __ret = 0;                                              \
+        if (__skb_gro_checksum_validate_needed(skb, zero_okay, check))  \
+                __ret = __skb_gro_checksum_validate_complete(skb,       \
+                                compute_pseudo(skb, proto));            \
+        if (!__ret)                                                     \
+                skb_gro_incr_csum_unnecessary(skb);                     \
+        __ret;                                                          \
+})
+
+#define skb_gro_checksum_validate(skb, proto, compute_pseudo)           \
+        __skb_gro_checksum_validate(skb, proto, false, 0, compute_pseudo)
+
+#define skb_gro_checksum_validate_zero_check(skb, proto, check,         \
+                                             compute_pseudo)            \
+        __skb_gro_checksum_validate(skb, proto, true, check, compute_pseudo)
+
+#define skb_gro_checksum_simple_validate(skb)                           \
+        __skb_gro_checksum_validate(skb, 0, false, 0, null_compute_pseudo)
+
 static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
                                   unsigned short type,
                                   const void *daddr, const void *saddr,