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 net_device
*fb_tunnel_dev
;
77 static struct rtnl_link_ops ip6gre_link_ops __read_mostly
;
78 static struct rtnl_link_ops ip6gre_tap_ops __read_mostly
;
79 static struct rtnl_link_ops ip6erspan_tap_ops __read_mostly
;
80 static int ip6gre_tunnel_init(struct net_device
*dev
);
81 static void ip6gre_tunnel_setup(struct net_device
*dev
);
82 static void ip6gre_tunnel_link(struct ip6gre_net
*ign
, struct ip6_tnl
*t
);
83 static void ip6gre_tnl_link_config(struct ip6_tnl
*t
, int set_mtu
);
85 /* Tunnel hash table */
95 We require exact key match i.e. if a key is present in packet
96 it will match only tunnel with the same key; if it is not present,
97 it will match only keyless tunnel.
99 All keysless packets, if not matched configured keyless tunnels
100 will match fallback tunnel.
103 #define HASH_KEY(key) (((__force u32)key^((__force u32)key>>4))&(IP6_GRE_HASH_SIZE - 1))
104 static u32
HASH_ADDR(const struct in6_addr
*addr
)
106 u32 hash
= ipv6_addr_hash(addr
);
108 return hash_32(hash
, IP6_GRE_HASH_SIZE_SHIFT
);
111 #define tunnels_r_l tunnels[3]
112 #define tunnels_r tunnels[2]
113 #define tunnels_l tunnels[1]
114 #define tunnels_wc tunnels[0]
116 /* Given src, dst and key, find appropriate for input tunnel. */
118 static struct ip6_tnl
*ip6gre_tunnel_lookup(struct net_device
*dev
,
119 const struct in6_addr
*remote
, const struct in6_addr
*local
,
120 __be32 key
, __be16 gre_proto
)
122 struct net
*net
= dev_net(dev
);
123 int link
= dev
->ifindex
;
124 unsigned int h0
= HASH_ADDR(remote
);
125 unsigned int h1
= HASH_KEY(key
);
126 struct ip6_tnl
*t
, *cand
= NULL
;
127 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
128 int dev_type
= (gre_proto
== htons(ETH_P_TEB
) ||
129 gre_proto
== htons(ETH_P_ERSPAN
)) ?
130 ARPHRD_ETHER
: ARPHRD_IP6GRE
;
131 int score
, cand_score
= 4;
133 for_each_ip_tunnel_rcu(t
, ign
->tunnels_r_l
[h0
^ h1
]) {
134 if (!ipv6_addr_equal(local
, &t
->parms
.laddr
) ||
135 !ipv6_addr_equal(remote
, &t
->parms
.raddr
) ||
136 key
!= t
->parms
.i_key
||
137 !(t
->dev
->flags
& IFF_UP
))
140 if (t
->dev
->type
!= ARPHRD_IP6GRE
&&
141 t
->dev
->type
!= dev_type
)
145 if (t
->parms
.link
!= link
)
147 if (t
->dev
->type
!= dev_type
)
152 if (score
< cand_score
) {
158 for_each_ip_tunnel_rcu(t
, ign
->tunnels_r
[h0
^ h1
]) {
159 if (!ipv6_addr_equal(remote
, &t
->parms
.raddr
) ||
160 key
!= t
->parms
.i_key
||
161 !(t
->dev
->flags
& IFF_UP
))
164 if (t
->dev
->type
!= ARPHRD_IP6GRE
&&
165 t
->dev
->type
!= dev_type
)
169 if (t
->parms
.link
!= link
)
171 if (t
->dev
->type
!= dev_type
)
176 if (score
< cand_score
) {
182 for_each_ip_tunnel_rcu(t
, ign
->tunnels_l
[h1
]) {
183 if ((!ipv6_addr_equal(local
, &t
->parms
.laddr
) &&
184 (!ipv6_addr_equal(local
, &t
->parms
.raddr
) ||
185 !ipv6_addr_is_multicast(local
))) ||
186 key
!= t
->parms
.i_key
||
187 !(t
->dev
->flags
& IFF_UP
))
190 if (t
->dev
->type
!= ARPHRD_IP6GRE
&&
191 t
->dev
->type
!= dev_type
)
195 if (t
->parms
.link
!= link
)
197 if (t
->dev
->type
!= dev_type
)
202 if (score
< cand_score
) {
208 for_each_ip_tunnel_rcu(t
, ign
->tunnels_wc
[h1
]) {
209 if (t
->parms
.i_key
!= key
||
210 !(t
->dev
->flags
& IFF_UP
))
213 if (t
->dev
->type
!= ARPHRD_IP6GRE
&&
214 t
->dev
->type
!= dev_type
)
218 if (t
->parms
.link
!= link
)
220 if (t
->dev
->type
!= dev_type
)
225 if (score
< cand_score
) {
234 t
= rcu_dereference(ign
->collect_md_tun
);
235 if (t
&& t
->dev
->flags
& IFF_UP
)
238 dev
= ign
->fb_tunnel_dev
;
239 if (dev
->flags
& IFF_UP
)
240 return netdev_priv(dev
);
245 static struct ip6_tnl __rcu
**__ip6gre_bucket(struct ip6gre_net
*ign
,
246 const struct __ip6_tnl_parm
*p
)
248 const struct in6_addr
*remote
= &p
->raddr
;
249 const struct in6_addr
*local
= &p
->laddr
;
250 unsigned int h
= HASH_KEY(p
->i_key
);
253 if (!ipv6_addr_any(local
))
255 if (!ipv6_addr_any(remote
) && !ipv6_addr_is_multicast(remote
)) {
257 h
^= HASH_ADDR(remote
);
260 return &ign
->tunnels
[prio
][h
];
263 static inline struct ip6_tnl __rcu
**ip6gre_bucket(struct ip6gre_net
*ign
,
264 const struct ip6_tnl
*t
)
266 return __ip6gre_bucket(ign
, &t
->parms
);
269 static void ip6gre_tunnel_link(struct ip6gre_net
*ign
, struct ip6_tnl
*t
)
271 struct ip6_tnl __rcu
**tp
= ip6gre_bucket(ign
, t
);
273 if (t
->parms
.collect_md
)
274 rcu_assign_pointer(ign
->collect_md_tun
, t
);
276 rcu_assign_pointer(t
->next
, rtnl_dereference(*tp
));
277 rcu_assign_pointer(*tp
, t
);
280 static void ip6gre_tunnel_unlink(struct ip6gre_net
*ign
, struct ip6_tnl
*t
)
282 struct ip6_tnl __rcu
**tp
;
283 struct ip6_tnl
*iter
;
285 if (t
->parms
.collect_md
)
286 rcu_assign_pointer(ign
->collect_md_tun
, NULL
);
288 for (tp
= ip6gre_bucket(ign
, t
);
289 (iter
= rtnl_dereference(*tp
)) != NULL
;
292 rcu_assign_pointer(*tp
, t
->next
);
298 static struct ip6_tnl
*ip6gre_tunnel_find(struct net
*net
,
299 const struct __ip6_tnl_parm
*parms
,
302 const struct in6_addr
*remote
= &parms
->raddr
;
303 const struct in6_addr
*local
= &parms
->laddr
;
304 __be32 key
= parms
->i_key
;
305 int link
= parms
->link
;
307 struct ip6_tnl __rcu
**tp
;
308 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
310 for (tp
= __ip6gre_bucket(ign
, parms
);
311 (t
= rtnl_dereference(*tp
)) != NULL
;
313 if (ipv6_addr_equal(local
, &t
->parms
.laddr
) &&
314 ipv6_addr_equal(remote
, &t
->parms
.raddr
) &&
315 key
== t
->parms
.i_key
&&
316 link
== t
->parms
.link
&&
317 type
== t
->dev
->type
)
323 static struct ip6_tnl
*ip6gre_tunnel_locate(struct net
*net
,
324 const struct __ip6_tnl_parm
*parms
, int create
)
326 struct ip6_tnl
*t
, *nt
;
327 struct net_device
*dev
;
329 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
331 t
= ip6gre_tunnel_find(net
, parms
, ARPHRD_IP6GRE
);
338 strlcpy(name
, parms
->name
, IFNAMSIZ
);
340 strcpy(name
, "ip6gre%d");
342 dev
= alloc_netdev(sizeof(*t
), name
, NET_NAME_UNKNOWN
,
343 ip6gre_tunnel_setup
);
347 dev_net_set(dev
, net
);
349 nt
= netdev_priv(dev
);
351 dev
->rtnl_link_ops
= &ip6gre_link_ops
;
354 nt
->net
= dev_net(dev
);
356 if (register_netdevice(dev
) < 0)
359 ip6gre_tnl_link_config(nt
, 1);
361 /* Can use a lockless transmit, unless we generate output sequences */
362 if (!(nt
->parms
.o_flags
& TUNNEL_SEQ
))
363 dev
->features
|= NETIF_F_LLTX
;
366 ip6gre_tunnel_link(ign
, nt
);
374 static void ip6gre_tunnel_uninit(struct net_device
*dev
)
376 struct ip6_tnl
*t
= netdev_priv(dev
);
377 struct ip6gre_net
*ign
= net_generic(t
->net
, ip6gre_net_id
);
379 ip6gre_tunnel_unlink(ign
, t
);
380 dst_cache_reset(&t
->dst_cache
);
385 static void ip6gre_err(struct sk_buff
*skb
, struct inet6_skb_parm
*opt
,
386 u8 type
, u8 code
, int offset
, __be32 info
)
388 struct net
*net
= dev_net(skb
->dev
);
389 const struct gre_base_hdr
*greh
;
390 const struct ipv6hdr
*ipv6h
;
391 int grehlen
= sizeof(*greh
);
397 if (!pskb_may_pull(skb
, offset
+ grehlen
))
399 greh
= (const struct gre_base_hdr
*)(skb
->data
+ offset
);
401 if (flags
& (GRE_VERSION
| GRE_ROUTING
))
403 if (flags
& GRE_CSUM
)
405 if (flags
& GRE_KEY
) {
406 key_off
= grehlen
+ offset
;
410 if (!pskb_may_pull(skb
, offset
+ grehlen
))
412 ipv6h
= (const struct ipv6hdr
*)skb
->data
;
413 greh
= (const struct gre_base_hdr
*)(skb
->data
+ offset
);
414 key
= key_off
? *(__be32
*)(skb
->data
+ key_off
) : 0;
416 t
= ip6gre_tunnel_lookup(skb
->dev
, &ipv6h
->daddr
, &ipv6h
->saddr
,
417 key
, greh
->protocol
);
422 struct ipv6_tlv_tnl_enc_lim
*tel
;
424 case ICMPV6_DEST_UNREACH
:
425 net_dbg_ratelimited("%s: Path to destination invalid or inactive!\n",
427 if (code
!= ICMPV6_PORT_UNREACH
)
430 case ICMPV6_TIME_EXCEED
:
431 if (code
== ICMPV6_EXC_HOPLIMIT
) {
432 net_dbg_ratelimited("%s: Too small hop limit or routing loop in tunnel!\n",
437 case ICMPV6_PARAMPROB
:
439 if (code
== ICMPV6_HDR_FIELD
)
440 teli
= ip6_tnl_parse_tlv_enc_lim(skb
, skb
->data
);
442 if (teli
&& teli
== be32_to_cpu(info
) - 2) {
443 tel
= (struct ipv6_tlv_tnl_enc_lim
*) &skb
->data
[teli
];
444 if (tel
->encap_limit
== 0) {
445 net_dbg_ratelimited("%s: Too small encapsulation limit or routing loop in tunnel!\n",
449 net_dbg_ratelimited("%s: Recipient unable to parse tunneled packet!\n",
453 case ICMPV6_PKT_TOOBIG
:
454 ip6_update_pmtu(skb
, net
, info
, 0, 0, sock_net_uid(net
, NULL
));
457 ip6_redirect(skb
, net
, skb
->dev
->ifindex
, 0,
458 sock_net_uid(net
, NULL
));
462 if (time_before(jiffies
, t
->err_time
+ IP6TUNNEL_ERR_TIMEO
))
466 t
->err_time
= jiffies
;
469 static int ip6gre_rcv(struct sk_buff
*skb
, const struct tnl_ptk_info
*tpi
)
471 const struct ipv6hdr
*ipv6h
;
472 struct ip6_tnl
*tunnel
;
474 ipv6h
= ipv6_hdr(skb
);
475 tunnel
= ip6gre_tunnel_lookup(skb
->dev
,
476 &ipv6h
->saddr
, &ipv6h
->daddr
, tpi
->key
,
479 if (tunnel
->parms
.collect_md
) {
480 struct metadata_dst
*tun_dst
;
485 tun_id
= key32_to_tunnel_id(tpi
->key
);
487 tun_dst
= ipv6_tun_rx_dst(skb
, flags
, tun_id
, 0);
489 return PACKET_REJECT
;
491 ip6_tnl_rcv(tunnel
, skb
, tpi
, tun_dst
, log_ecn_error
);
493 ip6_tnl_rcv(tunnel
, skb
, tpi
, NULL
, log_ecn_error
);
499 return PACKET_REJECT
;
502 static int ip6erspan_rcv(struct sk_buff
*skb
, int gre_hdr_len
,
503 struct tnl_ptk_info
*tpi
)
505 struct erspan_base_hdr
*ershdr
;
506 struct erspan_metadata
*pkt_md
;
507 const struct ipv6hdr
*ipv6h
;
508 struct ip6_tnl
*tunnel
;
511 if (unlikely(!pskb_may_pull(skb
, sizeof(*ershdr
))))
512 return PACKET_REJECT
;
514 ipv6h
= ipv6_hdr(skb
);
515 ershdr
= (struct erspan_base_hdr
*)skb
->data
;
516 ver
= (ntohs(ershdr
->ver_vlan
) & VER_MASK
) >> VER_OFFSET
;
517 tpi
->key
= cpu_to_be32(ntohs(ershdr
->session_id
) & ID_MASK
);
519 tunnel
= ip6gre_tunnel_lookup(skb
->dev
,
520 &ipv6h
->saddr
, &ipv6h
->daddr
, tpi
->key
,
523 int len
= erspan_hdr_len(ver
);
525 if (unlikely(!pskb_may_pull(skb
, len
)))
526 return PACKET_REJECT
;
528 ershdr
= (struct erspan_base_hdr
*)skb
->data
;
529 pkt_md
= (struct erspan_metadata
*)(ershdr
+ 1);
531 if (__iptunnel_pull_header(skb
, len
,
534 return PACKET_REJECT
;
536 if (tunnel
->parms
.collect_md
) {
537 struct metadata_dst
*tun_dst
;
538 struct ip_tunnel_info
*info
;
539 struct erspan_metadata
*md
;
543 tpi
->flags
|= TUNNEL_KEY
;
545 tun_id
= key32_to_tunnel_id(tpi
->key
);
547 tun_dst
= ipv6_tun_rx_dst(skb
, flags
, tun_id
,
550 return PACKET_REJECT
;
552 info
= &tun_dst
->u
.tun_info
;
553 md
= ip_tunnel_info_opts(info
);
555 memcpy(md
, pkt_md
, sizeof(*md
));
557 info
->key
.tun_flags
|= TUNNEL_ERSPAN_OPT
;
558 info
->options_len
= sizeof(*md
);
560 ip6_tnl_rcv(tunnel
, skb
, tpi
, tun_dst
, log_ecn_error
);
563 tunnel
->parms
.erspan_ver
= ver
;
566 tunnel
->parms
.index
= ntohl(pkt_md
->u
.index
);
571 md2_flags
= ntohs(pkt_md
->u
.md2
.flags
);
572 dir
= (md2_flags
& DIR_MASK
) >> DIR_OFFSET
;
573 hwid
= (md2_flags
& HWID_MASK
) >> HWID_OFFSET
;
574 tunnel
->parms
.dir
= dir
;
575 tunnel
->parms
.hwid
= hwid
;
578 ip6_tnl_rcv(tunnel
, skb
, tpi
, NULL
, log_ecn_error
);
584 return PACKET_REJECT
;
587 static int gre_rcv(struct sk_buff
*skb
)
589 struct tnl_ptk_info tpi
;
590 bool csum_err
= false;
593 hdr_len
= gre_parse_header(skb
, &tpi
, &csum_err
, htons(ETH_P_IPV6
), 0);
597 if (iptunnel_pull_header(skb
, hdr_len
, tpi
.proto
, false))
600 if (unlikely(tpi
.proto
== htons(ETH_P_ERSPAN
) ||
601 tpi
.proto
== htons(ETH_P_ERSPAN2
))) {
602 if (ip6erspan_rcv(skb
, hdr_len
, &tpi
) == PACKET_RCVD
)
607 if (ip6gre_rcv(skb
, &tpi
) == PACKET_RCVD
)
611 icmpv6_send(skb
, ICMPV6_DEST_UNREACH
, ICMPV6_PORT_UNREACH
, 0);
617 static int gre_handle_offloads(struct sk_buff
*skb
, bool csum
)
619 return iptunnel_handle_offloads(skb
,
620 csum
? SKB_GSO_GRE_CSUM
: SKB_GSO_GRE
);
623 static void prepare_ip6gre_xmit_ipv4(struct sk_buff
*skb
,
624 struct net_device
*dev
,
625 struct flowi6
*fl6
, __u8
*dsfield
,
628 const struct iphdr
*iph
= ip_hdr(skb
);
629 struct ip6_tnl
*t
= netdev_priv(dev
);
631 if (!(t
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
))
632 *encap_limit
= t
->parms
.encap_limit
;
634 memcpy(fl6
, &t
->fl
.u
.ip6
, sizeof(*fl6
));
636 if (t
->parms
.flags
& IP6_TNL_F_USE_ORIG_TCLASS
)
637 *dsfield
= ipv4_get_dsfield(iph
);
639 *dsfield
= ip6_tclass(t
->parms
.flowinfo
);
641 if (t
->parms
.flags
& IP6_TNL_F_USE_ORIG_FWMARK
)
642 fl6
->flowi6_mark
= skb
->mark
;
644 fl6
->flowi6_mark
= t
->parms
.fwmark
;
646 fl6
->flowi6_uid
= sock_net_uid(dev_net(dev
), NULL
);
649 static int prepare_ip6gre_xmit_ipv6(struct sk_buff
*skb
,
650 struct net_device
*dev
,
651 struct flowi6
*fl6
, __u8
*dsfield
,
654 struct ipv6hdr
*ipv6h
= ipv6_hdr(skb
);
655 struct ip6_tnl
*t
= netdev_priv(dev
);
658 offset
= ip6_tnl_parse_tlv_enc_lim(skb
, skb_network_header(skb
));
659 /* ip6_tnl_parse_tlv_enc_lim() might have reallocated skb->head */
662 struct ipv6_tlv_tnl_enc_lim
*tel
;
664 tel
= (struct ipv6_tlv_tnl_enc_lim
*)&skb_network_header(skb
)[offset
];
665 if (tel
->encap_limit
== 0) {
666 icmpv6_send(skb
, ICMPV6_PARAMPROB
,
667 ICMPV6_HDR_FIELD
, offset
+ 2);
670 *encap_limit
= tel
->encap_limit
- 1;
671 } else if (!(t
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
)) {
672 *encap_limit
= t
->parms
.encap_limit
;
675 memcpy(fl6
, &t
->fl
.u
.ip6
, sizeof(*fl6
));
677 if (t
->parms
.flags
& IP6_TNL_F_USE_ORIG_TCLASS
)
678 *dsfield
= ipv6_get_dsfield(ipv6h
);
680 *dsfield
= ip6_tclass(t
->parms
.flowinfo
);
682 if (t
->parms
.flags
& IP6_TNL_F_USE_ORIG_FLOWLABEL
)
683 fl6
->flowlabel
|= ip6_flowlabel(ipv6h
);
685 if (t
->parms
.flags
& IP6_TNL_F_USE_ORIG_FWMARK
)
686 fl6
->flowi6_mark
= skb
->mark
;
688 fl6
->flowi6_mark
= t
->parms
.fwmark
;
690 fl6
->flowi6_uid
= sock_net_uid(dev_net(dev
), NULL
);
695 static netdev_tx_t
__gre6_xmit(struct sk_buff
*skb
,
696 struct net_device
*dev
, __u8 dsfield
,
697 struct flowi6
*fl6
, int encap_limit
,
698 __u32
*pmtu
, __be16 proto
)
700 struct ip6_tnl
*tunnel
= netdev_priv(dev
);
703 if (dev
->type
== ARPHRD_ETHER
)
704 IPCB(skb
)->flags
= 0;
706 if (dev
->header_ops
&& dev
->type
== ARPHRD_IP6GRE
)
707 fl6
->daddr
= ((struct ipv6hdr
*)skb
->data
)->daddr
;
709 fl6
->daddr
= tunnel
->parms
.raddr
;
711 if (tunnel
->parms
.o_flags
& TUNNEL_SEQ
)
714 /* Push GRE header. */
715 protocol
= (dev
->type
== ARPHRD_ETHER
) ? htons(ETH_P_TEB
) : proto
;
717 if (tunnel
->parms
.collect_md
) {
718 struct ip_tunnel_info
*tun_info
;
719 const struct ip_tunnel_key
*key
;
722 tun_info
= skb_tunnel_info(skb
);
723 if (unlikely(!tun_info
||
724 !(tun_info
->mode
& IP_TUNNEL_INFO_TX
) ||
725 ip_tunnel_info_af(tun_info
) != AF_INET6
))
728 key
= &tun_info
->key
;
729 memset(fl6
, 0, sizeof(*fl6
));
730 fl6
->flowi6_proto
= IPPROTO_GRE
;
731 fl6
->daddr
= key
->u
.ipv6
.dst
;
732 fl6
->flowlabel
= key
->label
;
733 fl6
->flowi6_uid
= sock_net_uid(dev_net(dev
), NULL
);
736 flags
= key
->tun_flags
& (TUNNEL_CSUM
| TUNNEL_KEY
);
737 tunnel
->tun_hlen
= gre_calc_hlen(flags
);
739 gre_build_header(skb
, tunnel
->tun_hlen
,
741 tunnel_id_to_key32(tun_info
->key
.tun_id
), 0);
744 gre_build_header(skb
, tunnel
->tun_hlen
, tunnel
->parms
.o_flags
,
745 protocol
, tunnel
->parms
.o_key
,
746 htonl(tunnel
->o_seqno
));
749 return ip6_tnl_xmit(skb
, dev
, dsfield
, fl6
, encap_limit
, pmtu
,
753 static inline int ip6gre_xmit_ipv4(struct sk_buff
*skb
, struct net_device
*dev
)
755 struct ip6_tnl
*t
= netdev_priv(dev
);
756 int encap_limit
= -1;
762 memset(&(IPCB(skb
)->opt
), 0, sizeof(IPCB(skb
)->opt
));
764 if (!t
->parms
.collect_md
)
765 prepare_ip6gre_xmit_ipv4(skb
, dev
, &fl6
,
766 &dsfield
, &encap_limit
);
768 err
= gre_handle_offloads(skb
, !!(t
->parms
.o_flags
& TUNNEL_CSUM
));
772 err
= __gre6_xmit(skb
, dev
, dsfield
, &fl6
, encap_limit
, &mtu
,
775 /* XXX: send ICMP error even if DF is not set. */
776 if (err
== -EMSGSIZE
)
777 icmp_send(skb
, ICMP_DEST_UNREACH
, ICMP_FRAG_NEEDED
,
785 static inline int ip6gre_xmit_ipv6(struct sk_buff
*skb
, struct net_device
*dev
)
787 struct ip6_tnl
*t
= netdev_priv(dev
);
788 struct ipv6hdr
*ipv6h
= ipv6_hdr(skb
);
789 int encap_limit
= -1;
795 if (ipv6_addr_equal(&t
->parms
.raddr
, &ipv6h
->saddr
))
798 if (!t
->parms
.collect_md
&&
799 prepare_ip6gre_xmit_ipv6(skb
, dev
, &fl6
, &dsfield
, &encap_limit
))
802 if (gre_handle_offloads(skb
, !!(t
->parms
.o_flags
& TUNNEL_CSUM
)))
805 err
= __gre6_xmit(skb
, dev
, dsfield
, &fl6
, encap_limit
,
806 &mtu
, skb
->protocol
);
808 if (err
== -EMSGSIZE
)
809 icmpv6_send(skb
, ICMPV6_PKT_TOOBIG
, 0, mtu
);
817 * ip6_tnl_addr_conflict - compare packet addresses to tunnel's own
818 * @t: the outgoing tunnel device
819 * @hdr: IPv6 header from the incoming packet
822 * Avoid trivial tunneling loop by checking that tunnel exit-point
823 * doesn't match source of incoming packet.
830 static inline bool ip6gre_tnl_addr_conflict(const struct ip6_tnl
*t
,
831 const struct ipv6hdr
*hdr
)
833 return ipv6_addr_equal(&t
->parms
.raddr
, &hdr
->saddr
);
836 static int ip6gre_xmit_other(struct sk_buff
*skb
, struct net_device
*dev
)
838 struct ip6_tnl
*t
= netdev_priv(dev
);
839 int encap_limit
= -1;
844 if (!(t
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
))
845 encap_limit
= t
->parms
.encap_limit
;
847 if (!t
->parms
.collect_md
)
848 memcpy(&fl6
, &t
->fl
.u
.ip6
, sizeof(fl6
));
850 err
= gre_handle_offloads(skb
, !!(t
->parms
.o_flags
& TUNNEL_CSUM
));
854 err
= __gre6_xmit(skb
, dev
, 0, &fl6
, encap_limit
, &mtu
, skb
->protocol
);
859 static netdev_tx_t
ip6gre_tunnel_xmit(struct sk_buff
*skb
,
860 struct net_device
*dev
)
862 struct ip6_tnl
*t
= netdev_priv(dev
);
863 struct net_device_stats
*stats
= &t
->dev
->stats
;
866 if (!ip6_tnl_xmit_ctl(t
, &t
->parms
.laddr
, &t
->parms
.raddr
))
869 switch (skb
->protocol
) {
870 case htons(ETH_P_IP
):
871 ret
= ip6gre_xmit_ipv4(skb
, dev
);
873 case htons(ETH_P_IPV6
):
874 ret
= ip6gre_xmit_ipv6(skb
, dev
);
877 ret
= ip6gre_xmit_other(skb
, dev
);
893 static netdev_tx_t
ip6erspan_tunnel_xmit(struct sk_buff
*skb
,
894 struct net_device
*dev
)
896 struct ipv6hdr
*ipv6h
= ipv6_hdr(skb
);
897 struct ip6_tnl
*t
= netdev_priv(dev
);
898 struct dst_entry
*dst
= skb_dst(skb
);
899 struct net_device_stats
*stats
;
900 bool truncate
= false;
901 int encap_limit
= -1;
902 __u8 dsfield
= false;
907 if (!ip6_tnl_xmit_ctl(t
, &t
->parms
.laddr
, &t
->parms
.raddr
))
910 if (gre_handle_offloads(skb
, false))
913 if (skb
->len
> dev
->mtu
+ dev
->hard_header_len
) {
914 pskb_trim(skb
, dev
->mtu
+ dev
->hard_header_len
);
918 t
->parms
.o_flags
&= ~TUNNEL_KEY
;
919 IPCB(skb
)->flags
= 0;
921 /* For collect_md mode, derive fl6 from the tunnel key,
922 * for native mode, call prepare_ip6gre_xmit_{ipv4,ipv6}.
924 if (t
->parms
.collect_md
) {
925 struct ip_tunnel_info
*tun_info
;
926 const struct ip_tunnel_key
*key
;
927 struct erspan_metadata
*md
;
929 tun_info
= skb_tunnel_info(skb
);
930 if (unlikely(!tun_info
||
931 !(tun_info
->mode
& IP_TUNNEL_INFO_TX
) ||
932 ip_tunnel_info_af(tun_info
) != AF_INET6
))
935 key
= &tun_info
->key
;
936 memset(&fl6
, 0, sizeof(fl6
));
937 fl6
.flowi6_proto
= IPPROTO_GRE
;
938 fl6
.daddr
= key
->u
.ipv6
.dst
;
939 fl6
.flowlabel
= key
->label
;
940 fl6
.flowi6_uid
= sock_net_uid(dev_net(dev
), NULL
);
943 md
= ip_tunnel_info_opts(tun_info
);
947 if (md
->version
== 1) {
948 erspan_build_header(skb
,
949 tunnel_id_to_key32(key
->tun_id
),
950 ntohl(md
->u
.index
), truncate
,
952 } else if (md
->version
== 2) {
956 md2_flags
= ntohs(md
->u
.md2
.flags
);
957 dir
= (md2_flags
& DIR_MASK
) >> DIR_OFFSET
;
958 hwid
= (md2_flags
& HWID_MASK
) >> HWID_OFFSET
;
960 erspan_build_header_v2(skb
,
961 tunnel_id_to_key32(key
->tun_id
),
966 switch (skb
->protocol
) {
967 case htons(ETH_P_IP
):
968 memset(&(IPCB(skb
)->opt
), 0, sizeof(IPCB(skb
)->opt
));
969 prepare_ip6gre_xmit_ipv4(skb
, dev
, &fl6
,
970 &dsfield
, &encap_limit
);
972 case htons(ETH_P_IPV6
):
973 if (ipv6_addr_equal(&t
->parms
.raddr
, &ipv6h
->saddr
))
975 if (prepare_ip6gre_xmit_ipv6(skb
, dev
, &fl6
,
976 &dsfield
, &encap_limit
))
980 memcpy(&fl6
, &t
->fl
.u
.ip6
, sizeof(fl6
));
984 if (t
->parms
.erspan_ver
== 1)
985 erspan_build_header(skb
, t
->parms
.o_key
,
989 erspan_build_header_v2(skb
, t
->parms
.o_key
,
993 fl6
.daddr
= t
->parms
.raddr
;
996 /* Push GRE header. */
997 gre_build_header(skb
, 8, TUNNEL_SEQ
,
998 htons(ETH_P_ERSPAN
), 0, htonl(t
->o_seqno
++));
1000 /* TooBig packet may have updated dst->dev's mtu */
1001 if (!t
->parms
.collect_md
&& dst
&& dst_mtu(dst
) > dst
->dev
->mtu
)
1002 dst
->ops
->update_pmtu(dst
, NULL
, skb
, dst
->dev
->mtu
);
1004 err
= ip6_tnl_xmit(skb
, dev
, dsfield
, &fl6
, encap_limit
, &mtu
,
1007 /* XXX: send ICMP error even if DF is not set. */
1008 if (err
== -EMSGSIZE
) {
1009 if (skb
->protocol
== htons(ETH_P_IP
))
1010 icmp_send(skb
, ICMP_DEST_UNREACH
,
1011 ICMP_FRAG_NEEDED
, htonl(mtu
));
1013 icmpv6_send(skb
, ICMPV6_PKT_TOOBIG
, 0, mtu
);
1018 return NETDEV_TX_OK
;
1021 stats
= &t
->dev
->stats
;
1023 stats
->tx_dropped
++;
1025 return NETDEV_TX_OK
;
1028 static void ip6gre_tnl_link_config(struct ip6_tnl
*t
, int set_mtu
)
1030 struct net_device
*dev
= t
->dev
;
1031 struct __ip6_tnl_parm
*p
= &t
->parms
;
1032 struct flowi6
*fl6
= &t
->fl
.u
.ip6
;
1035 if (dev
->type
!= ARPHRD_ETHER
) {
1036 memcpy(dev
->dev_addr
, &p
->laddr
, sizeof(struct in6_addr
));
1037 memcpy(dev
->broadcast
, &p
->raddr
, sizeof(struct in6_addr
));
1040 /* Set up flowi template */
1041 fl6
->saddr
= p
->laddr
;
1042 fl6
->daddr
= p
->raddr
;
1043 fl6
->flowi6_oif
= p
->link
;
1045 fl6
->flowi6_proto
= IPPROTO_GRE
;
1047 if (!(p
->flags
&IP6_TNL_F_USE_ORIG_TCLASS
))
1048 fl6
->flowlabel
|= IPV6_TCLASS_MASK
& p
->flowinfo
;
1049 if (!(p
->flags
&IP6_TNL_F_USE_ORIG_FLOWLABEL
))
1050 fl6
->flowlabel
|= IPV6_FLOWLABEL_MASK
& p
->flowinfo
;
1052 p
->flags
&= ~(IP6_TNL_F_CAP_XMIT
|IP6_TNL_F_CAP_RCV
|IP6_TNL_F_CAP_PER_PACKET
);
1053 p
->flags
|= ip6_tnl_get_cap(t
, &p
->laddr
, &p
->raddr
);
1055 if (p
->flags
&IP6_TNL_F_CAP_XMIT
&&
1056 p
->flags
&IP6_TNL_F_CAP_RCV
&& dev
->type
!= ARPHRD_ETHER
)
1057 dev
->flags
|= IFF_POINTOPOINT
;
1059 dev
->flags
&= ~IFF_POINTOPOINT
;
1061 t
->tun_hlen
= gre_calc_hlen(t
->parms
.o_flags
);
1063 t
->hlen
= t
->encap_hlen
+ t
->tun_hlen
;
1065 t_hlen
= t
->hlen
+ sizeof(struct ipv6hdr
);
1067 if (p
->flags
& IP6_TNL_F_CAP_XMIT
) {
1068 int strict
= (ipv6_addr_type(&p
->raddr
) &
1069 (IPV6_ADDR_MULTICAST
|IPV6_ADDR_LINKLOCAL
));
1071 struct rt6_info
*rt
= rt6_lookup(t
->net
,
1072 &p
->raddr
, &p
->laddr
,
1079 dev
->hard_header_len
= rt
->dst
.dev
->hard_header_len
+
1083 dev
->mtu
= rt
->dst
.dev
->mtu
- t_hlen
;
1084 if (!(t
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
))
1086 if (dev
->type
== ARPHRD_ETHER
)
1087 dev
->mtu
-= ETH_HLEN
;
1089 if (dev
->mtu
< IPV6_MIN_MTU
)
1090 dev
->mtu
= IPV6_MIN_MTU
;
1097 static int ip6gre_tnl_change(struct ip6_tnl
*t
,
1098 const struct __ip6_tnl_parm
*p
, int set_mtu
)
1100 t
->parms
.laddr
= p
->laddr
;
1101 t
->parms
.raddr
= p
->raddr
;
1102 t
->parms
.flags
= p
->flags
;
1103 t
->parms
.hop_limit
= p
->hop_limit
;
1104 t
->parms
.encap_limit
= p
->encap_limit
;
1105 t
->parms
.flowinfo
= p
->flowinfo
;
1106 t
->parms
.link
= p
->link
;
1107 t
->parms
.proto
= p
->proto
;
1108 t
->parms
.i_key
= p
->i_key
;
1109 t
->parms
.o_key
= p
->o_key
;
1110 t
->parms
.i_flags
= p
->i_flags
;
1111 t
->parms
.o_flags
= p
->o_flags
;
1112 t
->parms
.fwmark
= p
->fwmark
;
1113 dst_cache_reset(&t
->dst_cache
);
1114 ip6gre_tnl_link_config(t
, set_mtu
);
1118 static void ip6gre_tnl_parm_from_user(struct __ip6_tnl_parm
*p
,
1119 const struct ip6_tnl_parm2
*u
)
1121 p
->laddr
= u
->laddr
;
1122 p
->raddr
= u
->raddr
;
1123 p
->flags
= u
->flags
;
1124 p
->hop_limit
= u
->hop_limit
;
1125 p
->encap_limit
= u
->encap_limit
;
1126 p
->flowinfo
= u
->flowinfo
;
1128 p
->i_key
= u
->i_key
;
1129 p
->o_key
= u
->o_key
;
1130 p
->i_flags
= gre_flags_to_tnl_flags(u
->i_flags
);
1131 p
->o_flags
= gre_flags_to_tnl_flags(u
->o_flags
);
1132 memcpy(p
->name
, u
->name
, sizeof(u
->name
));
1135 static void ip6gre_tnl_parm_to_user(struct ip6_tnl_parm2
*u
,
1136 const struct __ip6_tnl_parm
*p
)
1138 u
->proto
= IPPROTO_GRE
;
1139 u
->laddr
= p
->laddr
;
1140 u
->raddr
= p
->raddr
;
1141 u
->flags
= p
->flags
;
1142 u
->hop_limit
= p
->hop_limit
;
1143 u
->encap_limit
= p
->encap_limit
;
1144 u
->flowinfo
= p
->flowinfo
;
1146 u
->i_key
= p
->i_key
;
1147 u
->o_key
= p
->o_key
;
1148 u
->i_flags
= gre_tnl_flags_to_gre_flags(p
->i_flags
);
1149 u
->o_flags
= gre_tnl_flags_to_gre_flags(p
->o_flags
);
1150 memcpy(u
->name
, p
->name
, sizeof(u
->name
));
1153 static int ip6gre_tunnel_ioctl(struct net_device
*dev
,
1154 struct ifreq
*ifr
, int cmd
)
1157 struct ip6_tnl_parm2 p
;
1158 struct __ip6_tnl_parm p1
;
1159 struct ip6_tnl
*t
= netdev_priv(dev
);
1160 struct net
*net
= t
->net
;
1161 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
1163 memset(&p1
, 0, sizeof(p1
));
1167 if (dev
== ign
->fb_tunnel_dev
) {
1168 if (copy_from_user(&p
, ifr
->ifr_ifru
.ifru_data
, sizeof(p
))) {
1172 ip6gre_tnl_parm_from_user(&p1
, &p
);
1173 t
= ip6gre_tunnel_locate(net
, &p1
, 0);
1175 t
= netdev_priv(dev
);
1177 memset(&p
, 0, sizeof(p
));
1178 ip6gre_tnl_parm_to_user(&p
, &t
->parms
);
1179 if (copy_to_user(ifr
->ifr_ifru
.ifru_data
, &p
, sizeof(p
)))
1186 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
1190 if (copy_from_user(&p
, ifr
->ifr_ifru
.ifru_data
, sizeof(p
)))
1194 if ((p
.i_flags
|p
.o_flags
)&(GRE_VERSION
|GRE_ROUTING
))
1197 if (!(p
.i_flags
&GRE_KEY
))
1199 if (!(p
.o_flags
&GRE_KEY
))
1202 ip6gre_tnl_parm_from_user(&p1
, &p
);
1203 t
= ip6gre_tunnel_locate(net
, &p1
, cmd
== SIOCADDTUNNEL
);
1205 if (dev
!= ign
->fb_tunnel_dev
&& cmd
== SIOCCHGTUNNEL
) {
1207 if (t
->dev
!= dev
) {
1212 t
= netdev_priv(dev
);
1214 ip6gre_tunnel_unlink(ign
, t
);
1216 ip6gre_tnl_change(t
, &p1
, 1);
1217 ip6gre_tunnel_link(ign
, t
);
1218 netdev_state_change(dev
);
1225 memset(&p
, 0, sizeof(p
));
1226 ip6gre_tnl_parm_to_user(&p
, &t
->parms
);
1227 if (copy_to_user(ifr
->ifr_ifru
.ifru_data
, &p
, sizeof(p
)))
1230 err
= (cmd
== SIOCADDTUNNEL
? -ENOBUFS
: -ENOENT
);
1235 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
1238 if (dev
== ign
->fb_tunnel_dev
) {
1240 if (copy_from_user(&p
, ifr
->ifr_ifru
.ifru_data
, sizeof(p
)))
1243 ip6gre_tnl_parm_from_user(&p1
, &p
);
1244 t
= ip6gre_tunnel_locate(net
, &p1
, 0);
1248 if (t
== netdev_priv(ign
->fb_tunnel_dev
))
1252 unregister_netdevice(dev
);
1264 static int ip6gre_header(struct sk_buff
*skb
, struct net_device
*dev
,
1265 unsigned short type
, const void *daddr
,
1266 const void *saddr
, unsigned int len
)
1268 struct ip6_tnl
*t
= netdev_priv(dev
);
1269 struct ipv6hdr
*ipv6h
;
1272 ipv6h
= skb_push(skb
, t
->hlen
+ sizeof(*ipv6h
));
1273 ip6_flow_hdr(ipv6h
, 0, ip6_make_flowlabel(dev_net(dev
), skb
,
1274 t
->fl
.u
.ip6
.flowlabel
,
1275 true, &t
->fl
.u
.ip6
));
1276 ipv6h
->hop_limit
= t
->parms
.hop_limit
;
1277 ipv6h
->nexthdr
= NEXTHDR_GRE
;
1278 ipv6h
->saddr
= t
->parms
.laddr
;
1279 ipv6h
->daddr
= t
->parms
.raddr
;
1281 p
= (__be16
*)(ipv6h
+ 1);
1282 p
[0] = t
->parms
.o_flags
;
1286 * Set the source hardware address.
1290 memcpy(&ipv6h
->saddr
, saddr
, sizeof(struct in6_addr
));
1292 memcpy(&ipv6h
->daddr
, daddr
, sizeof(struct in6_addr
));
1293 if (!ipv6_addr_any(&ipv6h
->daddr
))
1299 static const struct header_ops ip6gre_header_ops
= {
1300 .create
= ip6gre_header
,
1303 static const struct net_device_ops ip6gre_netdev_ops
= {
1304 .ndo_init
= ip6gre_tunnel_init
,
1305 .ndo_uninit
= ip6gre_tunnel_uninit
,
1306 .ndo_start_xmit
= ip6gre_tunnel_xmit
,
1307 .ndo_do_ioctl
= ip6gre_tunnel_ioctl
,
1308 .ndo_change_mtu
= ip6_tnl_change_mtu
,
1309 .ndo_get_stats64
= ip_tunnel_get_stats64
,
1310 .ndo_get_iflink
= ip6_tnl_get_iflink
,
1313 static void ip6gre_dev_free(struct net_device
*dev
)
1315 struct ip6_tnl
*t
= netdev_priv(dev
);
1317 dst_cache_destroy(&t
->dst_cache
);
1318 free_percpu(dev
->tstats
);
1321 static void ip6gre_tunnel_setup(struct net_device
*dev
)
1323 dev
->netdev_ops
= &ip6gre_netdev_ops
;
1324 dev
->needs_free_netdev
= true;
1325 dev
->priv_destructor
= ip6gre_dev_free
;
1327 dev
->type
= ARPHRD_IP6GRE
;
1329 dev
->flags
|= IFF_NOARP
;
1330 dev
->addr_len
= sizeof(struct in6_addr
);
1331 netif_keep_dst(dev
);
1332 /* This perm addr will be used as interface identifier by IPv6 */
1333 dev
->addr_assign_type
= NET_ADDR_RANDOM
;
1334 eth_random_addr(dev
->perm_addr
);
1337 #define GRE6_FEATURES (NETIF_F_SG | \
1338 NETIF_F_FRAGLIST | \
1342 static void ip6gre_tnl_init_features(struct net_device
*dev
)
1344 struct ip6_tnl
*nt
= netdev_priv(dev
);
1346 dev
->features
|= GRE6_FEATURES
;
1347 dev
->hw_features
|= GRE6_FEATURES
;
1349 if (!(nt
->parms
.o_flags
& TUNNEL_SEQ
)) {
1350 /* TCP offload with GRE SEQ is not supported, nor
1351 * can we support 2 levels of outer headers requiring
1354 if (!(nt
->parms
.o_flags
& TUNNEL_CSUM
) ||
1355 nt
->encap
.type
== TUNNEL_ENCAP_NONE
) {
1356 dev
->features
|= NETIF_F_GSO_SOFTWARE
;
1357 dev
->hw_features
|= NETIF_F_GSO_SOFTWARE
;
1360 /* Can use a lockless transmit, unless we generate
1363 dev
->features
|= NETIF_F_LLTX
;
1367 static int ip6gre_tunnel_init_common(struct net_device
*dev
)
1369 struct ip6_tnl
*tunnel
;
1373 tunnel
= netdev_priv(dev
);
1376 tunnel
->net
= dev_net(dev
);
1377 strcpy(tunnel
->parms
.name
, dev
->name
);
1379 dev
->tstats
= netdev_alloc_pcpu_stats(struct pcpu_sw_netstats
);
1383 ret
= dst_cache_init(&tunnel
->dst_cache
, GFP_KERNEL
);
1385 free_percpu(dev
->tstats
);
1390 tunnel
->tun_hlen
= gre_calc_hlen(tunnel
->parms
.o_flags
);
1391 tunnel
->hlen
= tunnel
->tun_hlen
+ tunnel
->encap_hlen
;
1392 t_hlen
= tunnel
->hlen
+ sizeof(struct ipv6hdr
);
1394 dev
->hard_header_len
= LL_MAX_HEADER
+ t_hlen
;
1395 dev
->mtu
= ETH_DATA_LEN
- t_hlen
;
1396 if (dev
->type
== ARPHRD_ETHER
)
1397 dev
->mtu
-= ETH_HLEN
;
1398 if (!(tunnel
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
))
1401 if (tunnel
->parms
.collect_md
) {
1402 dev
->features
|= NETIF_F_NETNS_LOCAL
;
1403 netif_keep_dst(dev
);
1405 ip6gre_tnl_init_features(dev
);
1410 static int ip6gre_tunnel_init(struct net_device
*dev
)
1412 struct ip6_tnl
*tunnel
;
1415 ret
= ip6gre_tunnel_init_common(dev
);
1419 tunnel
= netdev_priv(dev
);
1421 if (tunnel
->parms
.collect_md
)
1424 memcpy(dev
->dev_addr
, &tunnel
->parms
.laddr
, sizeof(struct in6_addr
));
1425 memcpy(dev
->broadcast
, &tunnel
->parms
.raddr
, sizeof(struct in6_addr
));
1427 if (ipv6_addr_any(&tunnel
->parms
.raddr
))
1428 dev
->header_ops
= &ip6gre_header_ops
;
1433 static void ip6gre_fb_tunnel_init(struct net_device
*dev
)
1435 struct ip6_tnl
*tunnel
= netdev_priv(dev
);
1438 tunnel
->net
= dev_net(dev
);
1439 strcpy(tunnel
->parms
.name
, dev
->name
);
1441 tunnel
->hlen
= sizeof(struct ipv6hdr
) + 4;
1446 static struct inet6_protocol ip6gre_protocol __read_mostly
= {
1448 .err_handler
= ip6gre_err
,
1449 .flags
= INET6_PROTO_NOPOLICY
|INET6_PROTO_FINAL
,
1452 static void ip6gre_destroy_tunnels(struct net
*net
, struct list_head
*head
)
1454 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
1455 struct net_device
*dev
, *aux
;
1458 for_each_netdev_safe(net
, dev
, aux
)
1459 if (dev
->rtnl_link_ops
== &ip6gre_link_ops
||
1460 dev
->rtnl_link_ops
== &ip6gre_tap_ops
||
1461 dev
->rtnl_link_ops
== &ip6erspan_tap_ops
)
1462 unregister_netdevice_queue(dev
, head
);
1464 for (prio
= 0; prio
< 4; prio
++) {
1466 for (h
= 0; h
< IP6_GRE_HASH_SIZE
; h
++) {
1469 t
= rtnl_dereference(ign
->tunnels
[prio
][h
]);
1472 /* If dev is in the same netns, it has already
1473 * been added to the list by the previous loop.
1475 if (!net_eq(dev_net(t
->dev
), net
))
1476 unregister_netdevice_queue(t
->dev
,
1478 t
= rtnl_dereference(t
->next
);
1484 static int __net_init
ip6gre_init_net(struct net
*net
)
1486 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
1489 ign
->fb_tunnel_dev
= alloc_netdev(sizeof(struct ip6_tnl
), "ip6gre0",
1491 ip6gre_tunnel_setup
);
1492 if (!ign
->fb_tunnel_dev
) {
1496 dev_net_set(ign
->fb_tunnel_dev
, net
);
1497 /* FB netdevice is special: we have one, and only one per netns.
1498 * Allowing to move it to another netns is clearly unsafe.
1500 ign
->fb_tunnel_dev
->features
|= NETIF_F_NETNS_LOCAL
;
1503 ip6gre_fb_tunnel_init(ign
->fb_tunnel_dev
);
1504 ign
->fb_tunnel_dev
->rtnl_link_ops
= &ip6gre_link_ops
;
1506 err
= register_netdev(ign
->fb_tunnel_dev
);
1510 rcu_assign_pointer(ign
->tunnels_wc
[0],
1511 netdev_priv(ign
->fb_tunnel_dev
));
1515 free_netdev(ign
->fb_tunnel_dev
);
1520 static void __net_exit
ip6gre_exit_batch_net(struct list_head
*net_list
)
1526 list_for_each_entry(net
, net_list
, exit_list
)
1527 ip6gre_destroy_tunnels(net
, &list
);
1528 unregister_netdevice_many(&list
);
1532 static struct pernet_operations ip6gre_net_ops
= {
1533 .init
= ip6gre_init_net
,
1534 .exit_batch
= ip6gre_exit_batch_net
,
1535 .id
= &ip6gre_net_id
,
1536 .size
= sizeof(struct ip6gre_net
),
1539 static int ip6gre_tunnel_validate(struct nlattr
*tb
[], struct nlattr
*data
[],
1540 struct netlink_ext_ack
*extack
)
1548 if (data
[IFLA_GRE_IFLAGS
])
1549 flags
|= nla_get_be16(data
[IFLA_GRE_IFLAGS
]);
1550 if (data
[IFLA_GRE_OFLAGS
])
1551 flags
|= nla_get_be16(data
[IFLA_GRE_OFLAGS
]);
1552 if (flags
& (GRE_VERSION
|GRE_ROUTING
))
1558 static int ip6gre_tap_validate(struct nlattr
*tb
[], struct nlattr
*data
[],
1559 struct netlink_ext_ack
*extack
)
1561 struct in6_addr daddr
;
1563 if (tb
[IFLA_ADDRESS
]) {
1564 if (nla_len(tb
[IFLA_ADDRESS
]) != ETH_ALEN
)
1566 if (!is_valid_ether_addr(nla_data(tb
[IFLA_ADDRESS
])))
1567 return -EADDRNOTAVAIL
;
1573 if (data
[IFLA_GRE_REMOTE
]) {
1574 daddr
= nla_get_in6_addr(data
[IFLA_GRE_REMOTE
]);
1575 if (ipv6_addr_any(&daddr
))
1580 return ip6gre_tunnel_validate(tb
, data
, extack
);
1583 static int ip6erspan_tap_validate(struct nlattr
*tb
[], struct nlattr
*data
[],
1584 struct netlink_ext_ack
*extack
)
1592 ret
= ip6gre_tap_validate(tb
, data
, extack
);
1596 /* ERSPAN should only have GRE sequence and key flag */
1597 if (data
[IFLA_GRE_OFLAGS
])
1598 flags
|= nla_get_be16(data
[IFLA_GRE_OFLAGS
]);
1599 if (data
[IFLA_GRE_IFLAGS
])
1600 flags
|= nla_get_be16(data
[IFLA_GRE_IFLAGS
]);
1601 if (!data
[IFLA_GRE_COLLECT_METADATA
] &&
1602 flags
!= (GRE_SEQ
| GRE_KEY
))
1605 /* ERSPAN Session ID only has 10-bit. Since we reuse
1606 * 32-bit key field as ID, check it's range.
1608 if (data
[IFLA_GRE_IKEY
] &&
1609 (ntohl(nla_get_be32(data
[IFLA_GRE_IKEY
])) & ~ID_MASK
))
1612 if (data
[IFLA_GRE_OKEY
] &&
1613 (ntohl(nla_get_be32(data
[IFLA_GRE_OKEY
])) & ~ID_MASK
))
1616 if (data
[IFLA_GRE_ERSPAN_VER
]) {
1617 ver
= nla_get_u8(data
[IFLA_GRE_ERSPAN_VER
]);
1618 if (ver
!= 1 && ver
!= 2)
1623 if (data
[IFLA_GRE_ERSPAN_INDEX
]) {
1624 u32 index
= nla_get_u32(data
[IFLA_GRE_ERSPAN_INDEX
]);
1626 if (index
& ~INDEX_MASK
)
1629 } else if (ver
== 2) {
1630 if (data
[IFLA_GRE_ERSPAN_DIR
]) {
1631 u16 dir
= nla_get_u8(data
[IFLA_GRE_ERSPAN_DIR
]);
1633 if (dir
& ~(DIR_MASK
>> DIR_OFFSET
))
1637 if (data
[IFLA_GRE_ERSPAN_HWID
]) {
1638 u16 hwid
= nla_get_u16(data
[IFLA_GRE_ERSPAN_HWID
]);
1640 if (hwid
& ~(HWID_MASK
>> HWID_OFFSET
))
1648 static void ip6gre_netlink_parms(struct nlattr
*data
[],
1649 struct __ip6_tnl_parm
*parms
)
1651 memset(parms
, 0, sizeof(*parms
));
1656 if (data
[IFLA_GRE_LINK
])
1657 parms
->link
= nla_get_u32(data
[IFLA_GRE_LINK
]);
1659 if (data
[IFLA_GRE_IFLAGS
])
1660 parms
->i_flags
= gre_flags_to_tnl_flags(
1661 nla_get_be16(data
[IFLA_GRE_IFLAGS
]));
1663 if (data
[IFLA_GRE_OFLAGS
])
1664 parms
->o_flags
= gre_flags_to_tnl_flags(
1665 nla_get_be16(data
[IFLA_GRE_OFLAGS
]));
1667 if (data
[IFLA_GRE_IKEY
])
1668 parms
->i_key
= nla_get_be32(data
[IFLA_GRE_IKEY
]);
1670 if (data
[IFLA_GRE_OKEY
])
1671 parms
->o_key
= nla_get_be32(data
[IFLA_GRE_OKEY
]);
1673 if (data
[IFLA_GRE_LOCAL
])
1674 parms
->laddr
= nla_get_in6_addr(data
[IFLA_GRE_LOCAL
]);
1676 if (data
[IFLA_GRE_REMOTE
])
1677 parms
->raddr
= nla_get_in6_addr(data
[IFLA_GRE_REMOTE
]);
1679 if (data
[IFLA_GRE_TTL
])
1680 parms
->hop_limit
= nla_get_u8(data
[IFLA_GRE_TTL
]);
1682 if (data
[IFLA_GRE_ENCAP_LIMIT
])
1683 parms
->encap_limit
= nla_get_u8(data
[IFLA_GRE_ENCAP_LIMIT
]);
1685 if (data
[IFLA_GRE_FLOWINFO
])
1686 parms
->flowinfo
= nla_get_be32(data
[IFLA_GRE_FLOWINFO
]);
1688 if (data
[IFLA_GRE_FLAGS
])
1689 parms
->flags
= nla_get_u32(data
[IFLA_GRE_FLAGS
]);
1691 if (data
[IFLA_GRE_FWMARK
])
1692 parms
->fwmark
= nla_get_u32(data
[IFLA_GRE_FWMARK
]);
1694 if (data
[IFLA_GRE_COLLECT_METADATA
])
1695 parms
->collect_md
= true;
1697 if (data
[IFLA_GRE_ERSPAN_VER
])
1698 parms
->erspan_ver
= nla_get_u8(data
[IFLA_GRE_ERSPAN_VER
]);
1700 if (parms
->erspan_ver
== 1) {
1701 if (data
[IFLA_GRE_ERSPAN_INDEX
])
1702 parms
->index
= nla_get_u32(data
[IFLA_GRE_ERSPAN_INDEX
]);
1703 } else if (parms
->erspan_ver
== 2) {
1704 if (data
[IFLA_GRE_ERSPAN_DIR
])
1705 parms
->dir
= nla_get_u8(data
[IFLA_GRE_ERSPAN_DIR
]);
1706 if (data
[IFLA_GRE_ERSPAN_HWID
])
1707 parms
->hwid
= nla_get_u16(data
[IFLA_GRE_ERSPAN_HWID
]);
1711 static int ip6gre_tap_init(struct net_device
*dev
)
1715 ret
= ip6gre_tunnel_init_common(dev
);
1719 dev
->priv_flags
|= IFF_LIVE_ADDR_CHANGE
;
1724 static const struct net_device_ops ip6gre_tap_netdev_ops
= {
1725 .ndo_init
= ip6gre_tap_init
,
1726 .ndo_uninit
= ip6gre_tunnel_uninit
,
1727 .ndo_start_xmit
= ip6gre_tunnel_xmit
,
1728 .ndo_set_mac_address
= eth_mac_addr
,
1729 .ndo_validate_addr
= eth_validate_addr
,
1730 .ndo_change_mtu
= ip6_tnl_change_mtu
,
1731 .ndo_get_stats64
= ip_tunnel_get_stats64
,
1732 .ndo_get_iflink
= ip6_tnl_get_iflink
,
1735 static int ip6erspan_tap_init(struct net_device
*dev
)
1737 struct ip6_tnl
*tunnel
;
1741 tunnel
= netdev_priv(dev
);
1744 tunnel
->net
= dev_net(dev
);
1745 strcpy(tunnel
->parms
.name
, dev
->name
);
1747 dev
->tstats
= netdev_alloc_pcpu_stats(struct pcpu_sw_netstats
);
1751 ret
= dst_cache_init(&tunnel
->dst_cache
, GFP_KERNEL
);
1753 free_percpu(dev
->tstats
);
1758 tunnel
->tun_hlen
= 8;
1759 tunnel
->hlen
= tunnel
->tun_hlen
+ tunnel
->encap_hlen
+
1760 erspan_hdr_len(tunnel
->parms
.erspan_ver
);
1761 t_hlen
= tunnel
->hlen
+ sizeof(struct ipv6hdr
);
1763 dev
->hard_header_len
= LL_MAX_HEADER
+ t_hlen
;
1764 dev
->mtu
= ETH_DATA_LEN
- t_hlen
;
1765 if (dev
->type
== ARPHRD_ETHER
)
1766 dev
->mtu
-= ETH_HLEN
;
1767 if (!(tunnel
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
))
1770 dev
->priv_flags
|= IFF_LIVE_ADDR_CHANGE
;
1771 tunnel
= netdev_priv(dev
);
1772 ip6gre_tnl_link_config(tunnel
, 1);
1777 static const struct net_device_ops ip6erspan_netdev_ops
= {
1778 .ndo_init
= ip6erspan_tap_init
,
1779 .ndo_uninit
= ip6gre_tunnel_uninit
,
1780 .ndo_start_xmit
= ip6erspan_tunnel_xmit
,
1781 .ndo_set_mac_address
= eth_mac_addr
,
1782 .ndo_validate_addr
= eth_validate_addr
,
1783 .ndo_change_mtu
= ip6_tnl_change_mtu
,
1784 .ndo_get_stats64
= ip_tunnel_get_stats64
,
1785 .ndo_get_iflink
= ip6_tnl_get_iflink
,
1788 static void ip6gre_tap_setup(struct net_device
*dev
)
1794 dev
->netdev_ops
= &ip6gre_tap_netdev_ops
;
1795 dev
->needs_free_netdev
= true;
1796 dev
->priv_destructor
= ip6gre_dev_free
;
1798 dev
->features
|= NETIF_F_NETNS_LOCAL
;
1799 dev
->priv_flags
&= ~IFF_TX_SKB_SHARING
;
1800 dev
->priv_flags
|= IFF_LIVE_ADDR_CHANGE
;
1801 netif_keep_dst(dev
);
1804 static bool ip6gre_netlink_encap_parms(struct nlattr
*data
[],
1805 struct ip_tunnel_encap
*ipencap
)
1809 memset(ipencap
, 0, sizeof(*ipencap
));
1814 if (data
[IFLA_GRE_ENCAP_TYPE
]) {
1816 ipencap
->type
= nla_get_u16(data
[IFLA_GRE_ENCAP_TYPE
]);
1819 if (data
[IFLA_GRE_ENCAP_FLAGS
]) {
1821 ipencap
->flags
= nla_get_u16(data
[IFLA_GRE_ENCAP_FLAGS
]);
1824 if (data
[IFLA_GRE_ENCAP_SPORT
]) {
1826 ipencap
->sport
= nla_get_be16(data
[IFLA_GRE_ENCAP_SPORT
]);
1829 if (data
[IFLA_GRE_ENCAP_DPORT
]) {
1831 ipencap
->dport
= nla_get_be16(data
[IFLA_GRE_ENCAP_DPORT
]);
1837 static int ip6gre_newlink(struct net
*src_net
, struct net_device
*dev
,
1838 struct nlattr
*tb
[], struct nlattr
*data
[],
1839 struct netlink_ext_ack
*extack
)
1842 struct net
*net
= dev_net(dev
);
1843 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
1844 struct ip_tunnel_encap ipencap
;
1847 nt
= netdev_priv(dev
);
1849 if (ip6gre_netlink_encap_parms(data
, &ipencap
)) {
1850 int err
= ip6_tnl_encap_setup(nt
, &ipencap
);
1856 ip6gre_netlink_parms(data
, &nt
->parms
);
1858 if (nt
->parms
.collect_md
) {
1859 if (rtnl_dereference(ign
->collect_md_tun
))
1862 if (ip6gre_tunnel_find(net
, &nt
->parms
, dev
->type
))
1866 if (dev
->type
== ARPHRD_ETHER
&& !tb
[IFLA_ADDRESS
])
1867 eth_hw_addr_random(dev
);
1870 nt
->net
= dev_net(dev
);
1872 err
= register_netdevice(dev
);
1876 ip6gre_tnl_link_config(nt
, !tb
[IFLA_MTU
]);
1879 ip6_tnl_change_mtu(dev
, nla_get_u32(tb
[IFLA_MTU
]));
1882 ip6gre_tunnel_link(ign
, nt
);
1888 static int ip6gre_changelink(struct net_device
*dev
, struct nlattr
*tb
[],
1889 struct nlattr
*data
[],
1890 struct netlink_ext_ack
*extack
)
1892 struct ip6_tnl
*t
, *nt
= netdev_priv(dev
);
1893 struct net
*net
= nt
->net
;
1894 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
1895 struct __ip6_tnl_parm p
;
1896 struct ip_tunnel_encap ipencap
;
1898 if (dev
== ign
->fb_tunnel_dev
)
1901 if (ip6gre_netlink_encap_parms(data
, &ipencap
)) {
1902 int err
= ip6_tnl_encap_setup(nt
, &ipencap
);
1908 ip6gre_netlink_parms(data
, &p
);
1910 t
= ip6gre_tunnel_locate(net
, &p
, 0);
1919 ip6gre_tunnel_unlink(ign
, t
);
1920 ip6gre_tnl_change(t
, &p
, !tb
[IFLA_MTU
]);
1921 ip6gre_tunnel_link(ign
, t
);
1925 static void ip6gre_dellink(struct net_device
*dev
, struct list_head
*head
)
1927 struct net
*net
= dev_net(dev
);
1928 struct ip6gre_net
*ign
= net_generic(net
, ip6gre_net_id
);
1930 if (dev
!= ign
->fb_tunnel_dev
)
1931 unregister_netdevice_queue(dev
, head
);
1934 static size_t ip6gre_get_size(const struct net_device
*dev
)
1939 /* IFLA_GRE_IFLAGS */
1941 /* IFLA_GRE_OFLAGS */
1947 /* IFLA_GRE_LOCAL */
1948 nla_total_size(sizeof(struct in6_addr
)) +
1949 /* IFLA_GRE_REMOTE */
1950 nla_total_size(sizeof(struct in6_addr
)) +
1953 /* IFLA_GRE_ENCAP_LIMIT */
1955 /* IFLA_GRE_FLOWINFO */
1957 /* IFLA_GRE_FLAGS */
1959 /* IFLA_GRE_ENCAP_TYPE */
1961 /* IFLA_GRE_ENCAP_FLAGS */
1963 /* IFLA_GRE_ENCAP_SPORT */
1965 /* IFLA_GRE_ENCAP_DPORT */
1967 /* IFLA_GRE_COLLECT_METADATA */
1969 /* IFLA_GRE_FWMARK */
1971 /* IFLA_GRE_ERSPAN_INDEX */
1976 static int ip6gre_fill_info(struct sk_buff
*skb
, const struct net_device
*dev
)
1978 struct ip6_tnl
*t
= netdev_priv(dev
);
1979 struct __ip6_tnl_parm
*p
= &t
->parms
;
1981 if (nla_put_u32(skb
, IFLA_GRE_LINK
, p
->link
) ||
1982 nla_put_be16(skb
, IFLA_GRE_IFLAGS
,
1983 gre_tnl_flags_to_gre_flags(p
->i_flags
)) ||
1984 nla_put_be16(skb
, IFLA_GRE_OFLAGS
,
1985 gre_tnl_flags_to_gre_flags(p
->o_flags
)) ||
1986 nla_put_be32(skb
, IFLA_GRE_IKEY
, p
->i_key
) ||
1987 nla_put_be32(skb
, IFLA_GRE_OKEY
, p
->o_key
) ||
1988 nla_put_in6_addr(skb
, IFLA_GRE_LOCAL
, &p
->laddr
) ||
1989 nla_put_in6_addr(skb
, IFLA_GRE_REMOTE
, &p
->raddr
) ||
1990 nla_put_u8(skb
, IFLA_GRE_TTL
, p
->hop_limit
) ||
1991 nla_put_u8(skb
, IFLA_GRE_ENCAP_LIMIT
, p
->encap_limit
) ||
1992 nla_put_be32(skb
, IFLA_GRE_FLOWINFO
, p
->flowinfo
) ||
1993 nla_put_u32(skb
, IFLA_GRE_FLAGS
, p
->flags
) ||
1994 nla_put_u32(skb
, IFLA_GRE_FWMARK
, p
->fwmark
) ||
1995 nla_put_u32(skb
, IFLA_GRE_ERSPAN_INDEX
, p
->index
))
1996 goto nla_put_failure
;
1998 if (nla_put_u16(skb
, IFLA_GRE_ENCAP_TYPE
,
2000 nla_put_be16(skb
, IFLA_GRE_ENCAP_SPORT
,
2002 nla_put_be16(skb
, IFLA_GRE_ENCAP_DPORT
,
2004 nla_put_u16(skb
, IFLA_GRE_ENCAP_FLAGS
,
2006 goto nla_put_failure
;
2008 if (p
->collect_md
) {
2009 if (nla_put_flag(skb
, IFLA_GRE_COLLECT_METADATA
))
2010 goto nla_put_failure
;
2013 if (nla_put_u8(skb
, IFLA_GRE_ERSPAN_VER
, p
->erspan_ver
))
2014 goto nla_put_failure
;
2016 if (p
->erspan_ver
== 1) {
2017 if (nla_put_u32(skb
, IFLA_GRE_ERSPAN_INDEX
, p
->index
))
2018 goto nla_put_failure
;
2019 } else if (p
->erspan_ver
== 2) {
2020 if (nla_put_u8(skb
, IFLA_GRE_ERSPAN_DIR
, p
->dir
))
2021 goto nla_put_failure
;
2022 if (nla_put_u16(skb
, IFLA_GRE_ERSPAN_HWID
, p
->hwid
))
2023 goto nla_put_failure
;
2032 static const struct nla_policy ip6gre_policy
[IFLA_GRE_MAX
+ 1] = {
2033 [IFLA_GRE_LINK
] = { .type
= NLA_U32
},
2034 [IFLA_GRE_IFLAGS
] = { .type
= NLA_U16
},
2035 [IFLA_GRE_OFLAGS
] = { .type
= NLA_U16
},
2036 [IFLA_GRE_IKEY
] = { .type
= NLA_U32
},
2037 [IFLA_GRE_OKEY
] = { .type
= NLA_U32
},
2038 [IFLA_GRE_LOCAL
] = { .len
= FIELD_SIZEOF(struct ipv6hdr
, saddr
) },
2039 [IFLA_GRE_REMOTE
] = { .len
= FIELD_SIZEOF(struct ipv6hdr
, daddr
) },
2040 [IFLA_GRE_TTL
] = { .type
= NLA_U8
},
2041 [IFLA_GRE_ENCAP_LIMIT
] = { .type
= NLA_U8
},
2042 [IFLA_GRE_FLOWINFO
] = { .type
= NLA_U32
},
2043 [IFLA_GRE_FLAGS
] = { .type
= NLA_U32
},
2044 [IFLA_GRE_ENCAP_TYPE
] = { .type
= NLA_U16
},
2045 [IFLA_GRE_ENCAP_FLAGS
] = { .type
= NLA_U16
},
2046 [IFLA_GRE_ENCAP_SPORT
] = { .type
= NLA_U16
},
2047 [IFLA_GRE_ENCAP_DPORT
] = { .type
= NLA_U16
},
2048 [IFLA_GRE_COLLECT_METADATA
] = { .type
= NLA_FLAG
},
2049 [IFLA_GRE_FWMARK
] = { .type
= NLA_U32
},
2050 [IFLA_GRE_ERSPAN_INDEX
] = { .type
= NLA_U32
},
2051 [IFLA_GRE_ERSPAN_VER
] = { .type
= NLA_U8
},
2052 [IFLA_GRE_ERSPAN_DIR
] = { .type
= NLA_U8
},
2053 [IFLA_GRE_ERSPAN_HWID
] = { .type
= NLA_U16
},
2056 static void ip6erspan_tap_setup(struct net_device
*dev
)
2060 dev
->netdev_ops
= &ip6erspan_netdev_ops
;
2061 dev
->needs_free_netdev
= true;
2062 dev
->priv_destructor
= ip6gre_dev_free
;
2064 dev
->features
|= NETIF_F_NETNS_LOCAL
;
2065 dev
->priv_flags
&= ~IFF_TX_SKB_SHARING
;
2066 dev
->priv_flags
|= IFF_LIVE_ADDR_CHANGE
;
2067 netif_keep_dst(dev
);
2070 static struct rtnl_link_ops ip6gre_link_ops __read_mostly
= {
2072 .maxtype
= IFLA_GRE_MAX
,
2073 .policy
= ip6gre_policy
,
2074 .priv_size
= sizeof(struct ip6_tnl
),
2075 .setup
= ip6gre_tunnel_setup
,
2076 .validate
= ip6gre_tunnel_validate
,
2077 .newlink
= ip6gre_newlink
,
2078 .changelink
= ip6gre_changelink
,
2079 .dellink
= ip6gre_dellink
,
2080 .get_size
= ip6gre_get_size
,
2081 .fill_info
= ip6gre_fill_info
,
2082 .get_link_net
= ip6_tnl_get_link_net
,
2085 static struct rtnl_link_ops ip6gre_tap_ops __read_mostly
= {
2086 .kind
= "ip6gretap",
2087 .maxtype
= IFLA_GRE_MAX
,
2088 .policy
= ip6gre_policy
,
2089 .priv_size
= sizeof(struct ip6_tnl
),
2090 .setup
= ip6gre_tap_setup
,
2091 .validate
= ip6gre_tap_validate
,
2092 .newlink
= ip6gre_newlink
,
2093 .changelink
= ip6gre_changelink
,
2094 .get_size
= ip6gre_get_size
,
2095 .fill_info
= ip6gre_fill_info
,
2096 .get_link_net
= ip6_tnl_get_link_net
,
2099 static struct rtnl_link_ops ip6erspan_tap_ops __read_mostly
= {
2100 .kind
= "ip6erspan",
2101 .maxtype
= IFLA_GRE_MAX
,
2102 .policy
= ip6gre_policy
,
2103 .priv_size
= sizeof(struct ip6_tnl
),
2104 .setup
= ip6erspan_tap_setup
,
2105 .validate
= ip6erspan_tap_validate
,
2106 .newlink
= ip6gre_newlink
,
2107 .changelink
= ip6gre_changelink
,
2108 .get_size
= ip6gre_get_size
,
2109 .fill_info
= ip6gre_fill_info
,
2110 .get_link_net
= ip6_tnl_get_link_net
,
2114 * And now the modules code and kernel interface.
2117 static int __init
ip6gre_init(void)
2121 pr_info("GRE over IPv6 tunneling driver\n");
2123 err
= register_pernet_device(&ip6gre_net_ops
);
2127 err
= inet6_add_protocol(&ip6gre_protocol
, IPPROTO_GRE
);
2129 pr_info("%s: can't add protocol\n", __func__
);
2130 goto add_proto_failed
;
2133 err
= rtnl_link_register(&ip6gre_link_ops
);
2135 goto rtnl_link_failed
;
2137 err
= rtnl_link_register(&ip6gre_tap_ops
);
2139 goto tap_ops_failed
;
2141 err
= rtnl_link_register(&ip6erspan_tap_ops
);
2143 goto erspan_link_failed
;
2149 rtnl_link_unregister(&ip6gre_tap_ops
);
2151 rtnl_link_unregister(&ip6gre_link_ops
);
2153 inet6_del_protocol(&ip6gre_protocol
, IPPROTO_GRE
);
2155 unregister_pernet_device(&ip6gre_net_ops
);
2159 static void __exit
ip6gre_fini(void)
2161 rtnl_link_unregister(&ip6gre_tap_ops
);
2162 rtnl_link_unregister(&ip6gre_link_ops
);
2163 rtnl_link_unregister(&ip6erspan_tap_ops
);
2164 inet6_del_protocol(&ip6gre_protocol
, IPPROTO_GRE
);
2165 unregister_pernet_device(&ip6gre_net_ops
);
2168 module_init(ip6gre_init
);
2169 module_exit(ip6gre_fini
);
2170 MODULE_LICENSE("GPL");
2171 MODULE_AUTHOR("D. Kozlov (xeb@mail.ru)");
2172 MODULE_DESCRIPTION("GRE over IPv6 tunneling device");
2173 MODULE_ALIAS_RTNL_LINK("ip6gre");
2174 MODULE_ALIAS_RTNL_LINK("ip6gretap");
2175 MODULE_ALIAS_RTNL_LINK("ip6erspan");
2176 MODULE_ALIAS_NETDEV("ip6gre0");