7 files changed, 88 insertions, 21 deletions

diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index 2e75ab00dbf2..e530533b94be 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -364,8 +364,6 @@ struct ssb_device_id {
 } __attribute__((packed, aligned(2)));
 #define SSB_DEVICE(_vendor, _coreid, _revision)  \
         { .vendor = _vendor, .coreid = _coreid, .revision = _revision, }
-#define SSB_DEVTABLE_END  \
-        { 0, },
 
 #define SSB_ANY_VENDOR          0xFFFF
 #define SSB_ANY_ID              0xFFFF
@@ -380,8 +378,6 @@ struct bcma_device_id {
 } __attribute__((packed,aligned(2)));
 #define BCMA_CORE(_manuf, _id, _rev, _class)  \
         { .manuf = _manuf, .id = _id, .rev = _rev, .class = _class, }
-#define BCMA_CORETABLE_END  \
-        { 0, },
 
 #define BCMA_ANY_MANUF          0xFFFF
 #define BCMA_ANY_ID             0xFFFF
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index d115256ed5a2..5897b4ea5a3f 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -1923,13 +1923,8 @@ struct napi_gro_cb {
         /* Number of segments aggregated. */
         u16     count;
 
-        /* This is non-zero if the packet may be of the same flow. */
-        u8      same_flow;
-
-        /* Free the skb? */
-        u8      free;
-#define NAPI_GRO_FREE             1
-#define NAPI_GRO_FREE_STOLEN_HEAD 2
+        /* Start offset for remote checksum offload */
+        u16     gro_remcsum_start;
 
         /* jiffies when first packet was created/queued */
         unsigned long age;
@@ -1937,6 +1932,9 @@ struct napi_gro_cb {
         /* Used in ipv6_gro_receive() and foo-over-udp */
         u16     proto;
 
+        /* This is non-zero if the packet may be of the same flow. */
+        u8      same_flow:1;
+
         /* Used in udp_gro_receive */
         u8      udp_mark:1;
 
@@ -1946,9 +1944,16 @@ struct napi_gro_cb {
         /* Number of checksums via CHECKSUM_UNNECESSARY */
         u8      csum_cnt:3;
 
+        /* Free the skb? */
+        u8      free:2;
+#define NAPI_GRO_FREE             1
+#define NAPI_GRO_FREE_STOLEN_HEAD 2
+
         /* Used in foo-over-udp, set in udp[46]_gro_receive */
         u8      is_ipv6:1;
 
+        /* 7 bit hole */
+
         /* used to support CHECKSUM_COMPLETE for tunneling protocols */
         __wsum  csum;
 
@@ -2242,11 +2247,20 @@ static inline void skb_gro_postpull_rcsum(struct sk_buff *skb,
 
 __sum16 __skb_gro_checksum_complete(struct sk_buff *skb);
 
+static inline bool skb_at_gro_remcsum_start(struct sk_buff *skb)
+{
+        return (NAPI_GRO_CB(skb)->gro_remcsum_start - skb_headroom(skb) ==
+                skb_gro_offset(skb));
+}
+
 static inline bool __skb_gro_checksum_validate_needed(struct sk_buff *skb,
                                                       bool zero_okay,
                                                       __sum16 check)
 {
-        return (skb->ip_summed != CHECKSUM_PARTIAL &&
+        return ((skb->ip_summed != CHECKSUM_PARTIAL ||
+                skb_checksum_start_offset(skb) <
+                 skb_gro_offset(skb)) &&
+                !skb_at_gro_remcsum_start(skb) &&
                 NAPI_GRO_CB(skb)->csum_cnt == 0 &&
                 (!zero_okay || check));
 }
@@ -2321,20 +2335,48 @@ do {									\
                                            compute_pseudo(skb, proto)); \
 } while (0)
 
+struct gro_remcsum {
+        int offset;
+        __wsum delta;
+};
+
+static inline void skb_gro_remcsum_init(struct gro_remcsum *grc)
+{
+        grc->delta = 0;
+}
+
 static inline void skb_gro_remcsum_process(struct sk_buff *skb, void *ptr,
-                                           int start, int offset)
+                                           int start, int offset,
+                                           struct gro_remcsum *grc,
+                                           bool nopartial)
 {
         __wsum delta;
 
         BUG_ON(!NAPI_GRO_CB(skb)->csum_valid);
 
+        if (!nopartial) {
+                NAPI_GRO_CB(skb)->gro_remcsum_start =
+                    ((unsigned char *)ptr + start) - skb->head;
+                return;
+        }
+
         delta = remcsum_adjust(ptr, NAPI_GRO_CB(skb)->csum, start, offset);
 
         /* Adjust skb->csum since we changed the packet */
-        skb->csum = csum_add(skb->csum, delta);
         NAPI_GRO_CB(skb)->csum = csum_add(NAPI_GRO_CB(skb)->csum, delta);
+
+        grc->offset = (ptr + offset) - (void *)skb->head;
+        grc->delta = delta;
 }
 
+static inline void skb_gro_remcsum_cleanup(struct sk_buff *skb,
+                                           struct gro_remcsum *grc)
+{
+        if (!grc->delta)
+                return;
+
+        remcsum_unadjust((__sum16 *)(skb->head + grc->offset), grc->delta);
+}
 
 static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
                                   unsigned short type,
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 1bb36edb66b9..30007afe70b3 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -83,11 +83,15 @@
  *
  * CHECKSUM_PARTIAL:
  *
- *   This is identical to the case for output below. This may occur on a packet
+ *   A checksum is set up to be offloaded to a device as described in the
+ *   output description for CHECKSUM_PARTIAL. This may occur on a packet
  *   received directly from another Linux OS, e.g., a virtualized Linux kernel
- *   on the same host. The packet can be treated in the same way as
- *   CHECKSUM_UNNECESSARY, except that on output (i.e., forwarding) the
- *   checksum must be filled in by the OS or the hardware.
+ *   on the same host, or it may be set in the input path in GRO or remote
+ *   checksum offload. For the purposes of checksum verification, the checksum
+ *   referred to by skb->csum_start + skb->csum_offset and any preceding
+ *   checksums in the packet are considered verified. Any checksums in the
+ *   packet that are after the checksum being offloaded are not considered to
+ *   be verified.
  *
  * B. Checksumming on output.
  *
@@ -2915,7 +2919,10 @@ __sum16 __skb_checksum_complete(struct sk_buff *skb);
 
 static inline int skb_csum_unnecessary(const struct sk_buff *skb)
 {
-        return ((skb->ip_summed & CHECKSUM_UNNECESSARY) || skb->csum_valid);
+        return ((skb->ip_summed == CHECKSUM_UNNECESSARY) ||
+                skb->csum_valid ||
+                (skb->ip_summed == CHECKSUM_PARTIAL &&
+                 skb_checksum_start_offset(skb) >= 0));
 }
 
 /**
@@ -3097,16 +3104,29 @@ do {									\
                                        compute_pseudo(skb, proto));     \
 } while (0)
 
+static inline void skb_remcsum_adjust_partial(struct sk_buff *skb, void *ptr,
+                                              u16 start, u16 offset)
+{
+        skb->ip_summed = CHECKSUM_PARTIAL;
+        skb->csum_start = ((unsigned char *)ptr + start) - skb->head;
+        skb->csum_offset = offset - start;
+}
+
 /* Update skbuf and packet to reflect the remote checksum offload operation.
  * When called, ptr indicates the starting point for skb->csum when
  * ip_summed is CHECKSUM_COMPLETE. If we need create checksum complete
  * here, skb_postpull_rcsum is done so skb->csum start is ptr.
  */
 static inline void skb_remcsum_process(struct sk_buff *skb, void *ptr,
-                                       int start, int offset)
+                                       int start, int offset, bool nopartial)
 {
         __wsum delta;
 
+        if (!nopartial) {
+                skb_remcsum_adjust_partial(skb, ptr, start, offset);
+                return;
+        }
+
          if (unlikely(skb->ip_summed != CHECKSUM_COMPLETE)) {
                 __skb_checksum_complete(skb);
                 skb_postpull_rcsum(skb, skb->data, ptr - (void *)skb->data);
diff --git a/include/net/checksum.h b/include/net/checksum.h
index e339a9513e29..0a55ac715077 100644
--- a/include/net/checksum.h
+++ b/include/net/checksum.h
@@ -167,4 +167,9 @@ static inline __wsum remcsum_adjust(void *ptr, __wsum csum,
         return delta;
 }
 
+static inline void remcsum_unadjust(__sum16 *psum, __wsum delta)
+{
+        *psum = csum_fold(csum_sub(delta, *psum));
+}
+
 #endif
diff --git a/include/net/vxlan.h b/include/net/vxlan.h
index 2927d6244481..eabd3a038674 100644
--- a/include/net/vxlan.h
+++ b/include/net/vxlan.h
@@ -128,13 +128,15 @@ struct vxlan_sock {
 #define VXLAN_F_REMCSUM_TX              0x200
 #define VXLAN_F_REMCSUM_RX              0x400
 #define VXLAN_F_GBP                     0x800
+#define VXLAN_F_REMCSUM_NOPARTIAL       0x1000
 
 /* Flags that are used in the receive patch. These flags must match in
  * order for a socket to be shareable
  */
 #define VXLAN_F_RCV_FLAGS               (VXLAN_F_GBP |                  \
                                          VXLAN_F_UDP_ZERO_CSUM6_RX |    \
-                                         VXLAN_F_REMCSUM_RX)
+                                         VXLAN_F_REMCSUM_RX |           \
+                                         VXLAN_F_REMCSUM_NOPARTIAL)
 
 struct vxlan_sock *vxlan_sock_add(struct net *net, __be16 port,
                                   vxlan_rcv_t *rcv, void *data,
diff --git a/include/uapi/linux/fou.h b/include/uapi/linux/fou.h
index 8df06894da23..c303588bb767 100644
--- a/include/uapi/linux/fou.h
+++ b/include/uapi/linux/fou.h
@@ -14,6 +14,7 @@ enum {
         FOU_ATTR_AF,                            /* u8 */
         FOU_ATTR_IPPROTO,                       /* u8 */
         FOU_ATTR_TYPE,                          /* u8 */
+        FOU_ATTR_REMCSUM_NOPARTIAL,             /* flag */
 
         __FOU_ATTR_MAX,
 };
diff --git a/include/uapi/linux/if_link.h b/include/uapi/linux/if_link.h
index 0deee3eeddbf..dfd0bb22e554 100644
--- a/include/uapi/linux/if_link.h
+++ b/include/uapi/linux/if_link.h
@@ -374,6 +374,7 @@ enum {
         IFLA_VXLAN_REMCSUM_TX,
         IFLA_VXLAN_REMCSUM_RX,
         IFLA_VXLAN_GBP,
+        IFLA_VXLAN_REMCSUM_NOPARTIAL,
         __IFLA_VXLAN_MAX
 };
 #define IFLA_VXLAN_MAX  (__IFLA_VXLAN_MAX - 1)