]> git.proxmox.com Git - mirror_ovs.git/blob - datapath/linux/compat/ip6_gre.c
projects / mirror_ovs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
datapath: ip6_gre: Fix ip6erspan hlen calculation
[mirror_ovs.git] / datapath / linux / compat / ip6_gre.c
1 /*
2 * GRE over IPv6 protocol decoder.
3 *
4 * Authors: Dmitry Kozlov (xeb@mail.ru)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
15 #ifndef USE_UPSTREAM_TUNNEL
16 #include <linux/capability.h>
17 #include <linux/module.h>
18 #include <linux/types.h>
19 #include <linux/kernel.h>
20 #include <linux/slab.h>
21 #include <linux/uaccess.h>
22 #include <linux/skbuff.h>
23 #include <linux/netdevice.h>
24 #include <linux/in.h>
25 #include <linux/tcp.h>
26 #include <linux/udp.h>
27 #include <linux/if_arp.h>
28 #include <linux/init.h>
29 #include <linux/in6.h>
30 #include <linux/inetdevice.h>
31 #include <linux/igmp.h>
32 #include <linux/netfilter_ipv4.h>
33 #include <linux/etherdevice.h>
34 #include <linux/if_ether.h>
35 #include <linux/hash.h>
36 #include <linux/if_tunnel.h>
37 #include <linux/ip6_tunnel.h>
38
39 #include <net/sock.h>
40 #include <net/ip.h>
41 #include <net/ip_tunnels.h>
42 #include <net/icmp.h>
43 #include <net/protocol.h>
44 #include <net/addrconf.h>
45 #include <net/arp.h>
46 #include <net/checksum.h>
47 #include <net/dsfield.h>
48 #include <net/inet_ecn.h>
49 #include <net/xfrm.h>
50 #include <net/net_namespace.h>
51 #include <net/netns/generic.h>
52 #include <net/rtnetlink.h>
53
54 #include <net/ipv6.h>
55 #include <net/ip6_fib.h>
56 #include <net/ip6_route.h>
57 #include <net/ip6_tunnel.h>
58 #include <net/gre.h>
59 #include <net/erspan.h>
60 #include <net/dst_metadata.h>
61
62 #include "vport-netdev.h"
63
64 #define IP6_GRE_HASH_SIZE_SHIFT 5
65 #define IP6_GRE_HASH_SIZE (1 << IP6_GRE_HASH_SIZE_SHIFT)
66
67 static unsigned int ip6gre_net_id __read_mostly;
68 struct ip6gre_net {
69 struct ip6_tnl __rcu *tunnels[4][IP6_GRE_HASH_SIZE];
70
71 struct ip6_tnl __rcu *collect_md_tun;
72 struct net_device *fb_tunnel_dev;
73 };
74
75 static struct rtnl_link_ops ip6gre_link_ops __read_mostly;
76 static struct rtnl_link_ops ip6gre_tap_ops __read_mostly;
77 static struct rtnl_link_ops ip6erspan_tap_ops __read_mostly;
78 static int ip6gre_tunnel_init(struct net_device *dev);
79 static void ip6gre_tunnel_setup(struct net_device *dev);
80 static void ip6gre_tunnel_link(struct ip6gre_net *ign, struct ip6_tnl *t);
81 static void ip6gre_tnl_link_config(struct ip6_tnl *t, int set_mtu);
82 static void ip6erspan_tnl_link_config(struct ip6_tnl *t, int set_mtu);
83
84 #define gre_calc_hlen rpl_ip_gre_calc_hlen
85 static int rpl_ip_gre_calc_hlen(__be16 o_flags)
86 {
87 int addend = 4;
88
89 if (o_flags & TUNNEL_CSUM)
90 addend += 4;
91 if (o_flags & TUNNEL_KEY)
92 addend += 4;
93 if (o_flags & TUNNEL_SEQ)
94 addend += 4;
95 return addend;
96 }
97
98 /* Tunnel hash table */
99
100 /*
101 4 hash tables:
102
103 3: (remote,local)
104 2: (remote,*)
105 1: (*,local)
106 0: (*,*)
107
108 We require exact key match i.e. if a key is present in packet
109 it will match only tunnel with the same key; if it is not present,
110 it will match only keyless tunnel.
111
112 All keysless packets, if not matched configured keyless tunnels
113 will match fallback tunnel.
114 */
115
116 #define HASH_KEY(key) (((__force u32)key^((__force u32)key>>4))&(IP6_GRE_HASH_SIZE - 1))
117 static u32 HASH_ADDR(const struct in6_addr *addr)
118 {
119 u32 hash = ipv6_addr_hash(addr);
120
121 return hash_32(hash, IP6_GRE_HASH_SIZE_SHIFT);
122 }
123
124 #define tunnels_r_l tunnels[3]
125 #define tunnels_r tunnels[2]
126 #define tunnels_l tunnels[1]
127 #define tunnels_wc tunnels[0]
128
129 /* Given src, dst and key, find appropriate for input tunnel. */
130
131 static struct ip6_tnl *ip6gre_tunnel_lookup(struct net_device *dev,
132 const struct in6_addr *remote, const struct in6_addr *local,
133 __be32 key, __be16 gre_proto)
134 {
135 struct net *net = dev_net(dev);
136 int link = dev->ifindex;
137 unsigned int h0 = HASH_ADDR(remote);
138 unsigned int h1 = HASH_KEY(key);
139 struct ip6_tnl *t, *cand = NULL;
140 struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);
141 int dev_type = (gre_proto == htons(ETH_P_TEB) ||
142 gre_proto == htons(ETH_P_ERSPAN) ||
143 gre_proto == htons(ETH_P_ERSPAN2)) ?
144 ARPHRD_ETHER : ARPHRD_IP6GRE;
145 int score, cand_score = 4;
146
147 for_each_ip_tunnel_rcu(t, ign->tunnels_r_l[h0 ^ h1]) {
148 if (!ipv6_addr_equal(local, &t->parms.laddr) ||
149 !ipv6_addr_equal(remote, &t->parms.raddr) ||
150 key != t->parms.i_key ||
151 !(t->dev->flags & IFF_UP))
152 continue;
153
154 if (t->dev->type != ARPHRD_IP6GRE &&
155 t->dev->type != dev_type)
156 continue;
157
158 score = 0;
159 if (t->parms.link != link)
160 score |= 1;
161 if (t->dev->type != dev_type)
162 score |= 2;
163 if (score == 0)
164 return t;
165
166 if (score < cand_score) {
167 cand = t;
168 cand_score = score;
169 }
170 }
171
172 for_each_ip_tunnel_rcu(t, ign->tunnels_r[h0 ^ h1]) {
173 if (!ipv6_addr_equal(remote, &t->parms.raddr) ||
174 key != t->parms.i_key ||
175 !(t->dev->flags & IFF_UP))
176 continue;
177
178 if (t->dev->type != ARPHRD_IP6GRE &&
179 t->dev->type != dev_type)
180 continue;
181
182 score = 0;
183 if (t->parms.link != link)
184 score |= 1;
185 if (t->dev->type != dev_type)
186 score |= 2;
187 if (score == 0)
188 return t;
189
190 if (score < cand_score) {
191 cand = t;
192 cand_score = score;
193 }
194 }
195
196 for_each_ip_tunnel_rcu(t, ign->tunnels_l[h1]) {
197 if ((!ipv6_addr_equal(local, &t->parms.laddr) &&
198 (!ipv6_addr_equal(local, &t->parms.raddr) ||
199 !ipv6_addr_is_multicast(local))) ||
200 key != t->parms.i_key ||
201 !(t->dev->flags & IFF_UP))
202 continue;
203
204 if (t->dev->type != ARPHRD_IP6GRE &&
205 t->dev->type != dev_type)
206 continue;
207
208 score = 0;
209 if (t->parms.link != link)
210 score |= 1;
211 if (t->dev->type != dev_type)
212 score |= 2;
213 if (score == 0)
214 return t;
215
216 if (score < cand_score) {
217 cand = t;
218 cand_score = score;
219 }
220 }
221
222 for_each_ip_tunnel_rcu(t, ign->tunnels_wc[h1]) {
223 if (t->parms.i_key != key ||
224 !(t->dev->flags & IFF_UP))
225 continue;
226
227 if (t->dev->type != ARPHRD_IP6GRE &&
228 t->dev->type != dev_type)
229 continue;
230
231 score = 0;
232 if (t->parms.link != link)
233 score |= 1;
234 if (t->dev->type != dev_type)
235 score |= 2;
236 if (score == 0)
237 return t;
238
239 if (score < cand_score) {
240 cand = t;
241 cand_score = score;
242 }
243 }
244
245 if (cand)
246 return cand;
247
248 t = rcu_dereference(ign->collect_md_tun);
249 if (t && t->dev->flags & IFF_UP)
250 return t;
251
252 dev = ign->fb_tunnel_dev;
253 if (dev->flags & IFF_UP)
254 return netdev_priv(dev);
255
256 return NULL;
257 }
258
259 static struct ip6_tnl __rcu **__ip6gre_bucket(struct ip6gre_net *ign,
260 const struct __ip6_tnl_parm *p)
261 {
262 const struct in6_addr *remote = &p->raddr;
263 const struct in6_addr *local = &p->laddr;
264 unsigned int h = HASH_KEY(p->i_key);
265 int prio = 0;
266
267 if (!ipv6_addr_any(local))
268 prio |= 1;
269 if (!ipv6_addr_any(remote) && !ipv6_addr_is_multicast(remote)) {
270 prio |= 2;
271 h ^= HASH_ADDR(remote);
272 }
273
274 return &ign->tunnels[prio][h];
275 }
276
277 static inline struct ip6_tnl __rcu **ip6gre_bucket(struct ip6gre_net *ign,
278 const struct ip6_tnl *t)
279 {
280 return __ip6gre_bucket(ign, &t->parms);
281 }
282
283 static void ip6gre_tunnel_link(struct ip6gre_net *ign, struct ip6_tnl *t)
284 {
285 struct ip6_tnl __rcu **tp = ip6gre_bucket(ign, t);
286
287 if (t->parms.collect_md)
288 rcu_assign_pointer(ign->collect_md_tun, t);
289
290 rcu_assign_pointer(t->next, rtnl_dereference(*tp));
291 rcu_assign_pointer(*tp, t);
292 }
293
294 static void ip6gre_tunnel_unlink(struct ip6gre_net *ign, struct ip6_tnl *t)
295 {
296 struct ip6_tnl __rcu **tp;
297 struct ip6_tnl *iter;
298
299 if (t->parms.collect_md)
300 rcu_assign_pointer(ign->collect_md_tun, NULL);
301
302 for (tp = ip6gre_bucket(ign, t);
303 (iter = rtnl_dereference(*tp)) != NULL;
304 tp = &iter->next) {
305 if (t == iter) {
306 rcu_assign_pointer(*tp, t->next);
307 break;
308 }
309 }
310 }
311
312 static struct ip6_tnl *ip6gre_tunnel_find(struct net *net,
313 const struct __ip6_tnl_parm *parms,
314 int type)
315 {
316 const struct in6_addr *remote = &parms->raddr;
317 const struct in6_addr *local = &parms->laddr;
318 __be32 key = parms->i_key;
319 int link = parms->link;
320 struct ip6_tnl *t;
321 struct ip6_tnl __rcu **tp;
322 struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);
323
324 for (tp = __ip6gre_bucket(ign, parms);
325 (t = rtnl_dereference(*tp)) != NULL;
326 tp = &t->next)
327 if (ipv6_addr_equal(local, &t->parms.laddr) &&
328 ipv6_addr_equal(remote, &t->parms.raddr) &&
329 key == t->parms.i_key &&
330 link == t->parms.link &&
331 type == t->dev->type)
332 break;
333
334 return t;
335 }
336
337 static struct ip6_tnl *ip6gre_tunnel_locate(struct net *net,
338 const struct __ip6_tnl_parm *parms, int create)
339 {
340 struct ip6_tnl *t, *nt;
341 struct net_device *dev;
342 char name[IFNAMSIZ];
343 struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);
344
345 t = ip6gre_tunnel_find(net, parms, ARPHRD_IP6GRE);
346 if (t && create)
347 return NULL;
348 if (t || !create)
349 return t;
350
351 if (parms->name[0])
352 strlcpy(name, parms->name, IFNAMSIZ);
353 else
354 strcpy(name, "ip6gre%d");
355
356 dev = alloc_netdev(sizeof(*t), name, NET_NAME_UNKNOWN,
357 ip6gre_tunnel_setup);
358 if (!dev)
359 return NULL;
360
361 dev_net_set(dev, net);
362
363 nt = netdev_priv(dev);
364 nt->parms = *parms;
365 dev->rtnl_link_ops = &ip6gre_link_ops;
366
367 nt->dev = dev;
368 nt->net = dev_net(dev);
369
370 if (register_netdevice(dev) < 0)
371 goto failed_free;
372
373 ip6gre_tnl_link_config(nt, 1);
374
375 /* Can use a lockless transmit, unless we generate output sequences */
376 if (!(nt->parms.o_flags & TUNNEL_SEQ))
377 dev->features |= NETIF_F_LLTX;
378
379 dev_hold(dev);
380 ip6gre_tunnel_link(ign, nt);
381 return nt;
382
383 failed_free:
384 free_netdev(dev);
385 return NULL;
386 }
387
388 static void ip6gre_tunnel_uninit(struct net_device *dev)
389 {
390 struct ip6_tnl *t = netdev_priv(dev);
391 struct ip6gre_net *ign = net_generic(t->net, ip6gre_net_id);
392
393 ip6gre_tunnel_unlink(ign, t);
394 dst_cache_reset(&t->dst_cache);
395 dev_put(dev);
396 }
397
398
399 static void ip6gre_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
400 u8 type, u8 code, int offset, __be32 info)
401 {
402 #if 0
403 struct net *net = dev_net(skb->dev);
404 const struct gre_base_hdr *greh;
405 const struct ipv6hdr *ipv6h;
406 int grehlen = sizeof(*greh);
407 struct ip6_tnl *t;
408 int key_off = 0;
409 __be16 flags;
410 __be32 key;
411
412 if (!pskb_may_pull(skb, offset + grehlen))
413 return;
414 greh = (const struct gre_base_hdr *)(skb->data + offset);
415 flags = greh->flags;
416 if (flags & (GRE_VERSION | GRE_ROUTING))
417 return;
418 if (flags & GRE_CSUM)
419 grehlen += 4;
420 if (flags & GRE_KEY) {
421 key_off = grehlen + offset;
422 grehlen += 4;
423 }
424
425 if (!pskb_may_pull(skb, offset + grehlen))
426 return;
427 ipv6h = (const struct ipv6hdr *)skb->data;
428 greh = (const struct gre_base_hdr *)(skb->data + offset);
429 key = key_off ? *(__be32 *)(skb->data + key_off) : 0;
430
431 t = ip6gre_tunnel_lookup(skb->dev, &ipv6h->daddr, &ipv6h->saddr,
432 key, greh->protocol);
433 if (!t)
434 return;
435
436 switch (type) {
437 struct ipv6_tlv_tnl_enc_lim *tel;
438 __u32 teli;
439 case ICMPV6_DEST_UNREACH:
440 net_dbg_ratelimited("%s: Path to destination invalid or inactive!\n",
441 t->parms.name);
442 if (code != ICMPV6_PORT_UNREACH)
443 break;
444 return;
445 case ICMPV6_TIME_EXCEED:
446 if (code == ICMPV6_EXC_HOPLIMIT) {
447 net_dbg_ratelimited("%s: Too small hop limit or routing loop in tunnel!\n",
448 t->parms.name);
449 break;
450 }
451 return;
452 case ICMPV6_PARAMPROB:
453 teli = 0;
454 if (code == ICMPV6_HDR_FIELD)
455 teli = ip6_tnl_parse_tlv_enc_lim(skb, skb->data);
456
457 if (teli && teli == be32_to_cpu(info) - 2) {
458 tel = (struct ipv6_tlv_tnl_enc_lim *) &skb->data[teli];
459 if (tel->encap_limit == 0) {
460 net_dbg_ratelimited("%s: Too small encapsulation limit or routing loop in tunnel!\n",
461 t->parms.name);
462 }
463 } else {
464 net_dbg_ratelimited("%s: Recipient unable to parse tunneled packet!\n",
465 t->parms.name);
466 }
467 return;
468 case ICMPV6_PKT_TOOBIG:
469 ip6_update_pmtu(skb, net, info, 0, 0, sock_net_uid(net, NULL));
470 return;
471 case NDISC_REDIRECT:
472 ip6_redirect(skb, net, skb->dev->ifindex, 0,
473 sock_net_uid(net, NULL));
474 return;
475 }
476
477 if (time_before(jiffies, t->err_time + IP6TUNNEL_ERR_TIMEO))
478 t->err_count++;
479 else
480 t->err_count = 1;
481 t->err_time = jiffies;
482 #endif
483 }
484
485 static struct dst_ops md_dst_ops = {
486 .family = AF_UNSPEC,
487 };
488
489 #ifndef DST_METADATA
490 #define DST_METADATA 0x0080
491 #endif
492
493 static void rpl__metadata_dst_init(struct metadata_dst *md_dst,
494 enum metadata_type type, u8 optslen)
495
496 {
497 struct dst_entry *dst;
498
499 dst = &md_dst->dst;
500 dst_init(dst, &md_dst_ops, NULL, 1, DST_OBSOLETE_NONE,
501 DST_METADATA | DST_NOCOUNT);
502
503 #if 0
504 /* unused in OVS */
505 dst->input = dst_md_discard;
506 dst->output = dst_md_discard_out;
507 #endif
508 memset(dst + 1, 0, sizeof(*md_dst) + optslen - sizeof(*dst));
509 md_dst->type = type;
510 }
511
512 static struct metadata_dst *erspan_rpl_metadata_dst_alloc(u8 optslen, enum metadata_type type,
513 gfp_t flags)
514 {
515 struct metadata_dst *md_dst;
516
517 md_dst = kmalloc(sizeof(*md_dst) + optslen, flags);
518 if (!md_dst)
519 return NULL;
520
521 rpl__metadata_dst_init(md_dst, type, optslen);
522
523 return md_dst;
524 }
525 static inline struct metadata_dst *rpl_tun_rx_dst(int md_size)
526 {
527 struct metadata_dst *tun_dst;
528
529 tun_dst = erspan_rpl_metadata_dst_alloc(md_size, METADATA_IP_TUNNEL, GFP_ATOMIC);
530 if (!tun_dst)
531 return NULL;
532
533 tun_dst->u.tun_info.options_len = 0;
534 tun_dst->u.tun_info.mode = 0;
535 return tun_dst;
536 }
537 static inline
538 struct metadata_dst *rpl__ipv6_tun_set_dst(const struct in6_addr *saddr,
539 const struct in6_addr *daddr,
540 __u8 tos, __u8 ttl,
541 __be16 tp_dst,
542 __be32 label,
543 __be16 flags,
544 __be64 tunnel_id,
545 int md_size)
546 {
547 struct metadata_dst *tun_dst;
548 struct ip_tunnel_info *info;
549
550 tun_dst = rpl_tun_rx_dst(md_size);
551 if (!tun_dst)
552 return NULL;
553
554 info = &tun_dst->u.tun_info;
555 info->mode = IP_TUNNEL_INFO_IPV6;
556 info->key.tun_flags = flags;
557 info->key.tun_id = tunnel_id;
558 info->key.tp_src = 0;
559 info->key.tp_dst = tp_dst;
560
561 info->key.u.ipv6.src = *saddr;
562 info->key.u.ipv6.dst = *daddr;
563
564 info->key.tos = tos;
565 info->key.ttl = ttl;
566 info->key.label = label;
567
568 return tun_dst;
569 }
570
571 static inline struct metadata_dst *rpl_ipv6_tun_rx_dst(struct sk_buff *skb,
572 __be16 flags,
573 __be64 tunnel_id,
574 int md_size)
575 {
576 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
577
578 return rpl__ipv6_tun_set_dst(&ip6h->saddr, &ip6h->daddr,
579 ipv6_get_dsfield(ip6h), ip6h->hop_limit,
580 0, ip6_flowlabel(ip6h), flags, tunnel_id,
581 md_size);
582 }
583
584 static int ip6gre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi)
585 {
586 const struct ipv6hdr *ipv6h;
587 struct ip6_tnl *tunnel;
588
589 ipv6h = ipv6_hdr(skb);
590 tunnel = ip6gre_tunnel_lookup(skb->dev,
591 &ipv6h->saddr, &ipv6h->daddr, tpi->key,
592 tpi->proto);
593 if (tunnel) {
594 struct metadata_dst *tun_dst = NULL;
595 if (tunnel->parms.collect_md) {
596 __be64 tun_id;
597 __be16 flags;
598
599 flags = tpi->flags;
600 tun_id = key32_to_tunnel_id(tpi->key);
601
602 tun_dst = rpl_ipv6_tun_rx_dst(skb, flags, tun_id, 0);
603 if (!tun_dst)
604 return PACKET_REJECT;
605
606 }
607
608 ip6_tnl_rcv(tunnel, skb, tpi, tun_dst, false);
609 kfree(tun_dst);
610 return PACKET_RCVD;
611 }
612
613 return PACKET_RCVD;
614 }
615
616 static int ip6erspan_rcv(struct sk_buff *skb, int gre_hdr_len,
617 struct tnl_ptk_info *tpi)
618 {
619 struct erspan_base_hdr *ershdr;
620 struct erspan_metadata *pkt_md;
621 const struct ipv6hdr *ipv6h;
622 struct erspan_md2 *md2;
623 struct ip6_tnl *tunnel;
624 u8 ver;
625
626 if (unlikely(!pskb_may_pull(skb, sizeof(*ershdr))))
627 return PACKET_REJECT;
628
629 ipv6h = ipv6_hdr(skb);
630 ershdr = (struct erspan_base_hdr *)skb->data;
631 ver = ershdr->ver;
632 tpi->key = cpu_to_be32(get_session_id(ershdr));
633
634 tunnel = ip6gre_tunnel_lookup(skb->dev,
635 &ipv6h->saddr, &ipv6h->daddr, 0,
636 tpi->proto);
637 if (tunnel) {
638 struct metadata_dst *tun_dst = NULL;
639 int len = erspan_hdr_len(ver);
640
641 if (unlikely(!pskb_may_pull(skb, len)))
642 return PACKET_REJECT;
643
644 ershdr = (struct erspan_base_hdr *)skb->data;
645 pkt_md = (struct erspan_metadata *)(ershdr + 1);
646
647 if (__iptunnel_pull_header(skb, len,
648 htons(ETH_P_TEB),
649 false, false) < 0)
650 return PACKET_REJECT;
651
652 if (tunnel->parms.collect_md) {
653 struct ip_tunnel_info *info;
654 struct erspan_metadata *md;
655 __be64 tun_id;
656 __be16 flags;
657
658 tpi->flags |= TUNNEL_KEY;
659 flags = tpi->flags;
660 tun_id = key32_to_tunnel_id(tpi->key);
661
662 tun_dst = rpl_ipv6_tun_rx_dst(skb, flags, tun_id,
663 sizeof(*md));
664 if (!tun_dst)
665 return PACKET_REJECT;
666
667 info = &tun_dst->u.tun_info;
668 md = ip_tunnel_info_opts(info);
669 md->version = ver;
670 md2 = &md->u.md2;
671 memcpy(md2, pkt_md, ver == 1 ? ERSPAN_V1_MDSIZE :
672 ERSPAN_V2_MDSIZE);
673 info->key.tun_flags |= TUNNEL_ERSPAN_OPT;
674 info->options_len = sizeof(*md);
675 }
676
677 ip6_tnl_rcv(tunnel, skb, tpi, tun_dst, false);
678 kfree(tun_dst);
679 return PACKET_RCVD;
680 }
681
682 kfree(skb);
683 return PACKET_RCVD;
684 }
685
686 static int gre_rcv(struct sk_buff *skb)
687 {
688 struct tnl_ptk_info tpi;
689 bool csum_err = false;
690 int hdr_len;
691
692 hdr_len = gre_parse_header(skb, &tpi, &csum_err, htons(ETH_P_IPV6), 0);
693 if (hdr_len < 0)
694 goto drop;
695
696 if (iptunnel_pull_header(skb, hdr_len, tpi.proto, false))
697 goto drop;
698
699 if (unlikely(tpi.proto == htons(ETH_P_ERSPAN) ||
700 tpi.proto == htons(ETH_P_ERSPAN2))) {
701 if (ip6erspan_rcv(skb, hdr_len, &tpi) == PACKET_RCVD)
702 return 0;
703 goto out;
704 }
705
706 if (ip6gre_rcv(skb, &tpi) == PACKET_RCVD)
707 return 0;
708
709 out:
710 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0);
711 drop:
712 kfree_skb(skb);
713 return 0;
714 }
715
716 #if LINUX_VERSION_CODE < KERNEL_VERSION(4,7,0)
717 #include "gso.h"
718 /* gre_handle_offloads() has different return type on older kernsl. */
719 static void gre_nop_fix(struct sk_buff *skb) { }
720
721 static void gre_csum_fix(struct sk_buff *skb)
722 {
723 struct gre_base_hdr *greh;
724 __be32 *options;
725 int gre_offset = skb_transport_offset(skb);
726
727 greh = (struct gre_base_hdr *)skb_transport_header(skb);
728 options = ((__be32 *)greh + 1);
729
730 *options = 0;
731 *(__sum16 *)options = csum_fold(skb_checksum(skb, gre_offset,
732 skb->len - gre_offset, 0));
733 }
734
735 #define gre_handle_offloads rpl_gre_handle_offloads
736 static int rpl_gre_handle_offloads(struct sk_buff *skb, bool gre_csum)
737 {
738 int type = gre_csum ? SKB_GSO_GRE_CSUM : SKB_GSO_GRE;
739 gso_fix_segment_t fix_segment;
740
741 if (gre_csum)
742 fix_segment = gre_csum_fix;
743 else
744 fix_segment = gre_nop_fix;
745
746 return ovs_iptunnel_handle_offloads(skb, type, fix_segment);
747 }
748 #else
749 static int gre_handle_offloads(struct sk_buff *skb, bool csum)
750 {
751 return iptunnel_handle_offloads(skb,
752 csum ? SKB_GSO_GRE_CSUM : SKB_GSO_GRE);
753
754 #endif
755
756 static void prepare_ip6gre_xmit_ipv4(struct sk_buff *skb,
757 struct net_device *dev,
758 struct flowi6 *fl6, __u8 *dsfield,
759 int *encap_limit)
760 {
761 const struct iphdr *iph = ip_hdr(skb);
762 struct ip6_tnl *t = netdev_priv(dev);
763
764 if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
765 *encap_limit = t->parms.encap_limit;
766
767 memcpy(fl6, &t->fl.u.ip6, sizeof(*fl6));
768
769 if (t->parms.flags & IP6_TNL_F_USE_ORIG_TCLASS)
770 *dsfield = ipv4_get_dsfield(iph);
771 else
772 *dsfield = ip6_tclass(t->parms.flowinfo);
773
774 #ifndef IP6_TNL_F_USE_ORIG_FWMARK
775 if (t->parms.flags & IP6_TNL_F_USE_ORIG_FWMARK)
776 fl6->flowi6_mark = skb->mark;
777 else
778 fl6->flowi6_mark = t->parms.fwmark;
779
780 fl6->flowi6_uid = sock_net_uid(dev_net(dev), NULL);
781 #endif
782 }
783
784 static int prepare_ip6gre_xmit_ipv6(struct sk_buff *skb,
785 struct net_device *dev,
786 struct flowi6 *fl6, __u8 *dsfield,
787 int *encap_limit)
788 {
789 struct ipv6hdr *ipv6h = ipv6_hdr(skb);
790 struct ip6_tnl *t = netdev_priv(dev);
791 __u16 offset;
792
793 offset = ip6_tnl_parse_tlv_enc_lim(skb, skb_network_header(skb));
794 /* ip6_tnl_parse_tlv_enc_lim() might have reallocated skb->head */
795
796 if (offset > 0) {
797 struct ipv6_tlv_tnl_enc_lim *tel;
798
799 tel = (struct ipv6_tlv_tnl_enc_lim *)&skb_network_header(skb)[offset];
800 if (tel->encap_limit == 0) {
801 icmpv6_send(skb, ICMPV6_PARAMPROB,
802 ICMPV6_HDR_FIELD, offset + 2);
803 return -1;
804 }
805 *encap_limit = tel->encap_limit - 1;
806 } else if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT)) {
807 *encap_limit = t->parms.encap_limit;
808 }
809
810 memcpy(fl6, &t->fl.u.ip6, sizeof(*fl6));
811
812 if (t->parms.flags & IP6_TNL_F_USE_ORIG_TCLASS)
813 *dsfield = ipv6_get_dsfield(ipv6h);
814 else
815 *dsfield = ip6_tclass(t->parms.flowinfo);
816
817 if (t->parms.flags & IP6_TNL_F_USE_ORIG_FLOWLABEL)
818 fl6->flowlabel |= ip6_flowlabel(ipv6h);
819
820 #ifndef IP6_TNL_F_USE_ORIG_FWMARK
821 if (t->parms.flags & IP6_TNL_F_USE_ORIG_FWMARK)
822 fl6->flowi6_mark = skb->mark;
823 else
824 fl6->flowi6_mark = t->parms.fwmark;
825
826 fl6->flowi6_uid = sock_net_uid(dev_net(dev), NULL);
827 #endif
828
829 return 0;
830 }
831
832 static netdev_tx_t __gre6_xmit(struct sk_buff *skb,
833 struct net_device *dev, __u8 dsfield,
834 struct flowi6 *fl6, int encap_limit,
835 __u32 *pmtu, __be16 proto)
836 {
837 struct ip6_tnl *tunnel = netdev_priv(dev);
838 struct tnl_ptk_info tpi;
839 __be16 protocol;
840
841 if (dev->type == ARPHRD_ETHER)
842 IPCB(skb)->flags = 0;
843
844 if (dev->header_ops && dev->type == ARPHRD_IP6GRE)
845 fl6->daddr = ((struct ipv6hdr *)skb->data)->daddr;
846 else
847 fl6->daddr = tunnel->parms.raddr;
848
849 if (tunnel->parms.o_flags & TUNNEL_SEQ)
850 tunnel->o_seqno++;
851
852 if (skb_cow_head(skb, dev->needed_headroom ?: tunnel->hlen))
853 return -ENOMEM;
854
855 /* Push GRE header. */
856 protocol = (dev->type == ARPHRD_ETHER) ? htons(ETH_P_TEB) : proto;
857
858 if (tunnel->parms.collect_md) {
859 struct ip_tunnel_info *tun_info;
860 const struct ip_tunnel_key *key;
861 __be16 flags;
862
863 tun_info = skb_tunnel_info(skb);
864 if (unlikely(!tun_info ||
865 !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
866 ip_tunnel_info_af(tun_info) != AF_INET6))
867 return -EINVAL;
868
869 key = &tun_info->key;
870 memset(fl6, 0, sizeof(*fl6));
871 fl6->flowi6_proto = IPPROTO_GRE;
872 fl6->daddr = key->u.ipv6.dst;
873 fl6->flowlabel = key->label;
874 // FIX ME!
875 // fl6->flowi6_uid = sock_net_uid(dev_net(dev), NULL);
876
877 dsfield = key->tos;
878 flags = key->tun_flags & (TUNNEL_CSUM | TUNNEL_KEY);
879 tunnel->tun_hlen = gre_calc_hlen(flags);
880
881 tpi.flags = flags;
882 tpi.proto = protocol;
883 tpi.key = tunnel_id_to_key32(key->tun_id);
884 tpi.seq = htonl(tunnel->o_seqno++);
885 tpi.hdr_len = tunnel->tun_hlen;
886
887 gre_build_header(skb, &tpi, 8);
888 } else {
889 tpi.flags = tunnel->parms.o_flags;
890 tpi.proto = protocol;
891 tpi.key = tunnel->parms.o_key;
892 tpi.seq = htonl(tunnel->o_seqno++);
893 tpi.hdr_len = tunnel->tun_hlen;
894
895 gre_build_header(skb, &tpi, 8);
896 }
897
898 return ip6_tnl_xmit(skb, dev, dsfield, fl6, encap_limit, pmtu,
899 NEXTHDR_GRE);
900 }
901
902 static inline int ip6gre_xmit_ipv4(struct sk_buff *skb, struct net_device *dev)
903 {
904 struct ip6_tnl *t = netdev_priv(dev);
905 int encap_limit = -1;
906 struct flowi6 fl6;
907 __u8 dsfield = 0;
908 __u32 mtu;
909 int err;
910
911 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
912
913 if (!t->parms.collect_md)
914 prepare_ip6gre_xmit_ipv4(skb, dev, &fl6,
915 &dsfield, &encap_limit);
916
917 err = gre_handle_offloads(skb, !!(t->parms.o_flags & TUNNEL_CSUM));
918 if (err)
919 return -1;
920
921 err = __gre6_xmit(skb, dev, dsfield, &fl6, encap_limit, &mtu,
922 skb->protocol);
923 if (err != 0) {
924 /* XXX: send ICMP error even if DF is not set. */
925 if (err == -EMSGSIZE)
926 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
927 htonl(mtu));
928 return -1;
929 }
930
931 return 0;
932 }
933
934 static inline int ip6gre_xmit_ipv6(struct sk_buff *skb, struct net_device *dev)
935 {
936 struct ip6_tnl *t = netdev_priv(dev);
937 struct ipv6hdr *ipv6h = ipv6_hdr(skb);
938 int encap_limit = -1;
939 struct flowi6 fl6;
940 __u8 dsfield = 0;
941 __u32 mtu;
942 int err;
943
944 if (ipv6_addr_equal(&t->parms.raddr, &ipv6h->saddr))
945 return -1;
946
947 if (!t->parms.collect_md &&
948 prepare_ip6gre_xmit_ipv6(skb, dev, &fl6, &dsfield, &encap_limit))
949 return -1;
950
951 if (gre_handle_offloads(skb, !!(t->parms.o_flags & TUNNEL_CSUM)))
952 return -1;
953
954 err = __gre6_xmit(skb, dev, dsfield, &fl6, encap_limit,
955 &mtu, skb->protocol);
956 if (err != 0) {
957 if (err == -EMSGSIZE)
958 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
959 return -1;
960 }
961
962 return 0;
963 }
964
965 /**
966 * ip6_tnl_addr_conflict - compare packet addresses to tunnel's own
967 * @t: the outgoing tunnel device
968 * @hdr: IPv6 header from the incoming packet
969 *
970 * Description:
971 * Avoid trivial tunneling loop by checking that tunnel exit-point
972 * doesn't match source of incoming packet.
973 *
974 * Return:
975 * 1 if conflict,
976 * 0 else
977 **/
978
979 static inline bool ip6gre_tnl_addr_conflict(const struct ip6_tnl *t,
980 const struct ipv6hdr *hdr)
981 {
982 return ipv6_addr_equal(&t->parms.raddr, &hdr->saddr);
983 }
984
985 static int ip6gre_xmit_other(struct sk_buff *skb, struct net_device *dev)
986 {
987 struct ip6_tnl *t = netdev_priv(dev);
988 int encap_limit = -1;
989 struct flowi6 fl6;
990 __u32 mtu;
991 int err;
992
993 if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
994 encap_limit = t->parms.encap_limit;
995
996 if (!t->parms.collect_md)
997 memcpy(&fl6, &t->fl.u.ip6, sizeof(fl6));
998
999 err = gre_handle_offloads(skb, !!(t->parms.o_flags & TUNNEL_CSUM));
1000 if (err)
1001 return err;
1002
1003 err = __gre6_xmit(skb, dev, 0, &fl6, encap_limit, &mtu, skb->protocol);
1004
1005 return err;
1006 }
1007
1008 static netdev_tx_t ip6gre_tunnel_xmit(struct sk_buff *skb,
1009 struct net_device *dev)
1010 {
1011 struct ip6_tnl *t = netdev_priv(dev);
1012 struct net_device_stats *stats = &t->dev->stats;
1013 int ret;
1014
1015 if (!ip6_tnl_xmit_ctl(t, &t->parms.laddr, &t->parms.raddr))
1016 goto tx_err;
1017
1018 switch (skb->protocol) {
1019 case htons(ETH_P_IP):
1020 ret = ip6gre_xmit_ipv4(skb, dev);
1021 break;
1022 case htons(ETH_P_IPV6):
1023 ret = ip6gre_xmit_ipv6(skb, dev);
1024 break;
1025 default:
1026 ret = ip6gre_xmit_other(skb, dev);
1027 break;
1028 }
1029
1030 if (ret < 0)
1031 goto tx_err;
1032
1033 return NETDEV_TX_OK;
1034
1035 tx_err:
1036 stats->tx_errors++;
1037 stats->tx_dropped++;
1038 kfree_skb(skb);
1039 return NETDEV_TX_OK;
1040 }
1041
1042 static netdev_tx_t __ip6gre_tunnel_xmit(struct sk_buff *skb)
1043 {
1044 return ip6gre_tunnel_xmit(skb, skb->dev);
1045 }
1046
1047 static bool erspan_skb_would_panic(struct sk_buff *skb, int erspan_md_size)
1048 {
1049 /* check if there is enough headroom in packet, if not
1050 * drop it. Checking for 8 bytes of gre header space +
1051 * erspan base hdr and erspan type specific header.
1052 */
1053 if (skb_headroom(skb) < (8 + sizeof(struct erspan_base_hdr) +
1054 erspan_md_size))
1055 return true;
1056
1057 return false;
1058 }
1059
1060 static netdev_tx_t ip6erspan_tunnel_xmit(struct sk_buff *skb,
1061 struct net_device *dev)
1062 {
1063 struct ip6_tnl *t = netdev_priv(dev);
1064 struct dst_entry *dst = skb_dst(skb);
1065 struct ip_tunnel_info *tun_info;
1066 const struct ip_tunnel_key *key;
1067 struct net_device_stats *stats;
1068 struct erspan_metadata *md;
1069 struct tnl_ptk_info tpi;
1070 bool truncate = false;
1071 int encap_limit = -1;
1072 __u8 dsfield = false;
1073 struct flowi6 fl6;
1074 int err = -EINVAL;
1075 __be32 tun_id;
1076 __u32 mtu;
1077 int nhoff;
1078 int thoff;
1079
1080
1081 /* OVS doesn't support native mode ip6 tunnel traffic so
1082 * take an early exit in that case. */
1083 if (!t->parms.collect_md)
1084 goto tx_err;
1085
1086 if (!ip6_tnl_xmit_ctl(t, &t->parms.laddr, &t->parms.raddr))
1087 goto tx_err;
1088
1089 if (gre_handle_offloads(skb, false))
1090 goto tx_err;
1091
1092 if (skb->len > dev->mtu + dev->hard_header_len) {
1093 pskb_trim(skb, dev->mtu + dev->hard_header_len);
1094 truncate = true;
1095 }
1096
1097 nhoff = skb_network_header(skb) - skb_mac_header(skb);
1098 if (skb->protocol == htons(ETH_P_IP) &&
1099 (ntohs(ip_hdr(skb)->tot_len) > skb->len - nhoff))
1100 truncate = true;
1101
1102 thoff = skb_transport_header(skb) - skb_mac_header(skb);
1103 if (skb->protocol == htons(ETH_P_IPV6) &&
1104 (ntohs(ipv6_hdr(skb)->payload_len) > skb->len - thoff))
1105 truncate = true;
1106
1107 if (skb_cow_head(skb, dev->needed_headroom ? : t->hlen))
1108 goto tx_err;
1109
1110 t->parms.o_flags &= ~TUNNEL_KEY;
1111 IPCB(skb)->flags = 0;
1112
1113 tun_info = ovs_skb_tunnel_info(skb);
1114 if (unlikely(!tun_info ||
1115 !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
1116 ip_tunnel_info_af(tun_info) != AF_INET6))
1117 return -EINVAL;
1118
1119 key = &tun_info->key;
1120 memset(&fl6, 0, sizeof(fl6));
1121 fl6.flowi6_proto = IPPROTO_GRE;
1122 fl6.daddr = key->u.ipv6.dst;
1123 fl6.flowlabel = key->label;
1124 // fl6.flowi6_uid = sock_net_uid(dev_net(dev), NULL);
1125
1126 dsfield = key->tos;
1127 md = ip_tunnel_info_opts(tun_info);
1128 if (!md)
1129 goto tx_err;
1130
1131 if (erspan_skb_would_panic(skb,
1132 md->version == 1 ?
1133 ERSPAN_V1_MDSIZE : ERSPAN_V2_MDSIZE))
1134 goto tx_err;
1135
1136 tun_id = tunnel_id_to_key32(key->tun_id);
1137 if (md->version == 1) {
1138 erspan_build_header(skb,
1139 ntohl(tun_id),
1140 ntohl(md->u.index), truncate,
1141 false);
1142 tpi.hdr_len = ERSPAN_V1_MDSIZE;
1143 tpi.proto = htons(ETH_P_ERSPAN);
1144 } else if (md->version == 2) {
1145 erspan_build_header_v2(skb,
1146 ntohl(tun_id),
1147 md->u.md2.dir,
1148 get_hwid(&md->u.md2),
1149 truncate, false);
1150 tpi.hdr_len = ERSPAN_V2_MDSIZE;
1151 tpi.proto = htons(ETH_P_ERSPAN2);
1152 } else {
1153 goto tx_err;
1154 }
1155
1156 tpi.flags = TUNNEL_SEQ;
1157 tpi.key = 0;
1158 tpi.seq = htonl(t->o_seqno++);
1159
1160 /* Push GRE header. */
1161 gre_build_header(skb, &tpi, 8);
1162
1163 /* TooBig packet may have updated dst->dev's mtu */
1164 if (!t->parms.collect_md && dst && dst_mtu(dst) > dst->dev->mtu)
1165 dst->ops->update_pmtu(dst, NULL, skb, dst->dev->mtu);
1166
1167 err = ip6_tnl_xmit(skb, dev, dsfield, &fl6, encap_limit, &mtu,
1168 NEXTHDR_GRE);
1169 if (err != 0)
1170 goto tx_err;
1171
1172 return NETDEV_TX_OK;
1173
1174 tx_err:
1175 stats = &t->dev->stats;
1176 stats->tx_errors++;
1177 stats->tx_dropped++;
1178 kfree_skb(skb);
1179 return NETDEV_TX_OK;
1180 }
1181
1182 static netdev_tx_t __ip6erspan_tunnel_xmit(struct sk_buff *skb)
1183 {
1184 return ip6erspan_tunnel_xmit(skb, skb->dev);
1185 }
1186
1187 static void ip6gre_tnl_link_config_common(struct ip6_tnl *t)
1188 {
1189 struct net_device *dev = t->dev;
1190 struct __ip6_tnl_parm *p = &t->parms;
1191 struct flowi6 *fl6 = &t->fl.u.ip6;
1192
1193 if (dev->type != ARPHRD_ETHER) {
1194 memcpy(dev->dev_addr, &p->laddr, sizeof(struct in6_addr));
1195 memcpy(dev->broadcast, &p->raddr, sizeof(struct in6_addr));
1196 }
1197
1198 /* Set up flowi template */
1199 fl6->saddr = p->laddr;
1200 fl6->daddr = p->raddr;
1201 fl6->flowi6_oif = p->link;
1202 fl6->flowlabel = 0;
1203 fl6->flowi6_proto = IPPROTO_GRE;
1204
1205 if (!(p->flags&IP6_TNL_F_USE_ORIG_TCLASS))
1206 fl6->flowlabel |= IPV6_TCLASS_MASK & p->flowinfo;
1207 if (!(p->flags&IP6_TNL_F_USE_ORIG_FLOWLABEL))
1208 fl6->flowlabel |= IPV6_FLOWLABEL_MASK & p->flowinfo;
1209
1210 p->flags &= ~(IP6_TNL_F_CAP_XMIT|IP6_TNL_F_CAP_RCV|IP6_TNL_F_CAP_PER_PACKET);
1211 p->flags |= ip6_tnl_get_cap(t, &p->laddr, &p->raddr);
1212
1213 if (p->flags&IP6_TNL_F_CAP_XMIT &&
1214 p->flags&IP6_TNL_F_CAP_RCV && dev->type != ARPHRD_ETHER)
1215 dev->flags |= IFF_POINTOPOINT;
1216 else
1217 dev->flags &= ~IFF_POINTOPOINT;
1218 }
1219
1220 static void ip6gre_tnl_link_config_route(struct ip6_tnl *t, int set_mtu,
1221 int t_hlen)
1222 {
1223 const struct __ip6_tnl_parm *p = &t->parms;
1224 struct net_device *dev = t->dev;
1225
1226 if (p->flags & IP6_TNL_F_CAP_XMIT) {
1227 int strict = (ipv6_addr_type(&p->raddr) &
1228 (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL));
1229
1230 struct rt6_info *rt = rt6_lookup(t->net,
1231 &p->raddr, &p->laddr,
1232 p->link, strict);
1233
1234 if (!rt)
1235 return;
1236
1237 if (rt->dst.dev) {
1238 dev->hard_header_len = rt->dst.dev->hard_header_len +
1239 t_hlen;
1240
1241 if (set_mtu) {
1242 dev->mtu = rt->dst.dev->mtu - t_hlen;
1243 if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
1244 dev->mtu -= 8;
1245 if (dev->type == ARPHRD_ETHER)
1246 dev->mtu -= ETH_HLEN;
1247
1248 if (dev->mtu < IPV6_MIN_MTU)
1249 dev->mtu = IPV6_MIN_MTU;
1250 }
1251 }
1252 ip6_rt_put(rt);
1253 }
1254 }
1255
1256 static int ip6gre_calc_hlen(struct ip6_tnl *tunnel)
1257 {
1258 int t_hlen;
1259
1260 tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags);
1261 tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;
1262
1263 t_hlen = tunnel->hlen + sizeof(struct ipv6hdr);
1264 tunnel->dev->hard_header_len = LL_MAX_HEADER + t_hlen;
1265 return t_hlen;
1266 }
1267
1268 static void ip6gre_tnl_link_config(struct ip6_tnl *t, int set_mtu)
1269 {
1270 ip6gre_tnl_link_config_common(t);
1271 ip6gre_tnl_link_config_route(t, set_mtu, ip6gre_calc_hlen(t));
1272 }
1273
1274 static void ip6gre_tnl_copy_tnl_parm(struct ip6_tnl *t,
1275 const struct __ip6_tnl_parm *p)
1276 {
1277 t->parms.laddr = p->laddr;
1278 t->parms.raddr = p->raddr;
1279 t->parms.flags = p->flags;
1280 t->parms.hop_limit = p->hop_limit;
1281 t->parms.encap_limit = p->encap_limit;
1282 t->parms.flowinfo = p->flowinfo;
1283 t->parms.link = p->link;
1284 t->parms.proto = p->proto;
1285 t->parms.i_key = p->i_key;
1286 t->parms.o_key = p->o_key;
1287 t->parms.i_flags = p->i_flags;
1288 t->parms.o_flags = p->o_flags;
1289 t->parms.fwmark = p->fwmark;
1290 dst_cache_reset(&t->dst_cache);
1291 }
1292
1293 static int ip6gre_tnl_change(struct ip6_tnl *t, const struct __ip6_tnl_parm *p,
1294 int set_mtu)
1295 {
1296 ip6gre_tnl_copy_tnl_parm(t, p);
1297 ip6gre_tnl_link_config(t, set_mtu);
1298 return 0;
1299 }
1300
1301 static void ip6gre_tnl_parm_from_user(struct __ip6_tnl_parm *p,
1302 const struct ip6_tnl_parm2 *u)
1303 {
1304 p->laddr = u->laddr;
1305 p->raddr = u->raddr;
1306 p->flags = u->flags;
1307 p->hop_limit = u->hop_limit;
1308 p->encap_limit = u->encap_limit;
1309 p->flowinfo = u->flowinfo;
1310 p->link = u->link;
1311 p->i_key = u->i_key;
1312 p->o_key = u->o_key;
1313 p->i_flags = gre_flags_to_tnl_flags(u->i_flags);
1314 p->o_flags = gre_flags_to_tnl_flags(u->o_flags);
1315 memcpy(p->name, u->name, sizeof(u->name));
1316 }
1317
1318 static void ip6gre_tnl_parm_to_user(struct ip6_tnl_parm2 *u,
1319 const struct __ip6_tnl_parm *p)
1320 {
1321 u->proto = IPPROTO_GRE;
1322 u->laddr = p->laddr;
1323 u->raddr = p->raddr;
1324 u->flags = p->flags;
1325 u->hop_limit = p->hop_limit;
1326 u->encap_limit = p->encap_limit;
1327 u->flowinfo = p->flowinfo;
1328 u->link = p->link;
1329 u->i_key = p->i_key;
1330 u->o_key = p->o_key;
1331 u->i_flags = gre_tnl_flags_to_gre_flags(p->i_flags);
1332 u->o_flags = gre_tnl_flags_to_gre_flags(p->o_flags);
1333 memcpy(u->name, p->name, sizeof(u->name));
1334 }
1335
1336 static int ip6gre_tunnel_ioctl(struct net_device *dev,
1337 struct ifreq *ifr, int cmd)
1338 {
1339 int err = 0;
1340 struct ip6_tnl_parm2 p;
1341 struct __ip6_tnl_parm p1;
1342 struct ip6_tnl *t = netdev_priv(dev);
1343 struct net *net = t->net;
1344 struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);
1345
1346 memset(&p1, 0, sizeof(p1));
1347
1348 switch (cmd) {
1349 case SIOCGETTUNNEL:
1350 if (dev == ign->fb_tunnel_dev) {
1351 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
1352 err = -EFAULT;
1353 break;
1354 }
1355 ip6gre_tnl_parm_from_user(&p1, &p);
1356 t = ip6gre_tunnel_locate(net, &p1, 0);
1357 if (!t)
1358 t = netdev_priv(dev);
1359 }
1360 memset(&p, 0, sizeof(p));
1361 ip6gre_tnl_parm_to_user(&p, &t->parms);
1362 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
1363 err = -EFAULT;
1364 break;
1365
1366 case SIOCADDTUNNEL:
1367 case SIOCCHGTUNNEL:
1368 err = -EPERM;
1369 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1370 goto done;
1371
1372 err = -EFAULT;
1373 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1374 goto done;
1375
1376 err = -EINVAL;
1377 if ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING))
1378 goto done;
1379
1380 if (!(p.i_flags&GRE_KEY))
1381 p.i_key = 0;
1382 if (!(p.o_flags&GRE_KEY))
1383 p.o_key = 0;
1384
1385 ip6gre_tnl_parm_from_user(&p1, &p);
1386 t = ip6gre_tunnel_locate(net, &p1, cmd == SIOCADDTUNNEL);
1387
1388 if (dev != ign->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
1389 if (t) {
1390 if (t->dev != dev) {
1391 err = -EEXIST;
1392 break;
1393 }
1394 } else {
1395 t = netdev_priv(dev);
1396
1397 ip6gre_tunnel_unlink(ign, t);
1398 synchronize_net();
1399 ip6gre_tnl_change(t, &p1, 1);
1400 ip6gre_tunnel_link(ign, t);
1401 netdev_state_change(dev);
1402 }
1403 }
1404
1405 if (t) {
1406 err = 0;
1407
1408 memset(&p, 0, sizeof(p));
1409 ip6gre_tnl_parm_to_user(&p, &t->parms);
1410 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
1411 err = -EFAULT;
1412 } else
1413 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
1414 break;
1415
1416 case SIOCDELTUNNEL:
1417 err = -EPERM;
1418 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1419 goto done;
1420
1421 if (dev == ign->fb_tunnel_dev) {
1422 err = -EFAULT;
1423 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1424 goto done;
1425 err = -ENOENT;
1426 ip6gre_tnl_parm_from_user(&p1, &p);
1427 t = ip6gre_tunnel_locate(net, &p1, 0);
1428 if (!t)
1429 goto done;
1430 err = -EPERM;
1431 if (t == netdev_priv(ign->fb_tunnel_dev))
1432 goto done;
1433 dev = t->dev;
1434 }
1435 unregister_netdevice(dev);
1436 err = 0;
1437 break;
1438
1439 default:
1440 err = -EINVAL;
1441 }
1442
1443 done:
1444 return err;
1445 }
1446
1447 static int ip6gre_header(struct sk_buff *skb, struct net_device *dev,
1448 unsigned short type, const void *daddr,
1449 const void *saddr, unsigned int len)
1450 {
1451 struct ip6_tnl *t = netdev_priv(dev);
1452 struct ipv6hdr *ipv6h;
1453 __be16 *p;
1454
1455 ipv6h = (struct ipv6hdr *)skb_push(skb, t->hlen + sizeof(*ipv6h));
1456 ip6_flow_hdr(ipv6h, 0, ip6_make_flowlabel(dev_net(dev), skb,
1457 t->fl.u.ip6.flowlabel,
1458 true, &t->fl.u.ip6));
1459 ipv6h->hop_limit = t->parms.hop_limit;
1460 ipv6h->nexthdr = NEXTHDR_GRE;
1461 ipv6h->saddr = t->parms.laddr;
1462 ipv6h->daddr = t->parms.raddr;
1463
1464 p = (__be16 *)(ipv6h + 1);
1465 p[0] = t->parms.o_flags;
1466 p[1] = htons(type);
1467
1468 /*
1469 * Set the source hardware address.
1470 */
1471
1472 if (saddr)
1473 memcpy(&ipv6h->saddr, saddr, sizeof(struct in6_addr));
1474 if (daddr)
1475 memcpy(&ipv6h->daddr, daddr, sizeof(struct in6_addr));
1476 if (!ipv6_addr_any(&ipv6h->daddr))
1477 return t->hlen;
1478
1479 return -t->hlen;
1480 }
1481
1482 static const struct header_ops ip6gre_header_ops = {
1483 .create = ip6gre_header,
1484 };
1485
1486 static const struct net_device_ops ip6gre_netdev_ops = {
1487 .ndo_init = ip6gre_tunnel_init,
1488 .ndo_uninit = ip6gre_tunnel_uninit,
1489 .ndo_start_xmit = ip6gre_tunnel_xmit,
1490 .ndo_do_ioctl = ip6gre_tunnel_ioctl,
1491 .ndo_change_mtu = ip6_tnl_change_mtu,
1492 .ndo_get_stats64 = rpl_ip_tunnel_get_stats64,
1493 #ifdef HAVE_NDO_GET_IFLINK
1494 .ndo_get_iflink = ip6_tnl_get_iflink,
1495 #endif
1496 };
1497
1498 #ifdef HAVE_NEEDS_FREE_NETDEV
1499 static void ip6gre_dev_free(struct net_device *dev)
1500 {
1501 struct ip6_tnl *t = netdev_priv(dev);
1502
1503 dst_cache_destroy(&t->dst_cache);
1504 free_percpu(dev->tstats);
1505 }
1506
1507 #endif
1508 static void ip6gre_tunnel_setup(struct net_device *dev)
1509 {
1510 dev->netdev_ops = &ip6gre_netdev_ops;
1511 #ifndef HAVE_NEEDS_FREE_NETDEV
1512 dev->destructor = free_netdev;
1513 #else
1514 dev->needs_free_netdev = true;
1515 dev->priv_destructor = ip6gre_dev_free;
1516 #endif
1517
1518 dev->type = ARPHRD_IP6GRE;
1519
1520 dev->flags |= IFF_NOARP;
1521 dev->addr_len = sizeof(struct in6_addr);
1522 netif_keep_dst(dev);
1523 /* This perm addr will be used as interface identifier by IPv6 */
1524 dev->addr_assign_type = NET_ADDR_RANDOM;
1525 eth_random_addr(dev->perm_addr);
1526 }
1527
1528 #define GRE6_FEATURES (NETIF_F_SG | \
1529 NETIF_F_FRAGLIST | \
1530 NETIF_F_HIGHDMA | \
1531 NETIF_F_HW_CSUM)
1532
1533 static void ip6gre_tnl_init_features(struct net_device *dev)
1534 {
1535 struct ip6_tnl *nt = netdev_priv(dev);
1536
1537 dev->features |= GRE6_FEATURES;
1538 dev->hw_features |= GRE6_FEATURES;
1539
1540 if (!(nt->parms.o_flags & TUNNEL_SEQ)) {
1541 /* TCP offload with GRE SEQ is not supported, nor
1542 * can we support 2 levels of outer headers requiring
1543 * an update.
1544 */
1545 if (!(nt->parms.o_flags & TUNNEL_CSUM) ||
1546 nt->encap.type == TUNNEL_ENCAP_NONE) {
1547 dev->features |= NETIF_F_GSO_SOFTWARE;
1548 dev->hw_features |= NETIF_F_GSO_SOFTWARE;
1549 }
1550
1551 /* Can use a lockless transmit, unless we generate
1552 * output sequences
1553 */
1554 dev->features |= NETIF_F_LLTX;
1555 }
1556 }
1557
1558 static int ip6gre_tunnel_init_common(struct net_device *dev)
1559 {
1560 struct ip6_tnl *tunnel;
1561 int ret;
1562 int t_hlen;
1563
1564 tunnel = netdev_priv(dev);
1565
1566 tunnel->dev = dev;
1567 tunnel->net = dev_net(dev);
1568 strcpy(tunnel->parms.name, dev->name);
1569
1570 dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
1571 if (!dev->tstats)
1572 return -ENOMEM;
1573
1574 ret = dst_cache_init(&tunnel->dst_cache, GFP_KERNEL);
1575 if (ret) {
1576 free_percpu(dev->tstats);
1577 dev->tstats = NULL;
1578 return ret;
1579 }
1580
1581 t_hlen = ip6gre_calc_hlen(tunnel);
1582 dev->mtu = ETH_DATA_LEN - t_hlen;
1583 if (dev->type == ARPHRD_ETHER)
1584 dev->mtu -= ETH_HLEN;
1585 if (!(tunnel->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
1586 dev->mtu -= 8;
1587
1588 if (tunnel->parms.collect_md) {
1589 dev->features |= NETIF_F_NETNS_LOCAL;
1590 netif_keep_dst(dev);
1591 }
1592 ip6gre_tnl_init_features(dev);
1593
1594 return 0;
1595 }
1596
1597 static int ip6gre_tunnel_init(struct net_device *dev)
1598 {
1599 struct ip6_tnl *tunnel;
1600 int ret;
1601
1602 ret = ip6gre_tunnel_init_common(dev);
1603 if (ret)
1604 return ret;
1605
1606 tunnel = netdev_priv(dev);
1607
1608 if (tunnel->parms.collect_md)
1609 return 0;
1610
1611 memcpy(dev->dev_addr, &tunnel->parms.laddr, sizeof(struct in6_addr));
1612 memcpy(dev->broadcast, &tunnel->parms.raddr, sizeof(struct in6_addr));
1613
1614 if (ipv6_addr_any(&tunnel->parms.raddr))
1615 dev->header_ops = &ip6gre_header_ops;
1616
1617 return 0;
1618 }
1619
1620 static void ip6gre_fb_tunnel_init(struct net_device *dev)
1621 {
1622 struct ip6_tnl *tunnel = netdev_priv(dev);
1623
1624 tunnel->dev = dev;
1625 tunnel->net = dev_net(dev);
1626 strcpy(tunnel->parms.name, dev->name);
1627
1628 tunnel->hlen = sizeof(struct ipv6hdr) + 4;
1629
1630 dev_hold(dev);
1631 }
1632
1633 static struct inet6_protocol ip6gre_protocol __read_mostly = {
1634 .handler = gre_rcv,
1635 .err_handler = ip6gre_err,
1636 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
1637 };
1638
1639 static void ip6gre_destroy_tunnels(struct net *net, struct list_head *head)
1640 {
1641 struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);
1642 struct net_device *dev, *aux;
1643 int prio;
1644
1645 for_each_netdev_safe(net, dev, aux)
1646 if (dev->rtnl_link_ops == &ip6gre_link_ops ||
1647 dev->rtnl_link_ops == &ip6gre_tap_ops ||
1648 dev->rtnl_link_ops == &ip6erspan_tap_ops)
1649 unregister_netdevice_queue(dev, head);
1650
1651 for (prio = 0; prio < 4; prio++) {
1652 int h;
1653 for (h = 0; h < IP6_GRE_HASH_SIZE; h++) {
1654 struct ip6_tnl *t;
1655
1656 t = rtnl_dereference(ign->tunnels[prio][h]);
1657
1658 while (t) {
1659 /* If dev is in the same netns, it has already
1660 * been added to the list by the previous loop.
1661 */
1662 if (!net_eq(dev_net(t->dev), net))
1663 unregister_netdevice_queue(t->dev,
1664 head);
1665 t = rtnl_dereference(t->next);
1666 }
1667 }
1668 }
1669 }
1670
1671 static int __net_init ip6gre_init_net(struct net *net)
1672 {
1673 struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);
1674 int err;
1675
1676 ign->fb_tunnel_dev = alloc_netdev(sizeof(struct ip6_tnl), "ip6gre0",
1677 NET_NAME_UNKNOWN,
1678 ip6gre_tunnel_setup);
1679 if (!ign->fb_tunnel_dev) {
1680 err = -ENOMEM;
1681 goto err_alloc_dev;
1682 }
1683 dev_net_set(ign->fb_tunnel_dev, net);
1684 /* FB netdevice is special: we have one, and only one per netns.
1685 * Allowing to move it to another netns is clearly unsafe.
1686 */
1687 ign->fb_tunnel_dev->features |= NETIF_F_NETNS_LOCAL;
1688
1689
1690 ip6gre_fb_tunnel_init(ign->fb_tunnel_dev);
1691 ign->fb_tunnel_dev->rtnl_link_ops = &ip6gre_link_ops;
1692
1693 err = register_netdev(ign->fb_tunnel_dev);
1694 if (err)
1695 goto err_reg_dev;
1696
1697 rcu_assign_pointer(ign->tunnels_wc[0],
1698 netdev_priv(ign->fb_tunnel_dev));
1699 return 0;
1700
1701 err_reg_dev:
1702 free_netdev(ign->fb_tunnel_dev);
1703 err_alloc_dev:
1704 return err;
1705 }
1706
1707 static void __net_exit ip6gre_exit_batch_net(struct list_head *net_list)
1708 {
1709 struct net *net;
1710 LIST_HEAD(list);
1711
1712 rtnl_lock();
1713 list_for_each_entry(net, net_list, exit_list)
1714 ip6gre_destroy_tunnels(net, &list);
1715 unregister_netdevice_many(&list);
1716 rtnl_unlock();
1717 }
1718
1719 enum {
1720 #ifndef HAVE_IFLA_GRE_ENCAP_DPORT
1721 IFLA_GRE_ENCAP_TYPE = IFLA_GRE_FLAGS + 1,
1722 IFLA_GRE_ENCAP_FLAGS,
1723 IFLA_GRE_ENCAP_SPORT,
1724 IFLA_GRE_ENCAP_DPORT,
1725 #endif
1726 #ifndef HAVE_IFLA_GRE_COLLECT_METADATA
1727 IFLA_GRE_COLLECT_METADATA = IFLA_GRE_ENCAP_DPORT + 1,
1728 #endif
1729 #ifndef HAVE_IFLA_GRE_IGNORE_DF
1730 IFLA_GRE_IGNORE_DF = IFLA_GRE_COLLECT_METADATA + 1,
1731 #endif
1732 #ifndef HAVE_IFLA_GRE_FWMARK
1733 IFLA_GRE_FWMARK = IFLA_GRE_IGNORE_DF + 1,
1734 #endif
1735 #ifndef HAVE_IFLA_GRE_ERSPAN_INDEX
1736 IFLA_GRE_ERSPAN_INDEX = IFLA_GRE_FWMARK + 1,
1737 #endif
1738 #ifndef HAVE_IFLA_GRE_ERSPAN_HWID
1739 IFLA_GRE_ERSPAN_VER = IFLA_GRE_ERSPAN_INDEX + 1,
1740 IFLA_GRE_ERSPAN_DIR,
1741 IFLA_GRE_ERSPAN_HWID,
1742 #endif
1743 };
1744
1745 #define RPL_IFLA_GRE_MAX (IFLA_GRE_ERSPAN_HWID + 1)
1746
1747 static struct pernet_operations ip6gre_net_ops = {
1748 .init = ip6gre_init_net,
1749 .exit_batch = ip6gre_exit_batch_net,
1750 .id = &ip6gre_net_id,
1751 .size = sizeof(struct ip6gre_net),
1752 };
1753 #ifdef HAVE_IP6GRE_EXTACK
1754 static int rpl_ip6gre_tunnel_validate(struct nlattr *tb[],
1755 struct nlattr *data[],
1756 struct netlink_ext_ack *extack)
1757 #else
1758 static int rpl_ip6gre_tunnel_validate(struct nlattr *tb[],
1759 struct nlattr *data[])
1760 #endif
1761 {
1762 __be16 flags;
1763
1764 if (!data)
1765 return 0;
1766
1767 flags = 0;
1768 if (data[IFLA_GRE_IFLAGS])
1769 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
1770 if (data[IFLA_GRE_OFLAGS])
1771 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
1772 if (flags & (GRE_VERSION|GRE_ROUTING))
1773 return -EINVAL;
1774
1775 return 0;
1776 }
1777 #define ip6gre_tunnel_validate rpl_ip6gre_tunnel_validate
1778
1779 #ifdef HAVE_IP6GRE_EXTACK
1780 static int rpl_ip6gre_tap_validate(struct nlattr *tb[], struct nlattr *data[],
1781 struct netlink_ext_ack *extack)
1782 #else
1783 static int rpl_ip6gre_tap_validate(struct nlattr *tb[], struct nlattr *data[])
1784 #endif
1785 {
1786 struct in6_addr daddr;
1787
1788 if (tb[IFLA_ADDRESS]) {
1789 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
1790 return -EINVAL;
1791 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
1792 return -EADDRNOTAVAIL;
1793 }
1794
1795 if (!data)
1796 goto out;
1797
1798 if (data[IFLA_GRE_REMOTE]) {
1799 daddr = nla_get_in6_addr(data[IFLA_GRE_REMOTE]);
1800 if (ipv6_addr_any(&daddr))
1801 return -EINVAL;
1802 }
1803
1804 out:
1805 #ifdef HAVE_IP6GRE_EXTACK
1806 return ip6gre_tunnel_validate(tb, data, extack);
1807 #else
1808 return ip6gre_tunnel_validate(tb, data);
1809 #endif
1810 }
1811 #define ip6gre_tap_validate rpl_ip6gre_tap_validate
1812
1813 #ifdef HAVE_IP6GRE_EXTACK
1814 static int rpl_ip6erspan_tap_validate(struct nlattr *tb[],
1815 struct nlattr *data[],
1816 struct netlink_ext_ack *extack)
1817 #else
1818 static int rpl_ip6erspan_tap_validate(struct nlattr *tb[],
1819 struct nlattr *data[])
1820 #endif
1821 {
1822 __be16 flags = 0;
1823 int ret, ver = 0;
1824
1825 if (!data)
1826 return 0;
1827
1828 #ifdef HAVE_IP6GRE_EXTACK
1829 ret = ip6gre_tap_validate(tb, data, extack);
1830 #else
1831 ret = ip6gre_tap_validate(tb, data);
1832 #endif
1833 if (ret)
1834 return ret;
1835
1836 /* ERSPAN should only have GRE sequence and key flag */
1837 if (data[IFLA_GRE_OFLAGS])
1838 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
1839 if (data[IFLA_GRE_IFLAGS])
1840 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
1841 if (!data[IFLA_GRE_COLLECT_METADATA] &&
1842 flags != (GRE_SEQ | GRE_KEY))
1843 return -EINVAL;
1844
1845 /* ERSPAN Session ID only has 10-bit. Since we reuse
1846 * 32-bit key field as ID, check it's range.
1847 */
1848 if (data[IFLA_GRE_IKEY] &&
1849 (ntohl(nla_get_be32(data[IFLA_GRE_IKEY])) & ~ID_MASK))
1850 return -EINVAL;
1851
1852 if (data[IFLA_GRE_OKEY] &&
1853 (ntohl(nla_get_be32(data[IFLA_GRE_OKEY])) & ~ID_MASK))
1854 return -EINVAL;
1855
1856 if (data[IFLA_GRE_ERSPAN_VER]) {
1857 ver = nla_get_u8(data[IFLA_GRE_ERSPAN_VER]);
1858 if (ver != 1 && ver != 2)
1859 return -EINVAL;
1860 }
1861
1862 if (ver == 1) {
1863 if (data[IFLA_GRE_ERSPAN_INDEX]) {
1864 u32 index = nla_get_u32(data[IFLA_GRE_ERSPAN_INDEX]);
1865
1866 if (index & ~INDEX_MASK)
1867 return -EINVAL;
1868 }
1869 } else if (ver == 2) {
1870 if (data[IFLA_GRE_ERSPAN_DIR]) {
1871 u16 dir = nla_get_u8(data[IFLA_GRE_ERSPAN_DIR]);
1872
1873 if (dir & ~(DIR_MASK >> DIR_OFFSET))
1874 return -EINVAL;
1875 }
1876
1877 if (data[IFLA_GRE_ERSPAN_HWID]) {
1878 u16 hwid = nla_get_u16(data[IFLA_GRE_ERSPAN_HWID]);
1879
1880 if (hwid & ~(HWID_MASK >> HWID_OFFSET))
1881 return -EINVAL;
1882 }
1883 }
1884
1885 return 0;
1886 }
1887 #define ip6erspan_tap_validate rpl_ip6erspan_tap_validate
1888
1889 static void ip6gre_netlink_parms(struct nlattr *data[],
1890 struct __ip6_tnl_parm *parms)
1891 {
1892 #if 0
1893 /* Do not use in case of OVS - our vport needs to set a parm
1894 * directly and this erases it
1895 */
1896 memset(parms, 0, sizeof(*parms));
1897
1898 #endif
1899 if (!data)
1900 return;
1901
1902 if (data[IFLA_GRE_LINK])
1903 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
1904
1905 if (data[IFLA_GRE_IFLAGS])
1906 parms->i_flags = gre_flags_to_tnl_flags(
1907 nla_get_be16(data[IFLA_GRE_IFLAGS]));
1908
1909 if (data[IFLA_GRE_OFLAGS])
1910 parms->o_flags = gre_flags_to_tnl_flags(
1911 nla_get_be16(data[IFLA_GRE_OFLAGS]));
1912
1913 if (data[IFLA_GRE_IKEY])
1914 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
1915
1916 if (data[IFLA_GRE_OKEY])
1917 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
1918
1919 if (data[IFLA_GRE_LOCAL])
1920 parms->laddr = nla_get_in6_addr(data[IFLA_GRE_LOCAL]);
1921
1922 if (data[IFLA_GRE_REMOTE])
1923 parms->raddr = nla_get_in6_addr(data[IFLA_GRE_REMOTE]);
1924
1925 if (data[IFLA_GRE_TTL])
1926 parms->hop_limit = nla_get_u8(data[IFLA_GRE_TTL]);
1927
1928 if (data[IFLA_GRE_ENCAP_LIMIT])
1929 parms->encap_limit = nla_get_u8(data[IFLA_GRE_ENCAP_LIMIT]);
1930
1931 if (data[IFLA_GRE_FLOWINFO])
1932 parms->flowinfo = nla_get_be32(data[IFLA_GRE_FLOWINFO]);
1933
1934 if (data[IFLA_GRE_FLAGS])
1935 parms->flags = nla_get_u32(data[IFLA_GRE_FLAGS]);
1936
1937 if (data[IFLA_GRE_FWMARK])
1938 parms->fwmark = nla_get_u32(data[IFLA_GRE_FWMARK]);
1939
1940 if (data[IFLA_GRE_COLLECT_METADATA])
1941 parms->collect_md = true;
1942
1943 if (data[IFLA_GRE_ERSPAN_VER])
1944 parms->erspan_ver = nla_get_u8(data[IFLA_GRE_ERSPAN_VER]);
1945
1946 if (parms->erspan_ver == 1) {
1947 if (data[IFLA_GRE_ERSPAN_INDEX])
1948 parms->index = nla_get_u32(data[IFLA_GRE_ERSPAN_INDEX]);
1949 } else if (parms->erspan_ver == 2) {
1950 if (data[IFLA_GRE_ERSPAN_DIR])
1951 parms->dir = nla_get_u8(data[IFLA_GRE_ERSPAN_DIR]);
1952 if (data[IFLA_GRE_ERSPAN_HWID])
1953 parms->hwid = nla_get_u16(data[IFLA_GRE_ERSPAN_HWID]);
1954 }
1955 }
1956
1957 static int ip6gre_tap_init(struct net_device *dev)
1958 {
1959 int ret;
1960
1961 ret = ip6gre_tunnel_init_common(dev);
1962 if (ret)
1963 return ret;
1964
1965 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
1966
1967 return 0;
1968 }
1969
1970 static const struct net_device_ops ip6gre_tap_netdev_ops = {
1971 .ndo_init = ip6gre_tap_init,
1972 .ndo_uninit = ip6gre_tunnel_uninit,
1973 .ndo_start_xmit = ip6gre_tunnel_xmit,
1974 .ndo_set_mac_address = eth_mac_addr,
1975 .ndo_validate_addr = eth_validate_addr,
1976 .ndo_change_mtu = ip6_tnl_change_mtu,
1977 .ndo_get_stats64 = rpl_ip_tunnel_get_stats64,
1978 #ifdef HAVE_NDO_GET_IFLINK
1979 .ndo_get_iflink = ip6_tnl_get_iflink,
1980 #endif
1981 };
1982
1983 static int ip6erspan_calc_hlen(struct ip6_tnl *tunnel)
1984 {
1985 int t_hlen;
1986
1987 tunnel->tun_hlen = 8;
1988 tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen +
1989 erspan_hdr_len(tunnel->parms.erspan_ver);
1990
1991 t_hlen = tunnel->hlen + sizeof(struct ipv6hdr);
1992 tunnel->dev->hard_header_len = LL_MAX_HEADER + t_hlen;
1993 return t_hlen;
1994 }
1995
1996 static int ip6erspan_tap_init(struct net_device *dev)
1997 {
1998 struct ip6_tnl *tunnel;
1999 int t_hlen;
2000 int ret;
2001
2002 tunnel = netdev_priv(dev);
2003
2004 tunnel->dev = dev;
2005 tunnel->net = dev_net(dev);
2006 strcpy(tunnel->parms.name, dev->name);
2007
2008 dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
2009 if (!dev->tstats)
2010 return -ENOMEM;
2011
2012 ret = dst_cache_init(&tunnel->dst_cache, GFP_KERNEL);
2013 if (ret) {
2014 free_percpu(dev->tstats);
2015 dev->tstats = NULL;
2016 return ret;
2017 }
2018
2019 t_hlen = ip6erspan_calc_hlen(tunnel);
2020 dev->mtu = ETH_DATA_LEN - t_hlen;
2021 if (dev->type == ARPHRD_ETHER)
2022 dev->mtu -= ETH_HLEN;
2023 if (!(tunnel->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
2024 dev->mtu -= 8;
2025
2026 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
2027 tunnel = netdev_priv(dev);
2028 ip6erspan_tnl_link_config(tunnel, 1);
2029
2030 return 0;
2031 }
2032
2033 static const struct net_device_ops ip6erspan_netdev_ops = {
2034 .ndo_init = ip6erspan_tap_init,
2035 .ndo_uninit = ip6gre_tunnel_uninit,
2036 .ndo_start_xmit = ip6erspan_tunnel_xmit,
2037 .ndo_set_mac_address = eth_mac_addr,
2038 .ndo_validate_addr = eth_validate_addr,
2039 .ndo_change_mtu = ip6_tnl_change_mtu,
2040 .ndo_get_stats64 = ip_tunnel_get_stats64,
2041 #ifdef HAVE_NDO_GET_IFLINK
2042 .ndo_get_iflink = ip6_tnl_get_iflink,
2043 #endif
2044 };
2045
2046 static void ip6gre_tap_setup(struct net_device *dev)
2047 {
2048
2049 ether_setup(dev);
2050 #ifdef HAVE_NET_DEVICE_MAX_MTU
2051 dev->max_mtu = 0;
2052 #endif
2053 dev->netdev_ops = &ip6gre_tap_netdev_ops;
2054 #ifndef HAVE_NEEDS_FREE_NETDEV
2055 dev->destructor = free_netdev;
2056 #else
2057 dev->needs_free_netdev = true;
2058 dev->priv_destructor = ip6gre_dev_free;
2059 #endif
2060
2061 dev->features |= NETIF_F_NETNS_LOCAL;
2062 dev->priv_flags &= ~IFF_TX_SKB_SHARING;
2063 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
2064 netif_keep_dst(dev);
2065 }
2066
2067 static bool ip6gre_netlink_encap_parms(struct nlattr *data[],
2068 struct ip_tunnel_encap *ipencap)
2069 {
2070 bool ret = false;
2071
2072 memset(ipencap, 0, sizeof(*ipencap));
2073
2074 if (!data)
2075 return ret;
2076
2077 if (data[IFLA_GRE_ENCAP_TYPE]) {
2078 ret = true;
2079 ipencap->type = nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]);
2080 }
2081
2082 if (data[IFLA_GRE_ENCAP_FLAGS]) {
2083 ret = true;
2084 ipencap->flags = nla_get_u16(data[IFLA_GRE_ENCAP_FLAGS]);
2085 }
2086
2087 if (data[IFLA_GRE_ENCAP_SPORT]) {
2088 ret = true;
2089 ipencap->sport = nla_get_be16(data[IFLA_GRE_ENCAP_SPORT]);
2090 }
2091
2092 if (data[IFLA_GRE_ENCAP_DPORT]) {
2093 ret = true;
2094 ipencap->dport = nla_get_be16(data[IFLA_GRE_ENCAP_DPORT]);
2095 }
2096
2097 return ret;
2098 }
2099
2100 #ifdef HAVE_IP6GRE_EXTACK
2101 static int rpl_ip6gre_newlink_common(struct net *src_net, struct net_device *dev,
2102 struct nlattr *tb[], struct nlattr *data[],
2103 struct netlink_ext_ack *extack)
2104 #else
2105 static int rpl_ip6gre_newlink_common(struct net *src_net, struct net_device *dev,
2106 struct nlattr *tb[], struct nlattr *data[])
2107 #endif
2108 {
2109 struct ip6_tnl *nt;
2110 struct net *net = dev_net(dev);
2111 struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);
2112 struct ip_tunnel_encap ipencap;
2113 int err;
2114
2115 nt = netdev_priv(dev);
2116
2117 if (ip6gre_netlink_encap_parms(data, &ipencap)) {
2118 int err = ip6_tnl_encap_setup(nt, &ipencap);
2119
2120 if (err < 0)
2121 return err;
2122 }
2123
2124 ip6gre_netlink_parms(data, &nt->parms);
2125
2126 if (nt->parms.collect_md) {
2127 if (rtnl_dereference(ign->collect_md_tun))
2128 return -EEXIST;
2129 } else {
2130 if (ip6gre_tunnel_find(net, &nt->parms, dev->type))
2131 return -EEXIST;
2132 }
2133
2134 if (dev->type == ARPHRD_ETHER && !tb[IFLA_ADDRESS])
2135 eth_hw_addr_random(dev);
2136
2137 nt->dev = dev;
2138 nt->net = dev_net(dev);
2139
2140 err = register_netdevice(dev);
2141 if (err)
2142 goto out;
2143
2144 if (tb[IFLA_MTU])
2145 ip6_tnl_change_mtu(dev, nla_get_u32(tb[IFLA_MTU]));
2146
2147 dev_hold(dev);
2148
2149 out:
2150 return err;
2151 }
2152 #define ip6gre_newlink_common rpl_ip6gre_newlink_common
2153
2154 #ifdef HAVE_IP6GRE_EXTACK
2155 static int rpl_ip6gre_newlink(struct net *src_net, struct net_device *dev,
2156 struct nlattr *tb[], struct nlattr *data[],
2157 struct netlink_ext_ack *extack)
2158 #else
2159 static int rpl_ip6gre_newlink(struct net *src_net, struct net_device *dev,
2160 struct nlattr *tb[], struct nlattr *data[])
2161 #endif
2162 {
2163
2164 #ifdef HAVE_IP6GRE_EXTACK
2165 int err = ip6gre_newlink_common(src_net, dev, tb, data, extack);
2166 #else
2167 int err = ip6gre_newlink_common(src_net, dev, tb, data);
2168 #endif
2169 struct ip6_tnl *nt = netdev_priv(dev);
2170 struct net *net = dev_net(dev);
2171
2172 if (!err) {
2173 ip6gre_tnl_link_config(nt, !tb[IFLA_MTU]);
2174 ip6gre_tunnel_link(net_generic(net, ip6gre_net_id), nt);
2175 }
2176 return err;
2177 }
2178
2179 #define ip6gre_newlink rpl_ip6gre_newlink
2180
2181 #ifdef HAVE_IP6GRE_EXTACK
2182 static struct ip6_tnl *
2183 rpl_ip6gre_changelink_common(struct net_device *dev, struct nlattr *tb[],
2184 struct nlattr *data[], struct __ip6_tnl_parm *p_p,
2185 struct netlink_ext_ack *extack)
2186 #else
2187 static struct ip6_tnl *
2188 rpl_ip6gre_changelink_common(struct net_device *dev, struct nlattr *tb[],
2189 struct nlattr *data[], struct __ip6_tnl_parm *p_p)
2190 #endif
2191 {
2192 struct ip6_tnl *t, *nt = netdev_priv(dev);
2193 struct net *net = nt->net;
2194 struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);
2195 struct ip_tunnel_encap ipencap;
2196
2197 if (dev == ign->fb_tunnel_dev)
2198 return ERR_PTR(-EINVAL);
2199
2200 if (ip6gre_netlink_encap_parms(data, &ipencap)) {
2201 int err = ip6_tnl_encap_setup(nt, &ipencap);
2202
2203 if (err < 0)
2204 return ERR_PTR(err);
2205 }
2206
2207 ip6gre_netlink_parms(data, p_p);
2208
2209 t = ip6gre_tunnel_locate(net, p_p, 0);
2210
2211 if (t) {
2212 if (t->dev != dev)
2213 return ERR_PTR(-EEXIST);
2214 } else {
2215 t = nt;
2216 }
2217
2218 return t;
2219 }
2220 #define ip6gre_changelink_common rpl_ip6gre_changelink_common
2221
2222 #ifdef HAVE_IP6GRE_EXTACK
2223 static int rpl_ip6gre_changelink(struct net_device *dev, struct nlattr *tb[],
2224 struct nlattr *data[],
2225 struct netlink_ext_ack *extack)
2226 #else
2227 static int rpl_ip6gre_changelink(struct net_device *dev, struct nlattr *tb[],
2228 struct nlattr *data[])
2229 #endif
2230 {
2231 struct ip6gre_net *ign = net_generic(dev_net(dev), ip6gre_net_id);
2232 struct __ip6_tnl_parm p;
2233 struct ip6_tnl *t;
2234
2235 #ifdef HAVE_IP6GRE_EXTACK
2236 t = ip6gre_changelink_common(dev, tb, data, &p, extack);
2237 #else
2238 t = ip6gre_changelink_common(dev, tb, data, &p);
2239 #endif
2240 if (IS_ERR(t))
2241 return PTR_ERR(t);
2242
2243 ip6gre_tunnel_unlink(ign, t);
2244 ip6gre_tnl_change(t, &p, !tb[IFLA_MTU]);
2245 ip6gre_tunnel_link(ign, t);
2246 return 0;
2247 }
2248 #define ip6gre_changelink rpl_ip6gre_changelink
2249
2250 static void ip6gre_dellink(struct net_device *dev, struct list_head *head)
2251 {
2252 struct net *net = dev_net(dev);
2253 struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);
2254
2255 if (dev != ign->fb_tunnel_dev)
2256 unregister_netdevice_queue(dev, head);
2257 }
2258
2259 static size_t ip6gre_get_size(const struct net_device *dev)
2260 {
2261 return
2262 /* IFLA_GRE_LINK */
2263 nla_total_size(4) +
2264 /* IFLA_GRE_IFLAGS */
2265 nla_total_size(2) +
2266 /* IFLA_GRE_OFLAGS */
2267 nla_total_size(2) +
2268 /* IFLA_GRE_IKEY */
2269 nla_total_size(4) +
2270 /* IFLA_GRE_OKEY */
2271 nla_total_size(4) +
2272 /* IFLA_GRE_LOCAL */
2273 nla_total_size(sizeof(struct in6_addr)) +
2274 /* IFLA_GRE_REMOTE */
2275 nla_total_size(sizeof(struct in6_addr)) +
2276 /* IFLA_GRE_TTL */
2277 nla_total_size(1) +
2278 /* IFLA_GRE_ENCAP_LIMIT */
2279 nla_total_size(1) +
2280 /* IFLA_GRE_FLOWINFO */
2281 nla_total_size(4) +
2282 /* IFLA_GRE_FLAGS */
2283 nla_total_size(4) +
2284 /* IFLA_GRE_ENCAP_TYPE */
2285 nla_total_size(2) +
2286 /* IFLA_GRE_ENCAP_FLAGS */
2287 nla_total_size(2) +
2288 /* IFLA_GRE_ENCAP_SPORT */
2289 nla_total_size(2) +
2290 /* IFLA_GRE_ENCAP_DPORT */
2291 nla_total_size(2) +
2292 /* IFLA_GRE_COLLECT_METADATA */
2293 nla_total_size(0) +
2294 /* IFLA_GRE_FWMARK */
2295 nla_total_size(4) +
2296 /* IFLA_GRE_ERSPAN_INDEX */
2297 nla_total_size(4) +
2298 0;
2299 }
2300
2301 static int ip6gre_fill_info(struct sk_buff *skb, const struct net_device *dev)
2302 {
2303 struct ip6_tnl *t = netdev_priv(dev);
2304 struct __ip6_tnl_parm *p = &t->parms;
2305
2306 if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
2307 nla_put_be16(skb, IFLA_GRE_IFLAGS,
2308 gre_tnl_flags_to_gre_flags(p->i_flags)) ||
2309 nla_put_be16(skb, IFLA_GRE_OFLAGS,
2310 gre_tnl_flags_to_gre_flags(p->o_flags)) ||
2311 nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
2312 nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
2313 nla_put_in6_addr(skb, IFLA_GRE_LOCAL, &p->laddr) ||
2314 nla_put_in6_addr(skb, IFLA_GRE_REMOTE, &p->raddr) ||
2315 nla_put_u8(skb, IFLA_GRE_TTL, p->hop_limit) ||
2316 nla_put_u8(skb, IFLA_GRE_ENCAP_LIMIT, p->encap_limit) ||
2317 nla_put_be32(skb, IFLA_GRE_FLOWINFO, p->flowinfo) ||
2318 nla_put_u32(skb, IFLA_GRE_FLAGS, p->flags) ||
2319 nla_put_u32(skb, IFLA_GRE_FWMARK, p->fwmark) ||
2320 nla_put_u32(skb, IFLA_GRE_ERSPAN_INDEX, p->index))
2321 goto nla_put_failure;
2322
2323 if (nla_put_u16(skb, IFLA_GRE_ENCAP_TYPE,
2324 t->encap.type) ||
2325 nla_put_be16(skb, IFLA_GRE_ENCAP_SPORT,
2326 t->encap.sport) ||
2327 nla_put_be16(skb, IFLA_GRE_ENCAP_DPORT,
2328 t->encap.dport) ||
2329 nla_put_u16(skb, IFLA_GRE_ENCAP_FLAGS,
2330 t->encap.flags))
2331 goto nla_put_failure;
2332
2333 if (p->collect_md) {
2334 if (nla_put_flag(skb, IFLA_GRE_COLLECT_METADATA))
2335 goto nla_put_failure;
2336 }
2337
2338 if (nla_put_u8(skb, IFLA_GRE_ERSPAN_VER, p->erspan_ver))
2339 goto nla_put_failure;
2340
2341 if (p->erspan_ver == 1) {
2342 if (nla_put_u32(skb, IFLA_GRE_ERSPAN_INDEX, p->index))
2343 goto nla_put_failure;
2344 } else if (p->erspan_ver == 2) {
2345 if (nla_put_u8(skb, IFLA_GRE_ERSPAN_DIR, p->dir))
2346 goto nla_put_failure;
2347 if (nla_put_u16(skb, IFLA_GRE_ERSPAN_HWID, p->hwid))
2348 goto nla_put_failure;
2349 }
2350
2351 return 0;
2352
2353 nla_put_failure:
2354 return -EMSGSIZE;
2355 }
2356
2357 static const struct nla_policy ip6gre_policy[RPL_IFLA_GRE_MAX + 1] = {
2358 [IFLA_GRE_LINK] = { .type = NLA_U32 },
2359 [IFLA_GRE_IFLAGS] = { .type = NLA_U16 },
2360 [IFLA_GRE_OFLAGS] = { .type = NLA_U16 },
2361 [IFLA_GRE_IKEY] = { .type = NLA_U32 },
2362 [IFLA_GRE_OKEY] = { .type = NLA_U32 },
2363 [IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct ipv6hdr, saddr) },
2364 [IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct ipv6hdr, daddr) },
2365 [IFLA_GRE_TTL] = { .type = NLA_U8 },
2366 [IFLA_GRE_ENCAP_LIMIT] = { .type = NLA_U8 },
2367 [IFLA_GRE_FLOWINFO] = { .type = NLA_U32 },
2368 [IFLA_GRE_FLAGS] = { .type = NLA_U32 },
2369 [IFLA_GRE_ENCAP_TYPE] = { .type = NLA_U16 },
2370 [IFLA_GRE_ENCAP_FLAGS] = { .type = NLA_U16 },
2371 [IFLA_GRE_ENCAP_SPORT] = { .type = NLA_U16 },
2372 [IFLA_GRE_ENCAP_DPORT] = { .type = NLA_U16 },
2373 [IFLA_GRE_COLLECT_METADATA] = { .type = NLA_FLAG },
2374 [IFLA_GRE_FWMARK] = { .type = NLA_U32 },
2375 [IFLA_GRE_ERSPAN_INDEX] = { .type = NLA_U32 },
2376 [IFLA_GRE_ERSPAN_VER] = { .type = NLA_U8 },
2377 [IFLA_GRE_ERSPAN_DIR] = { .type = NLA_U8 },
2378 [IFLA_GRE_ERSPAN_HWID] = { .type = NLA_U16 },
2379 };
2380
2381 static void ip6erspan_tap_setup(struct net_device *dev)
2382 {
2383 ether_setup(dev);
2384
2385 dev->netdev_ops = &ip6erspan_netdev_ops;
2386 #ifndef HAVE_NEEDS_FREE_NETDEV
2387 dev->destructor = free_netdev;
2388 #else
2389 dev->needs_free_netdev = true;
2390 dev->priv_destructor = ip6gre_dev_free;
2391 #endif
2392
2393 dev->features |= NETIF_F_NETNS_LOCAL;
2394 dev->priv_flags &= ~IFF_TX_SKB_SHARING;
2395 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
2396 netif_keep_dst(dev);
2397 }
2398
2399 #ifdef HAVE_IP6GRE_EXTACK
2400 static int rpl_ip6erspan_newlink(struct net *src_net, struct net_device *dev,
2401 struct nlattr *tb[], struct nlattr *data[],
2402 struct netlink_ext_ack *extack)
2403 #else
2404 static int rpl_ip6erspan_newlink(struct net *src_net, struct net_device *dev,
2405 struct nlattr *tb[], struct nlattr *data[])
2406 #endif
2407 {
2408 #ifdef HAVE_IP6GRE_EXTACK
2409 int err = ip6gre_newlink_common(src_net, dev, tb, data, extack);
2410 #else
2411 int err = ip6gre_newlink_common(src_net, dev, tb, data);
2412 #endif
2413 struct ip6_tnl *nt = netdev_priv(dev);
2414 struct net *net = dev_net(dev);
2415
2416 if (!err) {
2417 ip6erspan_tnl_link_config(nt, !tb[IFLA_MTU]);
2418 ip6gre_tunnel_link(net_generic(net, ip6gre_net_id), nt);
2419 }
2420 return err;
2421 }
2422 #define ip6erspan_newlink rpl_ip6erspan_newlink
2423
2424 static void ip6erspan_tnl_link_config(struct ip6_tnl *t, int set_mtu)
2425 {
2426 ip6gre_tnl_link_config_common(t);
2427 ip6gre_tnl_link_config_route(t, set_mtu, ip6erspan_calc_hlen(t));
2428 }
2429
2430 static int ip6erspan_tnl_change(struct ip6_tnl *t,
2431 const struct __ip6_tnl_parm *p, int set_mtu)
2432 {
2433 ip6gre_tnl_copy_tnl_parm(t, p);
2434 ip6erspan_tnl_link_config(t, set_mtu);
2435 return 0;
2436 }
2437
2438 #ifdef HAVE_IP6GRE_EXTACK
2439 static int rpl_ip6erspan_changelink(struct net_device *dev, struct nlattr *tb[],
2440 struct nlattr *data[],
2441 struct netlink_ext_ack *extack)
2442 #else
2443 static int rpl_ip6erspan_changelink(struct net_device *dev, struct nlattr *tb[],
2444 struct nlattr *data[])
2445 #endif
2446 {
2447 struct ip6gre_net *ign = net_generic(dev_net(dev), ip6gre_net_id);
2448 struct __ip6_tnl_parm p;
2449 struct ip6_tnl *t;
2450 #ifdef HAVE_IP6GRE_EXTACK
2451 t = ip6gre_changelink_common(dev, tb, data, &p, extack);
2452 #else
2453 t = ip6gre_changelink_common(dev, tb, data, &p);
2454 #endif
2455 if (IS_ERR(t))
2456 return PTR_ERR(t);
2457
2458 ip6gre_tunnel_unlink(ign, t);
2459 ip6erspan_tnl_change(t, &p, !tb[IFLA_MTU]);
2460 ip6gre_tunnel_link(ign, t);
2461 return 0;
2462 }
2463 #define ip6erspan_changelink rpl_ip6erspan_changelink
2464
2465 static struct rtnl_link_ops ip6gre_link_ops __read_mostly = {
2466 .kind = "ip6gre",
2467 .maxtype = RPL_IFLA_GRE_MAX,
2468 .policy = ip6gre_policy,
2469 .priv_size = sizeof(struct ip6_tnl),
2470 .setup = ip6gre_tunnel_setup,
2471 .validate = ip6gre_tunnel_validate,
2472 .newlink = ip6gre_newlink,
2473 .changelink = ip6gre_changelink,
2474 .dellink = ip6gre_dellink,
2475 .get_size = ip6gre_get_size,
2476 .fill_info = ip6gre_fill_info,
2477 #ifdef HAVE_GET_LINK_NET
2478 .get_link_net = ip6_tnl_get_link_net,
2479 #endif
2480 };
2481
2482 static struct rtnl_link_ops ip6gre_tap_ops __read_mostly = {
2483 .kind = "ip6gre",
2484 .maxtype = RPL_IFLA_GRE_MAX,
2485 .policy = ip6gre_policy,
2486 .priv_size = sizeof(struct ip6_tnl),
2487 .setup = ip6gre_tap_setup,
2488 .validate = ip6gre_tap_validate,
2489 .newlink = ip6gre_newlink,
2490 .changelink = ip6gre_changelink,
2491 .dellink = ip6gre_dellink,
2492 .get_size = ip6gre_get_size,
2493 .fill_info = ip6gre_fill_info,
2494 #ifdef HAVE_GET_LINK_NET
2495 .get_link_net = ip6_tnl_get_link_net,
2496 #endif
2497 };
2498
2499 static struct rtnl_link_ops ip6erspan_tap_ops __read_mostly = {
2500 .kind = "ip6erspan",
2501 .maxtype = RPL_IFLA_GRE_MAX,
2502 .policy = ip6gre_policy,
2503 .priv_size = sizeof(struct ip6_tnl),
2504 .setup = ip6erspan_tap_setup,
2505 .validate = ip6erspan_tap_validate,
2506 .newlink = ip6erspan_newlink,
2507 .changelink = ip6erspan_changelink,
2508 .dellink = ip6gre_dellink,
2509 .get_size = ip6gre_get_size,
2510 .fill_info = ip6gre_fill_info,
2511 #ifdef HAVE_GET_LINK_NET
2512 .get_link_net = ip6_tnl_get_link_net,
2513 #endif
2514 };
2515
2516 struct net_device *ip6erspan_fb_dev_create(struct net *net, const char *name,
2517 u8 name_assign_type)
2518 {
2519 struct nlattr *tb[IFLA_MAX + 1];
2520 struct net_device *dev;
2521 LIST_HEAD(list_kill);
2522 struct ip6_tnl *t;
2523 int err;
2524
2525 memset(&tb, 0, sizeof(tb));
2526
2527 dev = rtnl_create_link(net, (char *)name, name_assign_type,
2528 &ip6erspan_tap_ops, tb);
2529 if (IS_ERR(dev))
2530 return dev;
2531
2532 t = netdev_priv(dev);
2533 t->parms.collect_md = true;
2534
2535 err = ip6gre_newlink(net, dev, tb, NULL);
2536 if (err < 0) {
2537 free_netdev(dev);
2538 return ERR_PTR(err);
2539 }
2540
2541 /* openvswitch users expect packet sizes to be unrestricted,
2542 * so set the largest MTU we can.
2543 */
2544 err = ip6_tnl_change_mtu(dev, 64000);
2545 if (err)
2546 goto out;
2547
2548 return dev;
2549 out:
2550 ip6gre_dellink(dev, &list_kill);
2551 unregister_netdevice_many(&list_kill);
2552 return ERR_PTR(err);
2553 }
2554
2555 static struct vport_ops ovs_erspan6_vport_ops;
2556
2557 static struct vport *erspan6_tnl_create(const struct vport_parms *parms)
2558 {
2559 struct net *net = ovs_dp_get_net(parms->dp);
2560 struct net_device *dev;
2561 struct vport *vport;
2562 int err;
2563
2564 vport = ovs_vport_alloc(0, &ovs_erspan6_vport_ops, parms);
2565 if (IS_ERR(vport))
2566 return vport;
2567
2568 rtnl_lock();
2569 dev = ip6erspan_fb_dev_create(net, parms->name, NET_NAME_USER);
2570 if (IS_ERR(dev)) {
2571 rtnl_unlock();
2572 ovs_vport_free(vport);
2573 return ERR_CAST(dev);
2574 }
2575
2576 err = dev_change_flags(dev, dev->flags | IFF_UP);
2577 if (err < 0) {
2578 rtnl_delete_link(dev);
2579 rtnl_unlock();
2580 ovs_vport_free(vport);
2581 return ERR_PTR(err);
2582 }
2583
2584 rtnl_unlock();
2585 return vport;
2586 }
2587
2588 static struct vport *erspan6_create(const struct vport_parms *parms)
2589 {
2590 struct vport *vport;
2591
2592 vport = erspan6_tnl_create(parms);
2593 if (IS_ERR(vport))
2594 return vport;
2595
2596 return ovs_netdev_link(vport, parms->name);
2597 }
2598
2599 #ifndef OVS_VPORT_TYPE_IP6ERSPAN
2600 /* Just until integration */
2601 #define OVS_VPORT_TYPE_IP6ERSPAN 108
2602 #endif
2603 static struct vport_ops ovs_erspan6_vport_ops = {
2604 .type = OVS_VPORT_TYPE_IP6ERSPAN,
2605 .create = erspan6_create,
2606 .send = __ip6erspan_tunnel_xmit,
2607 #ifndef USE_UPSTREAM_TUNNEL
2608 .fill_metadata_dst = gre_fill_metadata_dst,
2609 #endif
2610 .destroy = ovs_netdev_tunnel_destroy,
2611 };
2612
2613 struct net_device *ip6gre_fb_dev_create(struct net *net, const char *name,
2614 u8 name_assign_type)
2615 {
2616 struct nlattr *tb[IFLA_MAX + 1];
2617 struct net_device *dev;
2618 LIST_HEAD(list_kill);
2619 struct ip6_tnl *t;
2620 int err;
2621
2622 memset(&tb, 0, sizeof(tb));
2623
2624 dev = rtnl_create_link(net, (char *)name, name_assign_type,
2625 &ip6gre_tap_ops, tb);
2626 if (IS_ERR(dev))
2627 return dev;
2628
2629 t = netdev_priv(dev);
2630 t->parms.collect_md = true;
2631
2632 err = ip6gre_newlink(net, dev, tb, NULL);
2633 if (err < 0) {
2634 free_netdev(dev);
2635 return ERR_PTR(err);
2636 }
2637
2638 /* openvswitch users expect packet sizes to be unrestricted,
2639 * so set the largest MTU we can.
2640 */
2641 err = ip6_tnl_change_mtu(dev, 64000);
2642 if (err)
2643 goto out;
2644
2645 return dev;
2646 out:
2647 ip6gre_dellink(dev, &list_kill);
2648 unregister_netdevice_many(&list_kill);
2649 return ERR_PTR(err);
2650 }
2651
2652 static struct vport_ops ovs_ip6gre_vport_ops;
2653
2654 static struct vport *ip6gre_tnl_create(const struct vport_parms *parms)
2655 {
2656 struct net *net = ovs_dp_get_net(parms->dp);
2657 struct net_device *dev;
2658 struct vport *vport;
2659 int err;
2660
2661 vport = ovs_vport_alloc(0, &ovs_ip6gre_vport_ops, parms);
2662 if (IS_ERR(vport))
2663 return vport;
2664
2665 rtnl_lock();
2666 dev = ip6gre_fb_dev_create(net, parms->name, NET_NAME_USER);
2667 if (IS_ERR(dev)) {
2668 rtnl_unlock();
2669 ovs_vport_free(vport);
2670 return ERR_CAST(dev);
2671 }
2672
2673 err = dev_change_flags(dev, dev->flags | IFF_UP);
2674 if (err < 0) {
2675 rtnl_delete_link(dev);
2676 rtnl_unlock();
2677 ovs_vport_free(vport);
2678 return ERR_PTR(err);
2679 }
2680
2681 rtnl_unlock();
2682 return vport;
2683 }
2684
2685 static struct vport *ip6gre_create(const struct vport_parms *parms)
2686 {
2687 struct vport *vport;
2688
2689 vport = ip6gre_tnl_create(parms);
2690 if (IS_ERR(vport))
2691 return vport;
2692
2693 return ovs_netdev_link(vport, parms->name);
2694 }
2695
2696 static struct vport_ops ovs_ip6gre_vport_ops = {
2697 .type = OVS_VPORT_TYPE_IP6GRE,
2698 .create = ip6gre_create,
2699 .send = __ip6gre_tunnel_xmit,
2700 #ifndef USE_UPSTREAM_TUNNEL
2701 .fill_metadata_dst = gre_fill_metadata_dst,
2702 #endif
2703 .destroy = ovs_netdev_tunnel_destroy,
2704 };
2705
2706
2707 /*
2708 * And now the modules code and kernel interface.
2709 */
2710
2711 int rpl_ip6gre_init(void)
2712 {
2713 int err;
2714
2715 err = register_pernet_device(&ip6gre_net_ops);
2716 if (err < 0)
2717 return err;
2718
2719 err = inet6_add_protocol(&ip6gre_protocol, IPPROTO_GRE);
2720 if (err < 0) {
2721 pr_info("%s: can't add protocol\n", __func__);
2722 goto add_proto_failed;
2723 }
2724
2725 pr_info("GRE over IPv6 tunneling driver\n");
2726 ovs_vport_ops_register(&ovs_ip6gre_vport_ops);
2727 ovs_vport_ops_register(&ovs_erspan6_vport_ops);
2728 return 0;
2729 out:
2730 return err;
2731
2732 add_proto_failed:
2733 unregister_pernet_device(&ip6gre_net_ops);
2734 goto out;
2735 }
2736
2737 void rpl_ip6gre_fini(void)
2738 {
2739 ovs_vport_ops_unregister(&ovs_erspan6_vport_ops);
2740 ovs_vport_ops_unregister(&ovs_ip6gre_vport_ops);
2741 inet6_del_protocol(&ip6gre_protocol, IPPROTO_GRE);
2742 unregister_pernet_device(&ip6gre_net_ops);
2743 }
2744 #endif /* USE_UPSTREAM_TUNNEL */
openvswitch mirror