2 * GRE over IPv6 protocol decoder.
4 * Authors: Dmitry Kozlov (xeb@mail.ru)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15 #include <linux/capability.h>
16 #include <linux/module.h>
17 #include <linux/types.h>
18 #include <linux/kernel.h>
19 #include <linux/slab.h>
20 #include <linux/uaccess.h>
21 #include <linux/skbuff.h>
22 #include <linux/netdevice.h>
24 #include <linux/tcp.h>
25 #include <linux/udp.h>
26 #include <linux/if_arp.h>
27 #include <linux/init.h>
28 #include <linux/in6.h>
29 #include <linux/inetdevice.h>
30 #include <linux/igmp.h>
31 #include <linux/netfilter_ipv4.h>
32 #include <linux/etherdevice.h>
33 #include <linux/if_ether.h>
34 #include <linux/hash.h>
35 #include <linux/if_tunnel.h>
36 #include <linux/ip6_tunnel.h>
40 #include <net/ip_tunnels.h>
42 #include <net/protocol.h>
43 #include <net/addrconf.h>
45 #include <net/checksum.h>
46 #include <net/dsfield.h>
47 #include <net/inet_ecn.h>
49 #include <net/net_namespace.h>
50 #include <net/netns/generic.h>
51 #include <net/rtnetlink.h>
54 #include <net/ip6_fib.h>
55 #include <net/ip6_route.h>
56 #include <net/ip6_tunnel.h>
58 #include <net/erspan.h>
59 #include <net/dst_metadata.h>
62 static bool log_ecn_error
= true;
63 module_param(log_ecn_error
, bool, 0644);
64 MODULE_PARM_DESC(log_ecn_error
, "Log packets received with corrupted ECN");
66 #define IP6_GRE_HASH_SIZE_SHIFT 5
67 #define IP6_GRE_HASH_SIZE (1 << IP6_GRE_HASH_SIZE_SHIFT)
69 static unsigned int ip6gre_net_id __read_mostly
;
71 struct ip6_tnl __rcu
*tunnels
[4][IP6_GRE_HASH_SIZE
];
73 struct ip6_tnl __rcu
*collect_md_tun
;
74 struct ip6_tnl __rcu
*collect_md_tun_erspan
;
75 struct net_device
*fb_tunnel_dev
;
78 static struct rtnl_link_ops ip6gre_link_ops __read_mostly
;
79 static struct rtnl_link_ops ip6gre_tap_ops __read_mostly
;
80 static struct rtnl_link_ops ip6erspan_tap_ops __read_mostly
;
81 static int ip6gre_tunnel_init(struct net_device
*dev
);
82 static void ip6gre_tunnel_setup(struct net_device
*dev
);
83 static void ip6gre_tunnel_link(struct ip6gre_net
*ign
, struct ip6_tnl
*t
);
84 static void ip6gre_tnl_link_config(struct ip6_tnl
*t
, int set_mtu
);
85 static void ip6erspan_tnl_link_config(struct ip6_tnl
*t
, int set_mtu
);
87 /* Tunnel hash table */
97 We require exact key match i.e. if a key is present in packet
98 it will match only tunnel with the same key; if it is not present,
99 it will match only keyless tunnel.
101 All keysless packets, if not matched configured keyless tunnels
102 will match fallback tunnel.
105 #define HASH_KEY(key) (((__force u32)key^((__force u32)key>>4))&(IP6_GRE_HASH_SIZE - 1))
106 static u32
HASH_ADDR(const struct in6_addr
*addr
)
108 u32 hash
= ipv6_addr_hash(addr
);
110 return hash_32(hash
, IP6_GRE_HASH_SIZE_SHIFT
);
113 #define tunnels_r_l tunnels[3]
114 #define tunnels_r tunnels[2]
115 #define tunnels_l tunnels[1]
116 #define tunnels_wc tunnels[0]
118 /* Given src, dst and key, find appropriate for input tunnel. */
120 static struct ip6_tnl
*ip6gre_tunnel_lookup(struct net_device
*dev
,
121 const struct in6_addr
*remote
, const struct in6_addr
*local
,
122 __be32 key
, __be16 gre_proto
)
124 struct net
*net
= dev_net(dev
);
125 int link
= dev
->ifindex
;
126 unsigned int h0
= HASH_ADDR(remote
);
127 unsigned int h1
= HASH_KEY(key
);
128 struct ip6_tnl
*t
, *cand
= NULL
;
129 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
130 int dev_type
= (gre_proto
== htons(ETH_P_TEB
) ||
131 gre_proto
== htons(ETH_P_ERSPAN
) ||
132 gre_proto
== htons(ETH_P_ERSPAN2
)) ?
133 ARPHRD_ETHER
: ARPHRD_IP6GRE
;
134 int score
, cand_score
= 4;
136 for_each_ip_tunnel_rcu(t
, ign
->tunnels_r_l
[h0
^ h1
]) {
137 if (!ipv6_addr_equal(local
, &t
->parms
.laddr
) ||
138 !ipv6_addr_equal(remote
, &t
->parms
.raddr
) ||
139 key
!= t
->parms
.i_key
||
140 !(t
->dev
->flags
& IFF_UP
))
143 if (t
->dev
->type
!= ARPHRD_IP6GRE
&&
144 t
->dev
->type
!= dev_type
)
148 if (t
->parms
.link
!= link
)
150 if (t
->dev
->type
!= dev_type
)
155 if (score
< cand_score
) {
161 for_each_ip_tunnel_rcu(t
, ign
->tunnels_r
[h0
^ h1
]) {
162 if (!ipv6_addr_equal(remote
, &t
->parms
.raddr
) ||
163 key
!= t
->parms
.i_key
||
164 !(t
->dev
->flags
& IFF_UP
))
167 if (t
->dev
->type
!= ARPHRD_IP6GRE
&&
168 t
->dev
->type
!= dev_type
)
172 if (t
->parms
.link
!= link
)
174 if (t
->dev
->type
!= dev_type
)
179 if (score
< cand_score
) {
185 for_each_ip_tunnel_rcu(t
, ign
->tunnels_l
[h1
]) {
186 if ((!ipv6_addr_equal(local
, &t
->parms
.laddr
) &&
187 (!ipv6_addr_equal(local
, &t
->parms
.raddr
) ||
188 !ipv6_addr_is_multicast(local
))) ||
189 key
!= t
->parms
.i_key
||
190 !(t
->dev
->flags
& IFF_UP
))
193 if (t
->dev
->type
!= ARPHRD_IP6GRE
&&
194 t
->dev
->type
!= dev_type
)
198 if (t
->parms
.link
!= link
)
200 if (t
->dev
->type
!= dev_type
)
205 if (score
< cand_score
) {
211 for_each_ip_tunnel_rcu(t
, ign
->tunnels_wc
[h1
]) {
212 if (t
->parms
.i_key
!= key
||
213 !(t
->dev
->flags
& IFF_UP
))
216 if (t
->dev
->type
!= ARPHRD_IP6GRE
&&
217 t
->dev
->type
!= dev_type
)
221 if (t
->parms
.link
!= link
)
223 if (t
->dev
->type
!= dev_type
)
228 if (score
< cand_score
) {
237 if (gre_proto
== htons(ETH_P_ERSPAN
) ||
238 gre_proto
== htons(ETH_P_ERSPAN2
))
239 t
= rcu_dereference(ign
->collect_md_tun_erspan
);
241 t
= rcu_dereference(ign
->collect_md_tun
);
243 if (t
&& t
->dev
->flags
& IFF_UP
)
246 dev
= ign
->fb_tunnel_dev
;
247 if (dev
&& dev
->flags
& IFF_UP
)
248 return netdev_priv(dev
);
253 static struct ip6_tnl __rcu
**__ip6gre_bucket(struct ip6gre_net
*ign
,
254 const struct __ip6_tnl_parm
*p
)
256 const struct in6_addr
*remote
= &p
->raddr
;
257 const struct in6_addr
*local
= &p
->laddr
;
258 unsigned int h
= HASH_KEY(p
->i_key
);
261 if (!ipv6_addr_any(local
))
263 if (!ipv6_addr_any(remote
) && !ipv6_addr_is_multicast(remote
)) {
265 h
^= HASH_ADDR(remote
);
268 return &ign
->tunnels
[prio
][h
];
271 static void ip6gre_tunnel_link_md(struct ip6gre_net
*ign
, struct ip6_tnl
*t
)
273 if (t
->parms
.collect_md
)
274 rcu_assign_pointer(ign
->collect_md_tun
, t
);
277 static void ip6erspan_tunnel_link_md(struct ip6gre_net
*ign
, struct ip6_tnl
*t
)
279 if (t
->parms
.collect_md
)
280 rcu_assign_pointer(ign
->collect_md_tun_erspan
, t
);
283 static void ip6gre_tunnel_unlink_md(struct ip6gre_net
*ign
, struct ip6_tnl
*t
)
285 if (t
->parms
.collect_md
)
286 rcu_assign_pointer(ign
->collect_md_tun
, NULL
);
289 static void ip6erspan_tunnel_unlink_md(struct ip6gre_net
*ign
,
292 if (t
->parms
.collect_md
)
293 rcu_assign_pointer(ign
->collect_md_tun_erspan
, NULL
);
296 static inline struct ip6_tnl __rcu
**ip6gre_bucket(struct ip6gre_net
*ign
,
297 const struct ip6_tnl
*t
)
299 return __ip6gre_bucket(ign
, &t
->parms
);
302 static void ip6gre_tunnel_link(struct ip6gre_net
*ign
, struct ip6_tnl
*t
)
304 struct ip6_tnl __rcu
**tp
= ip6gre_bucket(ign
, t
);
306 rcu_assign_pointer(t
->next
, rtnl_dereference(*tp
));
307 rcu_assign_pointer(*tp
, t
);
310 static void ip6gre_tunnel_unlink(struct ip6gre_net
*ign
, struct ip6_tnl
*t
)
312 struct ip6_tnl __rcu
**tp
;
313 struct ip6_tnl
*iter
;
315 for (tp
= ip6gre_bucket(ign
, t
);
316 (iter
= rtnl_dereference(*tp
)) != NULL
;
319 rcu_assign_pointer(*tp
, t
->next
);
325 static struct ip6_tnl
*ip6gre_tunnel_find(struct net
*net
,
326 const struct __ip6_tnl_parm
*parms
,
329 const struct in6_addr
*remote
= &parms
->raddr
;
330 const struct in6_addr
*local
= &parms
->laddr
;
331 __be32 key
= parms
->i_key
;
332 int link
= parms
->link
;
334 struct ip6_tnl __rcu
**tp
;
335 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
337 for (tp
= __ip6gre_bucket(ign
, parms
);
338 (t
= rtnl_dereference(*tp
)) != NULL
;
340 if (ipv6_addr_equal(local
, &t
->parms
.laddr
) &&
341 ipv6_addr_equal(remote
, &t
->parms
.raddr
) &&
342 key
== t
->parms
.i_key
&&
343 link
== t
->parms
.link
&&
344 type
== t
->dev
->type
)
350 static struct ip6_tnl
*ip6gre_tunnel_locate(struct net
*net
,
351 const struct __ip6_tnl_parm
*parms
, int create
)
353 struct ip6_tnl
*t
, *nt
;
354 struct net_device
*dev
;
356 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
358 t
= ip6gre_tunnel_find(net
, parms
, ARPHRD_IP6GRE
);
364 if (parms
->name
[0]) {
365 if (!dev_valid_name(parms
->name
))
367 strlcpy(name
, parms
->name
, IFNAMSIZ
);
369 strcpy(name
, "ip6gre%d");
371 dev
= alloc_netdev(sizeof(*t
), name
, NET_NAME_UNKNOWN
,
372 ip6gre_tunnel_setup
);
376 dev_net_set(dev
, net
);
378 nt
= netdev_priv(dev
);
380 dev
->rtnl_link_ops
= &ip6gre_link_ops
;
383 nt
->net
= dev_net(dev
);
385 if (register_netdevice(dev
) < 0)
388 ip6gre_tnl_link_config(nt
, 1);
390 /* Can use a lockless transmit, unless we generate output sequences */
391 if (!(nt
->parms
.o_flags
& TUNNEL_SEQ
))
392 dev
->features
|= NETIF_F_LLTX
;
395 ip6gre_tunnel_link(ign
, nt
);
403 static void ip6erspan_tunnel_uninit(struct net_device
*dev
)
405 struct ip6_tnl
*t
= netdev_priv(dev
);
406 struct ip6gre_net
*ign
= net_generic(t
->net
, ip6gre_net_id
);
408 ip6erspan_tunnel_unlink_md(ign
, t
);
409 ip6gre_tunnel_unlink(ign
, t
);
410 dst_cache_reset(&t
->dst_cache
);
414 static void ip6gre_tunnel_uninit(struct net_device
*dev
)
416 struct ip6_tnl
*t
= netdev_priv(dev
);
417 struct ip6gre_net
*ign
= net_generic(t
->net
, ip6gre_net_id
);
419 ip6gre_tunnel_unlink_md(ign
, t
);
420 ip6gre_tunnel_unlink(ign
, t
);
421 dst_cache_reset(&t
->dst_cache
);
426 static void ip6gre_err(struct sk_buff
*skb
, struct inet6_skb_parm
*opt
,
427 u8 type
, u8 code
, int offset
, __be32 info
)
429 struct net
*net
= dev_net(skb
->dev
);
430 const struct gre_base_hdr
*greh
;
431 const struct ipv6hdr
*ipv6h
;
432 int grehlen
= sizeof(*greh
);
438 if (!pskb_may_pull(skb
, offset
+ grehlen
))
440 greh
= (const struct gre_base_hdr
*)(skb
->data
+ offset
);
442 if (flags
& (GRE_VERSION
| GRE_ROUTING
))
444 if (flags
& GRE_CSUM
)
446 if (flags
& GRE_KEY
) {
447 key_off
= grehlen
+ offset
;
451 if (!pskb_may_pull(skb
, offset
+ grehlen
))
453 ipv6h
= (const struct ipv6hdr
*)skb
->data
;
454 greh
= (const struct gre_base_hdr
*)(skb
->data
+ offset
);
455 key
= key_off
? *(__be32
*)(skb
->data
+ key_off
) : 0;
457 t
= ip6gre_tunnel_lookup(skb
->dev
, &ipv6h
->daddr
, &ipv6h
->saddr
,
458 key
, greh
->protocol
);
463 struct ipv6_tlv_tnl_enc_lim
*tel
;
465 case ICMPV6_DEST_UNREACH
:
466 net_dbg_ratelimited("%s: Path to destination invalid or inactive!\n",
468 if (code
!= ICMPV6_PORT_UNREACH
)
471 case ICMPV6_TIME_EXCEED
:
472 if (code
== ICMPV6_EXC_HOPLIMIT
) {
473 net_dbg_ratelimited("%s: Too small hop limit or routing loop in tunnel!\n",
478 case ICMPV6_PARAMPROB
:
480 if (code
== ICMPV6_HDR_FIELD
)
481 teli
= ip6_tnl_parse_tlv_enc_lim(skb
, skb
->data
);
483 if (teli
&& teli
== be32_to_cpu(info
) - 2) {
484 tel
= (struct ipv6_tlv_tnl_enc_lim
*) &skb
->data
[teli
];
485 if (tel
->encap_limit
== 0) {
486 net_dbg_ratelimited("%s: Too small encapsulation limit or routing loop in tunnel!\n",
490 net_dbg_ratelimited("%s: Recipient unable to parse tunneled packet!\n",
494 case ICMPV6_PKT_TOOBIG
:
495 ip6_update_pmtu(skb
, net
, info
, 0, 0, sock_net_uid(net
, NULL
));
498 ip6_redirect(skb
, net
, skb
->dev
->ifindex
, 0,
499 sock_net_uid(net
, NULL
));
503 if (time_before(jiffies
, t
->err_time
+ IP6TUNNEL_ERR_TIMEO
))
507 t
->err_time
= jiffies
;
510 static int ip6gre_rcv(struct sk_buff
*skb
, const struct tnl_ptk_info
*tpi
)
512 const struct ipv6hdr
*ipv6h
;
513 struct ip6_tnl
*tunnel
;
515 ipv6h
= ipv6_hdr(skb
);
516 tunnel
= ip6gre_tunnel_lookup(skb
->dev
,
517 &ipv6h
->saddr
, &ipv6h
->daddr
, tpi
->key
,
520 if (tunnel
->parms
.collect_md
) {
521 struct metadata_dst
*tun_dst
;
526 tun_id
= key32_to_tunnel_id(tpi
->key
);
528 tun_dst
= ipv6_tun_rx_dst(skb
, flags
, tun_id
, 0);
530 return PACKET_REJECT
;
532 ip6_tnl_rcv(tunnel
, skb
, tpi
, tun_dst
, log_ecn_error
);
534 ip6_tnl_rcv(tunnel
, skb
, tpi
, NULL
, log_ecn_error
);
540 return PACKET_REJECT
;
543 static int ip6erspan_rcv(struct sk_buff
*skb
, int gre_hdr_len
,
544 struct tnl_ptk_info
*tpi
)
546 struct erspan_base_hdr
*ershdr
;
547 struct erspan_metadata
*pkt_md
;
548 const struct ipv6hdr
*ipv6h
;
549 struct erspan_md2
*md2
;
550 struct ip6_tnl
*tunnel
;
553 if (unlikely(!pskb_may_pull(skb
, sizeof(*ershdr
))))
554 return PACKET_REJECT
;
556 ipv6h
= ipv6_hdr(skb
);
557 ershdr
= (struct erspan_base_hdr
*)skb
->data
;
559 tpi
->key
= cpu_to_be32(get_session_id(ershdr
));
561 tunnel
= ip6gre_tunnel_lookup(skb
->dev
,
562 &ipv6h
->saddr
, &ipv6h
->daddr
, tpi
->key
,
565 int len
= erspan_hdr_len(ver
);
567 if (unlikely(!pskb_may_pull(skb
, len
)))
568 return PACKET_REJECT
;
570 ershdr
= (struct erspan_base_hdr
*)skb
->data
;
571 pkt_md
= (struct erspan_metadata
*)(ershdr
+ 1);
573 if (__iptunnel_pull_header(skb
, len
,
576 return PACKET_REJECT
;
578 if (tunnel
->parms
.collect_md
) {
579 struct metadata_dst
*tun_dst
;
580 struct ip_tunnel_info
*info
;
581 struct erspan_metadata
*md
;
585 tpi
->flags
|= TUNNEL_KEY
;
587 tun_id
= key32_to_tunnel_id(tpi
->key
);
589 tun_dst
= ipv6_tun_rx_dst(skb
, flags
, tun_id
,
592 return PACKET_REJECT
;
594 info
= &tun_dst
->u
.tun_info
;
595 md
= ip_tunnel_info_opts(info
);
598 memcpy(md2
, pkt_md
, ver
== 1 ? ERSPAN_V1_MDSIZE
:
600 info
->key
.tun_flags
|= TUNNEL_ERSPAN_OPT
;
601 info
->options_len
= sizeof(*md
);
603 ip6_tnl_rcv(tunnel
, skb
, tpi
, tun_dst
, log_ecn_error
);
606 ip6_tnl_rcv(tunnel
, skb
, tpi
, NULL
, log_ecn_error
);
612 return PACKET_REJECT
;
615 static int gre_rcv(struct sk_buff
*skb
)
617 struct tnl_ptk_info tpi
;
618 bool csum_err
= false;
621 hdr_len
= gre_parse_header(skb
, &tpi
, &csum_err
, htons(ETH_P_IPV6
), 0);
625 if (iptunnel_pull_header(skb
, hdr_len
, tpi
.proto
, false))
628 if (unlikely(tpi
.proto
== htons(ETH_P_ERSPAN
) ||
629 tpi
.proto
== htons(ETH_P_ERSPAN2
))) {
630 if (ip6erspan_rcv(skb
, hdr_len
, &tpi
) == PACKET_RCVD
)
635 if (ip6gre_rcv(skb
, &tpi
) == PACKET_RCVD
)
639 icmpv6_send(skb
, ICMPV6_DEST_UNREACH
, ICMPV6_PORT_UNREACH
, 0);
645 static int gre_handle_offloads(struct sk_buff
*skb
, bool csum
)
647 return iptunnel_handle_offloads(skb
,
648 csum
? SKB_GSO_GRE_CSUM
: SKB_GSO_GRE
);
651 static void prepare_ip6gre_xmit_ipv4(struct sk_buff
*skb
,
652 struct net_device
*dev
,
653 struct flowi6
*fl6
, __u8
*dsfield
,
656 const struct iphdr
*iph
= ip_hdr(skb
);
657 struct ip6_tnl
*t
= netdev_priv(dev
);
659 if (!(t
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
))
660 *encap_limit
= t
->parms
.encap_limit
;
662 memcpy(fl6
, &t
->fl
.u
.ip6
, sizeof(*fl6
));
664 if (t
->parms
.flags
& IP6_TNL_F_USE_ORIG_TCLASS
)
665 *dsfield
= ipv4_get_dsfield(iph
);
667 *dsfield
= ip6_tclass(t
->parms
.flowinfo
);
669 if (t
->parms
.flags
& IP6_TNL_F_USE_ORIG_FWMARK
)
670 fl6
->flowi6_mark
= skb
->mark
;
672 fl6
->flowi6_mark
= t
->parms
.fwmark
;
674 fl6
->flowi6_uid
= sock_net_uid(dev_net(dev
), NULL
);
677 static int prepare_ip6gre_xmit_ipv6(struct sk_buff
*skb
,
678 struct net_device
*dev
,
679 struct flowi6
*fl6
, __u8
*dsfield
,
682 struct ipv6hdr
*ipv6h
= ipv6_hdr(skb
);
683 struct ip6_tnl
*t
= netdev_priv(dev
);
686 offset
= ip6_tnl_parse_tlv_enc_lim(skb
, skb_network_header(skb
));
687 /* ip6_tnl_parse_tlv_enc_lim() might have reallocated skb->head */
690 struct ipv6_tlv_tnl_enc_lim
*tel
;
692 tel
= (struct ipv6_tlv_tnl_enc_lim
*)&skb_network_header(skb
)[offset
];
693 if (tel
->encap_limit
== 0) {
694 icmpv6_send(skb
, ICMPV6_PARAMPROB
,
695 ICMPV6_HDR_FIELD
, offset
+ 2);
698 *encap_limit
= tel
->encap_limit
- 1;
699 } else if (!(t
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
)) {
700 *encap_limit
= t
->parms
.encap_limit
;
703 memcpy(fl6
, &t
->fl
.u
.ip6
, sizeof(*fl6
));
705 if (t
->parms
.flags
& IP6_TNL_F_USE_ORIG_TCLASS
)
706 *dsfield
= ipv6_get_dsfield(ipv6h
);
708 *dsfield
= ip6_tclass(t
->parms
.flowinfo
);
710 if (t
->parms
.flags
& IP6_TNL_F_USE_ORIG_FLOWLABEL
)
711 fl6
->flowlabel
|= ip6_flowlabel(ipv6h
);
713 if (t
->parms
.flags
& IP6_TNL_F_USE_ORIG_FWMARK
)
714 fl6
->flowi6_mark
= skb
->mark
;
716 fl6
->flowi6_mark
= t
->parms
.fwmark
;
718 fl6
->flowi6_uid
= sock_net_uid(dev_net(dev
), NULL
);
723 static netdev_tx_t
__gre6_xmit(struct sk_buff
*skb
,
724 struct net_device
*dev
, __u8 dsfield
,
725 struct flowi6
*fl6
, int encap_limit
,
726 __u32
*pmtu
, __be16 proto
)
728 struct ip6_tnl
*tunnel
= netdev_priv(dev
);
731 if (dev
->type
== ARPHRD_ETHER
)
732 IPCB(skb
)->flags
= 0;
734 if (dev
->header_ops
&& dev
->type
== ARPHRD_IP6GRE
)
735 fl6
->daddr
= ((struct ipv6hdr
*)skb
->data
)->daddr
;
737 fl6
->daddr
= tunnel
->parms
.raddr
;
739 if (skb_cow_head(skb
, dev
->needed_headroom
?: tunnel
->hlen
))
742 /* Push GRE header. */
743 protocol
= (dev
->type
== ARPHRD_ETHER
) ? htons(ETH_P_TEB
) : proto
;
745 if (tunnel
->parms
.collect_md
) {
746 struct ip_tunnel_info
*tun_info
;
747 const struct ip_tunnel_key
*key
;
750 tun_info
= skb_tunnel_info(skb
);
751 if (unlikely(!tun_info
||
752 !(tun_info
->mode
& IP_TUNNEL_INFO_TX
) ||
753 ip_tunnel_info_af(tun_info
) != AF_INET6
))
756 key
= &tun_info
->key
;
757 memset(fl6
, 0, sizeof(*fl6
));
758 fl6
->flowi6_proto
= IPPROTO_GRE
;
759 fl6
->daddr
= key
->u
.ipv6
.dst
;
760 fl6
->flowlabel
= key
->label
;
761 fl6
->flowi6_uid
= sock_net_uid(dev_net(dev
), NULL
);
764 flags
= key
->tun_flags
&
765 (TUNNEL_CSUM
| TUNNEL_KEY
| TUNNEL_SEQ
);
766 tunnel
->tun_hlen
= gre_calc_hlen(flags
);
768 gre_build_header(skb
, tunnel
->tun_hlen
,
770 tunnel_id_to_key32(tun_info
->key
.tun_id
),
771 (flags
& TUNNEL_SEQ
) ? htonl(tunnel
->o_seqno
++)
775 if (tunnel
->parms
.o_flags
& TUNNEL_SEQ
)
778 gre_build_header(skb
, tunnel
->tun_hlen
, tunnel
->parms
.o_flags
,
779 protocol
, tunnel
->parms
.o_key
,
780 htonl(tunnel
->o_seqno
));
783 return ip6_tnl_xmit(skb
, dev
, dsfield
, fl6
, encap_limit
, pmtu
,
787 static inline int ip6gre_xmit_ipv4(struct sk_buff
*skb
, struct net_device
*dev
)
789 struct ip6_tnl
*t
= netdev_priv(dev
);
790 int encap_limit
= -1;
796 memset(&(IPCB(skb
)->opt
), 0, sizeof(IPCB(skb
)->opt
));
798 if (!t
->parms
.collect_md
)
799 prepare_ip6gre_xmit_ipv4(skb
, dev
, &fl6
,
800 &dsfield
, &encap_limit
);
802 err
= gre_handle_offloads(skb
, !!(t
->parms
.o_flags
& TUNNEL_CSUM
));
806 err
= __gre6_xmit(skb
, dev
, dsfield
, &fl6
, encap_limit
, &mtu
,
809 /* XXX: send ICMP error even if DF is not set. */
810 if (err
== -EMSGSIZE
)
811 icmp_send(skb
, ICMP_DEST_UNREACH
, ICMP_FRAG_NEEDED
,
819 static inline int ip6gre_xmit_ipv6(struct sk_buff
*skb
, struct net_device
*dev
)
821 struct ip6_tnl
*t
= netdev_priv(dev
);
822 struct ipv6hdr
*ipv6h
= ipv6_hdr(skb
);
823 int encap_limit
= -1;
829 if (ipv6_addr_equal(&t
->parms
.raddr
, &ipv6h
->saddr
))
832 if (!t
->parms
.collect_md
&&
833 prepare_ip6gre_xmit_ipv6(skb
, dev
, &fl6
, &dsfield
, &encap_limit
))
836 if (gre_handle_offloads(skb
, !!(t
->parms
.o_flags
& TUNNEL_CSUM
)))
839 err
= __gre6_xmit(skb
, dev
, dsfield
, &fl6
, encap_limit
,
840 &mtu
, skb
->protocol
);
842 if (err
== -EMSGSIZE
)
843 icmpv6_send(skb
, ICMPV6_PKT_TOOBIG
, 0, mtu
);
851 * ip6gre_tnl_addr_conflict - compare packet addresses to tunnel's own
852 * @t: the outgoing tunnel device
853 * @hdr: IPv6 header from the incoming packet
856 * Avoid trivial tunneling loop by checking that tunnel exit-point
857 * doesn't match source of incoming packet.
864 static inline bool ip6gre_tnl_addr_conflict(const struct ip6_tnl
*t
,
865 const struct ipv6hdr
*hdr
)
867 return ipv6_addr_equal(&t
->parms
.raddr
, &hdr
->saddr
);
870 static int ip6gre_xmit_other(struct sk_buff
*skb
, struct net_device
*dev
)
872 struct ip6_tnl
*t
= netdev_priv(dev
);
873 int encap_limit
= -1;
878 if (!(t
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
))
879 encap_limit
= t
->parms
.encap_limit
;
881 if (!t
->parms
.collect_md
)
882 memcpy(&fl6
, &t
->fl
.u
.ip6
, sizeof(fl6
));
884 err
= gre_handle_offloads(skb
, !!(t
->parms
.o_flags
& TUNNEL_CSUM
));
888 err
= __gre6_xmit(skb
, dev
, 0, &fl6
, encap_limit
, &mtu
, skb
->protocol
);
893 static netdev_tx_t
ip6gre_tunnel_xmit(struct sk_buff
*skb
,
894 struct net_device
*dev
)
896 struct ip6_tnl
*t
= netdev_priv(dev
);
897 struct net_device_stats
*stats
= &t
->dev
->stats
;
900 if (!ip6_tnl_xmit_ctl(t
, &t
->parms
.laddr
, &t
->parms
.raddr
))
903 switch (skb
->protocol
) {
904 case htons(ETH_P_IP
):
905 ret
= ip6gre_xmit_ipv4(skb
, dev
);
907 case htons(ETH_P_IPV6
):
908 ret
= ip6gre_xmit_ipv6(skb
, dev
);
911 ret
= ip6gre_xmit_other(skb
, dev
);
927 static netdev_tx_t
ip6erspan_tunnel_xmit(struct sk_buff
*skb
,
928 struct net_device
*dev
)
930 struct ipv6hdr
*ipv6h
= ipv6_hdr(skb
);
931 struct ip6_tnl
*t
= netdev_priv(dev
);
932 struct dst_entry
*dst
= skb_dst(skb
);
933 struct net_device_stats
*stats
;
934 bool truncate
= false;
935 int encap_limit
= -1;
936 __u8 dsfield
= false;
943 if (!ip6_tnl_xmit_ctl(t
, &t
->parms
.laddr
, &t
->parms
.raddr
))
946 if (gre_handle_offloads(skb
, false))
949 if (skb
->len
> dev
->mtu
+ dev
->hard_header_len
) {
950 pskb_trim(skb
, dev
->mtu
+ dev
->hard_header_len
);
954 nhoff
= skb_network_header(skb
) - skb_mac_header(skb
);
955 if (skb
->protocol
== htons(ETH_P_IP
) &&
956 (ntohs(ip_hdr(skb
)->tot_len
) > skb
->len
- nhoff
))
959 thoff
= skb_transport_header(skb
) - skb_mac_header(skb
);
960 if (skb
->protocol
== htons(ETH_P_IPV6
) &&
961 (ntohs(ipv6_hdr(skb
)->payload_len
) > skb
->len
- thoff
))
964 if (skb_cow_head(skb
, dev
->needed_headroom
?: t
->hlen
))
967 t
->parms
.o_flags
&= ~TUNNEL_KEY
;
968 IPCB(skb
)->flags
= 0;
970 /* For collect_md mode, derive fl6 from the tunnel key,
971 * for native mode, call prepare_ip6gre_xmit_{ipv4,ipv6}.
973 if (t
->parms
.collect_md
) {
974 struct ip_tunnel_info
*tun_info
;
975 const struct ip_tunnel_key
*key
;
976 struct erspan_metadata
*md
;
979 tun_info
= skb_tunnel_info(skb
);
980 if (unlikely(!tun_info
||
981 !(tun_info
->mode
& IP_TUNNEL_INFO_TX
) ||
982 ip_tunnel_info_af(tun_info
) != AF_INET6
))
985 key
= &tun_info
->key
;
986 memset(&fl6
, 0, sizeof(fl6
));
987 fl6
.flowi6_proto
= IPPROTO_GRE
;
988 fl6
.daddr
= key
->u
.ipv6
.dst
;
989 fl6
.flowlabel
= key
->label
;
990 fl6
.flowi6_uid
= sock_net_uid(dev_net(dev
), NULL
);
993 md
= ip_tunnel_info_opts(tun_info
);
997 tun_id
= tunnel_id_to_key32(key
->tun_id
);
998 if (md
->version
== 1) {
999 erspan_build_header(skb
,
1001 ntohl(md
->u
.index
), truncate
,
1003 } else if (md
->version
== 2) {
1004 erspan_build_header_v2(skb
,
1007 get_hwid(&md
->u
.md2
),
1013 switch (skb
->protocol
) {
1014 case htons(ETH_P_IP
):
1015 memset(&(IPCB(skb
)->opt
), 0, sizeof(IPCB(skb
)->opt
));
1016 prepare_ip6gre_xmit_ipv4(skb
, dev
, &fl6
,
1017 &dsfield
, &encap_limit
);
1019 case htons(ETH_P_IPV6
):
1020 if (ipv6_addr_equal(&t
->parms
.raddr
, &ipv6h
->saddr
))
1022 if (prepare_ip6gre_xmit_ipv6(skb
, dev
, &fl6
,
1023 &dsfield
, &encap_limit
))
1027 memcpy(&fl6
, &t
->fl
.u
.ip6
, sizeof(fl6
));
1031 if (t
->parms
.erspan_ver
== 1)
1032 erspan_build_header(skb
, ntohl(t
->parms
.o_key
),
1035 else if (t
->parms
.erspan_ver
== 2)
1036 erspan_build_header_v2(skb
, ntohl(t
->parms
.o_key
),
1043 fl6
.daddr
= t
->parms
.raddr
;
1046 /* Push GRE header. */
1047 gre_build_header(skb
, 8, TUNNEL_SEQ
,
1048 htons(ETH_P_ERSPAN
), 0, htonl(t
->o_seqno
++));
1050 /* TooBig packet may have updated dst->dev's mtu */
1051 if (!t
->parms
.collect_md
&& dst
&& dst_mtu(dst
) > dst
->dev
->mtu
)
1052 dst
->ops
->update_pmtu(dst
, NULL
, skb
, dst
->dev
->mtu
);
1054 err
= ip6_tnl_xmit(skb
, dev
, dsfield
, &fl6
, encap_limit
, &mtu
,
1057 /* XXX: send ICMP error even if DF is not set. */
1058 if (err
== -EMSGSIZE
) {
1059 if (skb
->protocol
== htons(ETH_P_IP
))
1060 icmp_send(skb
, ICMP_DEST_UNREACH
,
1061 ICMP_FRAG_NEEDED
, htonl(mtu
));
1063 icmpv6_send(skb
, ICMPV6_PKT_TOOBIG
, 0, mtu
);
1068 return NETDEV_TX_OK
;
1071 stats
= &t
->dev
->stats
;
1073 stats
->tx_dropped
++;
1075 return NETDEV_TX_OK
;
1078 static void ip6gre_tnl_link_config_common(struct ip6_tnl
*t
)
1080 struct net_device
*dev
= t
->dev
;
1081 struct __ip6_tnl_parm
*p
= &t
->parms
;
1082 struct flowi6
*fl6
= &t
->fl
.u
.ip6
;
1084 if (dev
->type
!= ARPHRD_ETHER
) {
1085 memcpy(dev
->dev_addr
, &p
->laddr
, sizeof(struct in6_addr
));
1086 memcpy(dev
->broadcast
, &p
->raddr
, sizeof(struct in6_addr
));
1089 /* Set up flowi template */
1090 fl6
->saddr
= p
->laddr
;
1091 fl6
->daddr
= p
->raddr
;
1092 fl6
->flowi6_oif
= p
->link
;
1094 fl6
->flowi6_proto
= IPPROTO_GRE
;
1096 if (!(p
->flags
&IP6_TNL_F_USE_ORIG_TCLASS
))
1097 fl6
->flowlabel
|= IPV6_TCLASS_MASK
& p
->flowinfo
;
1098 if (!(p
->flags
&IP6_TNL_F_USE_ORIG_FLOWLABEL
))
1099 fl6
->flowlabel
|= IPV6_FLOWLABEL_MASK
& p
->flowinfo
;
1101 p
->flags
&= ~(IP6_TNL_F_CAP_XMIT
|IP6_TNL_F_CAP_RCV
|IP6_TNL_F_CAP_PER_PACKET
);
1102 p
->flags
|= ip6_tnl_get_cap(t
, &p
->laddr
, &p
->raddr
);
1104 if (p
->flags
&IP6_TNL_F_CAP_XMIT
&&
1105 p
->flags
&IP6_TNL_F_CAP_RCV
&& dev
->type
!= ARPHRD_ETHER
)
1106 dev
->flags
|= IFF_POINTOPOINT
;
1108 dev
->flags
&= ~IFF_POINTOPOINT
;
1111 static void ip6gre_tnl_link_config_route(struct ip6_tnl
*t
, int set_mtu
,
1114 const struct __ip6_tnl_parm
*p
= &t
->parms
;
1115 struct net_device
*dev
= t
->dev
;
1117 if (p
->flags
& IP6_TNL_F_CAP_XMIT
) {
1118 int strict
= (ipv6_addr_type(&p
->raddr
) &
1119 (IPV6_ADDR_MULTICAST
|IPV6_ADDR_LINKLOCAL
));
1121 struct rt6_info
*rt
= rt6_lookup(t
->net
,
1122 &p
->raddr
, &p
->laddr
,
1123 p
->link
, NULL
, strict
);
1129 dev
->hard_header_len
= rt
->dst
.dev
->hard_header_len
+
1133 dev
->mtu
= rt
->dst
.dev
->mtu
- t_hlen
;
1134 if (!(t
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
))
1136 if (dev
->type
== ARPHRD_ETHER
)
1137 dev
->mtu
-= ETH_HLEN
;
1139 if (dev
->mtu
< IPV6_MIN_MTU
)
1140 dev
->mtu
= IPV6_MIN_MTU
;
1147 static int ip6gre_calc_hlen(struct ip6_tnl
*tunnel
)
1151 tunnel
->tun_hlen
= gre_calc_hlen(tunnel
->parms
.o_flags
);
1152 tunnel
->hlen
= tunnel
->tun_hlen
+ tunnel
->encap_hlen
;
1154 t_hlen
= tunnel
->hlen
+ sizeof(struct ipv6hdr
);
1155 tunnel
->dev
->hard_header_len
= LL_MAX_HEADER
+ t_hlen
;
1159 static void ip6gre_tnl_link_config(struct ip6_tnl
*t
, int set_mtu
)
1161 ip6gre_tnl_link_config_common(t
);
1162 ip6gre_tnl_link_config_route(t
, set_mtu
, ip6gre_calc_hlen(t
));
1165 static void ip6gre_tnl_copy_tnl_parm(struct ip6_tnl
*t
,
1166 const struct __ip6_tnl_parm
*p
)
1168 t
->parms
.laddr
= p
->laddr
;
1169 t
->parms
.raddr
= p
->raddr
;
1170 t
->parms
.flags
= p
->flags
;
1171 t
->parms
.hop_limit
= p
->hop_limit
;
1172 t
->parms
.encap_limit
= p
->encap_limit
;
1173 t
->parms
.flowinfo
= p
->flowinfo
;
1174 t
->parms
.link
= p
->link
;
1175 t
->parms
.proto
= p
->proto
;
1176 t
->parms
.i_key
= p
->i_key
;
1177 t
->parms
.o_key
= p
->o_key
;
1178 t
->parms
.i_flags
= p
->i_flags
;
1179 t
->parms
.o_flags
= p
->o_flags
;
1180 t
->parms
.fwmark
= p
->fwmark
;
1181 dst_cache_reset(&t
->dst_cache
);
1184 static int ip6gre_tnl_change(struct ip6_tnl
*t
, const struct __ip6_tnl_parm
*p
,
1187 ip6gre_tnl_copy_tnl_parm(t
, p
);
1188 ip6gre_tnl_link_config(t
, set_mtu
);
1192 static void ip6gre_tnl_parm_from_user(struct __ip6_tnl_parm
*p
,
1193 const struct ip6_tnl_parm2
*u
)
1195 p
->laddr
= u
->laddr
;
1196 p
->raddr
= u
->raddr
;
1197 p
->flags
= u
->flags
;
1198 p
->hop_limit
= u
->hop_limit
;
1199 p
->encap_limit
= u
->encap_limit
;
1200 p
->flowinfo
= u
->flowinfo
;
1202 p
->i_key
= u
->i_key
;
1203 p
->o_key
= u
->o_key
;
1204 p
->i_flags
= gre_flags_to_tnl_flags(u
->i_flags
);
1205 p
->o_flags
= gre_flags_to_tnl_flags(u
->o_flags
);
1206 memcpy(p
->name
, u
->name
, sizeof(u
->name
));
1209 static void ip6gre_tnl_parm_to_user(struct ip6_tnl_parm2
*u
,
1210 const struct __ip6_tnl_parm
*p
)
1212 u
->proto
= IPPROTO_GRE
;
1213 u
->laddr
= p
->laddr
;
1214 u
->raddr
= p
->raddr
;
1215 u
->flags
= p
->flags
;
1216 u
->hop_limit
= p
->hop_limit
;
1217 u
->encap_limit
= p
->encap_limit
;
1218 u
->flowinfo
= p
->flowinfo
;
1220 u
->i_key
= p
->i_key
;
1221 u
->o_key
= p
->o_key
;
1222 u
->i_flags
= gre_tnl_flags_to_gre_flags(p
->i_flags
);
1223 u
->o_flags
= gre_tnl_flags_to_gre_flags(p
->o_flags
);
1224 memcpy(u
->name
, p
->name
, sizeof(u
->name
));
1227 static int ip6gre_tunnel_ioctl(struct net_device
*dev
,
1228 struct ifreq
*ifr
, int cmd
)
1231 struct ip6_tnl_parm2 p
;
1232 struct __ip6_tnl_parm p1
;
1233 struct ip6_tnl
*t
= netdev_priv(dev
);
1234 struct net
*net
= t
->net
;
1235 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
1237 memset(&p1
, 0, sizeof(p1
));
1241 if (dev
== ign
->fb_tunnel_dev
) {
1242 if (copy_from_user(&p
, ifr
->ifr_ifru
.ifru_data
, sizeof(p
))) {
1246 ip6gre_tnl_parm_from_user(&p1
, &p
);
1247 t
= ip6gre_tunnel_locate(net
, &p1
, 0);
1249 t
= netdev_priv(dev
);
1251 memset(&p
, 0, sizeof(p
));
1252 ip6gre_tnl_parm_to_user(&p
, &t
->parms
);
1253 if (copy_to_user(ifr
->ifr_ifru
.ifru_data
, &p
, sizeof(p
)))
1260 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
1264 if (copy_from_user(&p
, ifr
->ifr_ifru
.ifru_data
, sizeof(p
)))
1268 if ((p
.i_flags
|p
.o_flags
)&(GRE_VERSION
|GRE_ROUTING
))
1271 if (!(p
.i_flags
&GRE_KEY
))
1273 if (!(p
.o_flags
&GRE_KEY
))
1276 ip6gre_tnl_parm_from_user(&p1
, &p
);
1277 t
= ip6gre_tunnel_locate(net
, &p1
, cmd
== SIOCADDTUNNEL
);
1279 if (dev
!= ign
->fb_tunnel_dev
&& cmd
== SIOCCHGTUNNEL
) {
1281 if (t
->dev
!= dev
) {
1286 t
= netdev_priv(dev
);
1288 ip6gre_tunnel_unlink(ign
, t
);
1290 ip6gre_tnl_change(t
, &p1
, 1);
1291 ip6gre_tunnel_link(ign
, t
);
1292 netdev_state_change(dev
);
1299 memset(&p
, 0, sizeof(p
));
1300 ip6gre_tnl_parm_to_user(&p
, &t
->parms
);
1301 if (copy_to_user(ifr
->ifr_ifru
.ifru_data
, &p
, sizeof(p
)))
1304 err
= (cmd
== SIOCADDTUNNEL
? -ENOBUFS
: -ENOENT
);
1309 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
1312 if (dev
== ign
->fb_tunnel_dev
) {
1314 if (copy_from_user(&p
, ifr
->ifr_ifru
.ifru_data
, sizeof(p
)))
1317 ip6gre_tnl_parm_from_user(&p1
, &p
);
1318 t
= ip6gre_tunnel_locate(net
, &p1
, 0);
1322 if (t
== netdev_priv(ign
->fb_tunnel_dev
))
1326 unregister_netdevice(dev
);
1338 static int ip6gre_header(struct sk_buff
*skb
, struct net_device
*dev
,
1339 unsigned short type
, const void *daddr
,
1340 const void *saddr
, unsigned int len
)
1342 struct ip6_tnl
*t
= netdev_priv(dev
);
1343 struct ipv6hdr
*ipv6h
;
1346 ipv6h
= skb_push(skb
, t
->hlen
+ sizeof(*ipv6h
));
1347 ip6_flow_hdr(ipv6h
, 0, ip6_make_flowlabel(dev_net(dev
), skb
,
1348 t
->fl
.u
.ip6
.flowlabel
,
1349 true, &t
->fl
.u
.ip6
));
1350 ipv6h
->hop_limit
= t
->parms
.hop_limit
;
1351 ipv6h
->nexthdr
= NEXTHDR_GRE
;
1352 ipv6h
->saddr
= t
->parms
.laddr
;
1353 ipv6h
->daddr
= t
->parms
.raddr
;
1355 p
= (__be16
*)(ipv6h
+ 1);
1356 p
[0] = t
->parms
.o_flags
;
1360 * Set the source hardware address.
1364 memcpy(&ipv6h
->saddr
, saddr
, sizeof(struct in6_addr
));
1366 memcpy(&ipv6h
->daddr
, daddr
, sizeof(struct in6_addr
));
1367 if (!ipv6_addr_any(&ipv6h
->daddr
))
1373 static const struct header_ops ip6gre_header_ops
= {
1374 .create
= ip6gre_header
,
1377 static const struct net_device_ops ip6gre_netdev_ops
= {
1378 .ndo_init
= ip6gre_tunnel_init
,
1379 .ndo_uninit
= ip6gre_tunnel_uninit
,
1380 .ndo_start_xmit
= ip6gre_tunnel_xmit
,
1381 .ndo_do_ioctl
= ip6gre_tunnel_ioctl
,
1382 .ndo_change_mtu
= ip6_tnl_change_mtu
,
1383 .ndo_get_stats64
= ip_tunnel_get_stats64
,
1384 .ndo_get_iflink
= ip6_tnl_get_iflink
,
1387 static void ip6gre_dev_free(struct net_device
*dev
)
1389 struct ip6_tnl
*t
= netdev_priv(dev
);
1391 gro_cells_destroy(&t
->gro_cells
);
1392 dst_cache_destroy(&t
->dst_cache
);
1393 free_percpu(dev
->tstats
);
1396 static void ip6gre_tunnel_setup(struct net_device
*dev
)
1398 dev
->netdev_ops
= &ip6gre_netdev_ops
;
1399 dev
->needs_free_netdev
= true;
1400 dev
->priv_destructor
= ip6gre_dev_free
;
1402 dev
->type
= ARPHRD_IP6GRE
;
1404 dev
->flags
|= IFF_NOARP
;
1405 dev
->addr_len
= sizeof(struct in6_addr
);
1406 netif_keep_dst(dev
);
1407 /* This perm addr will be used as interface identifier by IPv6 */
1408 dev
->addr_assign_type
= NET_ADDR_RANDOM
;
1409 eth_random_addr(dev
->perm_addr
);
1412 #define GRE6_FEATURES (NETIF_F_SG | \
1413 NETIF_F_FRAGLIST | \
1417 static void ip6gre_tnl_init_features(struct net_device
*dev
)
1419 struct ip6_tnl
*nt
= netdev_priv(dev
);
1421 dev
->features
|= GRE6_FEATURES
;
1422 dev
->hw_features
|= GRE6_FEATURES
;
1424 if (!(nt
->parms
.o_flags
& TUNNEL_SEQ
)) {
1425 /* TCP offload with GRE SEQ is not supported, nor
1426 * can we support 2 levels of outer headers requiring
1429 if (!(nt
->parms
.o_flags
& TUNNEL_CSUM
) ||
1430 nt
->encap
.type
== TUNNEL_ENCAP_NONE
) {
1431 dev
->features
|= NETIF_F_GSO_SOFTWARE
;
1432 dev
->hw_features
|= NETIF_F_GSO_SOFTWARE
;
1435 /* Can use a lockless transmit, unless we generate
1438 dev
->features
|= NETIF_F_LLTX
;
1442 static int ip6gre_tunnel_init_common(struct net_device
*dev
)
1444 struct ip6_tnl
*tunnel
;
1448 tunnel
= netdev_priv(dev
);
1451 tunnel
->net
= dev_net(dev
);
1452 strcpy(tunnel
->parms
.name
, dev
->name
);
1454 dev
->tstats
= netdev_alloc_pcpu_stats(struct pcpu_sw_netstats
);
1458 ret
= dst_cache_init(&tunnel
->dst_cache
, GFP_KERNEL
);
1460 goto cleanup_alloc_pcpu_stats
;
1462 ret
= gro_cells_init(&tunnel
->gro_cells
, dev
);
1464 goto cleanup_dst_cache_init
;
1466 t_hlen
= ip6gre_calc_hlen(tunnel
);
1467 dev
->mtu
= ETH_DATA_LEN
- t_hlen
;
1468 if (dev
->type
== ARPHRD_ETHER
)
1469 dev
->mtu
-= ETH_HLEN
;
1470 if (!(tunnel
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
))
1473 if (tunnel
->parms
.collect_md
) {
1474 dev
->features
|= NETIF_F_NETNS_LOCAL
;
1475 netif_keep_dst(dev
);
1477 ip6gre_tnl_init_features(dev
);
1481 cleanup_dst_cache_init
:
1482 dst_cache_destroy(&tunnel
->dst_cache
);
1483 cleanup_alloc_pcpu_stats
:
1484 free_percpu(dev
->tstats
);
1489 static int ip6gre_tunnel_init(struct net_device
*dev
)
1491 struct ip6_tnl
*tunnel
;
1494 ret
= ip6gre_tunnel_init_common(dev
);
1498 tunnel
= netdev_priv(dev
);
1500 if (tunnel
->parms
.collect_md
)
1503 memcpy(dev
->dev_addr
, &tunnel
->parms
.laddr
, sizeof(struct in6_addr
));
1504 memcpy(dev
->broadcast
, &tunnel
->parms
.raddr
, sizeof(struct in6_addr
));
1506 if (ipv6_addr_any(&tunnel
->parms
.raddr
))
1507 dev
->header_ops
= &ip6gre_header_ops
;
1512 static void ip6gre_fb_tunnel_init(struct net_device
*dev
)
1514 struct ip6_tnl
*tunnel
= netdev_priv(dev
);
1517 tunnel
->net
= dev_net(dev
);
1518 strcpy(tunnel
->parms
.name
, dev
->name
);
1520 tunnel
->hlen
= sizeof(struct ipv6hdr
) + 4;
1525 static struct inet6_protocol ip6gre_protocol __read_mostly
= {
1527 .err_handler
= ip6gre_err
,
1528 .flags
= INET6_PROTO_NOPOLICY
|INET6_PROTO_FINAL
,
1531 static void ip6gre_destroy_tunnels(struct net
*net
, struct list_head
*head
)
1533 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
1534 struct net_device
*dev
, *aux
;
1537 for_each_netdev_safe(net
, dev
, aux
)
1538 if (dev
->rtnl_link_ops
== &ip6gre_link_ops
||
1539 dev
->rtnl_link_ops
== &ip6gre_tap_ops
||
1540 dev
->rtnl_link_ops
== &ip6erspan_tap_ops
)
1541 unregister_netdevice_queue(dev
, head
);
1543 for (prio
= 0; prio
< 4; prio
++) {
1545 for (h
= 0; h
< IP6_GRE_HASH_SIZE
; h
++) {
1548 t
= rtnl_dereference(ign
->tunnels
[prio
][h
]);
1551 /* If dev is in the same netns, it has already
1552 * been added to the list by the previous loop.
1554 if (!net_eq(dev_net(t
->dev
), net
))
1555 unregister_netdevice_queue(t
->dev
,
1557 t
= rtnl_dereference(t
->next
);
1563 static int __net_init
ip6gre_init_net(struct net
*net
)
1565 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
1568 if (!net_has_fallback_tunnels(net
))
1570 ign
->fb_tunnel_dev
= alloc_netdev(sizeof(struct ip6_tnl
), "ip6gre0",
1572 ip6gre_tunnel_setup
);
1573 if (!ign
->fb_tunnel_dev
) {
1577 dev_net_set(ign
->fb_tunnel_dev
, net
);
1578 /* FB netdevice is special: we have one, and only one per netns.
1579 * Allowing to move it to another netns is clearly unsafe.
1581 ign
->fb_tunnel_dev
->features
|= NETIF_F_NETNS_LOCAL
;
1584 ip6gre_fb_tunnel_init(ign
->fb_tunnel_dev
);
1585 ign
->fb_tunnel_dev
->rtnl_link_ops
= &ip6gre_link_ops
;
1587 err
= register_netdev(ign
->fb_tunnel_dev
);
1591 rcu_assign_pointer(ign
->tunnels_wc
[0],
1592 netdev_priv(ign
->fb_tunnel_dev
));
1596 free_netdev(ign
->fb_tunnel_dev
);
1601 static void __net_exit
ip6gre_exit_batch_net(struct list_head
*net_list
)
1607 list_for_each_entry(net
, net_list
, exit_list
)
1608 ip6gre_destroy_tunnels(net
, &list
);
1609 unregister_netdevice_many(&list
);
1613 static struct pernet_operations ip6gre_net_ops
= {
1614 .init
= ip6gre_init_net
,
1615 .exit_batch
= ip6gre_exit_batch_net
,
1616 .id
= &ip6gre_net_id
,
1617 .size
= sizeof(struct ip6gre_net
),
1620 static int ip6gre_tunnel_validate(struct nlattr
*tb
[], struct nlattr
*data
[],
1621 struct netlink_ext_ack
*extack
)
1629 if (data
[IFLA_GRE_IFLAGS
])
1630 flags
|= nla_get_be16(data
[IFLA_GRE_IFLAGS
]);
1631 if (data
[IFLA_GRE_OFLAGS
])
1632 flags
|= nla_get_be16(data
[IFLA_GRE_OFLAGS
]);
1633 if (flags
& (GRE_VERSION
|GRE_ROUTING
))
1639 static int ip6gre_tap_validate(struct nlattr
*tb
[], struct nlattr
*data
[],
1640 struct netlink_ext_ack
*extack
)
1642 struct in6_addr daddr
;
1644 if (tb
[IFLA_ADDRESS
]) {
1645 if (nla_len(tb
[IFLA_ADDRESS
]) != ETH_ALEN
)
1647 if (!is_valid_ether_addr(nla_data(tb
[IFLA_ADDRESS
])))
1648 return -EADDRNOTAVAIL
;
1654 if (data
[IFLA_GRE_REMOTE
]) {
1655 daddr
= nla_get_in6_addr(data
[IFLA_GRE_REMOTE
]);
1656 if (ipv6_addr_any(&daddr
))
1661 return ip6gre_tunnel_validate(tb
, data
, extack
);
1664 static int ip6erspan_tap_validate(struct nlattr
*tb
[], struct nlattr
*data
[],
1665 struct netlink_ext_ack
*extack
)
1673 ret
= ip6gre_tap_validate(tb
, data
, extack
);
1677 /* ERSPAN should only have GRE sequence and key flag */
1678 if (data
[IFLA_GRE_OFLAGS
])
1679 flags
|= nla_get_be16(data
[IFLA_GRE_OFLAGS
]);
1680 if (data
[IFLA_GRE_IFLAGS
])
1681 flags
|= nla_get_be16(data
[IFLA_GRE_IFLAGS
]);
1682 if (!data
[IFLA_GRE_COLLECT_METADATA
] &&
1683 flags
!= (GRE_SEQ
| GRE_KEY
))
1686 /* ERSPAN Session ID only has 10-bit. Since we reuse
1687 * 32-bit key field as ID, check it's range.
1689 if (data
[IFLA_GRE_IKEY
] &&
1690 (ntohl(nla_get_be32(data
[IFLA_GRE_IKEY
])) & ~ID_MASK
))
1693 if (data
[IFLA_GRE_OKEY
] &&
1694 (ntohl(nla_get_be32(data
[IFLA_GRE_OKEY
])) & ~ID_MASK
))
1697 if (data
[IFLA_GRE_ERSPAN_VER
]) {
1698 ver
= nla_get_u8(data
[IFLA_GRE_ERSPAN_VER
]);
1699 if (ver
!= 1 && ver
!= 2)
1704 if (data
[IFLA_GRE_ERSPAN_INDEX
]) {
1705 u32 index
= nla_get_u32(data
[IFLA_GRE_ERSPAN_INDEX
]);
1707 if (index
& ~INDEX_MASK
)
1710 } else if (ver
== 2) {
1711 if (data
[IFLA_GRE_ERSPAN_DIR
]) {
1712 u16 dir
= nla_get_u8(data
[IFLA_GRE_ERSPAN_DIR
]);
1714 if (dir
& ~(DIR_MASK
>> DIR_OFFSET
))
1718 if (data
[IFLA_GRE_ERSPAN_HWID
]) {
1719 u16 hwid
= nla_get_u16(data
[IFLA_GRE_ERSPAN_HWID
]);
1721 if (hwid
& ~(HWID_MASK
>> HWID_OFFSET
))
1729 static void ip6gre_netlink_parms(struct nlattr
*data
[],
1730 struct __ip6_tnl_parm
*parms
)
1732 memset(parms
, 0, sizeof(*parms
));
1737 if (data
[IFLA_GRE_LINK
])
1738 parms
->link
= nla_get_u32(data
[IFLA_GRE_LINK
]);
1740 if (data
[IFLA_GRE_IFLAGS
])
1741 parms
->i_flags
= gre_flags_to_tnl_flags(
1742 nla_get_be16(data
[IFLA_GRE_IFLAGS
]));
1744 if (data
[IFLA_GRE_OFLAGS
])
1745 parms
->o_flags
= gre_flags_to_tnl_flags(
1746 nla_get_be16(data
[IFLA_GRE_OFLAGS
]));
1748 if (data
[IFLA_GRE_IKEY
])
1749 parms
->i_key
= nla_get_be32(data
[IFLA_GRE_IKEY
]);
1751 if (data
[IFLA_GRE_OKEY
])
1752 parms
->o_key
= nla_get_be32(data
[IFLA_GRE_OKEY
]);
1754 if (data
[IFLA_GRE_LOCAL
])
1755 parms
->laddr
= nla_get_in6_addr(data
[IFLA_GRE_LOCAL
]);
1757 if (data
[IFLA_GRE_REMOTE
])
1758 parms
->raddr
= nla_get_in6_addr(data
[IFLA_GRE_REMOTE
]);
1760 if (data
[IFLA_GRE_TTL
])
1761 parms
->hop_limit
= nla_get_u8(data
[IFLA_GRE_TTL
]);
1763 if (data
[IFLA_GRE_ENCAP_LIMIT
])
1764 parms
->encap_limit
= nla_get_u8(data
[IFLA_GRE_ENCAP_LIMIT
]);
1766 if (data
[IFLA_GRE_FLOWINFO
])
1767 parms
->flowinfo
= nla_get_be32(data
[IFLA_GRE_FLOWINFO
]);
1769 if (data
[IFLA_GRE_FLAGS
])
1770 parms
->flags
= nla_get_u32(data
[IFLA_GRE_FLAGS
]);
1772 if (data
[IFLA_GRE_FWMARK
])
1773 parms
->fwmark
= nla_get_u32(data
[IFLA_GRE_FWMARK
]);
1775 if (data
[IFLA_GRE_COLLECT_METADATA
])
1776 parms
->collect_md
= true;
1778 if (data
[IFLA_GRE_ERSPAN_VER
])
1779 parms
->erspan_ver
= nla_get_u8(data
[IFLA_GRE_ERSPAN_VER
]);
1781 if (parms
->erspan_ver
== 1) {
1782 if (data
[IFLA_GRE_ERSPAN_INDEX
])
1783 parms
->index
= nla_get_u32(data
[IFLA_GRE_ERSPAN_INDEX
]);
1784 } else if (parms
->erspan_ver
== 2) {
1785 if (data
[IFLA_GRE_ERSPAN_DIR
])
1786 parms
->dir
= nla_get_u8(data
[IFLA_GRE_ERSPAN_DIR
]);
1787 if (data
[IFLA_GRE_ERSPAN_HWID
])
1788 parms
->hwid
= nla_get_u16(data
[IFLA_GRE_ERSPAN_HWID
]);
1792 static int ip6gre_tap_init(struct net_device
*dev
)
1796 ret
= ip6gre_tunnel_init_common(dev
);
1800 dev
->priv_flags
|= IFF_LIVE_ADDR_CHANGE
;
1805 static const struct net_device_ops ip6gre_tap_netdev_ops
= {
1806 .ndo_init
= ip6gre_tap_init
,
1807 .ndo_uninit
= ip6gre_tunnel_uninit
,
1808 .ndo_start_xmit
= ip6gre_tunnel_xmit
,
1809 .ndo_set_mac_address
= eth_mac_addr
,
1810 .ndo_validate_addr
= eth_validate_addr
,
1811 .ndo_change_mtu
= ip6_tnl_change_mtu
,
1812 .ndo_get_stats64
= ip_tunnel_get_stats64
,
1813 .ndo_get_iflink
= ip6_tnl_get_iflink
,
1816 static int ip6erspan_calc_hlen(struct ip6_tnl
*tunnel
)
1820 tunnel
->tun_hlen
= 8;
1821 tunnel
->hlen
= tunnel
->tun_hlen
+ tunnel
->encap_hlen
+
1822 erspan_hdr_len(tunnel
->parms
.erspan_ver
);
1824 t_hlen
= tunnel
->hlen
+ sizeof(struct ipv6hdr
);
1825 tunnel
->dev
->hard_header_len
= LL_MAX_HEADER
+ t_hlen
;
1829 static int ip6erspan_tap_init(struct net_device
*dev
)
1831 struct ip6_tnl
*tunnel
;
1835 tunnel
= netdev_priv(dev
);
1838 tunnel
->net
= dev_net(dev
);
1839 strcpy(tunnel
->parms
.name
, dev
->name
);
1841 dev
->tstats
= netdev_alloc_pcpu_stats(struct pcpu_sw_netstats
);
1845 ret
= dst_cache_init(&tunnel
->dst_cache
, GFP_KERNEL
);
1847 goto cleanup_alloc_pcpu_stats
;
1849 ret
= gro_cells_init(&tunnel
->gro_cells
, dev
);
1851 goto cleanup_dst_cache_init
;
1853 t_hlen
= ip6erspan_calc_hlen(tunnel
);
1854 dev
->mtu
= ETH_DATA_LEN
- t_hlen
;
1855 if (dev
->type
== ARPHRD_ETHER
)
1856 dev
->mtu
-= ETH_HLEN
;
1857 if (!(tunnel
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
))
1860 dev
->priv_flags
|= IFF_LIVE_ADDR_CHANGE
;
1861 ip6erspan_tnl_link_config(tunnel
, 1);
1865 cleanup_dst_cache_init
:
1866 dst_cache_destroy(&tunnel
->dst_cache
);
1867 cleanup_alloc_pcpu_stats
:
1868 free_percpu(dev
->tstats
);
1873 static const struct net_device_ops ip6erspan_netdev_ops
= {
1874 .ndo_init
= ip6erspan_tap_init
,
1875 .ndo_uninit
= ip6erspan_tunnel_uninit
,
1876 .ndo_start_xmit
= ip6erspan_tunnel_xmit
,
1877 .ndo_set_mac_address
= eth_mac_addr
,
1878 .ndo_validate_addr
= eth_validate_addr
,
1879 .ndo_change_mtu
= ip6_tnl_change_mtu
,
1880 .ndo_get_stats64
= ip_tunnel_get_stats64
,
1881 .ndo_get_iflink
= ip6_tnl_get_iflink
,
1884 static void ip6gre_tap_setup(struct net_device
*dev
)
1890 dev
->netdev_ops
= &ip6gre_tap_netdev_ops
;
1891 dev
->needs_free_netdev
= true;
1892 dev
->priv_destructor
= ip6gre_dev_free
;
1894 dev
->features
|= NETIF_F_NETNS_LOCAL
;
1895 dev
->priv_flags
&= ~IFF_TX_SKB_SHARING
;
1896 dev
->priv_flags
|= IFF_LIVE_ADDR_CHANGE
;
1897 netif_keep_dst(dev
);
1900 bool is_ip6gretap_dev(const struct net_device
*dev
)
1902 return dev
->netdev_ops
== &ip6gre_tap_netdev_ops
;
1904 EXPORT_SYMBOL_GPL(is_ip6gretap_dev
);
1906 static bool ip6gre_netlink_encap_parms(struct nlattr
*data
[],
1907 struct ip_tunnel_encap
*ipencap
)
1911 memset(ipencap
, 0, sizeof(*ipencap
));
1916 if (data
[IFLA_GRE_ENCAP_TYPE
]) {
1918 ipencap
->type
= nla_get_u16(data
[IFLA_GRE_ENCAP_TYPE
]);
1921 if (data
[IFLA_GRE_ENCAP_FLAGS
]) {
1923 ipencap
->flags
= nla_get_u16(data
[IFLA_GRE_ENCAP_FLAGS
]);
1926 if (data
[IFLA_GRE_ENCAP_SPORT
]) {
1928 ipencap
->sport
= nla_get_be16(data
[IFLA_GRE_ENCAP_SPORT
]);
1931 if (data
[IFLA_GRE_ENCAP_DPORT
]) {
1933 ipencap
->dport
= nla_get_be16(data
[IFLA_GRE_ENCAP_DPORT
]);
1939 static int ip6gre_newlink_common(struct net
*src_net
, struct net_device
*dev
,
1940 struct nlattr
*tb
[], struct nlattr
*data
[],
1941 struct netlink_ext_ack
*extack
)
1944 struct ip_tunnel_encap ipencap
;
1947 nt
= netdev_priv(dev
);
1949 if (ip6gre_netlink_encap_parms(data
, &ipencap
)) {
1950 int err
= ip6_tnl_encap_setup(nt
, &ipencap
);
1956 if (dev
->type
== ARPHRD_ETHER
&& !tb
[IFLA_ADDRESS
])
1957 eth_hw_addr_random(dev
);
1960 nt
->net
= dev_net(dev
);
1962 err
= register_netdevice(dev
);
1967 ip6_tnl_change_mtu(dev
, nla_get_u32(tb
[IFLA_MTU
]));
1975 static int ip6gre_newlink(struct net
*src_net
, struct net_device
*dev
,
1976 struct nlattr
*tb
[], struct nlattr
*data
[],
1977 struct netlink_ext_ack
*extack
)
1979 struct ip6_tnl
*nt
= netdev_priv(dev
);
1980 struct net
*net
= dev_net(dev
);
1981 struct ip6gre_net
*ign
;
1984 ip6gre_netlink_parms(data
, &nt
->parms
);
1985 ign
= net_generic(net
, ip6gre_net_id
);
1987 if (nt
->parms
.collect_md
) {
1988 if (rtnl_dereference(ign
->collect_md_tun
))
1991 if (ip6gre_tunnel_find(net
, &nt
->parms
, dev
->type
))
1995 err
= ip6gre_newlink_common(src_net
, dev
, tb
, data
, extack
);
1997 ip6gre_tnl_link_config(nt
, !tb
[IFLA_MTU
]);
1998 ip6gre_tunnel_link_md(ign
, nt
);
1999 ip6gre_tunnel_link(net_generic(net
, ip6gre_net_id
), nt
);
2004 static struct ip6_tnl
*
2005 ip6gre_changelink_common(struct net_device
*dev
, struct nlattr
*tb
[],
2006 struct nlattr
*data
[], struct __ip6_tnl_parm
*p_p
,
2007 struct netlink_ext_ack
*extack
)
2009 struct ip6_tnl
*t
, *nt
= netdev_priv(dev
);
2010 struct net
*net
= nt
->net
;
2011 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
2012 struct ip_tunnel_encap ipencap
;
2014 if (dev
== ign
->fb_tunnel_dev
)
2015 return ERR_PTR(-EINVAL
);
2017 if (ip6gre_netlink_encap_parms(data
, &ipencap
)) {
2018 int err
= ip6_tnl_encap_setup(nt
, &ipencap
);
2021 return ERR_PTR(err
);
2024 ip6gre_netlink_parms(data
, p_p
);
2026 t
= ip6gre_tunnel_locate(net
, p_p
, 0);
2030 return ERR_PTR(-EEXIST
);
2038 static int ip6gre_changelink(struct net_device
*dev
, struct nlattr
*tb
[],
2039 struct nlattr
*data
[],
2040 struct netlink_ext_ack
*extack
)
2042 struct ip6gre_net
*ign
= net_generic(dev_net(dev
), ip6gre_net_id
);
2043 struct __ip6_tnl_parm p
;
2046 t
= ip6gre_changelink_common(dev
, tb
, data
, &p
, extack
);
2050 ip6gre_tunnel_unlink_md(ign
, t
);
2051 ip6gre_tunnel_unlink(ign
, t
);
2052 ip6gre_tnl_change(t
, &p
, !tb
[IFLA_MTU
]);
2053 ip6gre_tunnel_link_md(ign
, t
);
2054 ip6gre_tunnel_link(ign
, t
);
2058 static void ip6gre_dellink(struct net_device
*dev
, struct list_head
*head
)
2060 struct net
*net
= dev_net(dev
);
2061 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
2063 if (dev
!= ign
->fb_tunnel_dev
)
2064 unregister_netdevice_queue(dev
, head
);
2067 static size_t ip6gre_get_size(const struct net_device
*dev
)
2072 /* IFLA_GRE_IFLAGS */
2074 /* IFLA_GRE_OFLAGS */
2080 /* IFLA_GRE_LOCAL */
2081 nla_total_size(sizeof(struct in6_addr
)) +
2082 /* IFLA_GRE_REMOTE */
2083 nla_total_size(sizeof(struct in6_addr
)) +
2086 /* IFLA_GRE_ENCAP_LIMIT */
2088 /* IFLA_GRE_FLOWINFO */
2090 /* IFLA_GRE_FLAGS */
2092 /* IFLA_GRE_ENCAP_TYPE */
2094 /* IFLA_GRE_ENCAP_FLAGS */
2096 /* IFLA_GRE_ENCAP_SPORT */
2098 /* IFLA_GRE_ENCAP_DPORT */
2100 /* IFLA_GRE_COLLECT_METADATA */
2102 /* IFLA_GRE_FWMARK */
2104 /* IFLA_GRE_ERSPAN_INDEX */
2109 static int ip6gre_fill_info(struct sk_buff
*skb
, const struct net_device
*dev
)
2111 struct ip6_tnl
*t
= netdev_priv(dev
);
2112 struct __ip6_tnl_parm
*p
= &t
->parms
;
2114 if (nla_put_u32(skb
, IFLA_GRE_LINK
, p
->link
) ||
2115 nla_put_be16(skb
, IFLA_GRE_IFLAGS
,
2116 gre_tnl_flags_to_gre_flags(p
->i_flags
)) ||
2117 nla_put_be16(skb
, IFLA_GRE_OFLAGS
,
2118 gre_tnl_flags_to_gre_flags(p
->o_flags
)) ||
2119 nla_put_be32(skb
, IFLA_GRE_IKEY
, p
->i_key
) ||
2120 nla_put_be32(skb
, IFLA_GRE_OKEY
, p
->o_key
) ||
2121 nla_put_in6_addr(skb
, IFLA_GRE_LOCAL
, &p
->laddr
) ||
2122 nla_put_in6_addr(skb
, IFLA_GRE_REMOTE
, &p
->raddr
) ||
2123 nla_put_u8(skb
, IFLA_GRE_TTL
, p
->hop_limit
) ||
2124 nla_put_u8(skb
, IFLA_GRE_ENCAP_LIMIT
, p
->encap_limit
) ||
2125 nla_put_be32(skb
, IFLA_GRE_FLOWINFO
, p
->flowinfo
) ||
2126 nla_put_u32(skb
, IFLA_GRE_FLAGS
, p
->flags
) ||
2127 nla_put_u32(skb
, IFLA_GRE_FWMARK
, p
->fwmark
) ||
2128 nla_put_u32(skb
, IFLA_GRE_ERSPAN_INDEX
, p
->index
))
2129 goto nla_put_failure
;
2131 if (nla_put_u16(skb
, IFLA_GRE_ENCAP_TYPE
,
2133 nla_put_be16(skb
, IFLA_GRE_ENCAP_SPORT
,
2135 nla_put_be16(skb
, IFLA_GRE_ENCAP_DPORT
,
2137 nla_put_u16(skb
, IFLA_GRE_ENCAP_FLAGS
,
2139 goto nla_put_failure
;
2141 if (p
->collect_md
) {
2142 if (nla_put_flag(skb
, IFLA_GRE_COLLECT_METADATA
))
2143 goto nla_put_failure
;
2146 if (nla_put_u8(skb
, IFLA_GRE_ERSPAN_VER
, p
->erspan_ver
))
2147 goto nla_put_failure
;
2149 if (p
->erspan_ver
== 1) {
2150 if (nla_put_u32(skb
, IFLA_GRE_ERSPAN_INDEX
, p
->index
))
2151 goto nla_put_failure
;
2152 } else if (p
->erspan_ver
== 2) {
2153 if (nla_put_u8(skb
, IFLA_GRE_ERSPAN_DIR
, p
->dir
))
2154 goto nla_put_failure
;
2155 if (nla_put_u16(skb
, IFLA_GRE_ERSPAN_HWID
, p
->hwid
))
2156 goto nla_put_failure
;
2165 static const struct nla_policy ip6gre_policy
[IFLA_GRE_MAX
+ 1] = {
2166 [IFLA_GRE_LINK
] = { .type
= NLA_U32
},
2167 [IFLA_GRE_IFLAGS
] = { .type
= NLA_U16
},
2168 [IFLA_GRE_OFLAGS
] = { .type
= NLA_U16
},
2169 [IFLA_GRE_IKEY
] = { .type
= NLA_U32
},
2170 [IFLA_GRE_OKEY
] = { .type
= NLA_U32
},
2171 [IFLA_GRE_LOCAL
] = { .len
= FIELD_SIZEOF(struct ipv6hdr
, saddr
) },
2172 [IFLA_GRE_REMOTE
] = { .len
= FIELD_SIZEOF(struct ipv6hdr
, daddr
) },
2173 [IFLA_GRE_TTL
] = { .type
= NLA_U8
},
2174 [IFLA_GRE_ENCAP_LIMIT
] = { .type
= NLA_U8
},
2175 [IFLA_GRE_FLOWINFO
] = { .type
= NLA_U32
},
2176 [IFLA_GRE_FLAGS
] = { .type
= NLA_U32
},
2177 [IFLA_GRE_ENCAP_TYPE
] = { .type
= NLA_U16
},
2178 [IFLA_GRE_ENCAP_FLAGS
] = { .type
= NLA_U16
},
2179 [IFLA_GRE_ENCAP_SPORT
] = { .type
= NLA_U16
},
2180 [IFLA_GRE_ENCAP_DPORT
] = { .type
= NLA_U16
},
2181 [IFLA_GRE_COLLECT_METADATA
] = { .type
= NLA_FLAG
},
2182 [IFLA_GRE_FWMARK
] = { .type
= NLA_U32
},
2183 [IFLA_GRE_ERSPAN_INDEX
] = { .type
= NLA_U32
},
2184 [IFLA_GRE_ERSPAN_VER
] = { .type
= NLA_U8
},
2185 [IFLA_GRE_ERSPAN_DIR
] = { .type
= NLA_U8
},
2186 [IFLA_GRE_ERSPAN_HWID
] = { .type
= NLA_U16
},
2189 static void ip6erspan_tap_setup(struct net_device
*dev
)
2193 dev
->netdev_ops
= &ip6erspan_netdev_ops
;
2194 dev
->needs_free_netdev
= true;
2195 dev
->priv_destructor
= ip6gre_dev_free
;
2197 dev
->features
|= NETIF_F_NETNS_LOCAL
;
2198 dev
->priv_flags
&= ~IFF_TX_SKB_SHARING
;
2199 dev
->priv_flags
|= IFF_LIVE_ADDR_CHANGE
;
2200 netif_keep_dst(dev
);
2203 static int ip6erspan_newlink(struct net
*src_net
, struct net_device
*dev
,
2204 struct nlattr
*tb
[], struct nlattr
*data
[],
2205 struct netlink_ext_ack
*extack
)
2207 struct ip6_tnl
*nt
= netdev_priv(dev
);
2208 struct net
*net
= dev_net(dev
);
2209 struct ip6gre_net
*ign
;
2212 ip6gre_netlink_parms(data
, &nt
->parms
);
2213 ign
= net_generic(net
, ip6gre_net_id
);
2215 if (nt
->parms
.collect_md
) {
2216 if (rtnl_dereference(ign
->collect_md_tun_erspan
))
2219 if (ip6gre_tunnel_find(net
, &nt
->parms
, dev
->type
))
2223 err
= ip6gre_newlink_common(src_net
, dev
, tb
, data
, extack
);
2225 ip6erspan_tnl_link_config(nt
, !tb
[IFLA_MTU
]);
2226 ip6erspan_tunnel_link_md(ign
, nt
);
2227 ip6gre_tunnel_link(net_generic(net
, ip6gre_net_id
), nt
);
2232 static void ip6erspan_tnl_link_config(struct ip6_tnl
*t
, int set_mtu
)
2234 ip6gre_tnl_link_config_common(t
);
2235 ip6gre_tnl_link_config_route(t
, set_mtu
, ip6erspan_calc_hlen(t
));
2238 static int ip6erspan_tnl_change(struct ip6_tnl
*t
,
2239 const struct __ip6_tnl_parm
*p
, int set_mtu
)
2241 ip6gre_tnl_copy_tnl_parm(t
, p
);
2242 ip6erspan_tnl_link_config(t
, set_mtu
);
2246 static int ip6erspan_changelink(struct net_device
*dev
, struct nlattr
*tb
[],
2247 struct nlattr
*data
[],
2248 struct netlink_ext_ack
*extack
)
2250 struct ip6gre_net
*ign
= net_generic(dev_net(dev
), ip6gre_net_id
);
2251 struct __ip6_tnl_parm p
;
2254 t
= ip6gre_changelink_common(dev
, tb
, data
, &p
, extack
);
2258 ip6gre_tunnel_unlink_md(ign
, t
);
2259 ip6gre_tunnel_unlink(ign
, t
);
2260 ip6erspan_tnl_change(t
, &p
, !tb
[IFLA_MTU
]);
2261 ip6erspan_tunnel_link_md(ign
, t
);
2262 ip6gre_tunnel_link(ign
, t
);
2266 static struct rtnl_link_ops ip6gre_link_ops __read_mostly
= {
2268 .maxtype
= IFLA_GRE_MAX
,
2269 .policy
= ip6gre_policy
,
2270 .priv_size
= sizeof(struct ip6_tnl
),
2271 .setup
= ip6gre_tunnel_setup
,
2272 .validate
= ip6gre_tunnel_validate
,
2273 .newlink
= ip6gre_newlink
,
2274 .changelink
= ip6gre_changelink
,
2275 .dellink
= ip6gre_dellink
,
2276 .get_size
= ip6gre_get_size
,
2277 .fill_info
= ip6gre_fill_info
,
2278 .get_link_net
= ip6_tnl_get_link_net
,
2281 static struct rtnl_link_ops ip6gre_tap_ops __read_mostly
= {
2282 .kind
= "ip6gretap",
2283 .maxtype
= IFLA_GRE_MAX
,
2284 .policy
= ip6gre_policy
,
2285 .priv_size
= sizeof(struct ip6_tnl
),
2286 .setup
= ip6gre_tap_setup
,
2287 .validate
= ip6gre_tap_validate
,
2288 .newlink
= ip6gre_newlink
,
2289 .changelink
= ip6gre_changelink
,
2290 .get_size
= ip6gre_get_size
,
2291 .fill_info
= ip6gre_fill_info
,
2292 .get_link_net
= ip6_tnl_get_link_net
,
2295 static struct rtnl_link_ops ip6erspan_tap_ops __read_mostly
= {
2296 .kind
= "ip6erspan",
2297 .maxtype
= IFLA_GRE_MAX
,
2298 .policy
= ip6gre_policy
,
2299 .priv_size
= sizeof(struct ip6_tnl
),
2300 .setup
= ip6erspan_tap_setup
,
2301 .validate
= ip6erspan_tap_validate
,
2302 .newlink
= ip6erspan_newlink
,
2303 .changelink
= ip6erspan_changelink
,
2304 .get_size
= ip6gre_get_size
,
2305 .fill_info
= ip6gre_fill_info
,
2306 .get_link_net
= ip6_tnl_get_link_net
,
2310 * And now the modules code and kernel interface.
2313 static int __init
ip6gre_init(void)
2317 pr_info("GRE over IPv6 tunneling driver\n");
2319 err
= register_pernet_device(&ip6gre_net_ops
);
2323 err
= inet6_add_protocol(&ip6gre_protocol
, IPPROTO_GRE
);
2325 pr_info("%s: can't add protocol\n", __func__
);
2326 goto add_proto_failed
;
2329 err
= rtnl_link_register(&ip6gre_link_ops
);
2331 goto rtnl_link_failed
;
2333 err
= rtnl_link_register(&ip6gre_tap_ops
);
2335 goto tap_ops_failed
;
2337 err
= rtnl_link_register(&ip6erspan_tap_ops
);
2339 goto erspan_link_failed
;
2345 rtnl_link_unregister(&ip6gre_tap_ops
);
2347 rtnl_link_unregister(&ip6gre_link_ops
);
2349 inet6_del_protocol(&ip6gre_protocol
, IPPROTO_GRE
);
2351 unregister_pernet_device(&ip6gre_net_ops
);
2355 static void __exit
ip6gre_fini(void)
2357 rtnl_link_unregister(&ip6gre_tap_ops
);
2358 rtnl_link_unregister(&ip6gre_link_ops
);
2359 rtnl_link_unregister(&ip6erspan_tap_ops
);
2360 inet6_del_protocol(&ip6gre_protocol
, IPPROTO_GRE
);
2361 unregister_pernet_device(&ip6gre_net_ops
);
2364 module_init(ip6gre_init
);
2365 module_exit(ip6gre_fini
);
2366 MODULE_LICENSE("GPL");
2367 MODULE_AUTHOR("D. Kozlov (xeb@mail.ru)");
2368 MODULE_DESCRIPTION("GRE over IPv6 tunneling device");
2369 MODULE_ALIAS_RTNL_LINK("ip6gre");
2370 MODULE_ALIAS_RTNL_LINK("ip6gretap");
2371 MODULE_ALIAS_RTNL_LINK("ip6erspan");
2372 MODULE_ALIAS_NETDEV("ip6gre0");