datapath: Enable OVS GSO to be used up to 3.18 if necessary.
[cascardo/ovs.git] / datapath / linux / compat / gso.c
1 /*
2  * Copyright (c) 2007-2013 Nicira, Inc.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of version 2 of the GNU General Public
6  * License as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful, but
9  * WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11  * General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program; if not, write to the Free Software
15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
16  * 02110-1301, USA
17  */
18
19 #include <linux/version.h>
20
21 #include <linux/module.h>
22 #include <linux/if.h>
23 #include <linux/if_tunnel.h>
24 #include <linux/if_vlan.h>
25 #include <linux/icmp.h>
26 #include <linux/in.h>
27 #include <linux/ip.h>
28 #include <linux/kernel.h>
29 #include <linux/kmod.h>
30 #include <linux/netdevice.h>
31 #include <linux/skbuff.h>
32 #include <linux/spinlock.h>
33
34 #include <net/gre.h>
35 #include <net/icmp.h>
36 #include <net/mpls.h>
37 #include <net/protocol.h>
38 #include <net/route.h>
39 #include <net/xfrm.h>
40
41 #include "gso.h"
42 #include "vlan.h"
43
44 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37) && \
45         !defined(HAVE_VLAN_BUG_WORKAROUND)
46 #include <linux/module.h>
47
48 static int vlan_tso __read_mostly;
49 module_param(vlan_tso, int, 0644);
50 MODULE_PARM_DESC(vlan_tso, "Enable TSO for VLAN packets");
51 #else
52 #define vlan_tso true
53 #endif
54
55 #if LINUX_VERSION_CODE < KERNEL_VERSION(3,16,0)
56 static bool dev_supports_vlan_tx(struct net_device *dev)
57 {
58 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37)
59         return true;
60 #elif defined(HAVE_VLAN_BUG_WORKAROUND)
61         return dev->features & NETIF_F_HW_VLAN_TX;
62 #else
63         /* Assume that the driver is buggy. */
64         return false;
65 #endif
66 }
67
68 /* Strictly this is not needed and will be optimised out
69  * as this code is guarded by if LINUX_VERSION_CODE < KERNEL_VERSION(3,16,0).
70  * It is here to make things explicit should the compatibility
71  * code be extended in some way prior extending its life-span
72  * beyond v3.16.
73  */
74 static bool supports_mpls_gso(void)
75 {
76 /* MPLS GSO was introduced in v3.11, however it was not correctly
77  * activated using mpls_features until v3.16. */
78 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3,16,0)
79         return true;
80 #else
81         return false;
82 #endif
83 }
84
85 int rpl_dev_queue_xmit(struct sk_buff *skb)
86 {
87 #undef dev_queue_xmit
88         int err = -ENOMEM;
89         bool vlan, mpls;
90
91         vlan = mpls = false;
92
93         /* Avoid traversing any VLAN tags that are present to determine if
94          * the ethtype is MPLS. Instead compare the mac_len (end of L2) and
95          * skb_network_offset() (beginning of L3) whose inequality will
96          * indicate the presence of an MPLS label stack. */
97         if (skb->mac_len != skb_network_offset(skb) && !supports_mpls_gso())
98                 mpls = true;
99
100         if (skb_vlan_tag_present(skb) && !dev_supports_vlan_tx(skb->dev))
101                 vlan = true;
102
103         if (vlan || mpls) {
104                 int features;
105
106                 features = netif_skb_features(skb);
107
108                 if (vlan) {
109                         if (!vlan_tso)
110                                 features &= ~(NETIF_F_TSO | NETIF_F_TSO6 |
111                                               NETIF_F_UFO | NETIF_F_FSO);
112
113                         skb = vlan_insert_tag_set_proto(skb, skb->vlan_proto,
114                                                         skb_vlan_tag_get(skb));
115                         if (unlikely(!skb))
116                                 return err;
117                         vlan_set_tci(skb, 0);
118                 }
119
120                 /* As of v3.11 the kernel provides an mpls_features field in
121                  * struct net_device which allows devices to advertise which
122                  * features its supports for MPLS. This value defaults to
123                  * NETIF_F_SG and as of v3.16.
124                  *
125                  * This compatibility code is intended for kernels older
126                  * than v3.16 that do not support MPLS GSO and do not
127                  * use mpls_features. Thus this code uses NETIF_F_SG
128                  * directly in place of mpls_features.
129                  */
130                 if (mpls)
131                         features &= NETIF_F_SG;
132
133                 if (netif_needs_gso(skb, features)) {
134                         struct sk_buff *nskb;
135
136                         nskb = skb_gso_segment(skb, features);
137                         if (!nskb) {
138                                 if (unlikely(skb_cloned(skb) &&
139                                     pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
140                                         goto drop;
141
142                                 skb_shinfo(skb)->gso_type &= ~SKB_GSO_DODGY;
143                                 goto xmit;
144                         }
145
146                         if (IS_ERR(nskb)) {
147                                 err = PTR_ERR(nskb);
148                                 goto drop;
149                         }
150                         consume_skb(skb);
151                         skb = nskb;
152
153                         do {
154                                 nskb = skb->next;
155                                 skb->next = NULL;
156                                 err = dev_queue_xmit(skb);
157                                 skb = nskb;
158                         } while (skb);
159
160                         return err;
161                 }
162         }
163 xmit:
164         return dev_queue_xmit(skb);
165
166 drop:
167         kfree_skb(skb);
168         return err;
169 }
170 #endif /* 3.16 */
171
172 #if LINUX_VERSION_CODE < KERNEL_VERSION(3,18,0)
173 static __be16 __skb_network_protocol(struct sk_buff *skb)
174 {
175         __be16 type = skb->protocol;
176         int vlan_depth = ETH_HLEN;
177
178         while (type == htons(ETH_P_8021Q) || type == htons(ETH_P_8021AD)) {
179                 struct vlan_hdr *vh;
180
181                 if (unlikely(!pskb_may_pull(skb, vlan_depth + VLAN_HLEN)))
182                         return 0;
183
184                 vh = (struct vlan_hdr *)(skb->data + vlan_depth);
185                 type = vh->h_vlan_encapsulated_proto;
186                 vlan_depth += VLAN_HLEN;
187         }
188
189         if (eth_p_mpls(type))
190                 type = ovs_skb_get_inner_protocol(skb);
191
192         return type;
193 }
194
195 static struct sk_buff *tnl_skb_gso_segment(struct sk_buff *skb,
196                                            netdev_features_t features,
197                                            bool tx_path)
198 {
199         struct iphdr *iph = ip_hdr(skb);
200         int pkt_hlen = skb_inner_network_offset(skb); /* inner l2 + tunnel hdr. */
201         int mac_offset = skb_inner_mac_offset(skb);
202         struct sk_buff *skb1 = skb;
203         struct sk_buff *segs;
204         __be16 proto = skb->protocol;
205         char cb[sizeof(skb->cb)];
206
207         /* setup whole inner packet to get protocol. */
208         __skb_pull(skb, mac_offset);
209         skb->protocol = __skb_network_protocol(skb);
210
211         /* setup l3 packet to gso, to get around segmentation bug on older kernel.*/
212         __skb_pull(skb, (pkt_hlen - mac_offset));
213         skb_reset_mac_header(skb);
214         skb_reset_network_header(skb);
215         skb_reset_transport_header(skb);
216
217         /* From 3.9 kernel skb->cb is used by skb gso. Therefore
218          * make copy of it to restore it back. */
219         memcpy(cb, skb->cb, sizeof(cb));
220
221         segs = __skb_gso_segment(skb, 0, tx_path);
222         if (!segs || IS_ERR(segs))
223                 goto free;
224
225         skb = segs;
226         while (skb) {
227                 __skb_push(skb, pkt_hlen);
228                 skb_reset_mac_header(skb);
229                 skb_reset_network_header(skb);
230                 skb_set_transport_header(skb, sizeof(struct iphdr));
231                 skb->mac_len = 0;
232
233                 memcpy(ip_hdr(skb), iph, pkt_hlen);
234                 memcpy(skb->cb, cb, sizeof(cb));
235                 OVS_GSO_CB(skb)->fix_segment(skb);
236
237                 skb->protocol = proto;
238                 skb = skb->next;
239         }
240 free:
241         consume_skb(skb1);
242         return segs;
243 }
244
245 static int output_ip(struct sk_buff *skb)
246 {
247         int ret = NETDEV_TX_OK;
248         int err;
249
250         memset(IPCB(skb), 0, sizeof(*IPCB(skb)));
251
252 #undef ip_local_out
253         err = ip_local_out(skb);
254         if (unlikely(net_xmit_eval(err)))
255                 ret = err;
256
257         return ret;
258 }
259
260 int rpl_ip_local_out(struct sk_buff *skb)
261 {
262         int ret = NETDEV_TX_OK;
263         int id = -1;
264
265         if (!OVS_GSO_CB(skb)->fix_segment)
266                 return output_ip(skb);
267
268         if (skb_is_gso(skb)) {
269                 struct iphdr *iph;
270
271                 iph = ip_hdr(skb);
272                 id = ntohs(iph->id);
273                 skb = tnl_skb_gso_segment(skb, 0, false);
274                 if (!skb || IS_ERR(skb))
275                         return 0;
276         }  else if (skb->ip_summed == CHECKSUM_PARTIAL) {
277                 int err;
278
279                 err = skb_checksum_help(skb);
280                 if (unlikely(err))
281                         return 0;
282         }
283
284         while (skb) {
285                 struct sk_buff *next_skb = skb->next;
286                 struct iphdr *iph;
287
288                 skb->next = NULL;
289
290                 iph = ip_hdr(skb);
291                 if (id >= 0)
292                         iph->id = htons(id++);
293
294                 ret = output_ip(skb);
295                 skb = next_skb;
296         }
297         return ret;
298 }
299 #endif /* 3.18 */