Merge branch 'csums-next'

Tom Herbert says:

====================
net: Checksum offload changes - Part VI

I am working on overhauling RX checksum offload. Goals of this effort
are:

- Specify what exactly it means when driver returns CHECKSUM_UNNECESSARY
- Preserve CHECKSUM_COMPLETE through encapsulation layers
- Don't do skb_checksum more than once per packet
- Unify GRO and non-GRO csum verification as much as possible
- Unify the checksum functions (checksum_init)
- Simplify code

What is in this sixth patch set:

- Clarify the specific requirements of devices returning
  CHECKSUM_UNNECESSARY (comments in skbuff.h).
- Add csum_level field to skbuff. This is used to express how
  many checksums are covered by CHECKSUM_UNNECESSARY (stores n - 1).
- Change __skb_checksum_validate_needed to "consume" each checksum
  as indicated by csum_level as layers of the the packet are parsed.
- Remove skb_pop_rcv_encapsulation, no longer needed in the new
  csum_level model.
- Allow GRO path to "consume" checksums provided in CHECKSUM_UNNECESSARY
  and to report new verfied checksums for use in normal path fallback.
- Add proper support to SCTP to accept CHECKSUM_UNNECESSARY to validate
  header CRC.
- Modify drivers to set skb->csum_level instead of setting
  skb->encapsulation to indicate validation of an encapsulated
  checksum on receive.

v2:

Allocate a new 16 bits for flags in skbuff.

Please review carefully and test if possible, mucking with basic
checksum functions is always a little precarious :-)
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

5 files changed, 27 insertions, 18 deletions

diff --git a/net/core/dev.c b/net/core/dev.c
index 26d296c2447c..a6077ef56345 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -3962,13 +3962,6 @@ static enum gro_result dev_gro_receive(struct napi_struct *napi, struct sk_buff
 
         gro_list_prepare(napi, skb);
 
-        if (skb->ip_summed == CHECKSUM_COMPLETE) {
-                NAPI_GRO_CB(skb)->csum = skb->csum;
-                NAPI_GRO_CB(skb)->csum_valid = 1;
-        } else {
-                NAPI_GRO_CB(skb)->csum_valid = 0;
-        }
-
         rcu_read_lock();
         list_for_each_entry_rcu(ptype, head, list) {
                 if (ptype->type != type || !ptype->callbacks.gro_receive)
@@ -3980,7 +3973,22 @@ static enum gro_result dev_gro_receive(struct napi_struct *napi, struct sk_buff
                 NAPI_GRO_CB(skb)->flush = 0;
                 NAPI_GRO_CB(skb)->free = 0;
                 NAPI_GRO_CB(skb)->udp_mark = 0;
-                NAPI_GRO_CB(skb)->encapsulation = 0;
+
+                /* Setup for GRO checksum validation */
+                switch (skb->ip_summed) {
+                case CHECKSUM_COMPLETE:
+                        NAPI_GRO_CB(skb)->csum = skb->csum;
+                        NAPI_GRO_CB(skb)->csum_valid = 1;
+                        NAPI_GRO_CB(skb)->csum_cnt = 0;
+                        break;
+                case CHECKSUM_UNNECESSARY:
+                        NAPI_GRO_CB(skb)->csum_cnt = skb->csum_level + 1;
+                        NAPI_GRO_CB(skb)->csum_valid = 0;
+                        break;
+                default:
+                        NAPI_GRO_CB(skb)->csum_cnt = 0;
+                        NAPI_GRO_CB(skb)->csum_valid = 0;
+                }
 
                 pp = ptype->callbacks.gro_receive(&napi->gro_list, skb);
                 break;
diff --git a/net/ipv4/gre_demux.c b/net/ipv4/gre_demux.c
index 7c1a8ff974dd..0485bf7f8f03 100644
--- a/net/ipv4/gre_demux.c
+++ b/net/ipv4/gre_demux.c
@@ -125,7 +125,6 @@ static int parse_gre_header(struct sk_buff *skb, struct tnl_ptk_info *tpi,
                         *csum_err = true;
                         return -EINVAL;
                 }
-                skb_pop_rcv_encapsulation(skb);
                 options++;
         }
 
diff --git a/net/ipv4/gre_offload.c b/net/ipv4/gre_offload.c
index d1bd16937d93..a4d7965fb880 100644
--- a/net/ipv4/gre_offload.c
+++ b/net/ipv4/gre_offload.c
@@ -172,12 +172,9 @@ static struct sk_buff **gre_gro_receive(struct sk_buff **head,
         }
 
         /* Don't bother verifying checksum if we're going to flush anyway. */
-        if (greh->flags & GRE_CSUM) {
-                if (!NAPI_GRO_CB(skb)->flush &&
-                    skb_gro_checksum_simple_validate(skb))
+        if ((greh->flags & GRE_CSUM) && !NAPI_GRO_CB(skb)->flush &&
+            skb_gro_checksum_simple_validate(skb))
                         goto out_unlock;
-                NAPI_GRO_CB(skb)->encapsulation++;
-        }
 
         flush = 0;
 
diff --git a/net/ipv4/udp_offload.c b/net/ipv4/udp_offload.c
index 8ed460e3753c..a6adff98382a 100644
--- a/net/ipv4/udp_offload.c
+++ b/net/ipv4/udp_offload.c
@@ -238,12 +238,13 @@ struct sk_buff **udp_gro_receive(struct sk_buff **head, struct sk_buff *skb,
         int flush = 1;
 
         if (NAPI_GRO_CB(skb)->udp_mark ||
-            (!skb->encapsulation && !NAPI_GRO_CB(skb)->csum_valid))
+            (skb->ip_summed != CHECKSUM_PARTIAL &&
+             NAPI_GRO_CB(skb)->csum_cnt == 0 &&
+             !NAPI_GRO_CB(skb)->csum_valid))
                 goto out;
 
         /* mark that this skb passed once through the udp gro layer */
         NAPI_GRO_CB(skb)->udp_mark = 1;
-        NAPI_GRO_CB(skb)->encapsulation++;
 
         rcu_read_lock();
         uo_priv = rcu_dereference(udp_offload_base);
diff --git a/net/sctp/input.c b/net/sctp/input.c
index c1b991294516..b6493b3f11a9 100644
--- a/net/sctp/input.c
+++ b/net/sctp/input.c
@@ -133,9 +133,13 @@ int sctp_rcv(struct sk_buff *skb)
         __skb_pull(skb, skb_transport_offset(skb));
         if (skb->len < sizeof(struct sctphdr))
                 goto discard_it;
-        if (!sctp_checksum_disable && !skb_csum_unnecessary(skb) &&
-                  sctp_rcv_checksum(net, skb) < 0)
+
+        skb->csum_valid = 0; /* Previous value not applicable */
+        if (skb_csum_unnecessary(skb))
+                __skb_decr_checksum_unnecessary(skb);
+        else if (!sctp_checksum_disable && sctp_rcv_checksum(net, skb) < 0)
                 goto discard_it;
+        skb->csum_valid = 1;
 
         skb_pull(skb, sizeof(struct sctphdr));