xref: /openbmc/linux/net/ipv6/ip6_tunnel.c (revision 8ffdff6a)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *	IPv6 tunneling device
4  *	Linux INET6 implementation
5  *
6  *	Authors:
7  *	Ville Nuorvala		<vnuorval@tcs.hut.fi>
8  *	Yasuyuki Kozakai	<kozakai@linux-ipv6.org>
9  *
10  *      Based on:
11  *      linux/net/ipv6/sit.c and linux/net/ipv4/ipip.c
12  *
13  *      RFC 2473
14  */
15 
16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17 
18 #include <linux/module.h>
19 #include <linux/capability.h>
20 #include <linux/errno.h>
21 #include <linux/types.h>
22 #include <linux/sockios.h>
23 #include <linux/icmp.h>
24 #include <linux/if.h>
25 #include <linux/in.h>
26 #include <linux/ip.h>
27 #include <linux/net.h>
28 #include <linux/in6.h>
29 #include <linux/netdevice.h>
30 #include <linux/if_arp.h>
31 #include <linux/icmpv6.h>
32 #include <linux/init.h>
33 #include <linux/route.h>
34 #include <linux/rtnetlink.h>
35 #include <linux/netfilter_ipv6.h>
36 #include <linux/slab.h>
37 #include <linux/hash.h>
38 #include <linux/etherdevice.h>
39 
40 #include <linux/uaccess.h>
41 #include <linux/atomic.h>
42 
43 #include <net/icmp.h>
44 #include <net/ip.h>
45 #include <net/ip_tunnels.h>
46 #include <net/ipv6.h>
47 #include <net/ip6_route.h>
48 #include <net/addrconf.h>
49 #include <net/ip6_tunnel.h>
50 #include <net/xfrm.h>
51 #include <net/dsfield.h>
52 #include <net/inet_ecn.h>
53 #include <net/net_namespace.h>
54 #include <net/netns/generic.h>
55 #include <net/dst_metadata.h>
56 
57 MODULE_AUTHOR("Ville Nuorvala");
58 MODULE_DESCRIPTION("IPv6 tunneling device");
59 MODULE_LICENSE("GPL");
60 MODULE_ALIAS_RTNL_LINK("ip6tnl");
61 MODULE_ALIAS_NETDEV("ip6tnl0");
62 
63 #define IP6_TUNNEL_HASH_SIZE_SHIFT  5
64 #define IP6_TUNNEL_HASH_SIZE (1 << IP6_TUNNEL_HASH_SIZE_SHIFT)
65 
66 static bool log_ecn_error = true;
67 module_param(log_ecn_error, bool, 0644);
68 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
69 
70 static u32 HASH(const struct in6_addr *addr1, const struct in6_addr *addr2)
71 {
72 	u32 hash = ipv6_addr_hash(addr1) ^ ipv6_addr_hash(addr2);
73 
74 	return hash_32(hash, IP6_TUNNEL_HASH_SIZE_SHIFT);
75 }
76 
77 static int ip6_tnl_dev_init(struct net_device *dev);
78 static void ip6_tnl_dev_setup(struct net_device *dev);
79 static struct rtnl_link_ops ip6_link_ops __read_mostly;
80 
81 static unsigned int ip6_tnl_net_id __read_mostly;
82 struct ip6_tnl_net {
83 	/* the IPv6 tunnel fallback device */
84 	struct net_device *fb_tnl_dev;
85 	/* lists for storing tunnels in use */
86 	struct ip6_tnl __rcu *tnls_r_l[IP6_TUNNEL_HASH_SIZE];
87 	struct ip6_tnl __rcu *tnls_wc[1];
88 	struct ip6_tnl __rcu **tnls[2];
89 	struct ip6_tnl __rcu *collect_md_tun;
90 };
91 
92 static inline int ip6_tnl_mpls_supported(void)
93 {
94 	return IS_ENABLED(CONFIG_MPLS);
95 }
96 
97 #define for_each_ip6_tunnel_rcu(start) \
98 	for (t = rcu_dereference(start); t; t = rcu_dereference(t->next))
99 
100 /**
101  * ip6_tnl_lookup - fetch tunnel matching the end-point addresses
102  *   @net: network namespace
103  *   @link: ifindex of underlying interface
104  *   @remote: the address of the tunnel exit-point
105  *   @local: the address of the tunnel entry-point
106  *
107  * Return:
108  *   tunnel matching given end-points if found,
109  *   else fallback tunnel if its device is up,
110  *   else %NULL
111  **/
112 
113 static struct ip6_tnl *
114 ip6_tnl_lookup(struct net *net, int link,
115 	       const struct in6_addr *remote, const struct in6_addr *local)
116 {
117 	unsigned int hash = HASH(remote, local);
118 	struct ip6_tnl *t, *cand = NULL;
119 	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
120 	struct in6_addr any;
121 
122 	for_each_ip6_tunnel_rcu(ip6n->tnls_r_l[hash]) {
123 		if (!ipv6_addr_equal(local, &t->parms.laddr) ||
124 		    !ipv6_addr_equal(remote, &t->parms.raddr) ||
125 		    !(t->dev->flags & IFF_UP))
126 			continue;
127 
128 		if (link == t->parms.link)
129 			return t;
130 		else
131 			cand = t;
132 	}
133 
134 	memset(&any, 0, sizeof(any));
135 	hash = HASH(&any, local);
136 	for_each_ip6_tunnel_rcu(ip6n->tnls_r_l[hash]) {
137 		if (!ipv6_addr_equal(local, &t->parms.laddr) ||
138 		    !ipv6_addr_any(&t->parms.raddr) ||
139 		    !(t->dev->flags & IFF_UP))
140 			continue;
141 
142 		if (link == t->parms.link)
143 			return t;
144 		else if (!cand)
145 			cand = t;
146 	}
147 
148 	hash = HASH(remote, &any);
149 	for_each_ip6_tunnel_rcu(ip6n->tnls_r_l[hash]) {
150 		if (!ipv6_addr_equal(remote, &t->parms.raddr) ||
151 		    !ipv6_addr_any(&t->parms.laddr) ||
152 		    !(t->dev->flags & IFF_UP))
153 			continue;
154 
155 		if (link == t->parms.link)
156 			return t;
157 		else if (!cand)
158 			cand = t;
159 	}
160 
161 	if (cand)
162 		return cand;
163 
164 	t = rcu_dereference(ip6n->collect_md_tun);
165 	if (t && t->dev->flags & IFF_UP)
166 		return t;
167 
168 	t = rcu_dereference(ip6n->tnls_wc[0]);
169 	if (t && (t->dev->flags & IFF_UP))
170 		return t;
171 
172 	return NULL;
173 }
174 
175 /**
176  * ip6_tnl_bucket - get head of list matching given tunnel parameters
177  *   @ip6n: the private data for ip6_vti in the netns
178  *   @p: parameters containing tunnel end-points
179  *
180  * Description:
181  *   ip6_tnl_bucket() returns the head of the list matching the
182  *   &struct in6_addr entries laddr and raddr in @p.
183  *
184  * Return: head of IPv6 tunnel list
185  **/
186 
187 static struct ip6_tnl __rcu **
188 ip6_tnl_bucket(struct ip6_tnl_net *ip6n, const struct __ip6_tnl_parm *p)
189 {
190 	const struct in6_addr *remote = &p->raddr;
191 	const struct in6_addr *local = &p->laddr;
192 	unsigned int h = 0;
193 	int prio = 0;
194 
195 	if (!ipv6_addr_any(remote) || !ipv6_addr_any(local)) {
196 		prio = 1;
197 		h = HASH(remote, local);
198 	}
199 	return &ip6n->tnls[prio][h];
200 }
201 
202 /**
203  * ip6_tnl_link - add tunnel to hash table
204  *   @ip6n: the private data for ip6_vti in the netns
205  *   @t: tunnel to be added
206  **/
207 
208 static void
209 ip6_tnl_link(struct ip6_tnl_net *ip6n, struct ip6_tnl *t)
210 {
211 	struct ip6_tnl __rcu **tp = ip6_tnl_bucket(ip6n, &t->parms);
212 
213 	if (t->parms.collect_md)
214 		rcu_assign_pointer(ip6n->collect_md_tun, t);
215 	rcu_assign_pointer(t->next , rtnl_dereference(*tp));
216 	rcu_assign_pointer(*tp, t);
217 }
218 
219 /**
220  * ip6_tnl_unlink - remove tunnel from hash table
221  *   @ip6n: the private data for ip6_vti in the netns
222  *   @t: tunnel to be removed
223  **/
224 
225 static void
226 ip6_tnl_unlink(struct ip6_tnl_net *ip6n, struct ip6_tnl *t)
227 {
228 	struct ip6_tnl __rcu **tp;
229 	struct ip6_tnl *iter;
230 
231 	if (t->parms.collect_md)
232 		rcu_assign_pointer(ip6n->collect_md_tun, NULL);
233 
234 	for (tp = ip6_tnl_bucket(ip6n, &t->parms);
235 	     (iter = rtnl_dereference(*tp)) != NULL;
236 	     tp = &iter->next) {
237 		if (t == iter) {
238 			rcu_assign_pointer(*tp, t->next);
239 			break;
240 		}
241 	}
242 }
243 
244 static void ip6_dev_free(struct net_device *dev)
245 {
246 	struct ip6_tnl *t = netdev_priv(dev);
247 
248 	gro_cells_destroy(&t->gro_cells);
249 	dst_cache_destroy(&t->dst_cache);
250 	free_percpu(dev->tstats);
251 }
252 
253 static int ip6_tnl_create2(struct net_device *dev)
254 {
255 	struct ip6_tnl *t = netdev_priv(dev);
256 	struct net *net = dev_net(dev);
257 	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
258 	int err;
259 
260 	t = netdev_priv(dev);
261 
262 	dev->rtnl_link_ops = &ip6_link_ops;
263 	err = register_netdevice(dev);
264 	if (err < 0)
265 		goto out;
266 
267 	strcpy(t->parms.name, dev->name);
268 
269 	dev_hold(dev);
270 	ip6_tnl_link(ip6n, t);
271 	return 0;
272 
273 out:
274 	return err;
275 }
276 
277 /**
278  * ip6_tnl_create - create a new tunnel
279  *   @net: network namespace
280  *   @p: tunnel parameters
281  *
282  * Description:
283  *   Create tunnel matching given parameters.
284  *
285  * Return:
286  *   created tunnel or error pointer
287  **/
288 
289 static struct ip6_tnl *ip6_tnl_create(struct net *net, struct __ip6_tnl_parm *p)
290 {
291 	struct net_device *dev;
292 	struct ip6_tnl *t;
293 	char name[IFNAMSIZ];
294 	int err = -E2BIG;
295 
296 	if (p->name[0]) {
297 		if (!dev_valid_name(p->name))
298 			goto failed;
299 		strlcpy(name, p->name, IFNAMSIZ);
300 	} else {
301 		sprintf(name, "ip6tnl%%d");
302 	}
303 	err = -ENOMEM;
304 	dev = alloc_netdev(sizeof(*t), name, NET_NAME_UNKNOWN,
305 			   ip6_tnl_dev_setup);
306 	if (!dev)
307 		goto failed;
308 
309 	dev_net_set(dev, net);
310 
311 	t = netdev_priv(dev);
312 	t->parms = *p;
313 	t->net = dev_net(dev);
314 	err = ip6_tnl_create2(dev);
315 	if (err < 0)
316 		goto failed_free;
317 
318 	return t;
319 
320 failed_free:
321 	free_netdev(dev);
322 failed:
323 	return ERR_PTR(err);
324 }
325 
326 /**
327  * ip6_tnl_locate - find or create tunnel matching given parameters
328  *   @net: network namespace
329  *   @p: tunnel parameters
330  *   @create: != 0 if allowed to create new tunnel if no match found
331  *
332  * Description:
333  *   ip6_tnl_locate() first tries to locate an existing tunnel
334  *   based on @parms. If this is unsuccessful, but @create is set a new
335  *   tunnel device is created and registered for use.
336  *
337  * Return:
338  *   matching tunnel or error pointer
339  **/
340 
341 static struct ip6_tnl *ip6_tnl_locate(struct net *net,
342 		struct __ip6_tnl_parm *p, int create)
343 {
344 	const struct in6_addr *remote = &p->raddr;
345 	const struct in6_addr *local = &p->laddr;
346 	struct ip6_tnl __rcu **tp;
347 	struct ip6_tnl *t;
348 	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
349 
350 	for (tp = ip6_tnl_bucket(ip6n, p);
351 	     (t = rtnl_dereference(*tp)) != NULL;
352 	     tp = &t->next) {
353 		if (ipv6_addr_equal(local, &t->parms.laddr) &&
354 		    ipv6_addr_equal(remote, &t->parms.raddr) &&
355 		    p->link == t->parms.link) {
356 			if (create)
357 				return ERR_PTR(-EEXIST);
358 
359 			return t;
360 		}
361 	}
362 	if (!create)
363 		return ERR_PTR(-ENODEV);
364 	return ip6_tnl_create(net, p);
365 }
366 
367 /**
368  * ip6_tnl_dev_uninit - tunnel device uninitializer
369  *   @dev: the device to be destroyed
370  *
371  * Description:
372  *   ip6_tnl_dev_uninit() removes tunnel from its list
373  **/
374 
375 static void
376 ip6_tnl_dev_uninit(struct net_device *dev)
377 {
378 	struct ip6_tnl *t = netdev_priv(dev);
379 	struct net *net = t->net;
380 	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
381 
382 	if (dev == ip6n->fb_tnl_dev)
383 		RCU_INIT_POINTER(ip6n->tnls_wc[0], NULL);
384 	else
385 		ip6_tnl_unlink(ip6n, t);
386 	dst_cache_reset(&t->dst_cache);
387 	dev_put(dev);
388 }
389 
390 /**
391  * parse_tvl_tnl_enc_lim - handle encapsulation limit option
392  *   @skb: received socket buffer
393  *   @raw: the ICMPv6 error message data
394  *
395  * Return:
396  *   0 if none was found,
397  *   else index to encapsulation limit
398  **/
399 
400 __u16 ip6_tnl_parse_tlv_enc_lim(struct sk_buff *skb, __u8 *raw)
401 {
402 	const struct ipv6hdr *ipv6h = (const struct ipv6hdr *)raw;
403 	unsigned int nhoff = raw - skb->data;
404 	unsigned int off = nhoff + sizeof(*ipv6h);
405 	u8 next, nexthdr = ipv6h->nexthdr;
406 
407 	while (ipv6_ext_hdr(nexthdr) && nexthdr != NEXTHDR_NONE) {
408 		struct ipv6_opt_hdr *hdr;
409 		u16 optlen;
410 
411 		if (!pskb_may_pull(skb, off + sizeof(*hdr)))
412 			break;
413 
414 		hdr = (struct ipv6_opt_hdr *)(skb->data + off);
415 		if (nexthdr == NEXTHDR_FRAGMENT) {
416 			struct frag_hdr *frag_hdr = (struct frag_hdr *) hdr;
417 			if (frag_hdr->frag_off)
418 				break;
419 			optlen = 8;
420 		} else if (nexthdr == NEXTHDR_AUTH) {
421 			optlen = ipv6_authlen(hdr);
422 		} else {
423 			optlen = ipv6_optlen(hdr);
424 		}
425 		/* cache hdr->nexthdr, since pskb_may_pull() might
426 		 * invalidate hdr
427 		 */
428 		next = hdr->nexthdr;
429 		if (nexthdr == NEXTHDR_DEST) {
430 			u16 i = 2;
431 
432 			/* Remember : hdr is no longer valid at this point. */
433 			if (!pskb_may_pull(skb, off + optlen))
434 				break;
435 
436 			while (1) {
437 				struct ipv6_tlv_tnl_enc_lim *tel;
438 
439 				/* No more room for encapsulation limit */
440 				if (i + sizeof(*tel) > optlen)
441 					break;
442 
443 				tel = (struct ipv6_tlv_tnl_enc_lim *)(skb->data + off + i);
444 				/* return index of option if found and valid */
445 				if (tel->type == IPV6_TLV_TNL_ENCAP_LIMIT &&
446 				    tel->length == 1)
447 					return i + off - nhoff;
448 				/* else jump to next option */
449 				if (tel->type)
450 					i += tel->length + 2;
451 				else
452 					i++;
453 			}
454 		}
455 		nexthdr = next;
456 		off += optlen;
457 	}
458 	return 0;
459 }
460 EXPORT_SYMBOL(ip6_tnl_parse_tlv_enc_lim);
461 
462 /* ip6_tnl_err() should handle errors in the tunnel according to the
463  * specifications in RFC 2473.
464  */
465 static int
466 ip6_tnl_err(struct sk_buff *skb, __u8 ipproto, struct inet6_skb_parm *opt,
467 	    u8 *type, u8 *code, int *msg, __u32 *info, int offset)
468 {
469 	const struct ipv6hdr *ipv6h = (const struct ipv6hdr *)skb->data;
470 	struct net *net = dev_net(skb->dev);
471 	u8 rel_type = ICMPV6_DEST_UNREACH;
472 	u8 rel_code = ICMPV6_ADDR_UNREACH;
473 	__u32 rel_info = 0;
474 	struct ip6_tnl *t;
475 	int err = -ENOENT;
476 	int rel_msg = 0;
477 	u8 tproto;
478 	__u16 len;
479 
480 	/* If the packet doesn't contain the original IPv6 header we are
481 	   in trouble since we might need the source address for further
482 	   processing of the error. */
483 
484 	rcu_read_lock();
485 	t = ip6_tnl_lookup(dev_net(skb->dev), skb->dev->ifindex, &ipv6h->daddr, &ipv6h->saddr);
486 	if (!t)
487 		goto out;
488 
489 	tproto = READ_ONCE(t->parms.proto);
490 	if (tproto != ipproto && tproto != 0)
491 		goto out;
492 
493 	err = 0;
494 
495 	switch (*type) {
496 	case ICMPV6_DEST_UNREACH:
497 		net_dbg_ratelimited("%s: Path to destination invalid or inactive!\n",
498 				    t->parms.name);
499 		rel_msg = 1;
500 		break;
501 	case ICMPV6_TIME_EXCEED:
502 		if ((*code) == ICMPV6_EXC_HOPLIMIT) {
503 			net_dbg_ratelimited("%s: Too small hop limit or routing loop in tunnel!\n",
504 					    t->parms.name);
505 			rel_msg = 1;
506 		}
507 		break;
508 	case ICMPV6_PARAMPROB: {
509 		struct ipv6_tlv_tnl_enc_lim *tel;
510 		__u32 teli;
511 
512 		teli = 0;
513 		if ((*code) == ICMPV6_HDR_FIELD)
514 			teli = ip6_tnl_parse_tlv_enc_lim(skb, skb->data);
515 
516 		if (teli && teli == *info - 2) {
517 			tel = (struct ipv6_tlv_tnl_enc_lim *) &skb->data[teli];
518 			if (tel->encap_limit == 0) {
519 				net_dbg_ratelimited("%s: Too small encapsulation limit or routing loop in tunnel!\n",
520 						    t->parms.name);
521 				rel_msg = 1;
522 			}
523 		} else {
524 			net_dbg_ratelimited("%s: Recipient unable to parse tunneled packet!\n",
525 					    t->parms.name);
526 		}
527 		break;
528 	}
529 	case ICMPV6_PKT_TOOBIG: {
530 		__u32 mtu;
531 
532 		ip6_update_pmtu(skb, net, htonl(*info), 0, 0,
533 				sock_net_uid(net, NULL));
534 		mtu = *info - offset;
535 		if (mtu < IPV6_MIN_MTU)
536 			mtu = IPV6_MIN_MTU;
537 		len = sizeof(*ipv6h) + ntohs(ipv6h->payload_len);
538 		if (len > mtu) {
539 			rel_type = ICMPV6_PKT_TOOBIG;
540 			rel_code = 0;
541 			rel_info = mtu;
542 			rel_msg = 1;
543 		}
544 		break;
545 	}
546 	case NDISC_REDIRECT:
547 		ip6_redirect(skb, net, skb->dev->ifindex, 0,
548 			     sock_net_uid(net, NULL));
549 		break;
550 	}
551 
552 	*type = rel_type;
553 	*code = rel_code;
554 	*info = rel_info;
555 	*msg = rel_msg;
556 
557 out:
558 	rcu_read_unlock();
559 	return err;
560 }
561 
562 static int
563 ip4ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
564 	   u8 type, u8 code, int offset, __be32 info)
565 {
566 	__u32 rel_info = ntohl(info);
567 	const struct iphdr *eiph;
568 	struct sk_buff *skb2;
569 	int err, rel_msg = 0;
570 	u8 rel_type = type;
571 	u8 rel_code = code;
572 	struct rtable *rt;
573 	struct flowi4 fl4;
574 
575 	err = ip6_tnl_err(skb, IPPROTO_IPIP, opt, &rel_type, &rel_code,
576 			  &rel_msg, &rel_info, offset);
577 	if (err < 0)
578 		return err;
579 
580 	if (rel_msg == 0)
581 		return 0;
582 
583 	switch (rel_type) {
584 	case ICMPV6_DEST_UNREACH:
585 		if (rel_code != ICMPV6_ADDR_UNREACH)
586 			return 0;
587 		rel_type = ICMP_DEST_UNREACH;
588 		rel_code = ICMP_HOST_UNREACH;
589 		break;
590 	case ICMPV6_PKT_TOOBIG:
591 		if (rel_code != 0)
592 			return 0;
593 		rel_type = ICMP_DEST_UNREACH;
594 		rel_code = ICMP_FRAG_NEEDED;
595 		break;
596 	default:
597 		return 0;
598 	}
599 
600 	if (!pskb_may_pull(skb, offset + sizeof(struct iphdr)))
601 		return 0;
602 
603 	skb2 = skb_clone(skb, GFP_ATOMIC);
604 	if (!skb2)
605 		return 0;
606 
607 	skb_dst_drop(skb2);
608 
609 	skb_pull(skb2, offset);
610 	skb_reset_network_header(skb2);
611 	eiph = ip_hdr(skb2);
612 
613 	/* Try to guess incoming interface */
614 	rt = ip_route_output_ports(dev_net(skb->dev), &fl4, NULL, eiph->saddr,
615 				   0, 0, 0, IPPROTO_IPIP, RT_TOS(eiph->tos), 0);
616 	if (IS_ERR(rt))
617 		goto out;
618 
619 	skb2->dev = rt->dst.dev;
620 	ip_rt_put(rt);
621 
622 	/* route "incoming" packet */
623 	if (rt->rt_flags & RTCF_LOCAL) {
624 		rt = ip_route_output_ports(dev_net(skb->dev), &fl4, NULL,
625 					   eiph->daddr, eiph->saddr, 0, 0,
626 					   IPPROTO_IPIP, RT_TOS(eiph->tos), 0);
627 		if (IS_ERR(rt) || rt->dst.dev->type != ARPHRD_TUNNEL6) {
628 			if (!IS_ERR(rt))
629 				ip_rt_put(rt);
630 			goto out;
631 		}
632 		skb_dst_set(skb2, &rt->dst);
633 	} else {
634 		if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos,
635 				   skb2->dev) ||
636 		    skb_dst(skb2)->dev->type != ARPHRD_TUNNEL6)
637 			goto out;
638 	}
639 
640 	/* change mtu on this route */
641 	if (rel_type == ICMP_DEST_UNREACH && rel_code == ICMP_FRAG_NEEDED) {
642 		if (rel_info > dst_mtu(skb_dst(skb2)))
643 			goto out;
644 
645 		skb_dst_update_pmtu_no_confirm(skb2, rel_info);
646 	}
647 
648 	icmp_send(skb2, rel_type, rel_code, htonl(rel_info));
649 
650 out:
651 	kfree_skb(skb2);
652 	return 0;
653 }
654 
655 static int
656 ip6ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
657 	   u8 type, u8 code, int offset, __be32 info)
658 {
659 	__u32 rel_info = ntohl(info);
660 	int err, rel_msg = 0;
661 	u8 rel_type = type;
662 	u8 rel_code = code;
663 
664 	err = ip6_tnl_err(skb, IPPROTO_IPV6, opt, &rel_type, &rel_code,
665 			  &rel_msg, &rel_info, offset);
666 	if (err < 0)
667 		return err;
668 
669 	if (rel_msg && pskb_may_pull(skb, offset + sizeof(struct ipv6hdr))) {
670 		struct rt6_info *rt;
671 		struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
672 
673 		if (!skb2)
674 			return 0;
675 
676 		skb_dst_drop(skb2);
677 		skb_pull(skb2, offset);
678 		skb_reset_network_header(skb2);
679 
680 		/* Try to guess incoming interface */
681 		rt = rt6_lookup(dev_net(skb->dev), &ipv6_hdr(skb2)->saddr,
682 				NULL, 0, skb2, 0);
683 
684 		if (rt && rt->dst.dev)
685 			skb2->dev = rt->dst.dev;
686 
687 		icmpv6_send(skb2, rel_type, rel_code, rel_info);
688 
689 		ip6_rt_put(rt);
690 
691 		kfree_skb(skb2);
692 	}
693 
694 	return 0;
695 }
696 
697 static int
698 mplsip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
699 	    u8 type, u8 code, int offset, __be32 info)
700 {
701 	__u32 rel_info = ntohl(info);
702 	int err, rel_msg = 0;
703 	u8 rel_type = type;
704 	u8 rel_code = code;
705 
706 	err = ip6_tnl_err(skb, IPPROTO_MPLS, opt, &rel_type, &rel_code,
707 			  &rel_msg, &rel_info, offset);
708 	return err;
709 }
710 
711 static int ip4ip6_dscp_ecn_decapsulate(const struct ip6_tnl *t,
712 				       const struct ipv6hdr *ipv6h,
713 				       struct sk_buff *skb)
714 {
715 	__u8 dsfield = ipv6_get_dsfield(ipv6h) & ~INET_ECN_MASK;
716 
717 	if (t->parms.flags & IP6_TNL_F_RCV_DSCP_COPY)
718 		ipv4_change_dsfield(ip_hdr(skb), INET_ECN_MASK, dsfield);
719 
720 	return IP6_ECN_decapsulate(ipv6h, skb);
721 }
722 
723 static int ip6ip6_dscp_ecn_decapsulate(const struct ip6_tnl *t,
724 				       const struct ipv6hdr *ipv6h,
725 				       struct sk_buff *skb)
726 {
727 	if (t->parms.flags & IP6_TNL_F_RCV_DSCP_COPY)
728 		ipv6_copy_dscp(ipv6_get_dsfield(ipv6h), ipv6_hdr(skb));
729 
730 	return IP6_ECN_decapsulate(ipv6h, skb);
731 }
732 
733 static inline int mplsip6_dscp_ecn_decapsulate(const struct ip6_tnl *t,
734 					       const struct ipv6hdr *ipv6h,
735 					       struct sk_buff *skb)
736 {
737 	/* ECN is not supported in AF_MPLS */
738 	return 0;
739 }
740 
741 __u32 ip6_tnl_get_cap(struct ip6_tnl *t,
742 			     const struct in6_addr *laddr,
743 			     const struct in6_addr *raddr)
744 {
745 	struct __ip6_tnl_parm *p = &t->parms;
746 	int ltype = ipv6_addr_type(laddr);
747 	int rtype = ipv6_addr_type(raddr);
748 	__u32 flags = 0;
749 
750 	if (ltype == IPV6_ADDR_ANY || rtype == IPV6_ADDR_ANY) {
751 		flags = IP6_TNL_F_CAP_PER_PACKET;
752 	} else if (ltype & (IPV6_ADDR_UNICAST|IPV6_ADDR_MULTICAST) &&
753 		   rtype & (IPV6_ADDR_UNICAST|IPV6_ADDR_MULTICAST) &&
754 		   !((ltype|rtype) & IPV6_ADDR_LOOPBACK) &&
755 		   (!((ltype|rtype) & IPV6_ADDR_LINKLOCAL) || p->link)) {
756 		if (ltype&IPV6_ADDR_UNICAST)
757 			flags |= IP6_TNL_F_CAP_XMIT;
758 		if (rtype&IPV6_ADDR_UNICAST)
759 			flags |= IP6_TNL_F_CAP_RCV;
760 	}
761 	return flags;
762 }
763 EXPORT_SYMBOL(ip6_tnl_get_cap);
764 
765 /* called with rcu_read_lock() */
766 int ip6_tnl_rcv_ctl(struct ip6_tnl *t,
767 				  const struct in6_addr *laddr,
768 				  const struct in6_addr *raddr)
769 {
770 	struct __ip6_tnl_parm *p = &t->parms;
771 	int ret = 0;
772 	struct net *net = t->net;
773 
774 	if ((p->flags & IP6_TNL_F_CAP_RCV) ||
775 	    ((p->flags & IP6_TNL_F_CAP_PER_PACKET) &&
776 	     (ip6_tnl_get_cap(t, laddr, raddr) & IP6_TNL_F_CAP_RCV))) {
777 		struct net_device *ldev = NULL;
778 
779 		if (p->link)
780 			ldev = dev_get_by_index_rcu(net, p->link);
781 
782 		if ((ipv6_addr_is_multicast(laddr) ||
783 		     likely(ipv6_chk_addr_and_flags(net, laddr, ldev, false,
784 						    0, IFA_F_TENTATIVE))) &&
785 		    ((p->flags & IP6_TNL_F_ALLOW_LOCAL_REMOTE) ||
786 		     likely(!ipv6_chk_addr_and_flags(net, raddr, ldev, true,
787 						     0, IFA_F_TENTATIVE))))
788 			ret = 1;
789 	}
790 	return ret;
791 }
792 EXPORT_SYMBOL_GPL(ip6_tnl_rcv_ctl);
793 
794 static int __ip6_tnl_rcv(struct ip6_tnl *tunnel, struct sk_buff *skb,
795 			 const struct tnl_ptk_info *tpi,
796 			 struct metadata_dst *tun_dst,
797 			 int (*dscp_ecn_decapsulate)(const struct ip6_tnl *t,
798 						const struct ipv6hdr *ipv6h,
799 						struct sk_buff *skb),
800 			 bool log_ecn_err)
801 {
802 	struct pcpu_sw_netstats *tstats;
803 	const struct ipv6hdr *ipv6h = ipv6_hdr(skb);
804 	int err;
805 
806 	if ((!(tpi->flags & TUNNEL_CSUM) &&
807 	     (tunnel->parms.i_flags & TUNNEL_CSUM)) ||
808 	    ((tpi->flags & TUNNEL_CSUM) &&
809 	     !(tunnel->parms.i_flags & TUNNEL_CSUM))) {
810 		tunnel->dev->stats.rx_crc_errors++;
811 		tunnel->dev->stats.rx_errors++;
812 		goto drop;
813 	}
814 
815 	if (tunnel->parms.i_flags & TUNNEL_SEQ) {
816 		if (!(tpi->flags & TUNNEL_SEQ) ||
817 		    (tunnel->i_seqno &&
818 		     (s32)(ntohl(tpi->seq) - tunnel->i_seqno) < 0)) {
819 			tunnel->dev->stats.rx_fifo_errors++;
820 			tunnel->dev->stats.rx_errors++;
821 			goto drop;
822 		}
823 		tunnel->i_seqno = ntohl(tpi->seq) + 1;
824 	}
825 
826 	skb->protocol = tpi->proto;
827 
828 	/* Warning: All skb pointers will be invalidated! */
829 	if (tunnel->dev->type == ARPHRD_ETHER) {
830 		if (!pskb_may_pull(skb, ETH_HLEN)) {
831 			tunnel->dev->stats.rx_length_errors++;
832 			tunnel->dev->stats.rx_errors++;
833 			goto drop;
834 		}
835 
836 		ipv6h = ipv6_hdr(skb);
837 		skb->protocol = eth_type_trans(skb, tunnel->dev);
838 		skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
839 	} else {
840 		skb->dev = tunnel->dev;
841 	}
842 
843 	skb_reset_network_header(skb);
844 	memset(skb->cb, 0, sizeof(struct inet6_skb_parm));
845 
846 	__skb_tunnel_rx(skb, tunnel->dev, tunnel->net);
847 
848 	err = dscp_ecn_decapsulate(tunnel, ipv6h, skb);
849 	if (unlikely(err)) {
850 		if (log_ecn_err)
851 			net_info_ratelimited("non-ECT from %pI6 with DS=%#x\n",
852 					     &ipv6h->saddr,
853 					     ipv6_get_dsfield(ipv6h));
854 		if (err > 1) {
855 			++tunnel->dev->stats.rx_frame_errors;
856 			++tunnel->dev->stats.rx_errors;
857 			goto drop;
858 		}
859 	}
860 
861 	tstats = this_cpu_ptr(tunnel->dev->tstats);
862 	u64_stats_update_begin(&tstats->syncp);
863 	tstats->rx_packets++;
864 	tstats->rx_bytes += skb->len;
865 	u64_stats_update_end(&tstats->syncp);
866 
867 	skb_scrub_packet(skb, !net_eq(tunnel->net, dev_net(tunnel->dev)));
868 
869 	if (tun_dst)
870 		skb_dst_set(skb, (struct dst_entry *)tun_dst);
871 
872 	gro_cells_receive(&tunnel->gro_cells, skb);
873 	return 0;
874 
875 drop:
876 	if (tun_dst)
877 		dst_release((struct dst_entry *)tun_dst);
878 	kfree_skb(skb);
879 	return 0;
880 }
881 
882 int ip6_tnl_rcv(struct ip6_tnl *t, struct sk_buff *skb,
883 		const struct tnl_ptk_info *tpi,
884 		struct metadata_dst *tun_dst,
885 		bool log_ecn_err)
886 {
887 	int (*dscp_ecn_decapsulate)(const struct ip6_tnl *t,
888 				    const struct ipv6hdr *ipv6h,
889 				    struct sk_buff *skb);
890 
891 	dscp_ecn_decapsulate = ip6ip6_dscp_ecn_decapsulate;
892 	if (tpi->proto == htons(ETH_P_IP))
893 		dscp_ecn_decapsulate = ip4ip6_dscp_ecn_decapsulate;
894 
895 	return __ip6_tnl_rcv(t, skb, tpi, tun_dst, dscp_ecn_decapsulate,
896 			     log_ecn_err);
897 }
898 EXPORT_SYMBOL(ip6_tnl_rcv);
899 
900 static const struct tnl_ptk_info tpi_v6 = {
901 	/* no tunnel info required for ipxip6. */
902 	.proto = htons(ETH_P_IPV6),
903 };
904 
905 static const struct tnl_ptk_info tpi_v4 = {
906 	/* no tunnel info required for ipxip6. */
907 	.proto = htons(ETH_P_IP),
908 };
909 
910 static const struct tnl_ptk_info tpi_mpls = {
911 	/* no tunnel info required for mplsip6. */
912 	.proto = htons(ETH_P_MPLS_UC),
913 };
914 
915 static int ipxip6_rcv(struct sk_buff *skb, u8 ipproto,
916 		      const struct tnl_ptk_info *tpi,
917 		      int (*dscp_ecn_decapsulate)(const struct ip6_tnl *t,
918 						  const struct ipv6hdr *ipv6h,
919 						  struct sk_buff *skb))
920 {
921 	struct ip6_tnl *t;
922 	const struct ipv6hdr *ipv6h = ipv6_hdr(skb);
923 	struct metadata_dst *tun_dst = NULL;
924 	int ret = -1;
925 
926 	rcu_read_lock();
927 	t = ip6_tnl_lookup(dev_net(skb->dev), skb->dev->ifindex, &ipv6h->saddr, &ipv6h->daddr);
928 
929 	if (t) {
930 		u8 tproto = READ_ONCE(t->parms.proto);
931 
932 		if (tproto != ipproto && tproto != 0)
933 			goto drop;
934 		if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
935 			goto drop;
936 		ipv6h = ipv6_hdr(skb);
937 		if (!ip6_tnl_rcv_ctl(t, &ipv6h->daddr, &ipv6h->saddr))
938 			goto drop;
939 		if (iptunnel_pull_header(skb, 0, tpi->proto, false))
940 			goto drop;
941 		if (t->parms.collect_md) {
942 			tun_dst = ipv6_tun_rx_dst(skb, 0, 0, 0);
943 			if (!tun_dst)
944 				goto drop;
945 		}
946 		ret = __ip6_tnl_rcv(t, skb, tpi, tun_dst, dscp_ecn_decapsulate,
947 				    log_ecn_error);
948 	}
949 
950 	rcu_read_unlock();
951 
952 	return ret;
953 
954 drop:
955 	rcu_read_unlock();
956 	kfree_skb(skb);
957 	return 0;
958 }
959 
960 static int ip4ip6_rcv(struct sk_buff *skb)
961 {
962 	return ipxip6_rcv(skb, IPPROTO_IPIP, &tpi_v4,
963 			  ip4ip6_dscp_ecn_decapsulate);
964 }
965 
966 static int ip6ip6_rcv(struct sk_buff *skb)
967 {
968 	return ipxip6_rcv(skb, IPPROTO_IPV6, &tpi_v6,
969 			  ip6ip6_dscp_ecn_decapsulate);
970 }
971 
972 static int mplsip6_rcv(struct sk_buff *skb)
973 {
974 	return ipxip6_rcv(skb, IPPROTO_MPLS, &tpi_mpls,
975 			  mplsip6_dscp_ecn_decapsulate);
976 }
977 
978 struct ipv6_tel_txoption {
979 	struct ipv6_txoptions ops;
980 	__u8 dst_opt[8];
981 };
982 
983 static void init_tel_txopt(struct ipv6_tel_txoption *opt, __u8 encap_limit)
984 {
985 	memset(opt, 0, sizeof(struct ipv6_tel_txoption));
986 
987 	opt->dst_opt[2] = IPV6_TLV_TNL_ENCAP_LIMIT;
988 	opt->dst_opt[3] = 1;
989 	opt->dst_opt[4] = encap_limit;
990 	opt->dst_opt[5] = IPV6_TLV_PADN;
991 	opt->dst_opt[6] = 1;
992 
993 	opt->ops.dst1opt = (struct ipv6_opt_hdr *) opt->dst_opt;
994 	opt->ops.opt_nflen = 8;
995 }
996 
997 /**
998  * ip6_tnl_addr_conflict - compare packet addresses to tunnel's own
999  *   @t: the outgoing tunnel device
1000  *   @hdr: IPv6 header from the incoming packet
1001  *
1002  * Description:
1003  *   Avoid trivial tunneling loop by checking that tunnel exit-point
1004  *   doesn't match source of incoming packet.
1005  *
1006  * Return:
1007  *   1 if conflict,
1008  *   0 else
1009  **/
1010 
1011 static inline bool
1012 ip6_tnl_addr_conflict(const struct ip6_tnl *t, const struct ipv6hdr *hdr)
1013 {
1014 	return ipv6_addr_equal(&t->parms.raddr, &hdr->saddr);
1015 }
1016 
1017 int ip6_tnl_xmit_ctl(struct ip6_tnl *t,
1018 		     const struct in6_addr *laddr,
1019 		     const struct in6_addr *raddr)
1020 {
1021 	struct __ip6_tnl_parm *p = &t->parms;
1022 	int ret = 0;
1023 	struct net *net = t->net;
1024 
1025 	if (t->parms.collect_md)
1026 		return 1;
1027 
1028 	if ((p->flags & IP6_TNL_F_CAP_XMIT) ||
1029 	    ((p->flags & IP6_TNL_F_CAP_PER_PACKET) &&
1030 	     (ip6_tnl_get_cap(t, laddr, raddr) & IP6_TNL_F_CAP_XMIT))) {
1031 		struct net_device *ldev = NULL;
1032 
1033 		rcu_read_lock();
1034 		if (p->link)
1035 			ldev = dev_get_by_index_rcu(net, p->link);
1036 
1037 		if (unlikely(!ipv6_chk_addr_and_flags(net, laddr, ldev, false,
1038 						      0, IFA_F_TENTATIVE)))
1039 			pr_warn("%s xmit: Local address not yet configured!\n",
1040 				p->name);
1041 		else if (!(p->flags & IP6_TNL_F_ALLOW_LOCAL_REMOTE) &&
1042 			 !ipv6_addr_is_multicast(raddr) &&
1043 			 unlikely(ipv6_chk_addr_and_flags(net, raddr, ldev,
1044 							  true, 0, IFA_F_TENTATIVE)))
1045 			pr_warn("%s xmit: Routing loop! Remote address found on this node!\n",
1046 				p->name);
1047 		else
1048 			ret = 1;
1049 		rcu_read_unlock();
1050 	}
1051 	return ret;
1052 }
1053 EXPORT_SYMBOL_GPL(ip6_tnl_xmit_ctl);
1054 
1055 /**
1056  * ip6_tnl_xmit - encapsulate packet and send
1057  *   @skb: the outgoing socket buffer
1058  *   @dev: the outgoing tunnel device
1059  *   @dsfield: dscp code for outer header
1060  *   @fl6: flow of tunneled packet
1061  *   @encap_limit: encapsulation limit
1062  *   @pmtu: Path MTU is stored if packet is too big
1063  *   @proto: next header value
1064  *
1065  * Description:
1066  *   Build new header and do some sanity checks on the packet before sending
1067  *   it.
1068  *
1069  * Return:
1070  *   0 on success
1071  *   -1 fail
1072  *   %-EMSGSIZE message too big. return mtu in this case.
1073  **/
1074 
1075 int ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev, __u8 dsfield,
1076 		 struct flowi6 *fl6, int encap_limit, __u32 *pmtu,
1077 		 __u8 proto)
1078 {
1079 	struct ip6_tnl *t = netdev_priv(dev);
1080 	struct net *net = t->net;
1081 	struct net_device_stats *stats = &t->dev->stats;
1082 	struct ipv6hdr *ipv6h;
1083 	struct ipv6_tel_txoption opt;
1084 	struct dst_entry *dst = NULL, *ndst = NULL;
1085 	struct net_device *tdev;
1086 	int mtu;
1087 	unsigned int eth_hlen = t->dev->type == ARPHRD_ETHER ? ETH_HLEN : 0;
1088 	unsigned int psh_hlen = sizeof(struct ipv6hdr) + t->encap_hlen;
1089 	unsigned int max_headroom = psh_hlen;
1090 	bool use_cache = false;
1091 	u8 hop_limit;
1092 	int err = -1;
1093 
1094 	if (t->parms.collect_md) {
1095 		hop_limit = skb_tunnel_info(skb)->key.ttl;
1096 		goto route_lookup;
1097 	} else {
1098 		hop_limit = t->parms.hop_limit;
1099 	}
1100 
1101 	/* NBMA tunnel */
1102 	if (ipv6_addr_any(&t->parms.raddr)) {
1103 		if (skb->protocol == htons(ETH_P_IPV6)) {
1104 			struct in6_addr *addr6;
1105 			struct neighbour *neigh;
1106 			int addr_type;
1107 
1108 			if (!skb_dst(skb))
1109 				goto tx_err_link_failure;
1110 
1111 			neigh = dst_neigh_lookup(skb_dst(skb),
1112 						 &ipv6_hdr(skb)->daddr);
1113 			if (!neigh)
1114 				goto tx_err_link_failure;
1115 
1116 			addr6 = (struct in6_addr *)&neigh->primary_key;
1117 			addr_type = ipv6_addr_type(addr6);
1118 
1119 			if (addr_type == IPV6_ADDR_ANY)
1120 				addr6 = &ipv6_hdr(skb)->daddr;
1121 
1122 			memcpy(&fl6->daddr, addr6, sizeof(fl6->daddr));
1123 			neigh_release(neigh);
1124 		}
1125 	} else if (t->parms.proto != 0 && !(t->parms.flags &
1126 					    (IP6_TNL_F_USE_ORIG_TCLASS |
1127 					     IP6_TNL_F_USE_ORIG_FWMARK))) {
1128 		/* enable the cache only if neither the outer protocol nor the
1129 		 * routing decision depends on the current inner header value
1130 		 */
1131 		use_cache = true;
1132 	}
1133 
1134 	if (use_cache)
1135 		dst = dst_cache_get(&t->dst_cache);
1136 
1137 	if (!ip6_tnl_xmit_ctl(t, &fl6->saddr, &fl6->daddr))
1138 		goto tx_err_link_failure;
1139 
1140 	if (!dst) {
1141 route_lookup:
1142 		/* add dsfield to flowlabel for route lookup */
1143 		fl6->flowlabel = ip6_make_flowinfo(dsfield, fl6->flowlabel);
1144 
1145 		dst = ip6_route_output(net, NULL, fl6);
1146 
1147 		if (dst->error)
1148 			goto tx_err_link_failure;
1149 		dst = xfrm_lookup(net, dst, flowi6_to_flowi(fl6), NULL, 0);
1150 		if (IS_ERR(dst)) {
1151 			err = PTR_ERR(dst);
1152 			dst = NULL;
1153 			goto tx_err_link_failure;
1154 		}
1155 		if (t->parms.collect_md && ipv6_addr_any(&fl6->saddr) &&
1156 		    ipv6_dev_get_saddr(net, ip6_dst_idev(dst)->dev,
1157 				       &fl6->daddr, 0, &fl6->saddr))
1158 			goto tx_err_link_failure;
1159 		ndst = dst;
1160 	}
1161 
1162 	tdev = dst->dev;
1163 
1164 	if (tdev == dev) {
1165 		stats->collisions++;
1166 		net_warn_ratelimited("%s: Local routing loop detected!\n",
1167 				     t->parms.name);
1168 		goto tx_err_dst_release;
1169 	}
1170 	mtu = dst_mtu(dst) - eth_hlen - psh_hlen - t->tun_hlen;
1171 	if (encap_limit >= 0) {
1172 		max_headroom += 8;
1173 		mtu -= 8;
1174 	}
1175 	mtu = max(mtu, skb->protocol == htons(ETH_P_IPV6) ?
1176 		       IPV6_MIN_MTU : IPV4_MIN_MTU);
1177 
1178 	skb_dst_update_pmtu_no_confirm(skb, mtu);
1179 	if (skb->len - t->tun_hlen - eth_hlen > mtu && !skb_is_gso(skb)) {
1180 		*pmtu = mtu;
1181 		err = -EMSGSIZE;
1182 		goto tx_err_dst_release;
1183 	}
1184 
1185 	if (t->err_count > 0) {
1186 		if (time_before(jiffies,
1187 				t->err_time + IP6TUNNEL_ERR_TIMEO)) {
1188 			t->err_count--;
1189 
1190 			dst_link_failure(skb);
1191 		} else {
1192 			t->err_count = 0;
1193 		}
1194 	}
1195 
1196 	skb_scrub_packet(skb, !net_eq(t->net, dev_net(dev)));
1197 
1198 	/*
1199 	 * Okay, now see if we can stuff it in the buffer as-is.
1200 	 */
1201 	max_headroom += LL_RESERVED_SPACE(tdev);
1202 
1203 	if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
1204 	    (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
1205 		struct sk_buff *new_skb;
1206 
1207 		new_skb = skb_realloc_headroom(skb, max_headroom);
1208 		if (!new_skb)
1209 			goto tx_err_dst_release;
1210 
1211 		if (skb->sk)
1212 			skb_set_owner_w(new_skb, skb->sk);
1213 		consume_skb(skb);
1214 		skb = new_skb;
1215 	}
1216 
1217 	if (t->parms.collect_md) {
1218 		if (t->encap.type != TUNNEL_ENCAP_NONE)
1219 			goto tx_err_dst_release;
1220 	} else {
1221 		if (use_cache && ndst)
1222 			dst_cache_set_ip6(&t->dst_cache, ndst, &fl6->saddr);
1223 	}
1224 	skb_dst_set(skb, dst);
1225 
1226 	if (hop_limit == 0) {
1227 		if (skb->protocol == htons(ETH_P_IP))
1228 			hop_limit = ip_hdr(skb)->ttl;
1229 		else if (skb->protocol == htons(ETH_P_IPV6))
1230 			hop_limit = ipv6_hdr(skb)->hop_limit;
1231 		else
1232 			hop_limit = ip6_dst_hoplimit(dst);
1233 	}
1234 
1235 	/* Calculate max headroom for all the headers and adjust
1236 	 * needed_headroom if necessary.
1237 	 */
1238 	max_headroom = LL_RESERVED_SPACE(dst->dev) + sizeof(struct ipv6hdr)
1239 			+ dst->header_len + t->hlen;
1240 	if (max_headroom > dev->needed_headroom)
1241 		dev->needed_headroom = max_headroom;
1242 
1243 	skb_set_inner_ipproto(skb, proto);
1244 
1245 	err = ip6_tnl_encap(skb, t, &proto, fl6);
1246 	if (err)
1247 		return err;
1248 
1249 	if (encap_limit >= 0) {
1250 		init_tel_txopt(&opt, encap_limit);
1251 		ipv6_push_frag_opts(skb, &opt.ops, &proto);
1252 	}
1253 
1254 	skb_push(skb, sizeof(struct ipv6hdr));
1255 	skb_reset_network_header(skb);
1256 	ipv6h = ipv6_hdr(skb);
1257 	ip6_flow_hdr(ipv6h, dsfield,
1258 		     ip6_make_flowlabel(net, skb, fl6->flowlabel, true, fl6));
1259 	ipv6h->hop_limit = hop_limit;
1260 	ipv6h->nexthdr = proto;
1261 	ipv6h->saddr = fl6->saddr;
1262 	ipv6h->daddr = fl6->daddr;
1263 	ip6tunnel_xmit(NULL, skb, dev);
1264 	return 0;
1265 tx_err_link_failure:
1266 	stats->tx_carrier_errors++;
1267 	dst_link_failure(skb);
1268 tx_err_dst_release:
1269 	dst_release(dst);
1270 	return err;
1271 }
1272 EXPORT_SYMBOL(ip6_tnl_xmit);
1273 
1274 static inline int
1275 ipxip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev,
1276 		u8 protocol)
1277 {
1278 	struct ip6_tnl *t = netdev_priv(dev);
1279 	struct ipv6hdr *ipv6h;
1280 	const struct iphdr  *iph;
1281 	int encap_limit = -1;
1282 	__u16 offset;
1283 	struct flowi6 fl6;
1284 	__u8 dsfield, orig_dsfield;
1285 	__u32 mtu;
1286 	u8 tproto;
1287 	int err;
1288 
1289 	tproto = READ_ONCE(t->parms.proto);
1290 	if (tproto != protocol && tproto != 0)
1291 		return -1;
1292 
1293 	if (t->parms.collect_md) {
1294 		struct ip_tunnel_info *tun_info;
1295 		const struct ip_tunnel_key *key;
1296 
1297 		tun_info = skb_tunnel_info(skb);
1298 		if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
1299 			     ip_tunnel_info_af(tun_info) != AF_INET6))
1300 			return -1;
1301 		key = &tun_info->key;
1302 		memset(&fl6, 0, sizeof(fl6));
1303 		fl6.flowi6_proto = protocol;
1304 		fl6.saddr = key->u.ipv6.src;
1305 		fl6.daddr = key->u.ipv6.dst;
1306 		fl6.flowlabel = key->label;
1307 		dsfield =  key->tos;
1308 		switch (protocol) {
1309 		case IPPROTO_IPIP:
1310 			iph = ip_hdr(skb);
1311 			orig_dsfield = ipv4_get_dsfield(iph);
1312 			break;
1313 		case IPPROTO_IPV6:
1314 			ipv6h = ipv6_hdr(skb);
1315 			orig_dsfield = ipv6_get_dsfield(ipv6h);
1316 			break;
1317 		default:
1318 			orig_dsfield = dsfield;
1319 			break;
1320 		}
1321 	} else {
1322 		if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
1323 			encap_limit = t->parms.encap_limit;
1324 		if (protocol == IPPROTO_IPV6) {
1325 			offset = ip6_tnl_parse_tlv_enc_lim(skb,
1326 						skb_network_header(skb));
1327 			/* ip6_tnl_parse_tlv_enc_lim() might have
1328 			 * reallocated skb->head
1329 			 */
1330 			if (offset > 0) {
1331 				struct ipv6_tlv_tnl_enc_lim *tel;
1332 
1333 				tel = (void *)&skb_network_header(skb)[offset];
1334 				if (tel->encap_limit == 0) {
1335 					icmpv6_ndo_send(skb, ICMPV6_PARAMPROB,
1336 							ICMPV6_HDR_FIELD, offset + 2);
1337 					return -1;
1338 				}
1339 				encap_limit = tel->encap_limit - 1;
1340 			}
1341 		}
1342 
1343 		memcpy(&fl6, &t->fl.u.ip6, sizeof(fl6));
1344 		fl6.flowi6_proto = protocol;
1345 
1346 		if (t->parms.flags & IP6_TNL_F_USE_ORIG_FWMARK)
1347 			fl6.flowi6_mark = skb->mark;
1348 		else
1349 			fl6.flowi6_mark = t->parms.fwmark;
1350 		switch (protocol) {
1351 		case IPPROTO_IPIP:
1352 			iph = ip_hdr(skb);
1353 			orig_dsfield = ipv4_get_dsfield(iph);
1354 			if (t->parms.flags & IP6_TNL_F_USE_ORIG_TCLASS)
1355 				dsfield = orig_dsfield;
1356 			else
1357 				dsfield = ip6_tclass(t->parms.flowinfo);
1358 			break;
1359 		case IPPROTO_IPV6:
1360 			ipv6h = ipv6_hdr(skb);
1361 			orig_dsfield = ipv6_get_dsfield(ipv6h);
1362 			if (t->parms.flags & IP6_TNL_F_USE_ORIG_TCLASS)
1363 				dsfield = orig_dsfield;
1364 			else
1365 				dsfield = ip6_tclass(t->parms.flowinfo);
1366 			if (t->parms.flags & IP6_TNL_F_USE_ORIG_FLOWLABEL)
1367 				fl6.flowlabel |= ip6_flowlabel(ipv6h);
1368 			break;
1369 		default:
1370 			orig_dsfield = dsfield = ip6_tclass(t->parms.flowinfo);
1371 			break;
1372 		}
1373 	}
1374 
1375 	fl6.flowi6_uid = sock_net_uid(dev_net(dev), NULL);
1376 	dsfield = INET_ECN_encapsulate(dsfield, orig_dsfield);
1377 
1378 	if (iptunnel_handle_offloads(skb, SKB_GSO_IPXIP6))
1379 		return -1;
1380 
1381 	err = ip6_tnl_xmit(skb, dev, dsfield, &fl6, encap_limit, &mtu,
1382 			   protocol);
1383 	if (err != 0) {
1384 		/* XXX: send ICMP error even if DF is not set. */
1385 		if (err == -EMSGSIZE)
1386 			switch (protocol) {
1387 			case IPPROTO_IPIP:
1388 				icmp_ndo_send(skb, ICMP_DEST_UNREACH,
1389 					      ICMP_FRAG_NEEDED, htonl(mtu));
1390 				break;
1391 			case IPPROTO_IPV6:
1392 				icmpv6_ndo_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
1393 				break;
1394 			default:
1395 				break;
1396 			}
1397 		return -1;
1398 	}
1399 
1400 	return 0;
1401 }
1402 
1403 static netdev_tx_t
1404 ip6_tnl_start_xmit(struct sk_buff *skb, struct net_device *dev)
1405 {
1406 	struct ip6_tnl *t = netdev_priv(dev);
1407 	struct net_device_stats *stats = &t->dev->stats;
1408 	u8 ipproto;
1409 	int ret;
1410 
1411 	if (!pskb_inet_may_pull(skb))
1412 		goto tx_err;
1413 
1414 	switch (skb->protocol) {
1415 	case htons(ETH_P_IP):
1416 		ipproto = IPPROTO_IPIP;
1417 		break;
1418 	case htons(ETH_P_IPV6):
1419 		if (ip6_tnl_addr_conflict(t, ipv6_hdr(skb)))
1420 			goto tx_err;
1421 		ipproto = IPPROTO_IPV6;
1422 		break;
1423 	case htons(ETH_P_MPLS_UC):
1424 		ipproto = IPPROTO_MPLS;
1425 		break;
1426 	default:
1427 		goto tx_err;
1428 	}
1429 
1430 	ret = ipxip6_tnl_xmit(skb, dev, ipproto);
1431 	if (ret < 0)
1432 		goto tx_err;
1433 
1434 	return NETDEV_TX_OK;
1435 
1436 tx_err:
1437 	stats->tx_errors++;
1438 	stats->tx_dropped++;
1439 	kfree_skb(skb);
1440 	return NETDEV_TX_OK;
1441 }
1442 
1443 static void ip6_tnl_link_config(struct ip6_tnl *t)
1444 {
1445 	struct net_device *dev = t->dev;
1446 	struct net_device *tdev = NULL;
1447 	struct __ip6_tnl_parm *p = &t->parms;
1448 	struct flowi6 *fl6 = &t->fl.u.ip6;
1449 	unsigned int mtu;
1450 	int t_hlen;
1451 
1452 	memcpy(dev->dev_addr, &p->laddr, sizeof(struct in6_addr));
1453 	memcpy(dev->broadcast, &p->raddr, sizeof(struct in6_addr));
1454 
1455 	/* Set up flowi template */
1456 	fl6->saddr = p->laddr;
1457 	fl6->daddr = p->raddr;
1458 	fl6->flowi6_oif = p->link;
1459 	fl6->flowlabel = 0;
1460 
1461 	if (!(p->flags&IP6_TNL_F_USE_ORIG_TCLASS))
1462 		fl6->flowlabel |= IPV6_TCLASS_MASK & p->flowinfo;
1463 	if (!(p->flags&IP6_TNL_F_USE_ORIG_FLOWLABEL))
1464 		fl6->flowlabel |= IPV6_FLOWLABEL_MASK & p->flowinfo;
1465 
1466 	p->flags &= ~(IP6_TNL_F_CAP_XMIT|IP6_TNL_F_CAP_RCV|IP6_TNL_F_CAP_PER_PACKET);
1467 	p->flags |= ip6_tnl_get_cap(t, &p->laddr, &p->raddr);
1468 
1469 	if (p->flags&IP6_TNL_F_CAP_XMIT && p->flags&IP6_TNL_F_CAP_RCV)
1470 		dev->flags |= IFF_POINTOPOINT;
1471 	else
1472 		dev->flags &= ~IFF_POINTOPOINT;
1473 
1474 	t->tun_hlen = 0;
1475 	t->hlen = t->encap_hlen + t->tun_hlen;
1476 	t_hlen = t->hlen + sizeof(struct ipv6hdr);
1477 
1478 	if (p->flags & IP6_TNL_F_CAP_XMIT) {
1479 		int strict = (ipv6_addr_type(&p->raddr) &
1480 			      (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL));
1481 
1482 		struct rt6_info *rt = rt6_lookup(t->net,
1483 						 &p->raddr, &p->laddr,
1484 						 p->link, NULL, strict);
1485 		if (rt) {
1486 			tdev = rt->dst.dev;
1487 			ip6_rt_put(rt);
1488 		}
1489 
1490 		if (!tdev && p->link)
1491 			tdev = __dev_get_by_index(t->net, p->link);
1492 
1493 		if (tdev) {
1494 			dev->hard_header_len = tdev->hard_header_len + t_hlen;
1495 			mtu = min_t(unsigned int, tdev->mtu, IP6_MAX_MTU);
1496 
1497 			dev->mtu = mtu - t_hlen;
1498 			if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
1499 				dev->mtu -= 8;
1500 
1501 			if (dev->mtu < IPV6_MIN_MTU)
1502 				dev->mtu = IPV6_MIN_MTU;
1503 		}
1504 	}
1505 }
1506 
1507 /**
1508  * ip6_tnl_change - update the tunnel parameters
1509  *   @t: tunnel to be changed
1510  *   @p: tunnel configuration parameters
1511  *
1512  * Description:
1513  *   ip6_tnl_change() updates the tunnel parameters
1514  **/
1515 
1516 static int
1517 ip6_tnl_change(struct ip6_tnl *t, const struct __ip6_tnl_parm *p)
1518 {
1519 	t->parms.laddr = p->laddr;
1520 	t->parms.raddr = p->raddr;
1521 	t->parms.flags = p->flags;
1522 	t->parms.hop_limit = p->hop_limit;
1523 	t->parms.encap_limit = p->encap_limit;
1524 	t->parms.flowinfo = p->flowinfo;
1525 	t->parms.link = p->link;
1526 	t->parms.proto = p->proto;
1527 	t->parms.fwmark = p->fwmark;
1528 	dst_cache_reset(&t->dst_cache);
1529 	ip6_tnl_link_config(t);
1530 	return 0;
1531 }
1532 
1533 static int ip6_tnl_update(struct ip6_tnl *t, struct __ip6_tnl_parm *p)
1534 {
1535 	struct net *net = t->net;
1536 	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1537 	int err;
1538 
1539 	ip6_tnl_unlink(ip6n, t);
1540 	synchronize_net();
1541 	err = ip6_tnl_change(t, p);
1542 	ip6_tnl_link(ip6n, t);
1543 	netdev_state_change(t->dev);
1544 	return err;
1545 }
1546 
1547 static int ip6_tnl0_update(struct ip6_tnl *t, struct __ip6_tnl_parm *p)
1548 {
1549 	/* for default tnl0 device allow to change only the proto */
1550 	t->parms.proto = p->proto;
1551 	netdev_state_change(t->dev);
1552 	return 0;
1553 }
1554 
1555 static void
1556 ip6_tnl_parm_from_user(struct __ip6_tnl_parm *p, const struct ip6_tnl_parm *u)
1557 {
1558 	p->laddr = u->laddr;
1559 	p->raddr = u->raddr;
1560 	p->flags = u->flags;
1561 	p->hop_limit = u->hop_limit;
1562 	p->encap_limit = u->encap_limit;
1563 	p->flowinfo = u->flowinfo;
1564 	p->link = u->link;
1565 	p->proto = u->proto;
1566 	memcpy(p->name, u->name, sizeof(u->name));
1567 }
1568 
1569 static void
1570 ip6_tnl_parm_to_user(struct ip6_tnl_parm *u, const struct __ip6_tnl_parm *p)
1571 {
1572 	u->laddr = p->laddr;
1573 	u->raddr = p->raddr;
1574 	u->flags = p->flags;
1575 	u->hop_limit = p->hop_limit;
1576 	u->encap_limit = p->encap_limit;
1577 	u->flowinfo = p->flowinfo;
1578 	u->link = p->link;
1579 	u->proto = p->proto;
1580 	memcpy(u->name, p->name, sizeof(u->name));
1581 }
1582 
1583 /**
1584  * ip6_tnl_ioctl - configure ipv6 tunnels from userspace
1585  *   @dev: virtual device associated with tunnel
1586  *   @ifr: parameters passed from userspace
1587  *   @cmd: command to be performed
1588  *
1589  * Description:
1590  *   ip6_tnl_ioctl() is used for managing IPv6 tunnels
1591  *   from userspace.
1592  *
1593  *   The possible commands are the following:
1594  *     %SIOCGETTUNNEL: get tunnel parameters for device
1595  *     %SIOCADDTUNNEL: add tunnel matching given tunnel parameters
1596  *     %SIOCCHGTUNNEL: change tunnel parameters to those given
1597  *     %SIOCDELTUNNEL: delete tunnel
1598  *
1599  *   The fallback device "ip6tnl0", created during module
1600  *   initialization, can be used for creating other tunnel devices.
1601  *
1602  * Return:
1603  *   0 on success,
1604  *   %-EFAULT if unable to copy data to or from userspace,
1605  *   %-EPERM if current process hasn't %CAP_NET_ADMIN set
1606  *   %-EINVAL if passed tunnel parameters are invalid,
1607  *   %-EEXIST if changing a tunnel's parameters would cause a conflict
1608  *   %-ENODEV if attempting to change or delete a nonexisting device
1609  **/
1610 
1611 static int
1612 ip6_tnl_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1613 {
1614 	int err = 0;
1615 	struct ip6_tnl_parm p;
1616 	struct __ip6_tnl_parm p1;
1617 	struct ip6_tnl *t = netdev_priv(dev);
1618 	struct net *net = t->net;
1619 	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1620 
1621 	memset(&p1, 0, sizeof(p1));
1622 
1623 	switch (cmd) {
1624 	case SIOCGETTUNNEL:
1625 		if (dev == ip6n->fb_tnl_dev) {
1626 			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
1627 				err = -EFAULT;
1628 				break;
1629 			}
1630 			ip6_tnl_parm_from_user(&p1, &p);
1631 			t = ip6_tnl_locate(net, &p1, 0);
1632 			if (IS_ERR(t))
1633 				t = netdev_priv(dev);
1634 		} else {
1635 			memset(&p, 0, sizeof(p));
1636 		}
1637 		ip6_tnl_parm_to_user(&p, &t->parms);
1638 		if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p))) {
1639 			err = -EFAULT;
1640 		}
1641 		break;
1642 	case SIOCADDTUNNEL:
1643 	case SIOCCHGTUNNEL:
1644 		err = -EPERM;
1645 		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1646 			break;
1647 		err = -EFAULT;
1648 		if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1649 			break;
1650 		err = -EINVAL;
1651 		if (p.proto != IPPROTO_IPV6 && p.proto != IPPROTO_IPIP &&
1652 		    p.proto != 0)
1653 			break;
1654 		ip6_tnl_parm_from_user(&p1, &p);
1655 		t = ip6_tnl_locate(net, &p1, cmd == SIOCADDTUNNEL);
1656 		if (cmd == SIOCCHGTUNNEL) {
1657 			if (!IS_ERR(t)) {
1658 				if (t->dev != dev) {
1659 					err = -EEXIST;
1660 					break;
1661 				}
1662 			} else
1663 				t = netdev_priv(dev);
1664 			if (dev == ip6n->fb_tnl_dev)
1665 				err = ip6_tnl0_update(t, &p1);
1666 			else
1667 				err = ip6_tnl_update(t, &p1);
1668 		}
1669 		if (!IS_ERR(t)) {
1670 			err = 0;
1671 			ip6_tnl_parm_to_user(&p, &t->parms);
1672 			if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
1673 				err = -EFAULT;
1674 
1675 		} else {
1676 			err = PTR_ERR(t);
1677 		}
1678 		break;
1679 	case SIOCDELTUNNEL:
1680 		err = -EPERM;
1681 		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1682 			break;
1683 
1684 		if (dev == ip6n->fb_tnl_dev) {
1685 			err = -EFAULT;
1686 			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1687 				break;
1688 			err = -ENOENT;
1689 			ip6_tnl_parm_from_user(&p1, &p);
1690 			t = ip6_tnl_locate(net, &p1, 0);
1691 			if (IS_ERR(t))
1692 				break;
1693 			err = -EPERM;
1694 			if (t->dev == ip6n->fb_tnl_dev)
1695 				break;
1696 			dev = t->dev;
1697 		}
1698 		err = 0;
1699 		unregister_netdevice(dev);
1700 		break;
1701 	default:
1702 		err = -EINVAL;
1703 	}
1704 	return err;
1705 }
1706 
1707 /**
1708  * ip6_tnl_change_mtu - change mtu manually for tunnel device
1709  *   @dev: virtual device associated with tunnel
1710  *   @new_mtu: the new mtu
1711  *
1712  * Return:
1713  *   0 on success,
1714  *   %-EINVAL if mtu too small
1715  **/
1716 
1717 int ip6_tnl_change_mtu(struct net_device *dev, int new_mtu)
1718 {
1719 	struct ip6_tnl *tnl = netdev_priv(dev);
1720 
1721 	if (tnl->parms.proto == IPPROTO_IPV6) {
1722 		if (new_mtu < IPV6_MIN_MTU)
1723 			return -EINVAL;
1724 	} else {
1725 		if (new_mtu < ETH_MIN_MTU)
1726 			return -EINVAL;
1727 	}
1728 	if (tnl->parms.proto == IPPROTO_IPV6 || tnl->parms.proto == 0) {
1729 		if (new_mtu > IP6_MAX_MTU - dev->hard_header_len)
1730 			return -EINVAL;
1731 	} else {
1732 		if (new_mtu > IP_MAX_MTU - dev->hard_header_len)
1733 			return -EINVAL;
1734 	}
1735 	dev->mtu = new_mtu;
1736 	return 0;
1737 }
1738 EXPORT_SYMBOL(ip6_tnl_change_mtu);
1739 
1740 int ip6_tnl_get_iflink(const struct net_device *dev)
1741 {
1742 	struct ip6_tnl *t = netdev_priv(dev);
1743 
1744 	return t->parms.link;
1745 }
1746 EXPORT_SYMBOL(ip6_tnl_get_iflink);
1747 
1748 int ip6_tnl_encap_add_ops(const struct ip6_tnl_encap_ops *ops,
1749 			  unsigned int num)
1750 {
1751 	if (num >= MAX_IPTUN_ENCAP_OPS)
1752 		return -ERANGE;
1753 
1754 	return !cmpxchg((const struct ip6_tnl_encap_ops **)
1755 			&ip6tun_encaps[num],
1756 			NULL, ops) ? 0 : -1;
1757 }
1758 EXPORT_SYMBOL(ip6_tnl_encap_add_ops);
1759 
1760 int ip6_tnl_encap_del_ops(const struct ip6_tnl_encap_ops *ops,
1761 			  unsigned int num)
1762 {
1763 	int ret;
1764 
1765 	if (num >= MAX_IPTUN_ENCAP_OPS)
1766 		return -ERANGE;
1767 
1768 	ret = (cmpxchg((const struct ip6_tnl_encap_ops **)
1769 		       &ip6tun_encaps[num],
1770 		       ops, NULL) == ops) ? 0 : -1;
1771 
1772 	synchronize_net();
1773 
1774 	return ret;
1775 }
1776 EXPORT_SYMBOL(ip6_tnl_encap_del_ops);
1777 
1778 int ip6_tnl_encap_setup(struct ip6_tnl *t,
1779 			struct ip_tunnel_encap *ipencap)
1780 {
1781 	int hlen;
1782 
1783 	memset(&t->encap, 0, sizeof(t->encap));
1784 
1785 	hlen = ip6_encap_hlen(ipencap);
1786 	if (hlen < 0)
1787 		return hlen;
1788 
1789 	t->encap.type = ipencap->type;
1790 	t->encap.sport = ipencap->sport;
1791 	t->encap.dport = ipencap->dport;
1792 	t->encap.flags = ipencap->flags;
1793 
1794 	t->encap_hlen = hlen;
1795 	t->hlen = t->encap_hlen + t->tun_hlen;
1796 
1797 	return 0;
1798 }
1799 EXPORT_SYMBOL_GPL(ip6_tnl_encap_setup);
1800 
1801 static const struct net_device_ops ip6_tnl_netdev_ops = {
1802 	.ndo_init	= ip6_tnl_dev_init,
1803 	.ndo_uninit	= ip6_tnl_dev_uninit,
1804 	.ndo_start_xmit = ip6_tnl_start_xmit,
1805 	.ndo_do_ioctl	= ip6_tnl_ioctl,
1806 	.ndo_change_mtu = ip6_tnl_change_mtu,
1807 	.ndo_get_stats64 = dev_get_tstats64,
1808 	.ndo_get_iflink = ip6_tnl_get_iflink,
1809 };
1810 
1811 #define IPXIPX_FEATURES (NETIF_F_SG |		\
1812 			 NETIF_F_FRAGLIST |	\
1813 			 NETIF_F_HIGHDMA |	\
1814 			 NETIF_F_GSO_SOFTWARE |	\
1815 			 NETIF_F_HW_CSUM)
1816 
1817 /**
1818  * ip6_tnl_dev_setup - setup virtual tunnel device
1819  *   @dev: virtual device associated with tunnel
1820  *
1821  * Description:
1822  *   Initialize function pointers and device parameters
1823  **/
1824 
1825 static void ip6_tnl_dev_setup(struct net_device *dev)
1826 {
1827 	dev->netdev_ops = &ip6_tnl_netdev_ops;
1828 	dev->header_ops = &ip_tunnel_header_ops;
1829 	dev->needs_free_netdev = true;
1830 	dev->priv_destructor = ip6_dev_free;
1831 
1832 	dev->type = ARPHRD_TUNNEL6;
1833 	dev->flags |= IFF_NOARP;
1834 	dev->addr_len = sizeof(struct in6_addr);
1835 	dev->features |= NETIF_F_LLTX;
1836 	netif_keep_dst(dev);
1837 
1838 	dev->features		|= IPXIPX_FEATURES;
1839 	dev->hw_features	|= IPXIPX_FEATURES;
1840 
1841 	/* This perm addr will be used as interface identifier by IPv6 */
1842 	dev->addr_assign_type = NET_ADDR_RANDOM;
1843 	eth_random_addr(dev->perm_addr);
1844 }
1845 
1846 
1847 /**
1848  * ip6_tnl_dev_init_gen - general initializer for all tunnel devices
1849  *   @dev: virtual device associated with tunnel
1850  **/
1851 
1852 static inline int
1853 ip6_tnl_dev_init_gen(struct net_device *dev)
1854 {
1855 	struct ip6_tnl *t = netdev_priv(dev);
1856 	int ret;
1857 	int t_hlen;
1858 
1859 	t->dev = dev;
1860 	t->net = dev_net(dev);
1861 	dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
1862 	if (!dev->tstats)
1863 		return -ENOMEM;
1864 
1865 	ret = dst_cache_init(&t->dst_cache, GFP_KERNEL);
1866 	if (ret)
1867 		goto free_stats;
1868 
1869 	ret = gro_cells_init(&t->gro_cells, dev);
1870 	if (ret)
1871 		goto destroy_dst;
1872 
1873 	t->tun_hlen = 0;
1874 	t->hlen = t->encap_hlen + t->tun_hlen;
1875 	t_hlen = t->hlen + sizeof(struct ipv6hdr);
1876 
1877 	dev->type = ARPHRD_TUNNEL6;
1878 	dev->hard_header_len = LL_MAX_HEADER + t_hlen;
1879 	dev->mtu = ETH_DATA_LEN - t_hlen;
1880 	if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
1881 		dev->mtu -= 8;
1882 	dev->min_mtu = ETH_MIN_MTU;
1883 	dev->max_mtu = IP6_MAX_MTU - dev->hard_header_len;
1884 
1885 	return 0;
1886 
1887 destroy_dst:
1888 	dst_cache_destroy(&t->dst_cache);
1889 free_stats:
1890 	free_percpu(dev->tstats);
1891 	dev->tstats = NULL;
1892 
1893 	return ret;
1894 }
1895 
1896 /**
1897  * ip6_tnl_dev_init - initializer for all non fallback tunnel devices
1898  *   @dev: virtual device associated with tunnel
1899  **/
1900 
1901 static int ip6_tnl_dev_init(struct net_device *dev)
1902 {
1903 	struct ip6_tnl *t = netdev_priv(dev);
1904 	int err = ip6_tnl_dev_init_gen(dev);
1905 
1906 	if (err)
1907 		return err;
1908 	ip6_tnl_link_config(t);
1909 	if (t->parms.collect_md)
1910 		netif_keep_dst(dev);
1911 	return 0;
1912 }
1913 
1914 /**
1915  * ip6_fb_tnl_dev_init - initializer for fallback tunnel device
1916  *   @dev: fallback device
1917  *
1918  * Return: 0
1919  **/
1920 
1921 static int __net_init ip6_fb_tnl_dev_init(struct net_device *dev)
1922 {
1923 	struct ip6_tnl *t = netdev_priv(dev);
1924 	struct net *net = dev_net(dev);
1925 	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1926 
1927 	t->parms.proto = IPPROTO_IPV6;
1928 	dev_hold(dev);
1929 
1930 	rcu_assign_pointer(ip6n->tnls_wc[0], t);
1931 	return 0;
1932 }
1933 
1934 static int ip6_tnl_validate(struct nlattr *tb[], struct nlattr *data[],
1935 			    struct netlink_ext_ack *extack)
1936 {
1937 	u8 proto;
1938 
1939 	if (!data || !data[IFLA_IPTUN_PROTO])
1940 		return 0;
1941 
1942 	proto = nla_get_u8(data[IFLA_IPTUN_PROTO]);
1943 	if (proto != IPPROTO_IPV6 &&
1944 	    proto != IPPROTO_IPIP &&
1945 	    proto != 0)
1946 		return -EINVAL;
1947 
1948 	return 0;
1949 }
1950 
1951 static void ip6_tnl_netlink_parms(struct nlattr *data[],
1952 				  struct __ip6_tnl_parm *parms)
1953 {
1954 	memset(parms, 0, sizeof(*parms));
1955 
1956 	if (!data)
1957 		return;
1958 
1959 	if (data[IFLA_IPTUN_LINK])
1960 		parms->link = nla_get_u32(data[IFLA_IPTUN_LINK]);
1961 
1962 	if (data[IFLA_IPTUN_LOCAL])
1963 		parms->laddr = nla_get_in6_addr(data[IFLA_IPTUN_LOCAL]);
1964 
1965 	if (data[IFLA_IPTUN_REMOTE])
1966 		parms->raddr = nla_get_in6_addr(data[IFLA_IPTUN_REMOTE]);
1967 
1968 	if (data[IFLA_IPTUN_TTL])
1969 		parms->hop_limit = nla_get_u8(data[IFLA_IPTUN_TTL]);
1970 
1971 	if (data[IFLA_IPTUN_ENCAP_LIMIT])
1972 		parms->encap_limit = nla_get_u8(data[IFLA_IPTUN_ENCAP_LIMIT]);
1973 
1974 	if (data[IFLA_IPTUN_FLOWINFO])
1975 		parms->flowinfo = nla_get_be32(data[IFLA_IPTUN_FLOWINFO]);
1976 
1977 	if (data[IFLA_IPTUN_FLAGS])
1978 		parms->flags = nla_get_u32(data[IFLA_IPTUN_FLAGS]);
1979 
1980 	if (data[IFLA_IPTUN_PROTO])
1981 		parms->proto = nla_get_u8(data[IFLA_IPTUN_PROTO]);
1982 
1983 	if (data[IFLA_IPTUN_COLLECT_METADATA])
1984 		parms->collect_md = true;
1985 
1986 	if (data[IFLA_IPTUN_FWMARK])
1987 		parms->fwmark = nla_get_u32(data[IFLA_IPTUN_FWMARK]);
1988 }
1989 
1990 static bool ip6_tnl_netlink_encap_parms(struct nlattr *data[],
1991 					struct ip_tunnel_encap *ipencap)
1992 {
1993 	bool ret = false;
1994 
1995 	memset(ipencap, 0, sizeof(*ipencap));
1996 
1997 	if (!data)
1998 		return ret;
1999 
2000 	if (data[IFLA_IPTUN_ENCAP_TYPE]) {
2001 		ret = true;
2002 		ipencap->type = nla_get_u16(data[IFLA_IPTUN_ENCAP_TYPE]);
2003 	}
2004 
2005 	if (data[IFLA_IPTUN_ENCAP_FLAGS]) {
2006 		ret = true;
2007 		ipencap->flags = nla_get_u16(data[IFLA_IPTUN_ENCAP_FLAGS]);
2008 	}
2009 
2010 	if (data[IFLA_IPTUN_ENCAP_SPORT]) {
2011 		ret = true;
2012 		ipencap->sport = nla_get_be16(data[IFLA_IPTUN_ENCAP_SPORT]);
2013 	}
2014 
2015 	if (data[IFLA_IPTUN_ENCAP_DPORT]) {
2016 		ret = true;
2017 		ipencap->dport = nla_get_be16(data[IFLA_IPTUN_ENCAP_DPORT]);
2018 	}
2019 
2020 	return ret;
2021 }
2022 
2023 static int ip6_tnl_newlink(struct net *src_net, struct net_device *dev,
2024 			   struct nlattr *tb[], struct nlattr *data[],
2025 			   struct netlink_ext_ack *extack)
2026 {
2027 	struct net *net = dev_net(dev);
2028 	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
2029 	struct ip_tunnel_encap ipencap;
2030 	struct ip6_tnl *nt, *t;
2031 	int err;
2032 
2033 	nt = netdev_priv(dev);
2034 
2035 	if (ip6_tnl_netlink_encap_parms(data, &ipencap)) {
2036 		err = ip6_tnl_encap_setup(nt, &ipencap);
2037 		if (err < 0)
2038 			return err;
2039 	}
2040 
2041 	ip6_tnl_netlink_parms(data, &nt->parms);
2042 
2043 	if (nt->parms.collect_md) {
2044 		if (rtnl_dereference(ip6n->collect_md_tun))
2045 			return -EEXIST;
2046 	} else {
2047 		t = ip6_tnl_locate(net, &nt->parms, 0);
2048 		if (!IS_ERR(t))
2049 			return -EEXIST;
2050 	}
2051 
2052 	err = ip6_tnl_create2(dev);
2053 	if (!err && tb[IFLA_MTU])
2054 		ip6_tnl_change_mtu(dev, nla_get_u32(tb[IFLA_MTU]));
2055 
2056 	return err;
2057 }
2058 
2059 static int ip6_tnl_changelink(struct net_device *dev, struct nlattr *tb[],
2060 			      struct nlattr *data[],
2061 			      struct netlink_ext_ack *extack)
2062 {
2063 	struct ip6_tnl *t = netdev_priv(dev);
2064 	struct __ip6_tnl_parm p;
2065 	struct net *net = t->net;
2066 	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
2067 	struct ip_tunnel_encap ipencap;
2068 
2069 	if (dev == ip6n->fb_tnl_dev)
2070 		return -EINVAL;
2071 
2072 	if (ip6_tnl_netlink_encap_parms(data, &ipencap)) {
2073 		int err = ip6_tnl_encap_setup(t, &ipencap);
2074 
2075 		if (err < 0)
2076 			return err;
2077 	}
2078 	ip6_tnl_netlink_parms(data, &p);
2079 	if (p.collect_md)
2080 		return -EINVAL;
2081 
2082 	t = ip6_tnl_locate(net, &p, 0);
2083 	if (!IS_ERR(t)) {
2084 		if (t->dev != dev)
2085 			return -EEXIST;
2086 	} else
2087 		t = netdev_priv(dev);
2088 
2089 	return ip6_tnl_update(t, &p);
2090 }
2091 
2092 static void ip6_tnl_dellink(struct net_device *dev, struct list_head *head)
2093 {
2094 	struct net *net = dev_net(dev);
2095 	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
2096 
2097 	if (dev != ip6n->fb_tnl_dev)
2098 		unregister_netdevice_queue(dev, head);
2099 }
2100 
2101 static size_t ip6_tnl_get_size(const struct net_device *dev)
2102 {
2103 	return
2104 		/* IFLA_IPTUN_LINK */
2105 		nla_total_size(4) +
2106 		/* IFLA_IPTUN_LOCAL */
2107 		nla_total_size(sizeof(struct in6_addr)) +
2108 		/* IFLA_IPTUN_REMOTE */
2109 		nla_total_size(sizeof(struct in6_addr)) +
2110 		/* IFLA_IPTUN_TTL */
2111 		nla_total_size(1) +
2112 		/* IFLA_IPTUN_ENCAP_LIMIT */
2113 		nla_total_size(1) +
2114 		/* IFLA_IPTUN_FLOWINFO */
2115 		nla_total_size(4) +
2116 		/* IFLA_IPTUN_FLAGS */
2117 		nla_total_size(4) +
2118 		/* IFLA_IPTUN_PROTO */
2119 		nla_total_size(1) +
2120 		/* IFLA_IPTUN_ENCAP_TYPE */
2121 		nla_total_size(2) +
2122 		/* IFLA_IPTUN_ENCAP_FLAGS */
2123 		nla_total_size(2) +
2124 		/* IFLA_IPTUN_ENCAP_SPORT */
2125 		nla_total_size(2) +
2126 		/* IFLA_IPTUN_ENCAP_DPORT */
2127 		nla_total_size(2) +
2128 		/* IFLA_IPTUN_COLLECT_METADATA */
2129 		nla_total_size(0) +
2130 		/* IFLA_IPTUN_FWMARK */
2131 		nla_total_size(4) +
2132 		0;
2133 }
2134 
2135 static int ip6_tnl_fill_info(struct sk_buff *skb, const struct net_device *dev)
2136 {
2137 	struct ip6_tnl *tunnel = netdev_priv(dev);
2138 	struct __ip6_tnl_parm *parm = &tunnel->parms;
2139 
2140 	if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
2141 	    nla_put_in6_addr(skb, IFLA_IPTUN_LOCAL, &parm->laddr) ||
2142 	    nla_put_in6_addr(skb, IFLA_IPTUN_REMOTE, &parm->raddr) ||
2143 	    nla_put_u8(skb, IFLA_IPTUN_TTL, parm->hop_limit) ||
2144 	    nla_put_u8(skb, IFLA_IPTUN_ENCAP_LIMIT, parm->encap_limit) ||
2145 	    nla_put_be32(skb, IFLA_IPTUN_FLOWINFO, parm->flowinfo) ||
2146 	    nla_put_u32(skb, IFLA_IPTUN_FLAGS, parm->flags) ||
2147 	    nla_put_u8(skb, IFLA_IPTUN_PROTO, parm->proto) ||
2148 	    nla_put_u32(skb, IFLA_IPTUN_FWMARK, parm->fwmark))
2149 		goto nla_put_failure;
2150 
2151 	if (nla_put_u16(skb, IFLA_IPTUN_ENCAP_TYPE, tunnel->encap.type) ||
2152 	    nla_put_be16(skb, IFLA_IPTUN_ENCAP_SPORT, tunnel->encap.sport) ||
2153 	    nla_put_be16(skb, IFLA_IPTUN_ENCAP_DPORT, tunnel->encap.dport) ||
2154 	    nla_put_u16(skb, IFLA_IPTUN_ENCAP_FLAGS, tunnel->encap.flags))
2155 		goto nla_put_failure;
2156 
2157 	if (parm->collect_md)
2158 		if (nla_put_flag(skb, IFLA_IPTUN_COLLECT_METADATA))
2159 			goto nla_put_failure;
2160 
2161 	return 0;
2162 
2163 nla_put_failure:
2164 	return -EMSGSIZE;
2165 }
2166 
2167 struct net *ip6_tnl_get_link_net(const struct net_device *dev)
2168 {
2169 	struct ip6_tnl *tunnel = netdev_priv(dev);
2170 
2171 	return tunnel->net;
2172 }
2173 EXPORT_SYMBOL(ip6_tnl_get_link_net);
2174 
2175 static const struct nla_policy ip6_tnl_policy[IFLA_IPTUN_MAX + 1] = {
2176 	[IFLA_IPTUN_LINK]		= { .type = NLA_U32 },
2177 	[IFLA_IPTUN_LOCAL]		= { .len = sizeof(struct in6_addr) },
2178 	[IFLA_IPTUN_REMOTE]		= { .len = sizeof(struct in6_addr) },
2179 	[IFLA_IPTUN_TTL]		= { .type = NLA_U8 },
2180 	[IFLA_IPTUN_ENCAP_LIMIT]	= { .type = NLA_U8 },
2181 	[IFLA_IPTUN_FLOWINFO]		= { .type = NLA_U32 },
2182 	[IFLA_IPTUN_FLAGS]		= { .type = NLA_U32 },
2183 	[IFLA_IPTUN_PROTO]		= { .type = NLA_U8 },
2184 	[IFLA_IPTUN_ENCAP_TYPE]		= { .type = NLA_U16 },
2185 	[IFLA_IPTUN_ENCAP_FLAGS]	= { .type = NLA_U16 },
2186 	[IFLA_IPTUN_ENCAP_SPORT]	= { .type = NLA_U16 },
2187 	[IFLA_IPTUN_ENCAP_DPORT]	= { .type = NLA_U16 },
2188 	[IFLA_IPTUN_COLLECT_METADATA]	= { .type = NLA_FLAG },
2189 	[IFLA_IPTUN_FWMARK]		= { .type = NLA_U32 },
2190 };
2191 
2192 static struct rtnl_link_ops ip6_link_ops __read_mostly = {
2193 	.kind		= "ip6tnl",
2194 	.maxtype	= IFLA_IPTUN_MAX,
2195 	.policy		= ip6_tnl_policy,
2196 	.priv_size	= sizeof(struct ip6_tnl),
2197 	.setup		= ip6_tnl_dev_setup,
2198 	.validate	= ip6_tnl_validate,
2199 	.newlink	= ip6_tnl_newlink,
2200 	.changelink	= ip6_tnl_changelink,
2201 	.dellink	= ip6_tnl_dellink,
2202 	.get_size	= ip6_tnl_get_size,
2203 	.fill_info	= ip6_tnl_fill_info,
2204 	.get_link_net	= ip6_tnl_get_link_net,
2205 };
2206 
2207 static struct xfrm6_tunnel ip4ip6_handler __read_mostly = {
2208 	.handler	= ip4ip6_rcv,
2209 	.err_handler	= ip4ip6_err,
2210 	.priority	=	1,
2211 };
2212 
2213 static struct xfrm6_tunnel ip6ip6_handler __read_mostly = {
2214 	.handler	= ip6ip6_rcv,
2215 	.err_handler	= ip6ip6_err,
2216 	.priority	=	1,
2217 };
2218 
2219 static struct xfrm6_tunnel mplsip6_handler __read_mostly = {
2220 	.handler	= mplsip6_rcv,
2221 	.err_handler	= mplsip6_err,
2222 	.priority	=	1,
2223 };
2224 
2225 static void __net_exit ip6_tnl_destroy_tunnels(struct net *net, struct list_head *list)
2226 {
2227 	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
2228 	struct net_device *dev, *aux;
2229 	int h;
2230 	struct ip6_tnl *t;
2231 
2232 	for_each_netdev_safe(net, dev, aux)
2233 		if (dev->rtnl_link_ops == &ip6_link_ops)
2234 			unregister_netdevice_queue(dev, list);
2235 
2236 	for (h = 0; h < IP6_TUNNEL_HASH_SIZE; h++) {
2237 		t = rtnl_dereference(ip6n->tnls_r_l[h]);
2238 		while (t) {
2239 			/* If dev is in the same netns, it has already
2240 			 * been added to the list by the previous loop.
2241 			 */
2242 			if (!net_eq(dev_net(t->dev), net))
2243 				unregister_netdevice_queue(t->dev, list);
2244 			t = rtnl_dereference(t->next);
2245 		}
2246 	}
2247 }
2248 
2249 static int __net_init ip6_tnl_init_net(struct net *net)
2250 {
2251 	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
2252 	struct ip6_tnl *t = NULL;
2253 	int err;
2254 
2255 	ip6n->tnls[0] = ip6n->tnls_wc;
2256 	ip6n->tnls[1] = ip6n->tnls_r_l;
2257 
2258 	if (!net_has_fallback_tunnels(net))
2259 		return 0;
2260 	err = -ENOMEM;
2261 	ip6n->fb_tnl_dev = alloc_netdev(sizeof(struct ip6_tnl), "ip6tnl0",
2262 					NET_NAME_UNKNOWN, ip6_tnl_dev_setup);
2263 
2264 	if (!ip6n->fb_tnl_dev)
2265 		goto err_alloc_dev;
2266 	dev_net_set(ip6n->fb_tnl_dev, net);
2267 	ip6n->fb_tnl_dev->rtnl_link_ops = &ip6_link_ops;
2268 	/* FB netdevice is special: we have one, and only one per netns.
2269 	 * Allowing to move it to another netns is clearly unsafe.
2270 	 */
2271 	ip6n->fb_tnl_dev->features |= NETIF_F_NETNS_LOCAL;
2272 
2273 	err = ip6_fb_tnl_dev_init(ip6n->fb_tnl_dev);
2274 	if (err < 0)
2275 		goto err_register;
2276 
2277 	err = register_netdev(ip6n->fb_tnl_dev);
2278 	if (err < 0)
2279 		goto err_register;
2280 
2281 	t = netdev_priv(ip6n->fb_tnl_dev);
2282 
2283 	strcpy(t->parms.name, ip6n->fb_tnl_dev->name);
2284 	return 0;
2285 
2286 err_register:
2287 	free_netdev(ip6n->fb_tnl_dev);
2288 err_alloc_dev:
2289 	return err;
2290 }
2291 
2292 static void __net_exit ip6_tnl_exit_batch_net(struct list_head *net_list)
2293 {
2294 	struct net *net;
2295 	LIST_HEAD(list);
2296 
2297 	rtnl_lock();
2298 	list_for_each_entry(net, net_list, exit_list)
2299 		ip6_tnl_destroy_tunnels(net, &list);
2300 	unregister_netdevice_many(&list);
2301 	rtnl_unlock();
2302 }
2303 
2304 static struct pernet_operations ip6_tnl_net_ops = {
2305 	.init = ip6_tnl_init_net,
2306 	.exit_batch = ip6_tnl_exit_batch_net,
2307 	.id   = &ip6_tnl_net_id,
2308 	.size = sizeof(struct ip6_tnl_net),
2309 };
2310 
2311 /**
2312  * ip6_tunnel_init - register protocol and reserve needed resources
2313  *
2314  * Return: 0 on success
2315  **/
2316 
2317 static int __init ip6_tunnel_init(void)
2318 {
2319 	int  err;
2320 
2321 	if (!ipv6_mod_enabled())
2322 		return -EOPNOTSUPP;
2323 
2324 	err = register_pernet_device(&ip6_tnl_net_ops);
2325 	if (err < 0)
2326 		goto out_pernet;
2327 
2328 	err = xfrm6_tunnel_register(&ip4ip6_handler, AF_INET);
2329 	if (err < 0) {
2330 		pr_err("%s: can't register ip4ip6\n", __func__);
2331 		goto out_ip4ip6;
2332 	}
2333 
2334 	err = xfrm6_tunnel_register(&ip6ip6_handler, AF_INET6);
2335 	if (err < 0) {
2336 		pr_err("%s: can't register ip6ip6\n", __func__);
2337 		goto out_ip6ip6;
2338 	}
2339 
2340 	if (ip6_tnl_mpls_supported()) {
2341 		err = xfrm6_tunnel_register(&mplsip6_handler, AF_MPLS);
2342 		if (err < 0) {
2343 			pr_err("%s: can't register mplsip6\n", __func__);
2344 			goto out_mplsip6;
2345 		}
2346 	}
2347 
2348 	err = rtnl_link_register(&ip6_link_ops);
2349 	if (err < 0)
2350 		goto rtnl_link_failed;
2351 
2352 	return 0;
2353 
2354 rtnl_link_failed:
2355 	if (ip6_tnl_mpls_supported())
2356 		xfrm6_tunnel_deregister(&mplsip6_handler, AF_MPLS);
2357 out_mplsip6:
2358 	xfrm6_tunnel_deregister(&ip6ip6_handler, AF_INET6);
2359 out_ip6ip6:
2360 	xfrm6_tunnel_deregister(&ip4ip6_handler, AF_INET);
2361 out_ip4ip6:
2362 	unregister_pernet_device(&ip6_tnl_net_ops);
2363 out_pernet:
2364 	return err;
2365 }
2366 
2367 /**
2368  * ip6_tunnel_cleanup - free resources and unregister protocol
2369  **/
2370 
2371 static void __exit ip6_tunnel_cleanup(void)
2372 {
2373 	rtnl_link_unregister(&ip6_link_ops);
2374 	if (xfrm6_tunnel_deregister(&ip4ip6_handler, AF_INET))
2375 		pr_info("%s: can't deregister ip4ip6\n", __func__);
2376 
2377 	if (xfrm6_tunnel_deregister(&ip6ip6_handler, AF_INET6))
2378 		pr_info("%s: can't deregister ip6ip6\n", __func__);
2379 
2380 	if (ip6_tnl_mpls_supported() &&
2381 	    xfrm6_tunnel_deregister(&mplsip6_handler, AF_MPLS))
2382 		pr_info("%s: can't deregister mplsip6\n", __func__);
2383 	unregister_pernet_device(&ip6_tnl_net_ops);
2384 }
2385 
2386 module_init(ip6_tunnel_init);
2387 module_exit(ip6_tunnel_cleanup);
2388