projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'for-3.16' of git://linux-nfs.org/~bfields/linux
[deliverable/linux.git] / net / ipv4 / ip_tunnel.c
CommitLineData
c5441932
PS		 1/*
2 * Copyright (c) 2013 Nicira, Inc.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of version 2 of the GNU General Public
6 * License as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
16 * 02110-1301, USA
17 */
18
19#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20
21#include <linux/capability.h>
22#include <linux/module.h>
23#include <linux/types.h>
24#include <linux/kernel.h>
25#include <linux/slab.h>
26#include <linux/uaccess.h>
27#include <linux/skbuff.h>
28#include <linux/netdevice.h>
29#include <linux/in.h>
30#include <linux/tcp.h>
31#include <linux/udp.h>
32#include <linux/if_arp.h>
33#include <linux/mroute.h>
34#include <linux/init.h>
35#include <linux/in6.h>
36#include <linux/inetdevice.h>
37#include <linux/igmp.h>
38#include <linux/netfilter_ipv4.h>
39#include <linux/etherdevice.h>
40#include <linux/if_ether.h>
41#include <linux/if_vlan.h>
42#include <linux/rculist.h>
27d79f3b 43#include <linux/err.h>
c5441932
PS		 44
45#include <net/sock.h>
46#include <net/ip.h>
47#include <net/icmp.h>
48#include <net/protocol.h>
49#include <net/ip_tunnels.h>
50#include <net/arp.h>
51#include <net/checksum.h>
52#include <net/dsfield.h>
53#include <net/inet_ecn.h>
54#include <net/xfrm.h>
55#include <net/net_namespace.h>
56#include <net/netns/generic.h>
57#include <net/rtnetlink.h>
58
59#if IS_ENABLED(CONFIG_IPV6)
60#include <net/ipv6.h>
61#include <net/ip6_fib.h>
62#include <net/ip6_route.h>
63#endif
64
967680e0 65static unsigned int ip_tunnel_hash(__be32 key, __be32 remote)
c5441932
PS		 66{
67 return hash_32((__force u32)key ^ (__force u32)remote,
68 IP_TNL_HASH_BITS);
69}
70
6c7e7610
ED		 71static void __tunnel_dst_set(struct ip_tunnel_dst *idst,
72 struct dst_entry *dst)
7d442fab
TH		 73{
74 struct dst_entry *old_dst;
75
f8864972 76 dst_clone(dst);
6c7e7610 77 old_dst = xchg((__force struct dst_entry **)&idst->dst, dst);
7d442fab 78 dst_release(old_dst);
7d442fab
TH		 79}
80
6c7e7610 81static void tunnel_dst_set(struct ip_tunnel *t, struct dst_entry *dst)
7d442fab 82{
9a4aa9af 83 __tunnel_dst_set(this_cpu_ptr(t->dst_cache), dst);
7d442fab
TH		 84}
85
6c7e7610 86static void tunnel_dst_reset(struct ip_tunnel *t)
7d442fab
TH		 87{
88 tunnel_dst_set(t, NULL);
89}
90
cf71d2bc 91void ip_tunnel_dst_reset_all(struct ip_tunnel *t)
9a4aa9af
TH		 92{
93 int i;
94
95 for_each_possible_cpu(i)
96 __tunnel_dst_set(per_cpu_ptr(t->dst_cache, i), NULL);
97}
cf71d2bc 98EXPORT_SYMBOL(ip_tunnel_dst_reset_all);
9a4aa9af 99
b045d37b 100static struct rtable *tunnel_rtable_get(struct ip_tunnel *t, u32 cookie)
7d442fab
TH		 101{
102 struct dst_entry *dst;
103
104 rcu_read_lock();
9a4aa9af 105 dst = rcu_dereference(this_cpu_ptr(t->dst_cache)->dst);
f8864972
ED		 106 if (dst && !atomic_inc_not_zero(&dst->__refcnt))
107 dst = NULL;
b045d37b
ED		 108 if (dst) {
109 if (dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
b045d37b 110 tunnel_dst_reset(t);
f8864972
ED		 111 dst_release(dst);
112 dst = NULL;
b045d37b 113 }
7d442fab 114 }
b045d37b
ED		 115 rcu_read_unlock();
116 return (struct rtable *)dst;
7d442fab
TH		 117}
118
c5441932
PS		 119static bool ip_tunnel_key_match(const struct ip_tunnel_parm *p,
120 __be16 flags, __be32 key)
121{
122 if (p->i_flags & TUNNEL_KEY) {
123 if (flags & TUNNEL_KEY)
124 return key == p->i_key;
125 else
126 /* key expected, none present */
127 return false;
128 } else
129 return !(flags & TUNNEL_KEY);
130}
131
132/* Fallback tunnel: no source, no destination, no key, no options
133
134 Tunnel hash table:
135 We require exact key match i.e. if a key is present in packet
136 it will match only tunnel with the same key; if it is not present,
137 it will match only keyless tunnel.
138
139 All keysless packets, if not matched configured keyless tunnels
140 will match fallback tunnel.
141 Given src, dst and key, find appropriate for input tunnel.
142*/
143struct ip_tunnel *ip_tunnel_lookup(struct ip_tunnel_net *itn,
144 int link, __be16 flags,
145 __be32 remote, __be32 local,
146 __be32 key)
147{
148 unsigned int hash;
149 struct ip_tunnel *t, *cand = NULL;
150 struct hlist_head *head;
151
967680e0 152 hash = ip_tunnel_hash(key, remote);
c5441932
PS		 153 head = &itn->tunnels[hash];
154
155 hlist_for_each_entry_rcu(t, head, hash_node) {
156 if (local != t->parms.iph.saddr ||
157 remote != t->parms.iph.daddr ||
158 !(t->dev->flags & IFF_UP))
159 continue;
160
161 if (!ip_tunnel_key_match(&t->parms, flags, key))
162 continue;
163
164 if (t->parms.link == link)
165 return t;
166 else
167 cand = t;
168 }
169
170 hlist_for_each_entry_rcu(t, head, hash_node) {
171 if (remote != t->parms.iph.daddr ||
172 !(t->dev->flags & IFF_UP))
173 continue;
174
175 if (!ip_tunnel_key_match(&t->parms, flags, key))
176 continue;
177
178 if (t->parms.link == link)
179 return t;
180 else if (!cand)
181 cand = t;
182 }
183
967680e0 184 hash = ip_tunnel_hash(key, 0);
c5441932
PS		 185 head = &itn->tunnels[hash];
186
187 hlist_for_each_entry_rcu(t, head, hash_node) {
188 if ((local != t->parms.iph.saddr &&
189 (local != t->parms.iph.daddr ||
190 !ipv4_is_multicast(local))) ||
191 !(t->dev->flags & IFF_UP))
192 continue;
193
194 if (!ip_tunnel_key_match(&t->parms, flags, key))
195 continue;
196
197 if (t->parms.link == link)
198 return t;
199 else if (!cand)
200 cand = t;
201 }
202
203 if (flags & TUNNEL_NO_KEY)
204 goto skip_key_lookup;
205
206 hlist_for_each_entry_rcu(t, head, hash_node) {
207 if (t->parms.i_key != key ||
208 !(t->dev->flags & IFF_UP))
209 continue;
210
211 if (t->parms.link == link)
212 return t;
213 else if (!cand)
214 cand = t;
215 }
216
217skip_key_lookup:
218 if (cand)
219 return cand;
220
221 if (itn->fb_tunnel_dev && itn->fb_tunnel_dev->flags & IFF_UP)
222 return netdev_priv(itn->fb_tunnel_dev);
223
224
225 return NULL;
226}
227EXPORT_SYMBOL_GPL(ip_tunnel_lookup);
228
229static struct hlist_head *ip_bucket(struct ip_tunnel_net *itn,
230 struct ip_tunnel_parm *parms)
231{
232 unsigned int h;
233 __be32 remote;
6d608f06 234 __be32 i_key = parms->i_key;
c5441932
PS		 235
236 if (parms->iph.daddr && !ipv4_is_multicast(parms->iph.daddr))
237 remote = parms->iph.daddr;
238 else
239 remote = 0;
240
6d608f06
SK		 241 if (!(parms->i_flags & TUNNEL_KEY) && (parms->i_flags & VTI_ISVTI))
242 i_key = 0;
243
244 h = ip_tunnel_hash(i_key, remote);
c5441932
PS		 245 return &itn->tunnels[h];
246}
247
248static void ip_tunnel_add(struct ip_tunnel_net *itn, struct ip_tunnel *t)
249{
250 struct hlist_head *head = ip_bucket(itn, &t->parms);
251
252 hlist_add_head_rcu(&t->hash_node, head);
253}
254
255static void ip_tunnel_del(struct ip_tunnel *t)
256{
257 hlist_del_init_rcu(&t->hash_node);
258}
259
260static struct ip_tunnel *ip_tunnel_find(struct ip_tunnel_net *itn,
261 struct ip_tunnel_parm *parms,
262 int type)
263{
264 __be32 remote = parms->iph.daddr;
265 __be32 local = parms->iph.saddr;
266 __be32 key = parms->i_key;
5ce54af1 267 __be16 flags = parms->i_flags;
c5441932
PS		 268 int link = parms->link;
269 struct ip_tunnel *t = NULL;
270 struct hlist_head *head = ip_bucket(itn, parms);
271
272 hlist_for_each_entry_rcu(t, head, hash_node) {
273 if (local == t->parms.iph.saddr &&
274 remote == t->parms.iph.daddr &&
c5441932 275 link == t->parms.link &&
5ce54af1
DP		 276 type == t->dev->type &&
277 ip_tunnel_key_match(&t->parms, flags, key))
c5441932
PS		 278 break;
279 }
280 return t;
281}
282
283static struct net_device *__ip_tunnel_create(struct net *net,
284 const struct rtnl_link_ops *ops,
285 struct ip_tunnel_parm *parms)
286{
287 int err;
288 struct ip_tunnel *tunnel;
289 struct net_device *dev;
290 char name[IFNAMSIZ];
291
292 if (parms->name[0])
293 strlcpy(name, parms->name, IFNAMSIZ);
294 else {
54a5d382 295 if (strlen(ops->kind) > (IFNAMSIZ - 3)) {
c5441932
PS		 296 err = -E2BIG;
297 goto failed;
298 }
299 strlcpy(name, ops->kind, IFNAMSIZ);
300 strncat(name, "%d", 2);
301 }
302
303 ASSERT_RTNL();
304 dev = alloc_netdev(ops->priv_size, name, ops->setup);
305 if (!dev) {
306 err = -ENOMEM;
307 goto failed;
308 }
309 dev_net_set(dev, net);
310
311 dev->rtnl_link_ops = ops;
312
313 tunnel = netdev_priv(dev);
314 tunnel->parms = *parms;
5e6700b3 315 tunnel->net = net;
c5441932
PS		 316
317 err = register_netdevice(dev);
318 if (err)
319 goto failed_free;
320
321 return dev;
322
323failed_free:
324 free_netdev(dev);
325failed:
326 return ERR_PTR(err);
327}
328
7d442fab
TH		 329static inline void init_tunnel_flow(struct flowi4 *fl4,
330 int proto,
331 __be32 daddr, __be32 saddr,
332 __be32 key, __u8 tos, int oif)
c5441932
PS		 333{
334 memset(fl4, 0, sizeof(*fl4));
335 fl4->flowi4_oif = oif;
336 fl4->daddr = daddr;
337 fl4->saddr = saddr;
338 fl4->flowi4_tos = tos;
339 fl4->flowi4_proto = proto;
340 fl4->fl4_gre_key = key;
c5441932
PS		 341}
342
343static int ip_tunnel_bind_dev(struct net_device *dev)
344{
345 struct net_device *tdev = NULL;
346 struct ip_tunnel *tunnel = netdev_priv(dev);
347 const struct iphdr *iph;
348 int hlen = LL_MAX_HEADER;
349 int mtu = ETH_DATA_LEN;
350 int t_hlen = tunnel->hlen + sizeof(struct iphdr);
351
352 iph = &tunnel->parms.iph;
353
354 /* Guess output device to choose reasonable mtu and needed_headroom */
355 if (iph->daddr) {
356 struct flowi4 fl4;
357 struct rtable *rt;
358
7d442fab
TH		 359 init_tunnel_flow(&fl4, iph->protocol, iph->daddr,
360 iph->saddr, tunnel->parms.o_key,
361 RT_TOS(iph->tos), tunnel->parms.link);
362 rt = ip_route_output_key(tunnel->net, &fl4);
363
c5441932
PS		 364 if (!IS_ERR(rt)) {
365 tdev = rt->dst.dev;
6c7e7610 366 tunnel_dst_set(tunnel, &rt->dst);
c5441932
PS		 367 ip_rt_put(rt);
368 }
369 if (dev->type != ARPHRD_ETHER)
370 dev->flags |= IFF_POINTOPOINT;
371 }
372
373 if (!tdev && tunnel->parms.link)
6c742e71 374 tdev = __dev_get_by_index(tunnel->net, tunnel->parms.link);
c5441932
PS		 375
376 if (tdev) {
377 hlen = tdev->hard_header_len + tdev->needed_headroom;
378 mtu = tdev->mtu;
379 }
380 dev->iflink = tunnel->parms.link;
381
382 dev->needed_headroom = t_hlen + hlen;
383 mtu -= (dev->hard_header_len + t_hlen);
384
385 if (mtu < 68)
386 mtu = 68;
387
388 return mtu;
389}
390
391static struct ip_tunnel *ip_tunnel_create(struct net *net,
392 struct ip_tunnel_net *itn,
393 struct ip_tunnel_parm *parms)
394{
4929fd8c 395 struct ip_tunnel *nt;
c5441932
PS		 396 struct net_device *dev;
397
398 BUG_ON(!itn->fb_tunnel_dev);
c5441932
PS		 399 dev = __ip_tunnel_create(net, itn->fb_tunnel_dev->rtnl_link_ops, parms);
400 if (IS_ERR(dev))
6dd3c9ec 401 return ERR_CAST(dev);
c5441932
PS		 402
403 dev->mtu = ip_tunnel_bind_dev(dev);
404
405 nt = netdev_priv(dev);
406 ip_tunnel_add(itn, nt);
407 return nt;
408}
409
410int ip_tunnel_rcv(struct ip_tunnel *tunnel, struct sk_buff *skb,
411 const struct tnl_ptk_info *tpi, bool log_ecn_error)
412{
8f84985f 413 struct pcpu_sw_netstats *tstats;
c5441932
PS		 414 const struct iphdr *iph = ip_hdr(skb);
415 int err;
416
c5441932
PS		 417#ifdef CONFIG_NET_IPGRE_BROADCAST
418 if (ipv4_is_multicast(iph->daddr)) {
c5441932
PS		 419 tunnel->dev->stats.multicast++;
420 skb->pkt_type = PACKET_BROADCAST;
421 }
422#endif
423
424 if ((!(tpi->flags&TUNNEL_CSUM) && (tunnel->parms.i_flags&TUNNEL_CSUM)) ||
425 ((tpi->flags&TUNNEL_CSUM) && !(tunnel->parms.i_flags&TUNNEL_CSUM))) {
426 tunnel->dev->stats.rx_crc_errors++;
427 tunnel->dev->stats.rx_errors++;
428 goto drop;
429 }
430
431 if (tunnel->parms.i_flags&TUNNEL_SEQ) {
432 if (!(tpi->flags&TUNNEL_SEQ) ||
433 (tunnel->i_seqno && (s32)(ntohl(tpi->seq) - tunnel->i_seqno) < 0)) {
434 tunnel->dev->stats.rx_fifo_errors++;
435 tunnel->dev->stats.rx_errors++;
436 goto drop;
437 }
438 tunnel->i_seqno = ntohl(tpi->seq) + 1;
439 }
440
e96f2e7c
YC		 441 skb_reset_network_header(skb);
442
c5441932
PS		 443 err = IP_ECN_decapsulate(iph, skb);
444 if (unlikely(err)) {
445 if (log_ecn_error)
446 net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
447 &iph->saddr, iph->tos);
448 if (err > 1) {
449 ++tunnel->dev->stats.rx_frame_errors;
450 ++tunnel->dev->stats.rx_errors;
451 goto drop;
452 }
453 }
454
455 tstats = this_cpu_ptr(tunnel->dev->tstats);
456 u64_stats_update_begin(&tstats->syncp);
457 tstats->rx_packets++;
458 tstats->rx_bytes += skb->len;
459 u64_stats_update_end(&tstats->syncp);
460
81b9eab5
AS		 461 skb_scrub_packet(skb, !net_eq(tunnel->net, dev_net(tunnel->dev)));
462
3d7b46cd
PS		 463 if (tunnel->dev->type == ARPHRD_ETHER) {
464 skb->protocol = eth_type_trans(skb, tunnel->dev);
465 skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
466 } else {
467 skb->dev = tunnel->dev;
468 }
64261f23 469
c5441932
PS		 470 gro_cells_receive(&tunnel->gro_cells, skb);
471 return 0;
472
473drop:
474 kfree_skb(skb);
475 return 0;
476}
477EXPORT_SYMBOL_GPL(ip_tunnel_rcv);
478
23a3647b
PS		 479static int tnl_update_pmtu(struct net_device *dev, struct sk_buff *skb,
480 struct rtable *rt, __be16 df)
481{
482 struct ip_tunnel *tunnel = netdev_priv(dev);
8c91e162 483 int pkt_size = skb->len - tunnel->hlen - dev->hard_header_len;
23a3647b
PS		 484 int mtu;
485
486 if (df)
487 mtu = dst_mtu(&rt->dst) - dev->hard_header_len
488 - sizeof(struct iphdr) - tunnel->hlen;
489 else
490 mtu = skb_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu;
491
492 if (skb_dst(skb))
493 skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
494
495 if (skb->protocol == htons(ETH_P_IP)) {
496 if (!skb_is_gso(skb) &&
497 (df & htons(IP_DF)) && mtu < pkt_size) {
498 memset(IPCB(skb), 0, sizeof(*IPCB(skb)));
499 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
500 return -E2BIG;
501 }
502 }
503#if IS_ENABLED(CONFIG_IPV6)
504 else if (skb->protocol == htons(ETH_P_IPV6)) {
505 struct rt6_info *rt6 = (struct rt6_info *)skb_dst(skb);
506
507 if (rt6 && mtu < dst_mtu(skb_dst(skb)) &&
508 mtu >= IPV6_MIN_MTU) {
509 if ((tunnel->parms.iph.daddr &&
510 !ipv4_is_multicast(tunnel->parms.iph.daddr)) ||
511 rt6->rt6i_dst.plen == 128) {
512 rt6->rt6i_flags |= RTF_MODIFIED;
513 dst_metric_set(skb_dst(skb), RTAX_MTU, mtu);
514 }
515 }
516
517 if (!skb_is_gso(skb) && mtu >= IPV6_MIN_MTU &&
518 mtu < pkt_size) {
519 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
520 return -E2BIG;
521 }
522 }
523#endif
524 return 0;
525}
526
c5441932 527void ip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev,
bf3d6a8f 528 const struct iphdr *tnl_params, const u8 protocol)
c5441932
PS		 529{
530 struct ip_tunnel *tunnel = netdev_priv(dev);
531 const struct iphdr *inner_iph;
c5441932
PS		 532 struct flowi4 fl4;
533 u8 tos, ttl;
534 __be16 df;
b045d37b 535 struct rtable *rt; /* Route to the other host */
c5441932
PS		 536 unsigned int max_headroom; /* The extra header space needed */
537 __be32 dst;
0e6fbc5b 538 int err;
22fb22ea 539 bool connected;
c5441932
PS		 540
541 inner_iph = (const struct iphdr *)skb_inner_network_header(skb);
22fb22ea 542 connected = (tunnel->parms.iph.daddr != 0);
c5441932
PS		 543
544 dst = tnl_params->daddr;
545 if (dst == 0) {
546 /* NBMA tunnel */
547
548 if (skb_dst(skb) == NULL) {
549 dev->stats.tx_fifo_errors++;
550 goto tx_error;
551 }
552
553 if (skb->protocol == htons(ETH_P_IP)) {
554 rt = skb_rtable(skb);
555 dst = rt_nexthop(rt, inner_iph->daddr);
556 }
557#if IS_ENABLED(CONFIG_IPV6)
558 else if (skb->protocol == htons(ETH_P_IPV6)) {
559 const struct in6_addr *addr6;
560 struct neighbour *neigh;
561 bool do_tx_error_icmp;
562 int addr_type;
563
564 neigh = dst_neigh_lookup(skb_dst(skb),
565 &ipv6_hdr(skb)->daddr);
566 if (neigh == NULL)
567 goto tx_error;
568
569 addr6 = (const struct in6_addr *)&neigh->primary_key;
570 addr_type = ipv6_addr_type(addr6);
571
572 if (addr_type == IPV6_ADDR_ANY) {
573 addr6 = &ipv6_hdr(skb)->daddr;
574 addr_type = ipv6_addr_type(addr6);
575 }
576
577 if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
578 do_tx_error_icmp = true;
579 else {
580 do_tx_error_icmp = false;
581 dst = addr6->s6_addr32[3];
582 }
583 neigh_release(neigh);
584 if (do_tx_error_icmp)
585 goto tx_error_icmp;
586 }
587#endif
588 else
589 goto tx_error;
7d442fab
TH		 590
591 connected = false;
c5441932
PS		 592 }
593
594 tos = tnl_params->tos;
595 if (tos & 0x1) {
596 tos &= ~0x1;
7d442fab 597 if (skb->protocol == htons(ETH_P_IP)) {
c5441932 598 tos = inner_iph->tos;
7d442fab
TH		 599 connected = false;
600 } else if (skb->protocol == htons(ETH_P_IPV6)) {
c5441932 601 tos = ipv6_get_dsfield((const struct ipv6hdr *)inner_iph);
7d442fab
TH		 602 connected = false;
603 }
c5441932
PS		 604 }
605
7d442fab
TH		 606 init_tunnel_flow(&fl4, protocol, dst, tnl_params->saddr,
607 tunnel->parms.o_key, RT_TOS(tos), tunnel->parms.link);
608
b045d37b 609 rt = connected ? tunnel_rtable_get(tunnel, 0) : NULL;
7d442fab
TH		 610
611 if (!rt) {
612 rt = ip_route_output_key(tunnel->net, &fl4);
613
614 if (IS_ERR(rt)) {
615 dev->stats.tx_carrier_errors++;
616 goto tx_error;
617 }
618 if (connected)
6c7e7610 619 tunnel_dst_set(tunnel, &rt->dst);
c5441932 620 }
7d442fab 621
0e6fbc5b 622 if (rt->dst.dev == dev) {
c5441932
PS		 623 ip_rt_put(rt);
624 dev->stats.collisions++;
625 goto tx_error;
626 }
c5441932 627
23a3647b
PS		 628 if (tnl_update_pmtu(dev, skb, rt, tnl_params->frag_off)) {
629 ip_rt_put(rt);
630 goto tx_error;
c5441932 631 }
c5441932
PS		 632
633 if (tunnel->err_count > 0) {
634 if (time_before(jiffies,
635 tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
636 tunnel->err_count--;
637
11c21a30 638 memset(IPCB(skb), 0, sizeof(*IPCB(skb)));
c5441932
PS		 639 dst_link_failure(skb);
640 } else
641 tunnel->err_count = 0;
642 }
643
d4a71b15 644 tos = ip_tunnel_ecn_encap(tos, inner_iph, skb);
c5441932
PS		 645 ttl = tnl_params->ttl;
646 if (ttl == 0) {
647 if (skb->protocol == htons(ETH_P_IP))
648 ttl = inner_iph->ttl;
649#if IS_ENABLED(CONFIG_IPV6)
650 else if (skb->protocol == htons(ETH_P_IPV6))
651 ttl = ((const struct ipv6hdr *)inner_iph)->hop_limit;
652#endif
653 else
654 ttl = ip4_dst_hoplimit(&rt->dst);
655 }
656
23a3647b
PS		 657 df = tnl_params->frag_off;
658 if (skb->protocol == htons(ETH_P_IP))
659 df |= (inner_iph->frag_off&htons(IP_DF));
660
0e6fbc5b
PS		 661 max_headroom = LL_RESERVED_SPACE(rt->dst.dev) + sizeof(struct iphdr)
662 + rt->dst.header_len;
3e08f4a7 663 if (max_headroom > dev->needed_headroom)
c5441932 664 dev->needed_headroom = max_headroom;
3e08f4a7
SK		 665
666 if (skb_cow_head(skb, dev->needed_headroom)) {
586d5fc8 667 ip_rt_put(rt);
3e08f4a7 668 dev->stats.tx_dropped++;
3acfa1e7 669 kfree_skb(skb);
3e08f4a7 670 return;
c5441932
PS		 671 }
672
aad88724 673 err = iptunnel_xmit(skb->sk, rt, skb, fl4.saddr, fl4.daddr, protocol,
d4a71b15 674 tos, ttl, df, !net_eq(tunnel->net, dev_net(dev)));
0e6fbc5b 675 iptunnel_xmit_stats(err, &dev->stats, dev->tstats);
c5441932 676
c5441932
PS		 677 return;
678
679#if IS_ENABLED(CONFIG_IPV6)
680tx_error_icmp:
681 dst_link_failure(skb);
682#endif
683tx_error:
684 dev->stats.tx_errors++;
3acfa1e7 685 kfree_skb(skb);
c5441932
PS		 686}
687EXPORT_SYMBOL_GPL(ip_tunnel_xmit);
688
689static void ip_tunnel_update(struct ip_tunnel_net *itn,
690 struct ip_tunnel *t,
691 struct net_device *dev,
692 struct ip_tunnel_parm *p,
693 bool set_mtu)
694{
695 ip_tunnel_del(t);
696 t->parms.iph.saddr = p->iph.saddr;
697 t->parms.iph.daddr = p->iph.daddr;
698 t->parms.i_key = p->i_key;
699 t->parms.o_key = p->o_key;
700 if (dev->type != ARPHRD_ETHER) {
701 memcpy(dev->dev_addr, &p->iph.saddr, 4);
702 memcpy(dev->broadcast, &p->iph.daddr, 4);
703 }
704 ip_tunnel_add(itn, t);
705
706 t->parms.iph.ttl = p->iph.ttl;
707 t->parms.iph.tos = p->iph.tos;
708 t->parms.iph.frag_off = p->iph.frag_off;
709
710 if (t->parms.link != p->link) {
711 int mtu;
712
713 t->parms.link = p->link;
714 mtu = ip_tunnel_bind_dev(dev);
715 if (set_mtu)
716 dev->mtu = mtu;
717 }
cf71d2bc 718 ip_tunnel_dst_reset_all(t);
c5441932
PS		 719 netdev_state_change(dev);
720}
721
722int ip_tunnel_ioctl(struct net_device *dev, struct ip_tunnel_parm *p, int cmd)
723{
724 int err = 0;
8c923ce2
ND		 725 struct ip_tunnel *t = netdev_priv(dev);
726 struct net *net = t->net;
727 struct ip_tunnel_net *itn = net_generic(net, t->ip_tnl_net_id);
c5441932
PS		 728
729 BUG_ON(!itn->fb_tunnel_dev);
730 switch (cmd) {
731 case SIOCGETTUNNEL:
8c923ce2 732 if (dev == itn->fb_tunnel_dev) {
c5441932 733 t = ip_tunnel_find(itn, p, itn->fb_tunnel_dev->type);
8c923ce2
ND		 734 if (t == NULL)
735 t = netdev_priv(dev);
736 }
c5441932
PS		 737 memcpy(p, &t->parms, sizeof(*p));
738 break;
739
740 case SIOCADDTUNNEL:
741 case SIOCCHGTUNNEL:
742 err = -EPERM;
743 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
744 goto done;
745 if (p->iph.ttl)
746 p->iph.frag_off |= htons(IP_DF);
7c8e6b9c
DP		 747 if (!(p->i_flags & VTI_ISVTI)) {
748 if (!(p->i_flags & TUNNEL_KEY))
749 p->i_key = 0;
750 if (!(p->o_flags & TUNNEL_KEY))
751 p->o_key = 0;
752 }
c5441932
PS		 753
754 t = ip_tunnel_find(itn, p, itn->fb_tunnel_dev->type);
755
6dd3c9ec 756 if (!t && (cmd == SIOCADDTUNNEL)) {
c5441932 757 t = ip_tunnel_create(net, itn, p);
ee30ef4d
DJ		 758 err = PTR_ERR_OR_ZERO(t);
759 break;
6dd3c9ec 760 }
c5441932
PS		 761 if (dev != itn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
762 if (t != NULL) {
763 if (t->dev != dev) {
764 err = -EEXIST;
765 break;
766 }
767 } else {
768 unsigned int nflags = 0;
769
770 if (ipv4_is_multicast(p->iph.daddr))
771 nflags = IFF_BROADCAST;
772 else if (p->iph.daddr)
773 nflags = IFF_POINTOPOINT;
774
775 if ((dev->flags^nflags)&(IFF_POINTOPOINT|IFF_BROADCAST)) {
776 err = -EINVAL;
777 break;
778 }
779
780 t = netdev_priv(dev);
781 }
782 }
783
784 if (t) {
785 err = 0;
786 ip_tunnel_update(itn, t, dev, p, true);
6dd3c9ec
FW		 787 } else {
788 err = -ENOENT;
789 }
c5441932
PS		 790 break;
791
792 case SIOCDELTUNNEL:
793 err = -EPERM;
794 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
795 goto done;
796
797 if (dev == itn->fb_tunnel_dev) {
798 err = -ENOENT;
799 t = ip_tunnel_find(itn, p, itn->fb_tunnel_dev->type);
800 if (t == NULL)
801 goto done;
802 err = -EPERM;
803 if (t == netdev_priv(itn->fb_tunnel_dev))
804 goto done;
805 dev = t->dev;
806 }
807 unregister_netdevice(dev);
808 err = 0;
809 break;
810
811 default:
812 err = -EINVAL;
813 }
814
815done:
816 return err;
817}
818EXPORT_SYMBOL_GPL(ip_tunnel_ioctl);
819
820int ip_tunnel_change_mtu(struct net_device *dev, int new_mtu)
821{
822 struct ip_tunnel *tunnel = netdev_priv(dev);
823 int t_hlen = tunnel->hlen + sizeof(struct iphdr);
824
825 if (new_mtu < 68 ||
826 new_mtu > 0xFFF8 - dev->hard_header_len - t_hlen)
827 return -EINVAL;
828 dev->mtu = new_mtu;
829 return 0;
830}
831EXPORT_SYMBOL_GPL(ip_tunnel_change_mtu);
832
833static void ip_tunnel_dev_free(struct net_device *dev)
834{
835 struct ip_tunnel *tunnel = netdev_priv(dev);
836
837 gro_cells_destroy(&tunnel->gro_cells);
9a4aa9af 838 free_percpu(tunnel->dst_cache);
c5441932
PS		 839 free_percpu(dev->tstats);
840 free_netdev(dev);
841}
842
843void ip_tunnel_dellink(struct net_device *dev, struct list_head *head)
844{
c5441932
PS		 845 struct ip_tunnel *tunnel = netdev_priv(dev);
846 struct ip_tunnel_net *itn;
847
6c742e71 848 itn = net_generic(tunnel->net, tunnel->ip_tnl_net_id);
c5441932
PS		 849
850 if (itn->fb_tunnel_dev != dev) {
851 ip_tunnel_del(netdev_priv(dev));
852 unregister_netdevice_queue(dev, head);
853 }
854}
855EXPORT_SYMBOL_GPL(ip_tunnel_dellink);
856
d3b6f614 857int ip_tunnel_init_net(struct net *net, int ip_tnl_net_id,
c5441932
PS		 858 struct rtnl_link_ops *ops, char *devname)
859{
860 struct ip_tunnel_net *itn = net_generic(net, ip_tnl_net_id);
861 struct ip_tunnel_parm parms;
6261d983 862 unsigned int i;
c5441932 863
6261d983 864 for (i = 0; i < IP_TNL_HASH_SIZE; i++)
865 INIT_HLIST_HEAD(&itn->tunnels[i]);
c5441932
PS		 866
867 if (!ops) {
868 itn->fb_tunnel_dev = NULL;
869 return 0;
870 }
6261d983 871
c5441932
PS		 872 memset(&parms, 0, sizeof(parms));
873 if (devname)
874 strlcpy(parms.name, devname, IFNAMSIZ);
875
876 rtnl_lock();
877 itn->fb_tunnel_dev = __ip_tunnel_create(net, ops, &parms);
ea857f28
DC		 878 /* FB netdevice is special: we have one, and only one per netns.
879 * Allowing to move it to another netns is clearly unsafe.
880 */
67013282 881 if (!IS_ERR(itn->fb_tunnel_dev)) {
b4de77ad 882 itn->fb_tunnel_dev->features |= NETIF_F_NETNS_LOCAL;
78ff4be4 883 itn->fb_tunnel_dev->mtu = ip_tunnel_bind_dev(itn->fb_tunnel_dev);
67013282
SK		 884 ip_tunnel_add(itn, netdev_priv(itn->fb_tunnel_dev));
885 }
b4de77ad 886 rtnl_unlock();
c5441932 887
27d79f3b 888 return PTR_ERR_OR_ZERO(itn->fb_tunnel_dev);
c5441932
PS		 889}
890EXPORT_SYMBOL_GPL(ip_tunnel_init_net);
891
6c742e71
ND		 892static void ip_tunnel_destroy(struct ip_tunnel_net *itn, struct list_head *head,
893 struct rtnl_link_ops *ops)
c5441932 894{
6c742e71
ND		 895 struct net *net = dev_net(itn->fb_tunnel_dev);
896 struct net_device *dev, *aux;
c5441932
PS		 897 int h;
898
6c742e71
ND		 899 for_each_netdev_safe(net, dev, aux)
900 if (dev->rtnl_link_ops == ops)
901 unregister_netdevice_queue(dev, head);
902
c5441932
PS		 903 for (h = 0; h < IP_TNL_HASH_SIZE; h++) {
904 struct ip_tunnel *t;
905 struct hlist_node *n;
906 struct hlist_head *thead = &itn->tunnels[h];
907
908 hlist_for_each_entry_safe(t, n, thead, hash_node)
6c742e71
ND		 909 /* If dev is in the same netns, it has already
910 * been added to the list by the previous loop.
911 */
912 if (!net_eq(dev_net(t->dev), net))
913 unregister_netdevice_queue(t->dev, head);
c5441932 914 }
c5441932
PS		 915}
916
6c742e71 917void ip_tunnel_delete_net(struct ip_tunnel_net *itn, struct rtnl_link_ops *ops)
c5441932
PS		 918{
919 LIST_HEAD(list);
920
921 rtnl_lock();
6c742e71 922 ip_tunnel_destroy(itn, &list, ops);
c5441932
PS		 923 unregister_netdevice_many(&list);
924 rtnl_unlock();
c5441932
PS		 925}
926EXPORT_SYMBOL_GPL(ip_tunnel_delete_net);
927
928int ip_tunnel_newlink(struct net_device *dev, struct nlattr *tb[],
929 struct ip_tunnel_parm *p)
930{
931 struct ip_tunnel *nt;
932 struct net *net = dev_net(dev);
933 struct ip_tunnel_net *itn;
934 int mtu;
935 int err;
936
937 nt = netdev_priv(dev);
938 itn = net_generic(net, nt->ip_tnl_net_id);
939
940 if (ip_tunnel_find(itn, p, dev->type))
941 return -EEXIST;
942
5e6700b3 943 nt->net = net;
c5441932
PS		 944 nt->parms = *p;
945 err = register_netdevice(dev);
946 if (err)
947 goto out;
948
949 if (dev->type == ARPHRD_ETHER && !tb[IFLA_ADDRESS])
950 eth_hw_addr_random(dev);
951
952 mtu = ip_tunnel_bind_dev(dev);
953 if (!tb[IFLA_MTU])
954 dev->mtu = mtu;
955
956 ip_tunnel_add(itn, nt);
957
958out:
959 return err;
960}
961EXPORT_SYMBOL_GPL(ip_tunnel_newlink);
962
963int ip_tunnel_changelink(struct net_device *dev, struct nlattr *tb[],
964 struct ip_tunnel_parm *p)
965{
6c742e71 966 struct ip_tunnel *t;
c5441932 967 struct ip_tunnel *tunnel = netdev_priv(dev);
6c742e71 968 struct net *net = tunnel->net;
c5441932
PS		 969 struct ip_tunnel_net *itn = net_generic(net, tunnel->ip_tnl_net_id);
970
971 if (dev == itn->fb_tunnel_dev)
972 return -EINVAL;
973
c5441932
PS		 974 t = ip_tunnel_find(itn, p, dev->type);
975
976 if (t) {
977 if (t->dev != dev)
978 return -EEXIST;
979 } else {
6c742e71 980 t = tunnel;
c5441932
PS		 981
982 if (dev->type != ARPHRD_ETHER) {
983 unsigned int nflags = 0;
984
985 if (ipv4_is_multicast(p->iph.daddr))
986 nflags = IFF_BROADCAST;
987 else if (p->iph.daddr)
988 nflags = IFF_POINTOPOINT;
989
990 if ((dev->flags ^ nflags) &
991 (IFF_POINTOPOINT | IFF_BROADCAST))
992 return -EINVAL;
993 }
994 }
995
996 ip_tunnel_update(itn, t, dev, p, !tb[IFLA_MTU]);
997 return 0;
998}
999EXPORT_SYMBOL_GPL(ip_tunnel_changelink);
1000
1001int ip_tunnel_init(struct net_device *dev)
1002{
1003 struct ip_tunnel *tunnel = netdev_priv(dev);
1004 struct iphdr *iph = &tunnel->parms.iph;
1c213bd2 1005 int err;
c5441932
PS		 1006
1007 dev->destructor = ip_tunnel_dev_free;
1c213bd2 1008 dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
c5441932
PS		 1009 if (!dev->tstats)
1010 return -ENOMEM;
1011
9a4aa9af
TH		 1012 tunnel->dst_cache = alloc_percpu(struct ip_tunnel_dst);
1013 if (!tunnel->dst_cache) {
1014 free_percpu(dev->tstats);
1015 return -ENOMEM;
1016 }
1017
c5441932
PS		 1018 err = gro_cells_init(&tunnel->gro_cells, dev);
1019 if (err) {
9a4aa9af 1020 free_percpu(tunnel->dst_cache);
c5441932
PS		 1021 free_percpu(dev->tstats);
1022 return err;
1023 }
1024
1025 tunnel->dev = dev;
6c742e71 1026 tunnel->net = dev_net(dev);
c5441932
PS		 1027 strcpy(tunnel->parms.name, dev->name);
1028 iph->version = 4;
1029 iph->ihl = 5;
1030
1031 return 0;
1032}
1033EXPORT_SYMBOL_GPL(ip_tunnel_init);
1034
1035void ip_tunnel_uninit(struct net_device *dev)
1036{
c5441932 1037 struct ip_tunnel *tunnel = netdev_priv(dev);
6c742e71 1038 struct net *net = tunnel->net;
c5441932
PS		 1039 struct ip_tunnel_net *itn;
1040
1041 itn = net_generic(net, tunnel->ip_tnl_net_id);
1042 /* fb_tunnel_dev will be unregisted in net-exit call. */
1043 if (itn->fb_tunnel_dev != dev)
1044 ip_tunnel_del(netdev_priv(dev));
7d442fab 1045
cf71d2bc 1046 ip_tunnel_dst_reset_all(tunnel);
c5441932
PS		 1047}
1048EXPORT_SYMBOL_GPL(ip_tunnel_uninit);
1049
1050/* Do least required initialization, rest of init is done in tunnel_init call */
1051void ip_tunnel_setup(struct net_device *dev, int net_id)
1052{
1053 struct ip_tunnel *tunnel = netdev_priv(dev);
1054 tunnel->ip_tnl_net_id = net_id;
1055}
1056EXPORT_SYMBOL_GPL(ip_tunnel_setup);
1057
1058MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.19619 seconds and 5 git commands to generate.