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 int 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 ipv6hdr
*ipv6h
;
431 struct tnl_ptk_info tpi
;
434 if (gre_parse_header(skb
, &tpi
, NULL
, htons(ETH_P_IPV6
),
438 ipv6h
= (const struct ipv6hdr
*)skb
->data
;
439 t
= ip6gre_tunnel_lookup(skb
->dev
, &ipv6h
->daddr
, &ipv6h
->saddr
,
445 struct ipv6_tlv_tnl_enc_lim
*tel
;
447 case ICMPV6_DEST_UNREACH
:
448 net_dbg_ratelimited("%s: Path to destination invalid or inactive!\n",
450 if (code
!= ICMPV6_PORT_UNREACH
)
453 case ICMPV6_TIME_EXCEED
:
454 if (code
== ICMPV6_EXC_HOPLIMIT
) {
455 net_dbg_ratelimited("%s: Too small hop limit or routing loop in tunnel!\n",
460 case ICMPV6_PARAMPROB
:
462 if (code
== ICMPV6_HDR_FIELD
)
463 teli
= ip6_tnl_parse_tlv_enc_lim(skb
, skb
->data
);
465 if (teli
&& teli
== be32_to_cpu(info
) - 2) {
466 tel
= (struct ipv6_tlv_tnl_enc_lim
*) &skb
->data
[teli
];
467 if (tel
->encap_limit
== 0) {
468 net_dbg_ratelimited("%s: Too small encapsulation limit or routing loop in tunnel!\n",
472 net_dbg_ratelimited("%s: Recipient unable to parse tunneled packet!\n",
476 case ICMPV6_PKT_TOOBIG
:
477 ip6_update_pmtu(skb
, net
, info
, 0, 0, sock_net_uid(net
, NULL
));
480 ip6_redirect(skb
, net
, skb
->dev
->ifindex
, 0,
481 sock_net_uid(net
, NULL
));
485 if (time_before(jiffies
, t
->err_time
+ IP6TUNNEL_ERR_TIMEO
))
489 t
->err_time
= jiffies
;
494 static int ip6gre_rcv(struct sk_buff
*skb
, const struct tnl_ptk_info
*tpi
)
496 const struct ipv6hdr
*ipv6h
;
497 struct ip6_tnl
*tunnel
;
499 ipv6h
= ipv6_hdr(skb
);
500 tunnel
= ip6gre_tunnel_lookup(skb
->dev
,
501 &ipv6h
->saddr
, &ipv6h
->daddr
, tpi
->key
,
504 if (tunnel
->parms
.collect_md
) {
505 struct metadata_dst
*tun_dst
;
510 tun_id
= key32_to_tunnel_id(tpi
->key
);
512 tun_dst
= ipv6_tun_rx_dst(skb
, flags
, tun_id
, 0);
514 return PACKET_REJECT
;
516 ip6_tnl_rcv(tunnel
, skb
, tpi
, tun_dst
, log_ecn_error
);
518 ip6_tnl_rcv(tunnel
, skb
, tpi
, NULL
, log_ecn_error
);
524 return PACKET_REJECT
;
527 static int ip6erspan_rcv(struct sk_buff
*skb
, int gre_hdr_len
,
528 struct tnl_ptk_info
*tpi
)
530 struct erspan_base_hdr
*ershdr
;
531 struct erspan_metadata
*pkt_md
;
532 const struct ipv6hdr
*ipv6h
;
533 struct erspan_md2
*md2
;
534 struct ip6_tnl
*tunnel
;
537 if (unlikely(!pskb_may_pull(skb
, sizeof(*ershdr
))))
538 return PACKET_REJECT
;
540 ipv6h
= ipv6_hdr(skb
);
541 ershdr
= (struct erspan_base_hdr
*)skb
->data
;
543 tpi
->key
= cpu_to_be32(get_session_id(ershdr
));
545 tunnel
= ip6gre_tunnel_lookup(skb
->dev
,
546 &ipv6h
->saddr
, &ipv6h
->daddr
, tpi
->key
,
549 int len
= erspan_hdr_len(ver
);
551 if (unlikely(!pskb_may_pull(skb
, len
)))
552 return PACKET_REJECT
;
554 ershdr
= (struct erspan_base_hdr
*)skb
->data
;
555 pkt_md
= (struct erspan_metadata
*)(ershdr
+ 1);
557 if (__iptunnel_pull_header(skb
, len
,
560 return PACKET_REJECT
;
562 if (tunnel
->parms
.collect_md
) {
563 struct metadata_dst
*tun_dst
;
564 struct ip_tunnel_info
*info
;
565 struct erspan_metadata
*md
;
569 tpi
->flags
|= TUNNEL_KEY
;
571 tun_id
= key32_to_tunnel_id(tpi
->key
);
573 tun_dst
= ipv6_tun_rx_dst(skb
, flags
, tun_id
,
576 return PACKET_REJECT
;
578 info
= &tun_dst
->u
.tun_info
;
579 md
= ip_tunnel_info_opts(info
);
582 memcpy(md2
, pkt_md
, ver
== 1 ? ERSPAN_V1_MDSIZE
:
584 info
->key
.tun_flags
|= TUNNEL_ERSPAN_OPT
;
585 info
->options_len
= sizeof(*md
);
587 ip6_tnl_rcv(tunnel
, skb
, tpi
, tun_dst
, log_ecn_error
);
590 ip6_tnl_rcv(tunnel
, skb
, tpi
, NULL
, log_ecn_error
);
596 return PACKET_REJECT
;
599 static int gre_rcv(struct sk_buff
*skb
)
601 struct tnl_ptk_info tpi
;
602 bool csum_err
= false;
605 hdr_len
= gre_parse_header(skb
, &tpi
, &csum_err
, htons(ETH_P_IPV6
), 0);
609 if (iptunnel_pull_header(skb
, hdr_len
, tpi
.proto
, false))
612 if (unlikely(tpi
.proto
== htons(ETH_P_ERSPAN
) ||
613 tpi
.proto
== htons(ETH_P_ERSPAN2
))) {
614 if (ip6erspan_rcv(skb
, hdr_len
, &tpi
) == PACKET_RCVD
)
619 if (ip6gre_rcv(skb
, &tpi
) == PACKET_RCVD
)
623 icmpv6_send(skb
, ICMPV6_DEST_UNREACH
, ICMPV6_PORT_UNREACH
, 0);
629 static int gre_handle_offloads(struct sk_buff
*skb
, bool csum
)
631 return iptunnel_handle_offloads(skb
,
632 csum
? SKB_GSO_GRE_CSUM
: SKB_GSO_GRE
);
635 static void prepare_ip6gre_xmit_ipv4(struct sk_buff
*skb
,
636 struct net_device
*dev
,
637 struct flowi6
*fl6
, __u8
*dsfield
,
640 const struct iphdr
*iph
= ip_hdr(skb
);
641 struct ip6_tnl
*t
= netdev_priv(dev
);
643 if (!(t
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
))
644 *encap_limit
= t
->parms
.encap_limit
;
646 memcpy(fl6
, &t
->fl
.u
.ip6
, sizeof(*fl6
));
648 if (t
->parms
.flags
& IP6_TNL_F_USE_ORIG_TCLASS
)
649 *dsfield
= ipv4_get_dsfield(iph
);
651 *dsfield
= ip6_tclass(t
->parms
.flowinfo
);
653 if (t
->parms
.flags
& IP6_TNL_F_USE_ORIG_FWMARK
)
654 fl6
->flowi6_mark
= skb
->mark
;
656 fl6
->flowi6_mark
= t
->parms
.fwmark
;
658 fl6
->flowi6_uid
= sock_net_uid(dev_net(dev
), NULL
);
661 static int prepare_ip6gre_xmit_ipv6(struct sk_buff
*skb
,
662 struct net_device
*dev
,
663 struct flowi6
*fl6
, __u8
*dsfield
,
666 struct ipv6hdr
*ipv6h
= ipv6_hdr(skb
);
667 struct ip6_tnl
*t
= netdev_priv(dev
);
670 offset
= ip6_tnl_parse_tlv_enc_lim(skb
, skb_network_header(skb
));
671 /* ip6_tnl_parse_tlv_enc_lim() might have reallocated skb->head */
674 struct ipv6_tlv_tnl_enc_lim
*tel
;
676 tel
= (struct ipv6_tlv_tnl_enc_lim
*)&skb_network_header(skb
)[offset
];
677 if (tel
->encap_limit
== 0) {
678 icmpv6_send(skb
, ICMPV6_PARAMPROB
,
679 ICMPV6_HDR_FIELD
, offset
+ 2);
682 *encap_limit
= tel
->encap_limit
- 1;
683 } else if (!(t
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
)) {
684 *encap_limit
= t
->parms
.encap_limit
;
687 memcpy(fl6
, &t
->fl
.u
.ip6
, sizeof(*fl6
));
689 if (t
->parms
.flags
& IP6_TNL_F_USE_ORIG_TCLASS
)
690 *dsfield
= ipv6_get_dsfield(ipv6h
);
692 *dsfield
= ip6_tclass(t
->parms
.flowinfo
);
694 if (t
->parms
.flags
& IP6_TNL_F_USE_ORIG_FLOWLABEL
)
695 fl6
->flowlabel
|= ip6_flowlabel(ipv6h
);
697 if (t
->parms
.flags
& IP6_TNL_F_USE_ORIG_FWMARK
)
698 fl6
->flowi6_mark
= skb
->mark
;
700 fl6
->flowi6_mark
= t
->parms
.fwmark
;
702 fl6
->flowi6_uid
= sock_net_uid(dev_net(dev
), NULL
);
707 static netdev_tx_t
__gre6_xmit(struct sk_buff
*skb
,
708 struct net_device
*dev
, __u8 dsfield
,
709 struct flowi6
*fl6
, int encap_limit
,
710 __u32
*pmtu
, __be16 proto
)
712 struct ip6_tnl
*tunnel
= netdev_priv(dev
);
715 if (dev
->type
== ARPHRD_ETHER
)
716 IPCB(skb
)->flags
= 0;
718 if (dev
->header_ops
&& dev
->type
== ARPHRD_IP6GRE
)
719 fl6
->daddr
= ((struct ipv6hdr
*)skb
->data
)->daddr
;
721 fl6
->daddr
= tunnel
->parms
.raddr
;
723 if (skb_cow_head(skb
, dev
->needed_headroom
?: tunnel
->hlen
))
726 /* Push GRE header. */
727 protocol
= (dev
->type
== ARPHRD_ETHER
) ? htons(ETH_P_TEB
) : proto
;
729 if (tunnel
->parms
.collect_md
) {
730 struct ip_tunnel_info
*tun_info
;
731 const struct ip_tunnel_key
*key
;
734 tun_info
= skb_tunnel_info(skb
);
735 if (unlikely(!tun_info
||
736 !(tun_info
->mode
& IP_TUNNEL_INFO_TX
) ||
737 ip_tunnel_info_af(tun_info
) != AF_INET6
))
740 key
= &tun_info
->key
;
741 memset(fl6
, 0, sizeof(*fl6
));
742 fl6
->flowi6_proto
= IPPROTO_GRE
;
743 fl6
->daddr
= key
->u
.ipv6
.dst
;
744 fl6
->flowlabel
= key
->label
;
745 fl6
->flowi6_uid
= sock_net_uid(dev_net(dev
), NULL
);
748 flags
= key
->tun_flags
&
749 (TUNNEL_CSUM
| TUNNEL_KEY
| TUNNEL_SEQ
);
750 tunnel
->tun_hlen
= gre_calc_hlen(flags
);
752 gre_build_header(skb
, tunnel
->tun_hlen
,
754 tunnel_id_to_key32(tun_info
->key
.tun_id
),
755 (flags
& TUNNEL_SEQ
) ? htonl(tunnel
->o_seqno
++)
759 if (tunnel
->parms
.o_flags
& TUNNEL_SEQ
)
762 gre_build_header(skb
, tunnel
->tun_hlen
, tunnel
->parms
.o_flags
,
763 protocol
, tunnel
->parms
.o_key
,
764 htonl(tunnel
->o_seqno
));
767 return ip6_tnl_xmit(skb
, dev
, dsfield
, fl6
, encap_limit
, pmtu
,
771 static inline int ip6gre_xmit_ipv4(struct sk_buff
*skb
, struct net_device
*dev
)
773 struct ip6_tnl
*t
= netdev_priv(dev
);
774 int encap_limit
= -1;
780 memset(&(IPCB(skb
)->opt
), 0, sizeof(IPCB(skb
)->opt
));
782 if (!t
->parms
.collect_md
)
783 prepare_ip6gre_xmit_ipv4(skb
, dev
, &fl6
,
784 &dsfield
, &encap_limit
);
786 err
= gre_handle_offloads(skb
, !!(t
->parms
.o_flags
& TUNNEL_CSUM
));
790 err
= __gre6_xmit(skb
, dev
, dsfield
, &fl6
, encap_limit
, &mtu
,
793 /* XXX: send ICMP error even if DF is not set. */
794 if (err
== -EMSGSIZE
)
795 icmp_send(skb
, ICMP_DEST_UNREACH
, ICMP_FRAG_NEEDED
,
803 static inline int ip6gre_xmit_ipv6(struct sk_buff
*skb
, struct net_device
*dev
)
805 struct ip6_tnl
*t
= netdev_priv(dev
);
806 struct ipv6hdr
*ipv6h
= ipv6_hdr(skb
);
807 int encap_limit
= -1;
813 if (ipv6_addr_equal(&t
->parms
.raddr
, &ipv6h
->saddr
))
816 if (!t
->parms
.collect_md
&&
817 prepare_ip6gre_xmit_ipv6(skb
, dev
, &fl6
, &dsfield
, &encap_limit
))
820 if (gre_handle_offloads(skb
, !!(t
->parms
.o_flags
& TUNNEL_CSUM
)))
823 err
= __gre6_xmit(skb
, dev
, dsfield
, &fl6
, encap_limit
,
824 &mtu
, skb
->protocol
);
826 if (err
== -EMSGSIZE
)
827 icmpv6_send(skb
, ICMPV6_PKT_TOOBIG
, 0, mtu
);
835 * ip6gre_tnl_addr_conflict - compare packet addresses to tunnel's own
836 * @t: the outgoing tunnel device
837 * @hdr: IPv6 header from the incoming packet
840 * Avoid trivial tunneling loop by checking that tunnel exit-point
841 * doesn't match source of incoming packet.
848 static inline bool ip6gre_tnl_addr_conflict(const struct ip6_tnl
*t
,
849 const struct ipv6hdr
*hdr
)
851 return ipv6_addr_equal(&t
->parms
.raddr
, &hdr
->saddr
);
854 static int ip6gre_xmit_other(struct sk_buff
*skb
, struct net_device
*dev
)
856 struct ip6_tnl
*t
= netdev_priv(dev
);
857 int encap_limit
= -1;
862 if (!(t
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
))
863 encap_limit
= t
->parms
.encap_limit
;
865 if (!t
->parms
.collect_md
)
866 memcpy(&fl6
, &t
->fl
.u
.ip6
, sizeof(fl6
));
868 err
= gre_handle_offloads(skb
, !!(t
->parms
.o_flags
& TUNNEL_CSUM
));
872 err
= __gre6_xmit(skb
, dev
, 0, &fl6
, encap_limit
, &mtu
, skb
->protocol
);
877 static netdev_tx_t
ip6gre_tunnel_xmit(struct sk_buff
*skb
,
878 struct net_device
*dev
)
880 struct ip6_tnl
*t
= netdev_priv(dev
);
881 struct net_device_stats
*stats
= &t
->dev
->stats
;
884 if (!pskb_inet_may_pull(skb
))
887 if (!ip6_tnl_xmit_ctl(t
, &t
->parms
.laddr
, &t
->parms
.raddr
))
890 switch (skb
->protocol
) {
891 case htons(ETH_P_IP
):
892 ret
= ip6gre_xmit_ipv4(skb
, dev
);
894 case htons(ETH_P_IPV6
):
895 ret
= ip6gre_xmit_ipv6(skb
, dev
);
898 ret
= ip6gre_xmit_other(skb
, dev
);
914 static netdev_tx_t
ip6erspan_tunnel_xmit(struct sk_buff
*skb
,
915 struct net_device
*dev
)
917 struct ip6_tnl
*t
= netdev_priv(dev
);
918 struct dst_entry
*dst
= skb_dst(skb
);
919 struct net_device_stats
*stats
;
920 bool truncate
= false;
921 int encap_limit
= -1;
922 __u8 dsfield
= false;
929 if (!pskb_inet_may_pull(skb
))
932 if (!ip6_tnl_xmit_ctl(t
, &t
->parms
.laddr
, &t
->parms
.raddr
))
935 if (gre_handle_offloads(skb
, false))
938 if (skb
->len
> dev
->mtu
+ dev
->hard_header_len
) {
939 pskb_trim(skb
, dev
->mtu
+ dev
->hard_header_len
);
943 nhoff
= skb_network_header(skb
) - skb_mac_header(skb
);
944 if (skb
->protocol
== htons(ETH_P_IP
) &&
945 (ntohs(ip_hdr(skb
)->tot_len
) > skb
->len
- nhoff
))
948 thoff
= skb_transport_header(skb
) - skb_mac_header(skb
);
949 if (skb
->protocol
== htons(ETH_P_IPV6
) &&
950 (ntohs(ipv6_hdr(skb
)->payload_len
) > skb
->len
- thoff
))
953 if (skb_cow_head(skb
, dev
->needed_headroom
?: t
->hlen
))
956 t
->parms
.o_flags
&= ~TUNNEL_KEY
;
957 IPCB(skb
)->flags
= 0;
959 /* For collect_md mode, derive fl6 from the tunnel key,
960 * for native mode, call prepare_ip6gre_xmit_{ipv4,ipv6}.
962 if (t
->parms
.collect_md
) {
963 struct ip_tunnel_info
*tun_info
;
964 const struct ip_tunnel_key
*key
;
965 struct erspan_metadata
*md
;
968 tun_info
= skb_tunnel_info(skb
);
969 if (unlikely(!tun_info
||
970 !(tun_info
->mode
& IP_TUNNEL_INFO_TX
) ||
971 ip_tunnel_info_af(tun_info
) != AF_INET6
))
974 key
= &tun_info
->key
;
975 memset(&fl6
, 0, sizeof(fl6
));
976 fl6
.flowi6_proto
= IPPROTO_GRE
;
977 fl6
.daddr
= key
->u
.ipv6
.dst
;
978 fl6
.flowlabel
= key
->label
;
979 fl6
.flowi6_uid
= sock_net_uid(dev_net(dev
), NULL
);
982 if (!(tun_info
->key
.tun_flags
& TUNNEL_ERSPAN_OPT
))
984 md
= ip_tunnel_info_opts(tun_info
);
988 tun_id
= tunnel_id_to_key32(key
->tun_id
);
989 if (md
->version
== 1) {
990 erspan_build_header(skb
,
992 ntohl(md
->u
.index
), truncate
,
994 } else if (md
->version
== 2) {
995 erspan_build_header_v2(skb
,
998 get_hwid(&md
->u
.md2
),
1004 switch (skb
->protocol
) {
1005 case htons(ETH_P_IP
):
1006 memset(&(IPCB(skb
)->opt
), 0, sizeof(IPCB(skb
)->opt
));
1007 prepare_ip6gre_xmit_ipv4(skb
, dev
, &fl6
,
1008 &dsfield
, &encap_limit
);
1010 case htons(ETH_P_IPV6
):
1011 if (ipv6_addr_equal(&t
->parms
.raddr
, &ipv6_hdr(skb
)->saddr
))
1013 if (prepare_ip6gre_xmit_ipv6(skb
, dev
, &fl6
,
1014 &dsfield
, &encap_limit
))
1018 memcpy(&fl6
, &t
->fl
.u
.ip6
, sizeof(fl6
));
1022 if (t
->parms
.erspan_ver
== 1)
1023 erspan_build_header(skb
, ntohl(t
->parms
.o_key
),
1026 else if (t
->parms
.erspan_ver
== 2)
1027 erspan_build_header_v2(skb
, ntohl(t
->parms
.o_key
),
1034 fl6
.daddr
= t
->parms
.raddr
;
1037 /* Push GRE header. */
1038 gre_build_header(skb
, 8, TUNNEL_SEQ
,
1039 htons(ETH_P_ERSPAN
), 0, htonl(t
->o_seqno
++));
1041 /* TooBig packet may have updated dst->dev's mtu */
1042 if (!t
->parms
.collect_md
&& dst
&& dst_mtu(dst
) > dst
->dev
->mtu
)
1043 dst
->ops
->update_pmtu(dst
, NULL
, skb
, dst
->dev
->mtu
);
1045 err
= ip6_tnl_xmit(skb
, dev
, dsfield
, &fl6
, encap_limit
, &mtu
,
1048 /* XXX: send ICMP error even if DF is not set. */
1049 if (err
== -EMSGSIZE
) {
1050 if (skb
->protocol
== htons(ETH_P_IP
))
1051 icmp_send(skb
, ICMP_DEST_UNREACH
,
1052 ICMP_FRAG_NEEDED
, htonl(mtu
));
1054 icmpv6_send(skb
, ICMPV6_PKT_TOOBIG
, 0, mtu
);
1059 return NETDEV_TX_OK
;
1062 stats
= &t
->dev
->stats
;
1064 stats
->tx_dropped
++;
1066 return NETDEV_TX_OK
;
1069 static void ip6gre_tnl_link_config_common(struct ip6_tnl
*t
)
1071 struct net_device
*dev
= t
->dev
;
1072 struct __ip6_tnl_parm
*p
= &t
->parms
;
1073 struct flowi6
*fl6
= &t
->fl
.u
.ip6
;
1075 if (dev
->type
!= ARPHRD_ETHER
) {
1076 memcpy(dev
->dev_addr
, &p
->laddr
, sizeof(struct in6_addr
));
1077 memcpy(dev
->broadcast
, &p
->raddr
, sizeof(struct in6_addr
));
1080 /* Set up flowi template */
1081 fl6
->saddr
= p
->laddr
;
1082 fl6
->daddr
= p
->raddr
;
1083 fl6
->flowi6_oif
= p
->link
;
1085 fl6
->flowi6_proto
= IPPROTO_GRE
;
1087 if (!(p
->flags
&IP6_TNL_F_USE_ORIG_TCLASS
))
1088 fl6
->flowlabel
|= IPV6_TCLASS_MASK
& p
->flowinfo
;
1089 if (!(p
->flags
&IP6_TNL_F_USE_ORIG_FLOWLABEL
))
1090 fl6
->flowlabel
|= IPV6_FLOWLABEL_MASK
& p
->flowinfo
;
1092 p
->flags
&= ~(IP6_TNL_F_CAP_XMIT
|IP6_TNL_F_CAP_RCV
|IP6_TNL_F_CAP_PER_PACKET
);
1093 p
->flags
|= ip6_tnl_get_cap(t
, &p
->laddr
, &p
->raddr
);
1095 if (p
->flags
&IP6_TNL_F_CAP_XMIT
&&
1096 p
->flags
&IP6_TNL_F_CAP_RCV
&& dev
->type
!= ARPHRD_ETHER
)
1097 dev
->flags
|= IFF_POINTOPOINT
;
1099 dev
->flags
&= ~IFF_POINTOPOINT
;
1102 static void ip6gre_tnl_link_config_route(struct ip6_tnl
*t
, int set_mtu
,
1105 const struct __ip6_tnl_parm
*p
= &t
->parms
;
1106 struct net_device
*dev
= t
->dev
;
1108 if (p
->flags
& IP6_TNL_F_CAP_XMIT
) {
1109 int strict
= (ipv6_addr_type(&p
->raddr
) &
1110 (IPV6_ADDR_MULTICAST
|IPV6_ADDR_LINKLOCAL
));
1112 struct rt6_info
*rt
= rt6_lookup(t
->net
,
1113 &p
->raddr
, &p
->laddr
,
1114 p
->link
, NULL
, strict
);
1120 dev
->needed_headroom
= rt
->dst
.dev
->hard_header_len
+
1124 dev
->mtu
= rt
->dst
.dev
->mtu
- t_hlen
;
1125 if (!(t
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
))
1127 if (dev
->type
== ARPHRD_ETHER
)
1128 dev
->mtu
-= ETH_HLEN
;
1130 if (dev
->mtu
< IPV6_MIN_MTU
)
1131 dev
->mtu
= IPV6_MIN_MTU
;
1138 static int ip6gre_calc_hlen(struct ip6_tnl
*tunnel
)
1142 tunnel
->tun_hlen
= gre_calc_hlen(tunnel
->parms
.o_flags
);
1143 tunnel
->hlen
= tunnel
->tun_hlen
+ tunnel
->encap_hlen
;
1145 t_hlen
= tunnel
->hlen
+ sizeof(struct ipv6hdr
);
1146 tunnel
->dev
->needed_headroom
= LL_MAX_HEADER
+ t_hlen
;
1150 static void ip6gre_tnl_link_config(struct ip6_tnl
*t
, int set_mtu
)
1152 ip6gre_tnl_link_config_common(t
);
1153 ip6gre_tnl_link_config_route(t
, set_mtu
, ip6gre_calc_hlen(t
));
1156 static void ip6gre_tnl_copy_tnl_parm(struct ip6_tnl
*t
,
1157 const struct __ip6_tnl_parm
*p
)
1159 t
->parms
.laddr
= p
->laddr
;
1160 t
->parms
.raddr
= p
->raddr
;
1161 t
->parms
.flags
= p
->flags
;
1162 t
->parms
.hop_limit
= p
->hop_limit
;
1163 t
->parms
.encap_limit
= p
->encap_limit
;
1164 t
->parms
.flowinfo
= p
->flowinfo
;
1165 t
->parms
.link
= p
->link
;
1166 t
->parms
.proto
= p
->proto
;
1167 t
->parms
.i_key
= p
->i_key
;
1168 t
->parms
.o_key
= p
->o_key
;
1169 t
->parms
.i_flags
= p
->i_flags
;
1170 t
->parms
.o_flags
= p
->o_flags
;
1171 t
->parms
.fwmark
= p
->fwmark
;
1172 t
->parms
.erspan_ver
= p
->erspan_ver
;
1173 t
->parms
.index
= p
->index
;
1174 t
->parms
.dir
= p
->dir
;
1175 t
->parms
.hwid
= p
->hwid
;
1176 dst_cache_reset(&t
->dst_cache
);
1179 static int ip6gre_tnl_change(struct ip6_tnl
*t
, const struct __ip6_tnl_parm
*p
,
1182 ip6gre_tnl_copy_tnl_parm(t
, p
);
1183 ip6gre_tnl_link_config(t
, set_mtu
);
1187 static void ip6gre_tnl_parm_from_user(struct __ip6_tnl_parm
*p
,
1188 const struct ip6_tnl_parm2
*u
)
1190 p
->laddr
= u
->laddr
;
1191 p
->raddr
= u
->raddr
;
1192 p
->flags
= u
->flags
;
1193 p
->hop_limit
= u
->hop_limit
;
1194 p
->encap_limit
= u
->encap_limit
;
1195 p
->flowinfo
= u
->flowinfo
;
1197 p
->i_key
= u
->i_key
;
1198 p
->o_key
= u
->o_key
;
1199 p
->i_flags
= gre_flags_to_tnl_flags(u
->i_flags
);
1200 p
->o_flags
= gre_flags_to_tnl_flags(u
->o_flags
);
1201 memcpy(p
->name
, u
->name
, sizeof(u
->name
));
1204 static void ip6gre_tnl_parm_to_user(struct ip6_tnl_parm2
*u
,
1205 const struct __ip6_tnl_parm
*p
)
1207 u
->proto
= IPPROTO_GRE
;
1208 u
->laddr
= p
->laddr
;
1209 u
->raddr
= p
->raddr
;
1210 u
->flags
= p
->flags
;
1211 u
->hop_limit
= p
->hop_limit
;
1212 u
->encap_limit
= p
->encap_limit
;
1213 u
->flowinfo
= p
->flowinfo
;
1215 u
->i_key
= p
->i_key
;
1216 u
->o_key
= p
->o_key
;
1217 u
->i_flags
= gre_tnl_flags_to_gre_flags(p
->i_flags
);
1218 u
->o_flags
= gre_tnl_flags_to_gre_flags(p
->o_flags
);
1219 memcpy(u
->name
, p
->name
, sizeof(u
->name
));
1222 static int ip6gre_tunnel_ioctl(struct net_device
*dev
,
1223 struct ifreq
*ifr
, int cmd
)
1226 struct ip6_tnl_parm2 p
;
1227 struct __ip6_tnl_parm p1
;
1228 struct ip6_tnl
*t
= netdev_priv(dev
);
1229 struct net
*net
= t
->net
;
1230 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
1232 memset(&p1
, 0, sizeof(p1
));
1236 if (dev
== ign
->fb_tunnel_dev
) {
1237 if (copy_from_user(&p
, ifr
->ifr_ifru
.ifru_data
, sizeof(p
))) {
1241 ip6gre_tnl_parm_from_user(&p1
, &p
);
1242 t
= ip6gre_tunnel_locate(net
, &p1
, 0);
1244 t
= netdev_priv(dev
);
1246 memset(&p
, 0, sizeof(p
));
1247 ip6gre_tnl_parm_to_user(&p
, &t
->parms
);
1248 if (copy_to_user(ifr
->ifr_ifru
.ifru_data
, &p
, sizeof(p
)))
1255 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
1259 if (copy_from_user(&p
, ifr
->ifr_ifru
.ifru_data
, sizeof(p
)))
1263 if ((p
.i_flags
|p
.o_flags
)&(GRE_VERSION
|GRE_ROUTING
))
1266 if (!(p
.i_flags
&GRE_KEY
))
1268 if (!(p
.o_flags
&GRE_KEY
))
1271 ip6gre_tnl_parm_from_user(&p1
, &p
);
1272 t
= ip6gre_tunnel_locate(net
, &p1
, cmd
== SIOCADDTUNNEL
);
1274 if (dev
!= ign
->fb_tunnel_dev
&& cmd
== SIOCCHGTUNNEL
) {
1276 if (t
->dev
!= dev
) {
1281 t
= netdev_priv(dev
);
1283 ip6gre_tunnel_unlink(ign
, t
);
1285 ip6gre_tnl_change(t
, &p1
, 1);
1286 ip6gre_tunnel_link(ign
, t
);
1287 netdev_state_change(dev
);
1294 memset(&p
, 0, sizeof(p
));
1295 ip6gre_tnl_parm_to_user(&p
, &t
->parms
);
1296 if (copy_to_user(ifr
->ifr_ifru
.ifru_data
, &p
, sizeof(p
)))
1299 err
= (cmd
== SIOCADDTUNNEL
? -ENOBUFS
: -ENOENT
);
1304 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
1307 if (dev
== ign
->fb_tunnel_dev
) {
1309 if (copy_from_user(&p
, ifr
->ifr_ifru
.ifru_data
, sizeof(p
)))
1312 ip6gre_tnl_parm_from_user(&p1
, &p
);
1313 t
= ip6gre_tunnel_locate(net
, &p1
, 0);
1317 if (t
== netdev_priv(ign
->fb_tunnel_dev
))
1321 unregister_netdevice(dev
);
1333 static int ip6gre_header(struct sk_buff
*skb
, struct net_device
*dev
,
1334 unsigned short type
, const void *daddr
,
1335 const void *saddr
, unsigned int len
)
1337 struct ip6_tnl
*t
= netdev_priv(dev
);
1338 struct ipv6hdr
*ipv6h
;
1341 ipv6h
= skb_push(skb
, t
->hlen
+ sizeof(*ipv6h
));
1342 ip6_flow_hdr(ipv6h
, 0, ip6_make_flowlabel(dev_net(dev
), skb
,
1343 t
->fl
.u
.ip6
.flowlabel
,
1344 true, &t
->fl
.u
.ip6
));
1345 ipv6h
->hop_limit
= t
->parms
.hop_limit
;
1346 ipv6h
->nexthdr
= NEXTHDR_GRE
;
1347 ipv6h
->saddr
= t
->parms
.laddr
;
1348 ipv6h
->daddr
= t
->parms
.raddr
;
1350 p
= (__be16
*)(ipv6h
+ 1);
1351 p
[0] = t
->parms
.o_flags
;
1355 * Set the source hardware address.
1359 memcpy(&ipv6h
->saddr
, saddr
, sizeof(struct in6_addr
));
1361 memcpy(&ipv6h
->daddr
, daddr
, sizeof(struct in6_addr
));
1362 if (!ipv6_addr_any(&ipv6h
->daddr
))
1368 static const struct header_ops ip6gre_header_ops
= {
1369 .create
= ip6gre_header
,
1372 static const struct net_device_ops ip6gre_netdev_ops
= {
1373 .ndo_init
= ip6gre_tunnel_init
,
1374 .ndo_uninit
= ip6gre_tunnel_uninit
,
1375 .ndo_start_xmit
= ip6gre_tunnel_xmit
,
1376 .ndo_do_ioctl
= ip6gre_tunnel_ioctl
,
1377 .ndo_change_mtu
= ip6_tnl_change_mtu
,
1378 .ndo_get_stats64
= ip_tunnel_get_stats64
,
1379 .ndo_get_iflink
= ip6_tnl_get_iflink
,
1382 static void ip6gre_dev_free(struct net_device
*dev
)
1384 struct ip6_tnl
*t
= netdev_priv(dev
);
1386 gro_cells_destroy(&t
->gro_cells
);
1387 dst_cache_destroy(&t
->dst_cache
);
1388 free_percpu(dev
->tstats
);
1391 static void ip6gre_tunnel_setup(struct net_device
*dev
)
1393 dev
->netdev_ops
= &ip6gre_netdev_ops
;
1394 dev
->needs_free_netdev
= true;
1395 dev
->priv_destructor
= ip6gre_dev_free
;
1397 dev
->type
= ARPHRD_IP6GRE
;
1399 dev
->flags
|= IFF_NOARP
;
1400 dev
->addr_len
= sizeof(struct in6_addr
);
1401 netif_keep_dst(dev
);
1402 /* This perm addr will be used as interface identifier by IPv6 */
1403 dev
->addr_assign_type
= NET_ADDR_RANDOM
;
1404 eth_random_addr(dev
->perm_addr
);
1407 #define GRE6_FEATURES (NETIF_F_SG | \
1408 NETIF_F_FRAGLIST | \
1412 static void ip6gre_tnl_init_features(struct net_device
*dev
)
1414 struct ip6_tnl
*nt
= netdev_priv(dev
);
1416 dev
->features
|= GRE6_FEATURES
;
1417 dev
->hw_features
|= GRE6_FEATURES
;
1419 if (!(nt
->parms
.o_flags
& TUNNEL_SEQ
)) {
1420 /* TCP offload with GRE SEQ is not supported, nor
1421 * can we support 2 levels of outer headers requiring
1424 if (!(nt
->parms
.o_flags
& TUNNEL_CSUM
) ||
1425 nt
->encap
.type
== TUNNEL_ENCAP_NONE
) {
1426 dev
->features
|= NETIF_F_GSO_SOFTWARE
;
1427 dev
->hw_features
|= NETIF_F_GSO_SOFTWARE
;
1430 /* Can use a lockless transmit, unless we generate
1433 dev
->features
|= NETIF_F_LLTX
;
1437 static int ip6gre_tunnel_init_common(struct net_device
*dev
)
1439 struct ip6_tnl
*tunnel
;
1443 tunnel
= netdev_priv(dev
);
1446 tunnel
->net
= dev_net(dev
);
1447 strcpy(tunnel
->parms
.name
, dev
->name
);
1449 dev
->tstats
= netdev_alloc_pcpu_stats(struct pcpu_sw_netstats
);
1453 ret
= dst_cache_init(&tunnel
->dst_cache
, GFP_KERNEL
);
1455 goto cleanup_alloc_pcpu_stats
;
1457 ret
= gro_cells_init(&tunnel
->gro_cells
, dev
);
1459 goto cleanup_dst_cache_init
;
1461 t_hlen
= ip6gre_calc_hlen(tunnel
);
1462 dev
->mtu
= ETH_DATA_LEN
- t_hlen
;
1463 if (dev
->type
== ARPHRD_ETHER
)
1464 dev
->mtu
-= ETH_HLEN
;
1465 if (!(tunnel
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
))
1468 if (tunnel
->parms
.collect_md
) {
1469 dev
->features
|= NETIF_F_NETNS_LOCAL
;
1470 netif_keep_dst(dev
);
1472 ip6gre_tnl_init_features(dev
);
1476 cleanup_dst_cache_init
:
1477 dst_cache_destroy(&tunnel
->dst_cache
);
1478 cleanup_alloc_pcpu_stats
:
1479 free_percpu(dev
->tstats
);
1484 static int ip6gre_tunnel_init(struct net_device
*dev
)
1486 struct ip6_tnl
*tunnel
;
1489 ret
= ip6gre_tunnel_init_common(dev
);
1493 tunnel
= netdev_priv(dev
);
1495 if (tunnel
->parms
.collect_md
)
1498 memcpy(dev
->dev_addr
, &tunnel
->parms
.laddr
, sizeof(struct in6_addr
));
1499 memcpy(dev
->broadcast
, &tunnel
->parms
.raddr
, sizeof(struct in6_addr
));
1501 if (ipv6_addr_any(&tunnel
->parms
.raddr
))
1502 dev
->header_ops
= &ip6gre_header_ops
;
1507 static void ip6gre_fb_tunnel_init(struct net_device
*dev
)
1509 struct ip6_tnl
*tunnel
= netdev_priv(dev
);
1512 tunnel
->net
= dev_net(dev
);
1513 strcpy(tunnel
->parms
.name
, dev
->name
);
1515 tunnel
->hlen
= sizeof(struct ipv6hdr
) + 4;
1520 static struct inet6_protocol ip6gre_protocol __read_mostly
= {
1522 .err_handler
= ip6gre_err
,
1523 .flags
= INET6_PROTO_NOPOLICY
|INET6_PROTO_FINAL
,
1526 static void ip6gre_destroy_tunnels(struct net
*net
, struct list_head
*head
)
1528 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
1529 struct net_device
*dev
, *aux
;
1532 for_each_netdev_safe(net
, dev
, aux
)
1533 if (dev
->rtnl_link_ops
== &ip6gre_link_ops
||
1534 dev
->rtnl_link_ops
== &ip6gre_tap_ops
||
1535 dev
->rtnl_link_ops
== &ip6erspan_tap_ops
)
1536 unregister_netdevice_queue(dev
, head
);
1538 for (prio
= 0; prio
< 4; prio
++) {
1540 for (h
= 0; h
< IP6_GRE_HASH_SIZE
; h
++) {
1543 t
= rtnl_dereference(ign
->tunnels
[prio
][h
]);
1546 /* If dev is in the same netns, it has already
1547 * been added to the list by the previous loop.
1549 if (!net_eq(dev_net(t
->dev
), net
))
1550 unregister_netdevice_queue(t
->dev
,
1552 t
= rtnl_dereference(t
->next
);
1558 static int __net_init
ip6gre_init_net(struct net
*net
)
1560 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
1563 if (!net_has_fallback_tunnels(net
))
1565 ign
->fb_tunnel_dev
= alloc_netdev(sizeof(struct ip6_tnl
), "ip6gre0",
1567 ip6gre_tunnel_setup
);
1568 if (!ign
->fb_tunnel_dev
) {
1572 dev_net_set(ign
->fb_tunnel_dev
, net
);
1573 /* FB netdevice is special: we have one, and only one per netns.
1574 * Allowing to move it to another netns is clearly unsafe.
1576 ign
->fb_tunnel_dev
->features
|= NETIF_F_NETNS_LOCAL
;
1579 ip6gre_fb_tunnel_init(ign
->fb_tunnel_dev
);
1580 ign
->fb_tunnel_dev
->rtnl_link_ops
= &ip6gre_link_ops
;
1582 err
= register_netdev(ign
->fb_tunnel_dev
);
1586 rcu_assign_pointer(ign
->tunnels_wc
[0],
1587 netdev_priv(ign
->fb_tunnel_dev
));
1591 free_netdev(ign
->fb_tunnel_dev
);
1596 static void __net_exit
ip6gre_exit_batch_net(struct list_head
*net_list
)
1602 list_for_each_entry(net
, net_list
, exit_list
)
1603 ip6gre_destroy_tunnels(net
, &list
);
1604 unregister_netdevice_many(&list
);
1608 static struct pernet_operations ip6gre_net_ops
= {
1609 .init
= ip6gre_init_net
,
1610 .exit_batch
= ip6gre_exit_batch_net
,
1611 .id
= &ip6gre_net_id
,
1612 .size
= sizeof(struct ip6gre_net
),
1615 static int ip6gre_tunnel_validate(struct nlattr
*tb
[], struct nlattr
*data
[],
1616 struct netlink_ext_ack
*extack
)
1624 if (data
[IFLA_GRE_IFLAGS
])
1625 flags
|= nla_get_be16(data
[IFLA_GRE_IFLAGS
]);
1626 if (data
[IFLA_GRE_OFLAGS
])
1627 flags
|= nla_get_be16(data
[IFLA_GRE_OFLAGS
]);
1628 if (flags
& (GRE_VERSION
|GRE_ROUTING
))
1634 static int ip6gre_tap_validate(struct nlattr
*tb
[], struct nlattr
*data
[],
1635 struct netlink_ext_ack
*extack
)
1637 struct in6_addr daddr
;
1639 if (tb
[IFLA_ADDRESS
]) {
1640 if (nla_len(tb
[IFLA_ADDRESS
]) != ETH_ALEN
)
1642 if (!is_valid_ether_addr(nla_data(tb
[IFLA_ADDRESS
])))
1643 return -EADDRNOTAVAIL
;
1649 if (data
[IFLA_GRE_REMOTE
]) {
1650 daddr
= nla_get_in6_addr(data
[IFLA_GRE_REMOTE
]);
1651 if (ipv6_addr_any(&daddr
))
1656 return ip6gre_tunnel_validate(tb
, data
, extack
);
1659 static int ip6erspan_tap_validate(struct nlattr
*tb
[], struct nlattr
*data
[],
1660 struct netlink_ext_ack
*extack
)
1668 ret
= ip6gre_tap_validate(tb
, data
, extack
);
1672 /* ERSPAN should only have GRE sequence and key flag */
1673 if (data
[IFLA_GRE_OFLAGS
])
1674 flags
|= nla_get_be16(data
[IFLA_GRE_OFLAGS
]);
1675 if (data
[IFLA_GRE_IFLAGS
])
1676 flags
|= nla_get_be16(data
[IFLA_GRE_IFLAGS
]);
1677 if (!data
[IFLA_GRE_COLLECT_METADATA
] &&
1678 flags
!= (GRE_SEQ
| GRE_KEY
))
1681 /* ERSPAN Session ID only has 10-bit. Since we reuse
1682 * 32-bit key field as ID, check it's range.
1684 if (data
[IFLA_GRE_IKEY
] &&
1685 (ntohl(nla_get_be32(data
[IFLA_GRE_IKEY
])) & ~ID_MASK
))
1688 if (data
[IFLA_GRE_OKEY
] &&
1689 (ntohl(nla_get_be32(data
[IFLA_GRE_OKEY
])) & ~ID_MASK
))
1692 if (data
[IFLA_GRE_ERSPAN_VER
]) {
1693 ver
= nla_get_u8(data
[IFLA_GRE_ERSPAN_VER
]);
1694 if (ver
!= 1 && ver
!= 2)
1699 if (data
[IFLA_GRE_ERSPAN_INDEX
]) {
1700 u32 index
= nla_get_u32(data
[IFLA_GRE_ERSPAN_INDEX
]);
1702 if (index
& ~INDEX_MASK
)
1705 } else if (ver
== 2) {
1706 if (data
[IFLA_GRE_ERSPAN_DIR
]) {
1707 u16 dir
= nla_get_u8(data
[IFLA_GRE_ERSPAN_DIR
]);
1709 if (dir
& ~(DIR_MASK
>> DIR_OFFSET
))
1713 if (data
[IFLA_GRE_ERSPAN_HWID
]) {
1714 u16 hwid
= nla_get_u16(data
[IFLA_GRE_ERSPAN_HWID
]);
1716 if (hwid
& ~(HWID_MASK
>> HWID_OFFSET
))
1724 static void ip6gre_netlink_parms(struct nlattr
*data
[],
1725 struct __ip6_tnl_parm
*parms
)
1727 memset(parms
, 0, sizeof(*parms
));
1732 if (data
[IFLA_GRE_LINK
])
1733 parms
->link
= nla_get_u32(data
[IFLA_GRE_LINK
]);
1735 if (data
[IFLA_GRE_IFLAGS
])
1736 parms
->i_flags
= gre_flags_to_tnl_flags(
1737 nla_get_be16(data
[IFLA_GRE_IFLAGS
]));
1739 if (data
[IFLA_GRE_OFLAGS
])
1740 parms
->o_flags
= gre_flags_to_tnl_flags(
1741 nla_get_be16(data
[IFLA_GRE_OFLAGS
]));
1743 if (data
[IFLA_GRE_IKEY
])
1744 parms
->i_key
= nla_get_be32(data
[IFLA_GRE_IKEY
]);
1746 if (data
[IFLA_GRE_OKEY
])
1747 parms
->o_key
= nla_get_be32(data
[IFLA_GRE_OKEY
]);
1749 if (data
[IFLA_GRE_LOCAL
])
1750 parms
->laddr
= nla_get_in6_addr(data
[IFLA_GRE_LOCAL
]);
1752 if (data
[IFLA_GRE_REMOTE
])
1753 parms
->raddr
= nla_get_in6_addr(data
[IFLA_GRE_REMOTE
]);
1755 if (data
[IFLA_GRE_TTL
])
1756 parms
->hop_limit
= nla_get_u8(data
[IFLA_GRE_TTL
]);
1758 if (data
[IFLA_GRE_ENCAP_LIMIT
])
1759 parms
->encap_limit
= nla_get_u8(data
[IFLA_GRE_ENCAP_LIMIT
]);
1761 if (data
[IFLA_GRE_FLOWINFO
])
1762 parms
->flowinfo
= nla_get_be32(data
[IFLA_GRE_FLOWINFO
]);
1764 if (data
[IFLA_GRE_FLAGS
])
1765 parms
->flags
= nla_get_u32(data
[IFLA_GRE_FLAGS
]);
1767 if (data
[IFLA_GRE_FWMARK
])
1768 parms
->fwmark
= nla_get_u32(data
[IFLA_GRE_FWMARK
]);
1770 if (data
[IFLA_GRE_COLLECT_METADATA
])
1771 parms
->collect_md
= true;
1773 parms
->erspan_ver
= 1;
1774 if (data
[IFLA_GRE_ERSPAN_VER
])
1775 parms
->erspan_ver
= nla_get_u8(data
[IFLA_GRE_ERSPAN_VER
]);
1777 if (parms
->erspan_ver
== 1) {
1778 if (data
[IFLA_GRE_ERSPAN_INDEX
])
1779 parms
->index
= nla_get_u32(data
[IFLA_GRE_ERSPAN_INDEX
]);
1780 } else if (parms
->erspan_ver
== 2) {
1781 if (data
[IFLA_GRE_ERSPAN_DIR
])
1782 parms
->dir
= nla_get_u8(data
[IFLA_GRE_ERSPAN_DIR
]);
1783 if (data
[IFLA_GRE_ERSPAN_HWID
])
1784 parms
->hwid
= nla_get_u16(data
[IFLA_GRE_ERSPAN_HWID
]);
1788 static int ip6gre_tap_init(struct net_device
*dev
)
1792 ret
= ip6gre_tunnel_init_common(dev
);
1796 dev
->priv_flags
|= IFF_LIVE_ADDR_CHANGE
;
1801 static const struct net_device_ops ip6gre_tap_netdev_ops
= {
1802 .ndo_init
= ip6gre_tap_init
,
1803 .ndo_uninit
= ip6gre_tunnel_uninit
,
1804 .ndo_start_xmit
= ip6gre_tunnel_xmit
,
1805 .ndo_set_mac_address
= eth_mac_addr
,
1806 .ndo_validate_addr
= eth_validate_addr
,
1807 .ndo_change_mtu
= ip6_tnl_change_mtu
,
1808 .ndo_get_stats64
= ip_tunnel_get_stats64
,
1809 .ndo_get_iflink
= ip6_tnl_get_iflink
,
1812 static int ip6erspan_calc_hlen(struct ip6_tnl
*tunnel
)
1816 tunnel
->tun_hlen
= 8;
1817 tunnel
->hlen
= tunnel
->tun_hlen
+ tunnel
->encap_hlen
+
1818 erspan_hdr_len(tunnel
->parms
.erspan_ver
);
1820 t_hlen
= tunnel
->hlen
+ sizeof(struct ipv6hdr
);
1821 tunnel
->dev
->needed_headroom
= LL_MAX_HEADER
+ t_hlen
;
1825 static int ip6erspan_tap_init(struct net_device
*dev
)
1827 struct ip6_tnl
*tunnel
;
1831 tunnel
= netdev_priv(dev
);
1834 tunnel
->net
= dev_net(dev
);
1835 strcpy(tunnel
->parms
.name
, dev
->name
);
1837 dev
->tstats
= netdev_alloc_pcpu_stats(struct pcpu_sw_netstats
);
1841 ret
= dst_cache_init(&tunnel
->dst_cache
, GFP_KERNEL
);
1843 goto cleanup_alloc_pcpu_stats
;
1845 ret
= gro_cells_init(&tunnel
->gro_cells
, dev
);
1847 goto cleanup_dst_cache_init
;
1849 t_hlen
= ip6erspan_calc_hlen(tunnel
);
1850 dev
->mtu
= ETH_DATA_LEN
- t_hlen
;
1851 if (dev
->type
== ARPHRD_ETHER
)
1852 dev
->mtu
-= ETH_HLEN
;
1853 if (!(tunnel
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
))
1856 dev
->priv_flags
|= IFF_LIVE_ADDR_CHANGE
;
1857 ip6erspan_tnl_link_config(tunnel
, 1);
1861 cleanup_dst_cache_init
:
1862 dst_cache_destroy(&tunnel
->dst_cache
);
1863 cleanup_alloc_pcpu_stats
:
1864 free_percpu(dev
->tstats
);
1869 static const struct net_device_ops ip6erspan_netdev_ops
= {
1870 .ndo_init
= ip6erspan_tap_init
,
1871 .ndo_uninit
= ip6erspan_tunnel_uninit
,
1872 .ndo_start_xmit
= ip6erspan_tunnel_xmit
,
1873 .ndo_set_mac_address
= eth_mac_addr
,
1874 .ndo_validate_addr
= eth_validate_addr
,
1875 .ndo_change_mtu
= ip6_tnl_change_mtu
,
1876 .ndo_get_stats64
= ip_tunnel_get_stats64
,
1877 .ndo_get_iflink
= ip6_tnl_get_iflink
,
1880 static void ip6gre_tap_setup(struct net_device
*dev
)
1886 dev
->netdev_ops
= &ip6gre_tap_netdev_ops
;
1887 dev
->needs_free_netdev
= true;
1888 dev
->priv_destructor
= ip6gre_dev_free
;
1890 dev
->features
|= NETIF_F_NETNS_LOCAL
;
1891 dev
->priv_flags
&= ~IFF_TX_SKB_SHARING
;
1892 dev
->priv_flags
|= IFF_LIVE_ADDR_CHANGE
;
1893 netif_keep_dst(dev
);
1896 static bool ip6gre_netlink_encap_parms(struct nlattr
*data
[],
1897 struct ip_tunnel_encap
*ipencap
)
1901 memset(ipencap
, 0, sizeof(*ipencap
));
1906 if (data
[IFLA_GRE_ENCAP_TYPE
]) {
1908 ipencap
->type
= nla_get_u16(data
[IFLA_GRE_ENCAP_TYPE
]);
1911 if (data
[IFLA_GRE_ENCAP_FLAGS
]) {
1913 ipencap
->flags
= nla_get_u16(data
[IFLA_GRE_ENCAP_FLAGS
]);
1916 if (data
[IFLA_GRE_ENCAP_SPORT
]) {
1918 ipencap
->sport
= nla_get_be16(data
[IFLA_GRE_ENCAP_SPORT
]);
1921 if (data
[IFLA_GRE_ENCAP_DPORT
]) {
1923 ipencap
->dport
= nla_get_be16(data
[IFLA_GRE_ENCAP_DPORT
]);
1929 static int ip6gre_newlink_common(struct net
*src_net
, struct net_device
*dev
,
1930 struct nlattr
*tb
[], struct nlattr
*data
[],
1931 struct netlink_ext_ack
*extack
)
1934 struct ip_tunnel_encap ipencap
;
1937 nt
= netdev_priv(dev
);
1939 if (ip6gre_netlink_encap_parms(data
, &ipencap
)) {
1940 int err
= ip6_tnl_encap_setup(nt
, &ipencap
);
1946 if (dev
->type
== ARPHRD_ETHER
&& !tb
[IFLA_ADDRESS
])
1947 eth_hw_addr_random(dev
);
1950 nt
->net
= dev_net(dev
);
1952 err
= register_netdevice(dev
);
1957 ip6_tnl_change_mtu(dev
, nla_get_u32(tb
[IFLA_MTU
]));
1965 static int ip6gre_newlink(struct net
*src_net
, struct net_device
*dev
,
1966 struct nlattr
*tb
[], struct nlattr
*data
[],
1967 struct netlink_ext_ack
*extack
)
1969 struct ip6_tnl
*nt
= netdev_priv(dev
);
1970 struct net
*net
= dev_net(dev
);
1971 struct ip6gre_net
*ign
;
1974 ip6gre_netlink_parms(data
, &nt
->parms
);
1975 ign
= net_generic(net
, ip6gre_net_id
);
1977 if (nt
->parms
.collect_md
) {
1978 if (rtnl_dereference(ign
->collect_md_tun
))
1981 if (ip6gre_tunnel_find(net
, &nt
->parms
, dev
->type
))
1985 err
= ip6gre_newlink_common(src_net
, dev
, tb
, data
, extack
);
1987 ip6gre_tnl_link_config(nt
, !tb
[IFLA_MTU
]);
1988 ip6gre_tunnel_link_md(ign
, nt
);
1989 ip6gre_tunnel_link(net_generic(net
, ip6gre_net_id
), nt
);
1994 static struct ip6_tnl
*
1995 ip6gre_changelink_common(struct net_device
*dev
, struct nlattr
*tb
[],
1996 struct nlattr
*data
[], struct __ip6_tnl_parm
*p_p
,
1997 struct netlink_ext_ack
*extack
)
1999 struct ip6_tnl
*t
, *nt
= netdev_priv(dev
);
2000 struct net
*net
= nt
->net
;
2001 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
2002 struct ip_tunnel_encap ipencap
;
2004 if (dev
== ign
->fb_tunnel_dev
)
2005 return ERR_PTR(-EINVAL
);
2007 if (ip6gre_netlink_encap_parms(data
, &ipencap
)) {
2008 int err
= ip6_tnl_encap_setup(nt
, &ipencap
);
2011 return ERR_PTR(err
);
2014 ip6gre_netlink_parms(data
, p_p
);
2016 t
= ip6gre_tunnel_locate(net
, p_p
, 0);
2020 return ERR_PTR(-EEXIST
);
2028 static int ip6gre_changelink(struct net_device
*dev
, struct nlattr
*tb
[],
2029 struct nlattr
*data
[],
2030 struct netlink_ext_ack
*extack
)
2032 struct ip6_tnl
*t
= netdev_priv(dev
);
2033 struct ip6gre_net
*ign
= net_generic(t
->net
, ip6gre_net_id
);
2034 struct __ip6_tnl_parm p
;
2036 t
= ip6gre_changelink_common(dev
, tb
, data
, &p
, extack
);
2040 ip6gre_tunnel_unlink_md(ign
, t
);
2041 ip6gre_tunnel_unlink(ign
, t
);
2042 ip6gre_tnl_change(t
, &p
, !tb
[IFLA_MTU
]);
2043 ip6gre_tunnel_link_md(ign
, t
);
2044 ip6gre_tunnel_link(ign
, t
);
2048 static void ip6gre_dellink(struct net_device
*dev
, struct list_head
*head
)
2050 struct net
*net
= dev_net(dev
);
2051 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
2053 if (dev
!= ign
->fb_tunnel_dev
)
2054 unregister_netdevice_queue(dev
, head
);
2057 static size_t ip6gre_get_size(const struct net_device
*dev
)
2062 /* IFLA_GRE_IFLAGS */
2064 /* IFLA_GRE_OFLAGS */
2070 /* IFLA_GRE_LOCAL */
2071 nla_total_size(sizeof(struct in6_addr
)) +
2072 /* IFLA_GRE_REMOTE */
2073 nla_total_size(sizeof(struct in6_addr
)) +
2076 /* IFLA_GRE_ENCAP_LIMIT */
2078 /* IFLA_GRE_FLOWINFO */
2080 /* IFLA_GRE_FLAGS */
2082 /* IFLA_GRE_ENCAP_TYPE */
2084 /* IFLA_GRE_ENCAP_FLAGS */
2086 /* IFLA_GRE_ENCAP_SPORT */
2088 /* IFLA_GRE_ENCAP_DPORT */
2090 /* IFLA_GRE_COLLECT_METADATA */
2092 /* IFLA_GRE_FWMARK */
2094 /* IFLA_GRE_ERSPAN_INDEX */
2099 static int ip6gre_fill_info(struct sk_buff
*skb
, const struct net_device
*dev
)
2101 struct ip6_tnl
*t
= netdev_priv(dev
);
2102 struct __ip6_tnl_parm
*p
= &t
->parms
;
2104 if (nla_put_u32(skb
, IFLA_GRE_LINK
, p
->link
) ||
2105 nla_put_be16(skb
, IFLA_GRE_IFLAGS
,
2106 gre_tnl_flags_to_gre_flags(p
->i_flags
)) ||
2107 nla_put_be16(skb
, IFLA_GRE_OFLAGS
,
2108 gre_tnl_flags_to_gre_flags(p
->o_flags
)) ||
2109 nla_put_be32(skb
, IFLA_GRE_IKEY
, p
->i_key
) ||
2110 nla_put_be32(skb
, IFLA_GRE_OKEY
, p
->o_key
) ||
2111 nla_put_in6_addr(skb
, IFLA_GRE_LOCAL
, &p
->laddr
) ||
2112 nla_put_in6_addr(skb
, IFLA_GRE_REMOTE
, &p
->raddr
) ||
2113 nla_put_u8(skb
, IFLA_GRE_TTL
, p
->hop_limit
) ||
2114 nla_put_u8(skb
, IFLA_GRE_ENCAP_LIMIT
, p
->encap_limit
) ||
2115 nla_put_be32(skb
, IFLA_GRE_FLOWINFO
, p
->flowinfo
) ||
2116 nla_put_u32(skb
, IFLA_GRE_FLAGS
, p
->flags
) ||
2117 nla_put_u32(skb
, IFLA_GRE_FWMARK
, p
->fwmark
) ||
2118 nla_put_u32(skb
, IFLA_GRE_ERSPAN_INDEX
, p
->index
))
2119 goto nla_put_failure
;
2121 if (nla_put_u16(skb
, IFLA_GRE_ENCAP_TYPE
,
2123 nla_put_be16(skb
, IFLA_GRE_ENCAP_SPORT
,
2125 nla_put_be16(skb
, IFLA_GRE_ENCAP_DPORT
,
2127 nla_put_u16(skb
, IFLA_GRE_ENCAP_FLAGS
,
2129 goto nla_put_failure
;
2131 if (p
->collect_md
) {
2132 if (nla_put_flag(skb
, IFLA_GRE_COLLECT_METADATA
))
2133 goto nla_put_failure
;
2136 if (nla_put_u8(skb
, IFLA_GRE_ERSPAN_VER
, p
->erspan_ver
))
2137 goto nla_put_failure
;
2139 if (p
->erspan_ver
== 1) {
2140 if (nla_put_u32(skb
, IFLA_GRE_ERSPAN_INDEX
, p
->index
))
2141 goto nla_put_failure
;
2142 } else if (p
->erspan_ver
== 2) {
2143 if (nla_put_u8(skb
, IFLA_GRE_ERSPAN_DIR
, p
->dir
))
2144 goto nla_put_failure
;
2145 if (nla_put_u16(skb
, IFLA_GRE_ERSPAN_HWID
, p
->hwid
))
2146 goto nla_put_failure
;
2155 static const struct nla_policy ip6gre_policy
[IFLA_GRE_MAX
+ 1] = {
2156 [IFLA_GRE_LINK
] = { .type
= NLA_U32
},
2157 [IFLA_GRE_IFLAGS
] = { .type
= NLA_U16
},
2158 [IFLA_GRE_OFLAGS
] = { .type
= NLA_U16
},
2159 [IFLA_GRE_IKEY
] = { .type
= NLA_U32
},
2160 [IFLA_GRE_OKEY
] = { .type
= NLA_U32
},
2161 [IFLA_GRE_LOCAL
] = { .len
= FIELD_SIZEOF(struct ipv6hdr
, saddr
) },
2162 [IFLA_GRE_REMOTE
] = { .len
= FIELD_SIZEOF(struct ipv6hdr
, daddr
) },
2163 [IFLA_GRE_TTL
] = { .type
= NLA_U8
},
2164 [IFLA_GRE_ENCAP_LIMIT
] = { .type
= NLA_U8
},
2165 [IFLA_GRE_FLOWINFO
] = { .type
= NLA_U32
},
2166 [IFLA_GRE_FLAGS
] = { .type
= NLA_U32
},
2167 [IFLA_GRE_ENCAP_TYPE
] = { .type
= NLA_U16
},
2168 [IFLA_GRE_ENCAP_FLAGS
] = { .type
= NLA_U16
},
2169 [IFLA_GRE_ENCAP_SPORT
] = { .type
= NLA_U16
},
2170 [IFLA_GRE_ENCAP_DPORT
] = { .type
= NLA_U16
},
2171 [IFLA_GRE_COLLECT_METADATA
] = { .type
= NLA_FLAG
},
2172 [IFLA_GRE_FWMARK
] = { .type
= NLA_U32
},
2173 [IFLA_GRE_ERSPAN_INDEX
] = { .type
= NLA_U32
},
2174 [IFLA_GRE_ERSPAN_VER
] = { .type
= NLA_U8
},
2175 [IFLA_GRE_ERSPAN_DIR
] = { .type
= NLA_U8
},
2176 [IFLA_GRE_ERSPAN_HWID
] = { .type
= NLA_U16
},
2179 static void ip6erspan_tap_setup(struct net_device
*dev
)
2183 dev
->netdev_ops
= &ip6erspan_netdev_ops
;
2184 dev
->needs_free_netdev
= true;
2185 dev
->priv_destructor
= ip6gre_dev_free
;
2187 dev
->features
|= NETIF_F_NETNS_LOCAL
;
2188 dev
->priv_flags
&= ~IFF_TX_SKB_SHARING
;
2189 dev
->priv_flags
|= IFF_LIVE_ADDR_CHANGE
;
2190 netif_keep_dst(dev
);
2193 static int ip6erspan_newlink(struct net
*src_net
, struct net_device
*dev
,
2194 struct nlattr
*tb
[], struct nlattr
*data
[],
2195 struct netlink_ext_ack
*extack
)
2197 struct ip6_tnl
*nt
= netdev_priv(dev
);
2198 struct net
*net
= dev_net(dev
);
2199 struct ip6gre_net
*ign
;
2202 ip6gre_netlink_parms(data
, &nt
->parms
);
2203 ign
= net_generic(net
, ip6gre_net_id
);
2205 if (nt
->parms
.collect_md
) {
2206 if (rtnl_dereference(ign
->collect_md_tun_erspan
))
2209 if (ip6gre_tunnel_find(net
, &nt
->parms
, dev
->type
))
2213 err
= ip6gre_newlink_common(src_net
, dev
, tb
, data
, extack
);
2215 ip6erspan_tnl_link_config(nt
, !tb
[IFLA_MTU
]);
2216 ip6erspan_tunnel_link_md(ign
, nt
);
2217 ip6gre_tunnel_link(net_generic(net
, ip6gre_net_id
), nt
);
2222 static void ip6erspan_tnl_link_config(struct ip6_tnl
*t
, int set_mtu
)
2224 ip6gre_tnl_link_config_common(t
);
2225 ip6gre_tnl_link_config_route(t
, set_mtu
, ip6erspan_calc_hlen(t
));
2228 static int ip6erspan_tnl_change(struct ip6_tnl
*t
,
2229 const struct __ip6_tnl_parm
*p
, int set_mtu
)
2231 ip6gre_tnl_copy_tnl_parm(t
, p
);
2232 ip6erspan_tnl_link_config(t
, set_mtu
);
2236 static int ip6erspan_changelink(struct net_device
*dev
, struct nlattr
*tb
[],
2237 struct nlattr
*data
[],
2238 struct netlink_ext_ack
*extack
)
2240 struct ip6gre_net
*ign
= net_generic(dev_net(dev
), ip6gre_net_id
);
2241 struct __ip6_tnl_parm p
;
2244 t
= ip6gre_changelink_common(dev
, tb
, data
, &p
, extack
);
2248 ip6gre_tunnel_unlink_md(ign
, t
);
2249 ip6gre_tunnel_unlink(ign
, t
);
2250 ip6erspan_tnl_change(t
, &p
, !tb
[IFLA_MTU
]);
2251 ip6erspan_tunnel_link_md(ign
, t
);
2252 ip6gre_tunnel_link(ign
, t
);
2256 static struct rtnl_link_ops ip6gre_link_ops __read_mostly
= {
2258 .maxtype
= IFLA_GRE_MAX
,
2259 .policy
= ip6gre_policy
,
2260 .priv_size
= sizeof(struct ip6_tnl
),
2261 .setup
= ip6gre_tunnel_setup
,
2262 .validate
= ip6gre_tunnel_validate
,
2263 .newlink
= ip6gre_newlink
,
2264 .changelink
= ip6gre_changelink
,
2265 .dellink
= ip6gre_dellink
,
2266 .get_size
= ip6gre_get_size
,
2267 .fill_info
= ip6gre_fill_info
,
2268 .get_link_net
= ip6_tnl_get_link_net
,
2271 static struct rtnl_link_ops ip6gre_tap_ops __read_mostly
= {
2272 .kind
= "ip6gretap",
2273 .maxtype
= IFLA_GRE_MAX
,
2274 .policy
= ip6gre_policy
,
2275 .priv_size
= sizeof(struct ip6_tnl
),
2276 .setup
= ip6gre_tap_setup
,
2277 .validate
= ip6gre_tap_validate
,
2278 .newlink
= ip6gre_newlink
,
2279 .changelink
= ip6gre_changelink
,
2280 .get_size
= ip6gre_get_size
,
2281 .fill_info
= ip6gre_fill_info
,
2282 .get_link_net
= ip6_tnl_get_link_net
,
2285 static struct rtnl_link_ops ip6erspan_tap_ops __read_mostly
= {
2286 .kind
= "ip6erspan",
2287 .maxtype
= IFLA_GRE_MAX
,
2288 .policy
= ip6gre_policy
,
2289 .priv_size
= sizeof(struct ip6_tnl
),
2290 .setup
= ip6erspan_tap_setup
,
2291 .validate
= ip6erspan_tap_validate
,
2292 .newlink
= ip6erspan_newlink
,
2293 .changelink
= ip6erspan_changelink
,
2294 .get_size
= ip6gre_get_size
,
2295 .fill_info
= ip6gre_fill_info
,
2296 .get_link_net
= ip6_tnl_get_link_net
,
2300 * And now the modules code and kernel interface.
2303 static int __init
ip6gre_init(void)
2307 pr_info("GRE over IPv6 tunneling driver\n");
2309 err
= register_pernet_device(&ip6gre_net_ops
);
2313 err
= inet6_add_protocol(&ip6gre_protocol
, IPPROTO_GRE
);
2315 pr_info("%s: can't add protocol\n", __func__
);
2316 goto add_proto_failed
;
2319 err
= rtnl_link_register(&ip6gre_link_ops
);
2321 goto rtnl_link_failed
;
2323 err
= rtnl_link_register(&ip6gre_tap_ops
);
2325 goto tap_ops_failed
;
2327 err
= rtnl_link_register(&ip6erspan_tap_ops
);
2329 goto erspan_link_failed
;
2335 rtnl_link_unregister(&ip6gre_tap_ops
);
2337 rtnl_link_unregister(&ip6gre_link_ops
);
2339 inet6_del_protocol(&ip6gre_protocol
, IPPROTO_GRE
);
2341 unregister_pernet_device(&ip6gre_net_ops
);
2345 static void __exit
ip6gre_fini(void)
2347 rtnl_link_unregister(&ip6gre_tap_ops
);
2348 rtnl_link_unregister(&ip6gre_link_ops
);
2349 rtnl_link_unregister(&ip6erspan_tap_ops
);
2350 inet6_del_protocol(&ip6gre_protocol
, IPPROTO_GRE
);
2351 unregister_pernet_device(&ip6gre_net_ops
);
2354 module_init(ip6gre_init
);
2355 module_exit(ip6gre_fini
);
2356 MODULE_LICENSE("GPL");
2357 MODULE_AUTHOR("D. Kozlov (xeb@mail.ru)");
2358 MODULE_DESCRIPTION("GRE over IPv6 tunneling device");
2359 MODULE_ALIAS_RTNL_LINK("ip6gre");
2360 MODULE_ALIAS_RTNL_LINK("ip6gretap");
2361 MODULE_ALIAS_RTNL_LINK("ip6erspan");
2362 MODULE_ALIAS_NETDEV("ip6gre0");