]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - net/ipv6/ip6_offload.c
net: Fix possible wrong checksum generation.
[~shefty/rdma-dev.git] / net / ipv6 / ip6_offload.c
1 /*
2  *      IPV6 GSO/GRO offload support
3  *      Linux INET6 implementation
4  *
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.
9  */
10
11 #include <linux/kernel.h>
12 #include <linux/socket.h>
13 #include <linux/netdevice.h>
14 #include <linux/skbuff.h>
15 #include <linux/printk.h>
16
17 #include <net/protocol.h>
18 #include <net/ipv6.h>
19
20 #include "ip6_offload.h"
21
22 static int ipv6_gso_pull_exthdrs(struct sk_buff *skb, int proto)
23 {
24         const struct net_offload *ops = NULL;
25
26         for (;;) {
27                 struct ipv6_opt_hdr *opth;
28                 int len;
29
30                 if (proto != NEXTHDR_HOP) {
31                         ops = rcu_dereference(inet6_offloads[proto]);
32
33                         if (unlikely(!ops))
34                                 break;
35
36                         if (!(ops->flags & INET6_PROTO_GSO_EXTHDR))
37                                 break;
38                 }
39
40                 if (unlikely(!pskb_may_pull(skb, 8)))
41                         break;
42
43                 opth = (void *)skb->data;
44                 len = ipv6_optlen(opth);
45
46                 if (unlikely(!pskb_may_pull(skb, len)))
47                         break;
48
49                 proto = opth->nexthdr;
50                 __skb_pull(skb, len);
51         }
52
53         return proto;
54 }
55
56 static int ipv6_gso_send_check(struct sk_buff *skb)
57 {
58         const struct ipv6hdr *ipv6h;
59         const struct net_offload *ops;
60         int err = -EINVAL;
61
62         if (unlikely(!pskb_may_pull(skb, sizeof(*ipv6h))))
63                 goto out;
64
65         ipv6h = ipv6_hdr(skb);
66         __skb_pull(skb, sizeof(*ipv6h));
67         err = -EPROTONOSUPPORT;
68
69         rcu_read_lock();
70         ops = rcu_dereference(inet6_offloads[
71                 ipv6_gso_pull_exthdrs(skb, ipv6h->nexthdr)]);
72
73         if (likely(ops && ops->callbacks.gso_send_check)) {
74                 skb_reset_transport_header(skb);
75                 err = ops->callbacks.gso_send_check(skb);
76         }
77         rcu_read_unlock();
78
79 out:
80         return err;
81 }
82
83 static struct sk_buff *ipv6_gso_segment(struct sk_buff *skb,
84         netdev_features_t features)
85 {
86         struct sk_buff *segs = ERR_PTR(-EINVAL);
87         struct ipv6hdr *ipv6h;
88         const struct net_offload *ops;
89         int proto;
90         struct frag_hdr *fptr;
91         unsigned int unfrag_ip6hlen;
92         u8 *prevhdr;
93         int offset = 0;
94
95         if (!(features & NETIF_F_V6_CSUM))
96                 features &= ~NETIF_F_SG;
97
98         if (unlikely(skb_shinfo(skb)->gso_type &
99                      ~(SKB_GSO_UDP |
100                        SKB_GSO_DODGY |
101                        SKB_GSO_TCP_ECN |
102                        SKB_GSO_TCPV6 |
103                        0)))
104                 goto out;
105
106         if (unlikely(!pskb_may_pull(skb, sizeof(*ipv6h))))
107                 goto out;
108
109         ipv6h = ipv6_hdr(skb);
110         __skb_pull(skb, sizeof(*ipv6h));
111         segs = ERR_PTR(-EPROTONOSUPPORT);
112
113         proto = ipv6_gso_pull_exthdrs(skb, ipv6h->nexthdr);
114         rcu_read_lock();
115         ops = rcu_dereference(inet6_offloads[proto]);
116         if (likely(ops && ops->callbacks.gso_segment)) {
117                 skb_reset_transport_header(skb);
118                 segs = ops->callbacks.gso_segment(skb, features);
119         }
120         rcu_read_unlock();
121
122         if (IS_ERR(segs))
123                 goto out;
124
125         for (skb = segs; skb; skb = skb->next) {
126                 ipv6h = ipv6_hdr(skb);
127                 ipv6h->payload_len = htons(skb->len - skb->mac_len -
128                                            sizeof(*ipv6h));
129                 if (proto == IPPROTO_UDP) {
130                         unfrag_ip6hlen = ip6_find_1stfragopt(skb, &prevhdr);
131                         fptr = (struct frag_hdr *)(skb_network_header(skb) +
132                                 unfrag_ip6hlen);
133                         fptr->frag_off = htons(offset);
134                         if (skb->next != NULL)
135                                 fptr->frag_off |= htons(IP6_MF);
136                         offset += (ntohs(ipv6h->payload_len) -
137                                    sizeof(struct frag_hdr));
138                 }
139         }
140
141 out:
142         return segs;
143 }
144
145 static struct sk_buff **ipv6_gro_receive(struct sk_buff **head,
146                                          struct sk_buff *skb)
147 {
148         const struct net_offload *ops;
149         struct sk_buff **pp = NULL;
150         struct sk_buff *p;
151         struct ipv6hdr *iph;
152         unsigned int nlen;
153         unsigned int hlen;
154         unsigned int off;
155         int flush = 1;
156         int proto;
157         __wsum csum;
158
159         off = skb_gro_offset(skb);
160         hlen = off + sizeof(*iph);
161         iph = skb_gro_header_fast(skb, off);
162         if (skb_gro_header_hard(skb, hlen)) {
163                 iph = skb_gro_header_slow(skb, hlen, off);
164                 if (unlikely(!iph))
165                         goto out;
166         }
167
168         skb_gro_pull(skb, sizeof(*iph));
169         skb_set_transport_header(skb, skb_gro_offset(skb));
170
171         flush += ntohs(iph->payload_len) != skb_gro_len(skb);
172
173         rcu_read_lock();
174         proto = iph->nexthdr;
175         ops = rcu_dereference(inet6_offloads[proto]);
176         if (!ops || !ops->callbacks.gro_receive) {
177                 __pskb_pull(skb, skb_gro_offset(skb));
178                 proto = ipv6_gso_pull_exthdrs(skb, proto);
179                 skb_gro_pull(skb, -skb_transport_offset(skb));
180                 skb_reset_transport_header(skb);
181                 __skb_push(skb, skb_gro_offset(skb));
182
183                 ops = rcu_dereference(inet6_offloads[proto]);
184                 if (!ops || !ops->callbacks.gro_receive)
185                         goto out_unlock;
186
187                 iph = ipv6_hdr(skb);
188         }
189
190         NAPI_GRO_CB(skb)->proto = proto;
191
192         flush--;
193         nlen = skb_network_header_len(skb);
194
195         for (p = *head; p; p = p->next) {
196                 const struct ipv6hdr *iph2;
197                 __be32 first_word; /* <Version:4><Traffic_Class:8><Flow_Label:20> */
198
199                 if (!NAPI_GRO_CB(p)->same_flow)
200                         continue;
201
202                 iph2 = ipv6_hdr(p);
203                 first_word = *(__be32 *)iph ^ *(__be32 *)iph2 ;
204
205                 /* All fields must match except length and Traffic Class. */
206                 if (nlen != skb_network_header_len(p) ||
207                     (first_word & htonl(0xF00FFFFF)) ||
208                     memcmp(&iph->nexthdr, &iph2->nexthdr,
209                            nlen - offsetof(struct ipv6hdr, nexthdr))) {
210                         NAPI_GRO_CB(p)->same_flow = 0;
211                         continue;
212                 }
213                 /* flush if Traffic Class fields are different */
214                 NAPI_GRO_CB(p)->flush |= !!(first_word & htonl(0x0FF00000));
215                 NAPI_GRO_CB(p)->flush |= flush;
216         }
217
218         NAPI_GRO_CB(skb)->flush |= flush;
219
220         csum = skb->csum;
221         skb_postpull_rcsum(skb, iph, skb_network_header_len(skb));
222
223         pp = ops->callbacks.gro_receive(head, skb);
224
225         skb->csum = csum;
226
227 out_unlock:
228         rcu_read_unlock();
229
230 out:
231         NAPI_GRO_CB(skb)->flush |= flush;
232
233         return pp;
234 }
235
236 static int ipv6_gro_complete(struct sk_buff *skb)
237 {
238         const struct net_offload *ops;
239         struct ipv6hdr *iph = ipv6_hdr(skb);
240         int err = -ENOSYS;
241
242         iph->payload_len = htons(skb->len - skb_network_offset(skb) -
243                                  sizeof(*iph));
244
245         rcu_read_lock();
246         ops = rcu_dereference(inet6_offloads[NAPI_GRO_CB(skb)->proto]);
247         if (WARN_ON(!ops || !ops->callbacks.gro_complete))
248                 goto out_unlock;
249
250         err = ops->callbacks.gro_complete(skb);
251
252 out_unlock:
253         rcu_read_unlock();
254
255         return err;
256 }
257
258 static struct packet_offload ipv6_packet_offload __read_mostly = {
259         .type = cpu_to_be16(ETH_P_IPV6),
260         .callbacks = {
261                 .gso_send_check = ipv6_gso_send_check,
262                 .gso_segment = ipv6_gso_segment,
263                 .gro_receive = ipv6_gro_receive,
264                 .gro_complete = ipv6_gro_complete,
265         },
266 };
267
268 static int __init ipv6_offload_init(void)
269 {
270
271         if (tcpv6_offload_init() < 0)
272                 pr_crit("%s: Cannot add TCP protocol offload\n", __func__);
273         if (udp_offload_init() < 0)
274                 pr_crit("%s: Cannot add UDP protocol offload\n", __func__);
275         if (ipv6_exthdrs_offload_init() < 0)
276                 pr_crit("%s: Cannot add EXTHDRS protocol offload\n", __func__);
277
278         dev_add_offload(&ipv6_packet_offload);
279         return 0;
280 }
281
282 fs_initcall(ipv6_offload_init);