2 * IPV4 GSO/GRO offload support
3 * Linux INET implementation
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version
8 * 2 of the License, or (at your option) any later version.
13 #include <linux/skbuff.h>
14 #include <linux/init.h>
15 #include <net/protocol.h>
18 static struct sk_buff
*gre_gso_segment(struct sk_buff
*skb
,
19 netdev_features_t features
)
21 int tnl_hlen
= skb_inner_mac_header(skb
) - skb_transport_header(skb
);
22 struct sk_buff
*segs
= ERR_PTR(-EINVAL
);
23 u16 mac_offset
= skb
->mac_header
;
24 __be16 protocol
= skb
->protocol
;
25 u16 mac_len
= skb
->mac_len
;
26 int gre_offset
, outer_hlen
;
29 if (unlikely(skb_shinfo(skb
)->gso_type
&
41 if (!skb
->encapsulation
)
44 if (unlikely(tnl_hlen
< sizeof(struct gre_base_hdr
)))
47 if (unlikely(!pskb_may_pull(skb
, tnl_hlen
)))
50 /* setup inner skb. */
51 skb
->encapsulation
= 0;
52 __skb_pull(skb
, tnl_hlen
);
53 skb_reset_mac_header(skb
);
54 skb_set_network_header(skb
, skb_inner_network_offset(skb
));
55 skb
->mac_len
= skb_inner_network_offset(skb
);
56 skb
->protocol
= skb
->inner_protocol
;
58 need_csum
= !!(skb_shinfo(skb
)->gso_type
& SKB_GSO_GRE_CSUM
);
59 skb
->encap_hdr_csum
= need_csum
;
61 features
&= skb
->dev
->hw_enc_features
;
63 /* segment inner packet. */
64 segs
= skb_mac_gso_segment(skb
, features
);
65 if (IS_ERR_OR_NULL(segs
)) {
66 skb_gso_error_unwind(skb
, protocol
, tnl_hlen
, mac_offset
,
71 outer_hlen
= skb_tnl_header_len(skb
);
72 gre_offset
= outer_hlen
- tnl_hlen
;
75 struct gre_base_hdr
*greh
;
78 skb_reset_inner_headers(skb
);
79 skb
->encapsulation
= 1;
81 skb
->mac_len
= mac_len
;
82 skb
->protocol
= protocol
;
84 __skb_push(skb
, outer_hlen
);
85 skb_reset_mac_header(skb
);
86 skb_set_network_header(skb
, mac_len
);
87 skb_set_transport_header(skb
, gre_offset
);
92 greh
= (struct gre_base_hdr
*)skb_transport_header(skb
);
93 pcsum
= (__be32
*)(greh
+ 1);
96 *(__sum16
*)pcsum
= gso_make_checksum(skb
, 0);
97 } while ((skb
= skb
->next
));
102 static struct sk_buff
**gre_gro_receive(struct sk_buff
**head
,
105 struct sk_buff
**pp
= NULL
;
107 const struct gre_base_hdr
*greh
;
108 unsigned int hlen
, grehlen
;
111 struct packet_offload
*ptype
;
114 off
= skb_gro_offset(skb
);
115 hlen
= off
+ sizeof(*greh
);
116 greh
= skb_gro_header_fast(skb
, off
);
117 if (skb_gro_header_hard(skb
, hlen
)) {
118 greh
= skb_gro_header_slow(skb
, hlen
, off
);
123 /* Only support version 0 and K (key), C (csum) flags. Note that
124 * although the support for the S (seq#) flag can be added easily
125 * for GRO, this is problematic for GSO hence can not be enabled
126 * here because a GRO pkt may end up in the forwarding path, thus
127 * requiring GSO support to break it up correctly.
129 if ((greh
->flags
& ~(GRE_KEY
|GRE_CSUM
)) != 0)
132 type
= greh
->protocol
;
135 ptype
= gro_find_receive_by_type(type
);
139 grehlen
= GRE_HEADER_SECTION
;
141 if (greh
->flags
& GRE_KEY
)
142 grehlen
+= GRE_HEADER_SECTION
;
144 if (greh
->flags
& GRE_CSUM
)
145 grehlen
+= GRE_HEADER_SECTION
;
147 hlen
= off
+ grehlen
;
148 if (skb_gro_header_hard(skb
, hlen
)) {
149 greh
= skb_gro_header_slow(skb
, hlen
, off
);
154 /* Don't bother verifying checksum if we're going to flush anyway. */
155 if ((greh
->flags
& GRE_CSUM
) && !NAPI_GRO_CB(skb
)->flush
) {
156 if (skb_gro_checksum_simple_validate(skb
))
159 skb_gro_checksum_try_convert(skb
, IPPROTO_GRE
, 0,
160 null_compute_pseudo
);
165 for (p
= *head
; p
; p
= p
->next
) {
166 const struct gre_base_hdr
*greh2
;
168 if (!NAPI_GRO_CB(p
)->same_flow
)
171 /* The following checks are needed to ensure only pkts
172 * from the same tunnel are considered for aggregation.
173 * The criteria for "the same tunnel" includes:
174 * 1) same version (we only support version 0 here)
175 * 2) same protocol (we only support ETH_P_IP for now)
176 * 3) same set of flags
177 * 4) same key if the key field is present.
179 greh2
= (struct gre_base_hdr
*)(p
->data
+ off
);
181 if (greh2
->flags
!= greh
->flags
||
182 greh2
->protocol
!= greh
->protocol
) {
183 NAPI_GRO_CB(p
)->same_flow
= 0;
186 if (greh
->flags
& GRE_KEY
) {
188 if (*(__be32
*)(greh2
+1) != *(__be32
*)(greh
+1)) {
189 NAPI_GRO_CB(p
)->same_flow
= 0;
195 skb_gro_pull(skb
, grehlen
);
197 /* Adjusted NAPI_GRO_CB(skb)->csum after skb_gro_pull()*/
198 skb_gro_postpull_rcsum(skb
, greh
, grehlen
);
200 pp
= ptype
->callbacks
.gro_receive(head
, skb
);
205 NAPI_GRO_CB(skb
)->flush
|= flush
;
210 static int gre_gro_complete(struct sk_buff
*skb
, int nhoff
)
212 struct gre_base_hdr
*greh
= (struct gre_base_hdr
*)(skb
->data
+ nhoff
);
213 struct packet_offload
*ptype
;
214 unsigned int grehlen
= sizeof(*greh
);
218 skb
->encapsulation
= 1;
219 skb_shinfo(skb
)->gso_type
= SKB_GSO_GRE
;
221 type
= greh
->protocol
;
222 if (greh
->flags
& GRE_KEY
)
223 grehlen
+= GRE_HEADER_SECTION
;
225 if (greh
->flags
& GRE_CSUM
)
226 grehlen
+= GRE_HEADER_SECTION
;
229 ptype
= gro_find_complete_by_type(type
);
231 err
= ptype
->callbacks
.gro_complete(skb
, nhoff
+ grehlen
);
235 skb_set_inner_mac_header(skb
, nhoff
+ grehlen
);
240 static const struct net_offload gre_offload
= {
242 .gso_segment
= gre_gso_segment
,
243 .gro_receive
= gre_gro_receive
,
244 .gro_complete
= gre_gro_complete
,
248 static int __init
gre_offload_init(void)
250 return inet_add_offload(&gre_offload
, IPPROTO_GRE
);
252 device_initcall(gre_offload_init
);