2 * GENEVE: Generic Network Virtualization Encapsulation
4 * Copyright (c) 2015 Red Hat, Inc.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/netdevice.h>
16 #include <linux/etherdevice.h>
17 #include <linux/hash.h>
18 #include <net/dst_metadata.h>
19 #include <net/gro_cells.h>
20 #include <net/rtnetlink.h>
21 #include <net/geneve.h>
22 #include <net/protocol.h>
24 #define GENEVE_NETDEV_VER "0.6"
26 #define GENEVE_UDP_PORT 6081
28 #define GENEVE_N_VID (1u << 24)
29 #define GENEVE_VID_MASK (GENEVE_N_VID - 1)
31 #define VNI_HASH_BITS 10
32 #define VNI_HASH_SIZE (1<<VNI_HASH_BITS)
34 static bool log_ecn_error
= true;
35 module_param(log_ecn_error
, bool, 0644);
36 MODULE_PARM_DESC(log_ecn_error
, "Log packets received with corrupted ECN");
39 #define GENEVE_BASE_HLEN (sizeof(struct udphdr) + sizeof(struct genevehdr))
41 /* per-network namespace private data for this module */
43 struct list_head geneve_list
;
44 struct list_head sock_list
;
47 static int geneve_net_id
;
50 struct sockaddr_in sin
;
51 struct sockaddr_in6 sin6
;
55 static union geneve_addr geneve_remote_unspec
= { .sa
.sa_family
= AF_UNSPEC
, };
57 /* Pseudo network device */
59 struct hlist_node hlist
; /* vni hash table */
60 struct net
*net
; /* netns for packet i/o */
61 struct net_device
*dev
; /* netdev for geneve tunnel */
62 struct geneve_sock
*sock4
; /* IPv4 socket used for geneve tunnel */
63 #if IS_ENABLED(CONFIG_IPV6)
64 struct geneve_sock
*sock6
; /* IPv6 socket used for geneve tunnel */
66 u8 vni
[3]; /* virtual network ID for tunnel */
67 u8 ttl
; /* TTL override */
68 u8 tos
; /* TOS override */
69 union geneve_addr remote
; /* IP address for link partner */
70 struct list_head next
; /* geneve's per namespace list */
73 struct gro_cells gro_cells
;
77 /* Geneve device flags */
78 #define GENEVE_F_UDP_CSUM BIT(0)
79 #define GENEVE_F_UDP_ZERO_CSUM6_TX BIT(1)
80 #define GENEVE_F_UDP_ZERO_CSUM6_RX BIT(2)
84 struct list_head list
;
88 struct udp_offload udp_offloads
;
89 struct hlist_head vni_list
[VNI_HASH_SIZE
];
93 static inline __u32
geneve_net_vni_hash(u8 vni
[3])
97 vnid
= (vni
[0] << 16) | (vni
[1] << 8) | vni
[2];
98 return hash_32(vnid
, VNI_HASH_BITS
);
101 static __be64
vni_to_tunnel_id(const __u8
*vni
)
104 return (vni
[0] << 16) | (vni
[1] << 8) | vni
[2];
106 return (__force __be64
)(((__force u64
)vni
[0] << 40) |
107 ((__force u64
)vni
[1] << 48) |
108 ((__force u64
)vni
[2] << 56));
112 static struct geneve_dev
*geneve_lookup(struct geneve_sock
*gs
,
113 __be32 addr
, u8 vni
[])
115 struct hlist_head
*vni_list_head
;
116 struct geneve_dev
*geneve
;
119 /* Find the device for this VNI */
120 hash
= geneve_net_vni_hash(vni
);
121 vni_list_head
= &gs
->vni_list
[hash
];
122 hlist_for_each_entry_rcu(geneve
, vni_list_head
, hlist
) {
123 if (!memcmp(vni
, geneve
->vni
, sizeof(geneve
->vni
)) &&
124 addr
== geneve
->remote
.sin
.sin_addr
.s_addr
)
130 #if IS_ENABLED(CONFIG_IPV6)
131 static struct geneve_dev
*geneve6_lookup(struct geneve_sock
*gs
,
132 struct in6_addr addr6
, u8 vni
[])
134 struct hlist_head
*vni_list_head
;
135 struct geneve_dev
*geneve
;
138 /* Find the device for this VNI */
139 hash
= geneve_net_vni_hash(vni
);
140 vni_list_head
= &gs
->vni_list
[hash
];
141 hlist_for_each_entry_rcu(geneve
, vni_list_head
, hlist
) {
142 if (!memcmp(vni
, geneve
->vni
, sizeof(geneve
->vni
)) &&
143 ipv6_addr_equal(&addr6
, &geneve
->remote
.sin6
.sin6_addr
))
150 static inline struct genevehdr
*geneve_hdr(const struct sk_buff
*skb
)
152 return (struct genevehdr
*)(udp_hdr(skb
) + 1);
155 /* geneve receive/decap routine */
156 static void geneve_rx(struct geneve_sock
*gs
, struct sk_buff
*skb
)
158 struct genevehdr
*gnvh
= geneve_hdr(skb
);
159 struct metadata_dst
*tun_dst
= NULL
;
160 struct geneve_dev
*geneve
= NULL
;
161 struct pcpu_sw_netstats
*stats
;
162 struct iphdr
*iph
= NULL
;
164 static u8 zero_vni
[3];
167 sa_family_t sa_family
;
168 #if IS_ENABLED(CONFIG_IPV6)
169 struct ipv6hdr
*ip6h
= NULL
;
170 struct in6_addr addr6
;
171 static struct in6_addr zero_addr6
;
174 sa_family
= gs
->sock
->sk
->sk_family
;
176 if (sa_family
== AF_INET
) {
177 iph
= ip_hdr(skb
); /* outer IP header... */
179 if (gs
->collect_md
) {
188 geneve
= geneve_lookup(gs
, addr
, vni
);
189 #if IS_ENABLED(CONFIG_IPV6)
190 } else if (sa_family
== AF_INET6
) {
191 ip6h
= ipv6_hdr(skb
); /* outer IPv6 header... */
193 if (gs
->collect_md
) {
202 geneve
= geneve6_lookup(gs
, addr6
, vni
);
208 if (ip_tunnel_collect_metadata() || gs
->collect_md
) {
211 flags
= TUNNEL_KEY
| TUNNEL_GENEVE_OPT
|
212 (gnvh
->oam
? TUNNEL_OAM
: 0) |
213 (gnvh
->critical
? TUNNEL_CRIT_OPT
: 0);
215 tun_dst
= udp_tun_rx_dst(skb
, sa_family
, flags
,
216 vni_to_tunnel_id(gnvh
->vni
),
220 /* Update tunnel dst according to Geneve options. */
221 ip_tunnel_info_opts_set(&tun_dst
->u
.tun_info
,
222 gnvh
->options
, gnvh
->opt_len
* 4);
224 /* Drop packets w/ critical options,
225 * since we don't support any...
231 skb_reset_mac_header(skb
);
232 skb_scrub_packet(skb
, !net_eq(geneve
->net
, dev_net(geneve
->dev
)));
233 skb
->protocol
= eth_type_trans(skb
, geneve
->dev
);
234 skb_postpull_rcsum(skb
, eth_hdr(skb
), ETH_HLEN
);
237 skb_dst_set(skb
, &tun_dst
->dst
);
239 /* Ignore packet loops (and multicast echo) */
240 if (ether_addr_equal(eth_hdr(skb
)->h_source
, geneve
->dev
->dev_addr
))
243 skb_reset_network_header(skb
);
246 err
= IP_ECN_decapsulate(iph
, skb
);
247 #if IS_ENABLED(CONFIG_IPV6)
249 err
= IP6_ECN_decapsulate(ip6h
, skb
);
255 net_info_ratelimited("non-ECT from %pI4 "
257 &iph
->saddr
, iph
->tos
);
258 #if IS_ENABLED(CONFIG_IPV6)
260 net_info_ratelimited("non-ECT from %pI6\n",
265 ++geneve
->dev
->stats
.rx_frame_errors
;
266 ++geneve
->dev
->stats
.rx_errors
;
271 stats
= this_cpu_ptr(geneve
->dev
->tstats
);
272 u64_stats_update_begin(&stats
->syncp
);
274 stats
->rx_bytes
+= skb
->len
;
275 u64_stats_update_end(&stats
->syncp
);
277 gro_cells_receive(&geneve
->gro_cells
, skb
);
280 /* Consume bad packet */
284 /* Setup stats when device is created */
285 static int geneve_init(struct net_device
*dev
)
287 struct geneve_dev
*geneve
= netdev_priv(dev
);
290 dev
->tstats
= netdev_alloc_pcpu_stats(struct pcpu_sw_netstats
);
294 err
= gro_cells_init(&geneve
->gro_cells
, dev
);
296 free_percpu(dev
->tstats
);
303 static void geneve_uninit(struct net_device
*dev
)
305 struct geneve_dev
*geneve
= netdev_priv(dev
);
307 gro_cells_destroy(&geneve
->gro_cells
);
308 free_percpu(dev
->tstats
);
311 /* Callback from net/ipv4/udp.c to receive packets */
312 static int geneve_udp_encap_recv(struct sock
*sk
, struct sk_buff
*skb
)
314 struct genevehdr
*geneveh
;
315 struct geneve_sock
*gs
;
318 /* Need Geneve and inner Ethernet header to be present */
319 if (unlikely(!pskb_may_pull(skb
, GENEVE_BASE_HLEN
)))
322 /* Return packets with reserved bits set */
323 geneveh
= geneve_hdr(skb
);
324 if (unlikely(geneveh
->ver
!= GENEVE_VER
))
327 if (unlikely(geneveh
->proto_type
!= htons(ETH_P_TEB
)))
330 opts_len
= geneveh
->opt_len
* 4;
331 if (iptunnel_pull_header(skb
, GENEVE_BASE_HLEN
+ opts_len
,
335 gs
= rcu_dereference_sk_user_data(sk
);
343 /* Consume bad packet */
348 /* Let the UDP layer deal with the skb */
352 static struct socket
*geneve_create_sock(struct net
*net
, bool ipv6
,
353 __be16 port
, u32 flags
)
356 struct udp_port_cfg udp_conf
;
359 memset(&udp_conf
, 0, sizeof(udp_conf
));
362 udp_conf
.family
= AF_INET6
;
363 udp_conf
.ipv6_v6only
= 1;
364 udp_conf
.use_udp6_rx_checksums
=
365 !(flags
& GENEVE_F_UDP_ZERO_CSUM6_RX
);
367 udp_conf
.family
= AF_INET
;
368 udp_conf
.local_ip
.s_addr
= htonl(INADDR_ANY
);
371 udp_conf
.local_udp_port
= port
;
373 /* Open UDP socket */
374 err
= udp_sock_create(net
, &udp_conf
, &sock
);
381 static void geneve_notify_add_rx_port(struct geneve_sock
*gs
)
383 struct net_device
*dev
;
384 struct sock
*sk
= gs
->sock
->sk
;
385 struct net
*net
= sock_net(sk
);
386 sa_family_t sa_family
= sk
->sk_family
;
387 __be16 port
= inet_sk(sk
)->inet_sport
;
390 if (sa_family
== AF_INET
) {
391 err
= udp_add_offload(sock_net(sk
), &gs
->udp_offloads
);
393 pr_warn("geneve: udp_add_offload failed with status %d\n",
398 for_each_netdev_rcu(net
, dev
) {
399 if (dev
->netdev_ops
->ndo_add_geneve_port
)
400 dev
->netdev_ops
->ndo_add_geneve_port(dev
, sa_family
,
406 static int geneve_hlen(struct genevehdr
*gh
)
408 return sizeof(*gh
) + gh
->opt_len
* 4;
411 static struct sk_buff
**geneve_gro_receive(struct sk_buff
**head
,
413 struct udp_offload
*uoff
)
415 struct sk_buff
*p
, **pp
= NULL
;
416 struct genevehdr
*gh
, *gh2
;
417 unsigned int hlen
, gh_len
, off_gnv
;
418 const struct packet_offload
*ptype
;
422 off_gnv
= skb_gro_offset(skb
);
423 hlen
= off_gnv
+ sizeof(*gh
);
424 gh
= skb_gro_header_fast(skb
, off_gnv
);
425 if (skb_gro_header_hard(skb
, hlen
)) {
426 gh
= skb_gro_header_slow(skb
, hlen
, off_gnv
);
431 if (gh
->ver
!= GENEVE_VER
|| gh
->oam
)
433 gh_len
= geneve_hlen(gh
);
435 hlen
= off_gnv
+ gh_len
;
436 if (skb_gro_header_hard(skb
, hlen
)) {
437 gh
= skb_gro_header_slow(skb
, hlen
, off_gnv
);
444 for (p
= *head
; p
; p
= p
->next
) {
445 if (!NAPI_GRO_CB(p
)->same_flow
)
448 gh2
= (struct genevehdr
*)(p
->data
+ off_gnv
);
449 if (gh
->opt_len
!= gh2
->opt_len
||
450 memcmp(gh
, gh2
, gh_len
)) {
451 NAPI_GRO_CB(p
)->same_flow
= 0;
456 type
= gh
->proto_type
;
459 ptype
= gro_find_receive_by_type(type
);
465 skb_gro_pull(skb
, gh_len
);
466 skb_gro_postpull_rcsum(skb
, gh
, gh_len
);
467 pp
= ptype
->callbacks
.gro_receive(head
, skb
);
472 NAPI_GRO_CB(skb
)->flush
|= flush
;
477 static int geneve_gro_complete(struct sk_buff
*skb
, int nhoff
,
478 struct udp_offload
*uoff
)
480 struct genevehdr
*gh
;
481 struct packet_offload
*ptype
;
486 udp_tunnel_gro_complete(skb
, nhoff
);
488 gh
= (struct genevehdr
*)(skb
->data
+ nhoff
);
489 gh_len
= geneve_hlen(gh
);
490 type
= gh
->proto_type
;
493 ptype
= gro_find_complete_by_type(type
);
495 err
= ptype
->callbacks
.gro_complete(skb
, nhoff
+ gh_len
);
501 /* Create new listen socket if needed */
502 static struct geneve_sock
*geneve_socket_create(struct net
*net
, __be16 port
,
503 bool ipv6
, u32 flags
)
505 struct geneve_net
*gn
= net_generic(net
, geneve_net_id
);
506 struct geneve_sock
*gs
;
508 struct udp_tunnel_sock_cfg tunnel_cfg
;
511 gs
= kzalloc(sizeof(*gs
), GFP_KERNEL
);
513 return ERR_PTR(-ENOMEM
);
515 sock
= geneve_create_sock(net
, ipv6
, port
, flags
);
518 return ERR_CAST(sock
);
523 for (h
= 0; h
< VNI_HASH_SIZE
; ++h
)
524 INIT_HLIST_HEAD(&gs
->vni_list
[h
]);
526 /* Initialize the geneve udp offloads structure */
527 gs
->udp_offloads
.port
= port
;
528 gs
->udp_offloads
.callbacks
.gro_receive
= geneve_gro_receive
;
529 gs
->udp_offloads
.callbacks
.gro_complete
= geneve_gro_complete
;
530 geneve_notify_add_rx_port(gs
);
532 /* Mark socket as an encapsulation socket */
533 tunnel_cfg
.sk_user_data
= gs
;
534 tunnel_cfg
.encap_type
= 1;
535 tunnel_cfg
.encap_rcv
= geneve_udp_encap_recv
;
536 tunnel_cfg
.encap_destroy
= NULL
;
537 setup_udp_tunnel_sock(net
, sock
, &tunnel_cfg
);
538 list_add(&gs
->list
, &gn
->sock_list
);
542 static void geneve_notify_del_rx_port(struct geneve_sock
*gs
)
544 struct net_device
*dev
;
545 struct sock
*sk
= gs
->sock
->sk
;
546 struct net
*net
= sock_net(sk
);
547 sa_family_t sa_family
= sk
->sk_family
;
548 __be16 port
= inet_sk(sk
)->inet_sport
;
551 for_each_netdev_rcu(net
, dev
) {
552 if (dev
->netdev_ops
->ndo_del_geneve_port
)
553 dev
->netdev_ops
->ndo_del_geneve_port(dev
, sa_family
,
559 if (sa_family
== AF_INET
)
560 udp_del_offload(&gs
->udp_offloads
);
563 static void __geneve_sock_release(struct geneve_sock
*gs
)
565 if (!gs
|| --gs
->refcnt
)
569 geneve_notify_del_rx_port(gs
);
570 udp_tunnel_sock_release(gs
->sock
);
574 static void geneve_sock_release(struct geneve_dev
*geneve
)
576 __geneve_sock_release(geneve
->sock4
);
577 #if IS_ENABLED(CONFIG_IPV6)
578 __geneve_sock_release(geneve
->sock6
);
582 static struct geneve_sock
*geneve_find_sock(struct geneve_net
*gn
,
586 struct geneve_sock
*gs
;
588 list_for_each_entry(gs
, &gn
->sock_list
, list
) {
589 if (inet_sk(gs
->sock
->sk
)->inet_sport
== dst_port
&&
590 inet_sk(gs
->sock
->sk
)->sk
.sk_family
== family
) {
597 static int geneve_sock_add(struct geneve_dev
*geneve
, bool ipv6
)
599 struct net
*net
= geneve
->net
;
600 struct geneve_net
*gn
= net_generic(net
, geneve_net_id
);
601 struct geneve_sock
*gs
;
604 gs
= geneve_find_sock(gn
, ipv6
? AF_INET6
: AF_INET
, geneve
->dst_port
);
610 gs
= geneve_socket_create(net
, geneve
->dst_port
, ipv6
, geneve
->flags
);
615 gs
->collect_md
= geneve
->collect_md
;
616 gs
->flags
= geneve
->flags
;
617 #if IS_ENABLED(CONFIG_IPV6)
624 hash
= geneve_net_vni_hash(geneve
->vni
);
625 hlist_add_head_rcu(&geneve
->hlist
, &gs
->vni_list
[hash
]);
629 static int geneve_open(struct net_device
*dev
)
631 struct geneve_dev
*geneve
= netdev_priv(dev
);
632 bool ipv6
= geneve
->remote
.sa
.sa_family
== AF_INET6
;
633 bool metadata
= geneve
->collect_md
;
636 geneve
->sock4
= NULL
;
637 #if IS_ENABLED(CONFIG_IPV6)
638 geneve
->sock6
= NULL
;
639 if (ipv6
|| metadata
)
640 ret
= geneve_sock_add(geneve
, true);
642 if (!ret
&& (!ipv6
|| metadata
))
643 ret
= geneve_sock_add(geneve
, false);
645 geneve_sock_release(geneve
);
650 static int geneve_stop(struct net_device
*dev
)
652 struct geneve_dev
*geneve
= netdev_priv(dev
);
654 if (!hlist_unhashed(&geneve
->hlist
))
655 hlist_del_rcu(&geneve
->hlist
);
656 geneve_sock_release(geneve
);
660 static void geneve_build_header(struct genevehdr
*geneveh
,
661 __be16 tun_flags
, u8 vni
[3],
662 u8 options_len
, u8
*options
)
664 geneveh
->ver
= GENEVE_VER
;
665 geneveh
->opt_len
= options_len
/ 4;
666 geneveh
->oam
= !!(tun_flags
& TUNNEL_OAM
);
667 geneveh
->critical
= !!(tun_flags
& TUNNEL_CRIT_OPT
);
669 memcpy(geneveh
->vni
, vni
, 3);
670 geneveh
->proto_type
= htons(ETH_P_TEB
);
673 memcpy(geneveh
->options
, options
, options_len
);
676 static int geneve_build_skb(struct rtable
*rt
, struct sk_buff
*skb
,
677 __be16 tun_flags
, u8 vni
[3], u8 opt_len
, u8
*opt
,
678 u32 flags
, bool xnet
)
680 struct genevehdr
*gnvh
;
683 bool udp_sum
= !!(flags
& GENEVE_F_UDP_CSUM
);
685 skb_scrub_packet(skb
, xnet
);
687 min_headroom
= LL_RESERVED_SPACE(rt
->dst
.dev
) + rt
->dst
.header_len
688 + GENEVE_BASE_HLEN
+ opt_len
+ sizeof(struct iphdr
);
689 err
= skb_cow_head(skb
, min_headroom
);
695 skb
= udp_tunnel_handle_offloads(skb
, udp_sum
);
701 gnvh
= (struct genevehdr
*)__skb_push(skb
, sizeof(*gnvh
) + opt_len
);
702 geneve_build_header(gnvh
, tun_flags
, vni
, opt_len
, opt
);
704 skb_set_inner_protocol(skb
, htons(ETH_P_TEB
));
712 #if IS_ENABLED(CONFIG_IPV6)
713 static int geneve6_build_skb(struct dst_entry
*dst
, struct sk_buff
*skb
,
714 __be16 tun_flags
, u8 vni
[3], u8 opt_len
, u8
*opt
,
715 u32 flags
, bool xnet
)
717 struct genevehdr
*gnvh
;
720 bool udp_sum
= !(flags
& GENEVE_F_UDP_ZERO_CSUM6_TX
);
722 skb_scrub_packet(skb
, xnet
);
724 min_headroom
= LL_RESERVED_SPACE(dst
->dev
) + dst
->header_len
725 + GENEVE_BASE_HLEN
+ opt_len
+ sizeof(struct ipv6hdr
);
726 err
= skb_cow_head(skb
, min_headroom
);
732 skb
= udp_tunnel_handle_offloads(skb
, udp_sum
);
738 gnvh
= (struct genevehdr
*)__skb_push(skb
, sizeof(*gnvh
) + opt_len
);
739 geneve_build_header(gnvh
, tun_flags
, vni
, opt_len
, opt
);
741 skb_set_inner_protocol(skb
, htons(ETH_P_TEB
));
750 static struct rtable
*geneve_get_v4_rt(struct sk_buff
*skb
,
751 struct net_device
*dev
,
753 struct ip_tunnel_info
*info
)
755 struct geneve_dev
*geneve
= netdev_priv(dev
);
756 struct rtable
*rt
= NULL
;
759 memset(fl4
, 0, sizeof(*fl4
));
760 fl4
->flowi4_mark
= skb
->mark
;
761 fl4
->flowi4_proto
= IPPROTO_UDP
;
764 fl4
->daddr
= info
->key
.u
.ipv4
.dst
;
765 fl4
->saddr
= info
->key
.u
.ipv4
.src
;
766 fl4
->flowi4_tos
= RT_TOS(info
->key
.tos
);
770 const struct iphdr
*iip
= ip_hdr(skb
);
772 tos
= ip_tunnel_get_dsfield(iip
, skb
);
775 fl4
->flowi4_tos
= RT_TOS(tos
);
776 fl4
->daddr
= geneve
->remote
.sin
.sin_addr
.s_addr
;
779 rt
= ip_route_output_key(geneve
->net
, fl4
);
781 netdev_dbg(dev
, "no route to %pI4\n", &fl4
->daddr
);
782 return ERR_PTR(-ENETUNREACH
);
784 if (rt
->dst
.dev
== dev
) { /* is this necessary? */
785 netdev_dbg(dev
, "circular route to %pI4\n", &fl4
->daddr
);
787 return ERR_PTR(-ELOOP
);
792 #if IS_ENABLED(CONFIG_IPV6)
793 static struct dst_entry
*geneve_get_v6_dst(struct sk_buff
*skb
,
794 struct net_device
*dev
,
796 struct ip_tunnel_info
*info
)
798 struct geneve_dev
*geneve
= netdev_priv(dev
);
799 struct geneve_sock
*gs6
= geneve
->sock6
;
800 struct dst_entry
*dst
= NULL
;
803 memset(fl6
, 0, sizeof(*fl6
));
804 fl6
->flowi6_mark
= skb
->mark
;
805 fl6
->flowi6_proto
= IPPROTO_UDP
;
808 fl6
->daddr
= info
->key
.u
.ipv6
.dst
;
809 fl6
->saddr
= info
->key
.u
.ipv6
.src
;
810 fl6
->flowi6_tos
= RT_TOS(info
->key
.tos
);
814 const struct iphdr
*iip
= ip_hdr(skb
);
816 prio
= ip_tunnel_get_dsfield(iip
, skb
);
819 fl6
->flowi6_tos
= RT_TOS(prio
);
820 fl6
->daddr
= geneve
->remote
.sin6
.sin6_addr
;
823 if (ipv6_stub
->ipv6_dst_lookup(geneve
->net
, gs6
->sock
->sk
, &dst
, fl6
)) {
824 netdev_dbg(dev
, "no route to %pI6\n", &fl6
->daddr
);
825 return ERR_PTR(-ENETUNREACH
);
827 if (dst
->dev
== dev
) { /* is this necessary? */
828 netdev_dbg(dev
, "circular route to %pI6\n", &fl6
->daddr
);
830 return ERR_PTR(-ELOOP
);
837 /* Convert 64 bit tunnel ID to 24 bit VNI. */
838 static void tunnel_id_to_vni(__be64 tun_id
, __u8
*vni
)
841 vni
[0] = (__force __u8
)(tun_id
>> 16);
842 vni
[1] = (__force __u8
)(tun_id
>> 8);
843 vni
[2] = (__force __u8
)tun_id
;
845 vni
[0] = (__force __u8
)((__force u64
)tun_id
>> 40);
846 vni
[1] = (__force __u8
)((__force u64
)tun_id
>> 48);
847 vni
[2] = (__force __u8
)((__force u64
)tun_id
>> 56);
851 static netdev_tx_t
geneve_xmit_skb(struct sk_buff
*skb
, struct net_device
*dev
,
852 struct ip_tunnel_info
*info
)
854 struct geneve_dev
*geneve
= netdev_priv(dev
);
855 struct geneve_sock
*gs4
= geneve
->sock4
;
856 struct rtable
*rt
= NULL
;
857 const struct iphdr
*iip
; /* interior IP header */
863 bool xnet
= !net_eq(geneve
->net
, dev_net(geneve
->dev
));
864 u32 flags
= geneve
->flags
;
866 if (geneve
->collect_md
) {
867 if (unlikely(!info
|| !(info
->mode
& IP_TUNNEL_INFO_TX
))) {
868 netdev_dbg(dev
, "no tunnel metadata\n");
871 if (info
&& ip_tunnel_info_af(info
) != AF_INET
)
875 rt
= geneve_get_v4_rt(skb
, dev
, &fl4
, info
);
881 sport
= udp_flow_src_port(geneve
->net
, skb
, 1, USHRT_MAX
, true);
882 skb_reset_mac_header(skb
);
887 const struct ip_tunnel_key
*key
= &info
->key
;
891 tunnel_id_to_vni(key
->tun_id
, vni
);
892 if (key
->tun_flags
& TUNNEL_GENEVE_OPT
)
893 opts
= ip_tunnel_info_opts(info
);
895 if (key
->tun_flags
& TUNNEL_CSUM
)
896 flags
|= GENEVE_F_UDP_CSUM
;
898 flags
&= ~GENEVE_F_UDP_CSUM
;
900 err
= geneve_build_skb(rt
, skb
, key
->tun_flags
, vni
,
901 info
->options_len
, opts
, flags
, xnet
);
905 tos
= ip_tunnel_ecn_encap(key
->tos
, iip
, skb
);
907 df
= key
->tun_flags
& TUNNEL_DONT_FRAGMENT
? htons(IP_DF
) : 0;
909 err
= geneve_build_skb(rt
, skb
, 0, geneve
->vni
,
910 0, NULL
, flags
, xnet
);
914 tos
= ip_tunnel_ecn_encap(fl4
.flowi4_tos
, iip
, skb
);
916 if (!ttl
&& IN_MULTICAST(ntohl(fl4
.daddr
)))
918 ttl
= ttl
? : ip4_dst_hoplimit(&rt
->dst
);
921 udp_tunnel_xmit_skb(rt
, gs4
->sock
->sk
, skb
, fl4
.saddr
, fl4
.daddr
,
922 tos
, ttl
, df
, sport
, geneve
->dst_port
,
923 !net_eq(geneve
->net
, dev_net(geneve
->dev
)),
924 !(flags
& GENEVE_F_UDP_CSUM
));
932 dev
->stats
.collisions
++;
933 else if (err
== -ENETUNREACH
)
934 dev
->stats
.tx_carrier_errors
++;
936 dev
->stats
.tx_errors
++;
940 #if IS_ENABLED(CONFIG_IPV6)
941 static netdev_tx_t
geneve6_xmit_skb(struct sk_buff
*skb
, struct net_device
*dev
,
942 struct ip_tunnel_info
*info
)
944 struct geneve_dev
*geneve
= netdev_priv(dev
);
945 struct geneve_sock
*gs6
= geneve
->sock6
;
946 struct dst_entry
*dst
= NULL
;
947 const struct iphdr
*iip
; /* interior IP header */
952 bool xnet
= !net_eq(geneve
->net
, dev_net(geneve
->dev
));
953 u32 flags
= geneve
->flags
;
955 if (geneve
->collect_md
) {
956 if (unlikely(!info
|| !(info
->mode
& IP_TUNNEL_INFO_TX
))) {
957 netdev_dbg(dev
, "no tunnel metadata\n");
962 dst
= geneve_get_v6_dst(skb
, dev
, &fl6
, info
);
968 sport
= udp_flow_src_port(geneve
->net
, skb
, 1, USHRT_MAX
, true);
969 skb_reset_mac_header(skb
);
974 const struct ip_tunnel_key
*key
= &info
->key
;
978 tunnel_id_to_vni(key
->tun_id
, vni
);
979 if (key
->tun_flags
& TUNNEL_GENEVE_OPT
)
980 opts
= ip_tunnel_info_opts(info
);
982 if (key
->tun_flags
& TUNNEL_CSUM
)
983 flags
|= GENEVE_F_UDP_CSUM
;
985 flags
&= ~GENEVE_F_UDP_CSUM
;
987 err
= geneve6_build_skb(dst
, skb
, key
->tun_flags
, vni
,
988 info
->options_len
, opts
,
993 prio
= ip_tunnel_ecn_encap(key
->tos
, iip
, skb
);
996 err
= geneve6_build_skb(dst
, skb
, 0, geneve
->vni
,
997 0, NULL
, flags
, xnet
);
1001 prio
= ip_tunnel_ecn_encap(fl6
.flowi6_tos
, iip
, skb
);
1003 if (!ttl
&& ipv6_addr_is_multicast(&fl6
.daddr
))
1005 ttl
= ttl
? : ip6_dst_hoplimit(dst
);
1007 udp_tunnel6_xmit_skb(dst
, gs6
->sock
->sk
, skb
, dev
,
1008 &fl6
.saddr
, &fl6
.daddr
, prio
, ttl
,
1009 sport
, geneve
->dst_port
,
1010 !!(flags
& GENEVE_F_UDP_ZERO_CSUM6_TX
));
1011 return NETDEV_TX_OK
;
1017 dev
->stats
.collisions
++;
1018 else if (err
== -ENETUNREACH
)
1019 dev
->stats
.tx_carrier_errors
++;
1021 dev
->stats
.tx_errors
++;
1022 return NETDEV_TX_OK
;
1026 static netdev_tx_t
geneve_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1028 struct geneve_dev
*geneve
= netdev_priv(dev
);
1029 struct ip_tunnel_info
*info
= NULL
;
1031 if (geneve
->collect_md
)
1032 info
= skb_tunnel_info(skb
);
1034 #if IS_ENABLED(CONFIG_IPV6)
1035 if ((info
&& ip_tunnel_info_af(info
) == AF_INET6
) ||
1036 (!info
&& geneve
->remote
.sa
.sa_family
== AF_INET6
))
1037 return geneve6_xmit_skb(skb
, dev
, info
);
1039 return geneve_xmit_skb(skb
, dev
, info
);
1042 static int geneve_fill_metadata_dst(struct net_device
*dev
, struct sk_buff
*skb
)
1044 struct ip_tunnel_info
*info
= skb_tunnel_info(skb
);
1045 struct geneve_dev
*geneve
= netdev_priv(dev
);
1048 #if IS_ENABLED(CONFIG_IPV6)
1049 struct dst_entry
*dst
;
1053 if (ip_tunnel_info_af(info
) == AF_INET
) {
1054 rt
= geneve_get_v4_rt(skb
, dev
, &fl4
, info
);
1059 info
->key
.u
.ipv4
.src
= fl4
.saddr
;
1060 #if IS_ENABLED(CONFIG_IPV6)
1061 } else if (ip_tunnel_info_af(info
) == AF_INET6
) {
1062 dst
= geneve_get_v6_dst(skb
, dev
, &fl6
, info
);
1064 return PTR_ERR(dst
);
1067 info
->key
.u
.ipv6
.src
= fl6
.saddr
;
1073 info
->key
.tp_src
= udp_flow_src_port(geneve
->net
, skb
,
1074 1, USHRT_MAX
, true);
1075 info
->key
.tp_dst
= geneve
->dst_port
;
1079 static const struct net_device_ops geneve_netdev_ops
= {
1080 .ndo_init
= geneve_init
,
1081 .ndo_uninit
= geneve_uninit
,
1082 .ndo_open
= geneve_open
,
1083 .ndo_stop
= geneve_stop
,
1084 .ndo_start_xmit
= geneve_xmit
,
1085 .ndo_get_stats64
= ip_tunnel_get_stats64
,
1086 .ndo_change_mtu
= eth_change_mtu
,
1087 .ndo_validate_addr
= eth_validate_addr
,
1088 .ndo_set_mac_address
= eth_mac_addr
,
1089 .ndo_fill_metadata_dst
= geneve_fill_metadata_dst
,
1092 static void geneve_get_drvinfo(struct net_device
*dev
,
1093 struct ethtool_drvinfo
*drvinfo
)
1095 strlcpy(drvinfo
->version
, GENEVE_NETDEV_VER
, sizeof(drvinfo
->version
));
1096 strlcpy(drvinfo
->driver
, "geneve", sizeof(drvinfo
->driver
));
1099 static const struct ethtool_ops geneve_ethtool_ops
= {
1100 .get_drvinfo
= geneve_get_drvinfo
,
1101 .get_link
= ethtool_op_get_link
,
1104 /* Info for udev, that this is a virtual tunnel endpoint */
1105 static struct device_type geneve_type
= {
1109 /* Calls the ndo_add_geneve_port of the caller in order to
1110 * supply the listening GENEVE udp ports. Callers are expected
1111 * to implement the ndo_add_geneve_port.
1113 void geneve_get_rx_port(struct net_device
*dev
)
1115 struct net
*net
= dev_net(dev
);
1116 struct geneve_net
*gn
= net_generic(net
, geneve_net_id
);
1117 struct geneve_sock
*gs
;
1118 sa_family_t sa_family
;
1123 list_for_each_entry_rcu(gs
, &gn
->sock_list
, list
) {
1125 sa_family
= sk
->sk_family
;
1126 port
= inet_sk(sk
)->inet_sport
;
1127 dev
->netdev_ops
->ndo_add_geneve_port(dev
, sa_family
, port
);
1131 EXPORT_SYMBOL_GPL(geneve_get_rx_port
);
1133 /* Initialize the device structure. */
1134 static void geneve_setup(struct net_device
*dev
)
1138 dev
->netdev_ops
= &geneve_netdev_ops
;
1139 dev
->ethtool_ops
= &geneve_ethtool_ops
;
1140 dev
->destructor
= free_netdev
;
1142 SET_NETDEV_DEVTYPE(dev
, &geneve_type
);
1144 dev
->features
|= NETIF_F_LLTX
;
1145 dev
->features
|= NETIF_F_SG
| NETIF_F_HW_CSUM
;
1146 dev
->features
|= NETIF_F_RXCSUM
;
1147 dev
->features
|= NETIF_F_GSO_SOFTWARE
;
1149 dev
->hw_features
|= NETIF_F_SG
| NETIF_F_HW_CSUM
| NETIF_F_RXCSUM
;
1150 dev
->hw_features
|= NETIF_F_GSO_SOFTWARE
;
1152 netif_keep_dst(dev
);
1153 dev
->priv_flags
|= IFF_LIVE_ADDR_CHANGE
| IFF_NO_QUEUE
;
1154 eth_hw_addr_random(dev
);
1157 static const struct nla_policy geneve_policy
[IFLA_GENEVE_MAX
+ 1] = {
1158 [IFLA_GENEVE_ID
] = { .type
= NLA_U32
},
1159 [IFLA_GENEVE_REMOTE
] = { .len
= FIELD_SIZEOF(struct iphdr
, daddr
) },
1160 [IFLA_GENEVE_REMOTE6
] = { .len
= sizeof(struct in6_addr
) },
1161 [IFLA_GENEVE_TTL
] = { .type
= NLA_U8
},
1162 [IFLA_GENEVE_TOS
] = { .type
= NLA_U8
},
1163 [IFLA_GENEVE_PORT
] = { .type
= NLA_U16
},
1164 [IFLA_GENEVE_COLLECT_METADATA
] = { .type
= NLA_FLAG
},
1165 [IFLA_GENEVE_UDP_CSUM
] = { .type
= NLA_U8
},
1166 [IFLA_GENEVE_UDP_ZERO_CSUM6_TX
] = { .type
= NLA_U8
},
1167 [IFLA_GENEVE_UDP_ZERO_CSUM6_RX
] = { .type
= NLA_U8
},
1170 static int geneve_validate(struct nlattr
*tb
[], struct nlattr
*data
[])
1172 if (tb
[IFLA_ADDRESS
]) {
1173 if (nla_len(tb
[IFLA_ADDRESS
]) != ETH_ALEN
)
1176 if (!is_valid_ether_addr(nla_data(tb
[IFLA_ADDRESS
])))
1177 return -EADDRNOTAVAIL
;
1183 if (data
[IFLA_GENEVE_ID
]) {
1184 __u32 vni
= nla_get_u32(data
[IFLA_GENEVE_ID
]);
1186 if (vni
>= GENEVE_VID_MASK
)
1193 static struct geneve_dev
*geneve_find_dev(struct geneve_net
*gn
,
1195 union geneve_addr
*remote
,
1197 bool *tun_on_same_port
,
1198 bool *tun_collect_md
)
1200 struct geneve_dev
*geneve
, *t
;
1202 *tun_on_same_port
= false;
1203 *tun_collect_md
= false;
1205 list_for_each_entry(geneve
, &gn
->geneve_list
, next
) {
1206 if (geneve
->dst_port
== dst_port
) {
1207 *tun_collect_md
= geneve
->collect_md
;
1208 *tun_on_same_port
= true;
1210 if (!memcmp(vni
, geneve
->vni
, sizeof(geneve
->vni
)) &&
1211 !memcmp(remote
, &geneve
->remote
, sizeof(geneve
->remote
)) &&
1212 dst_port
== geneve
->dst_port
)
1218 static int geneve_configure(struct net
*net
, struct net_device
*dev
,
1219 union geneve_addr
*remote
,
1220 __u32 vni
, __u8 ttl
, __u8 tos
, __be16 dst_port
,
1221 bool metadata
, u32 flags
)
1223 struct geneve_net
*gn
= net_generic(net
, geneve_net_id
);
1224 struct geneve_dev
*t
, *geneve
= netdev_priv(dev
);
1225 bool tun_collect_md
, tun_on_same_port
;
1231 (remote
->sa
.sa_family
!= AF_UNSPEC
|| vni
|| tos
|| ttl
))
1237 geneve
->vni
[0] = (vni
& 0x00ff0000) >> 16;
1238 geneve
->vni
[1] = (vni
& 0x0000ff00) >> 8;
1239 geneve
->vni
[2] = vni
& 0x000000ff;
1241 if ((remote
->sa
.sa_family
== AF_INET
&&
1242 IN_MULTICAST(ntohl(remote
->sin
.sin_addr
.s_addr
))) ||
1243 (remote
->sa
.sa_family
== AF_INET6
&&
1244 ipv6_addr_is_multicast(&remote
->sin6
.sin6_addr
)))
1246 geneve
->remote
= *remote
;
1250 geneve
->dst_port
= dst_port
;
1251 geneve
->collect_md
= metadata
;
1252 geneve
->flags
= flags
;
1254 t
= geneve_find_dev(gn
, dst_port
, remote
, geneve
->vni
,
1255 &tun_on_same_port
, &tun_collect_md
);
1259 /* make enough headroom for basic scenario */
1260 encap_len
= GENEVE_BASE_HLEN
+ ETH_HLEN
;
1261 if (remote
->sa
.sa_family
== AF_INET
)
1262 encap_len
+= sizeof(struct iphdr
);
1264 encap_len
+= sizeof(struct ipv6hdr
);
1265 dev
->needed_headroom
= encap_len
+ ETH_HLEN
;
1268 if (tun_on_same_port
)
1275 err
= register_netdevice(dev
);
1279 list_add(&geneve
->next
, &gn
->geneve_list
);
1283 static int geneve_newlink(struct net
*net
, struct net_device
*dev
,
1284 struct nlattr
*tb
[], struct nlattr
*data
[])
1286 __be16 dst_port
= htons(GENEVE_UDP_PORT
);
1287 __u8 ttl
= 0, tos
= 0;
1288 bool metadata
= false;
1289 union geneve_addr remote
= geneve_remote_unspec
;
1293 if (data
[IFLA_GENEVE_REMOTE
] && data
[IFLA_GENEVE_REMOTE6
])
1296 if (data
[IFLA_GENEVE_REMOTE
]) {
1297 remote
.sa
.sa_family
= AF_INET
;
1298 remote
.sin
.sin_addr
.s_addr
=
1299 nla_get_in_addr(data
[IFLA_GENEVE_REMOTE
]);
1302 if (data
[IFLA_GENEVE_REMOTE6
]) {
1303 if (!IS_ENABLED(CONFIG_IPV6
))
1304 return -EPFNOSUPPORT
;
1306 remote
.sa
.sa_family
= AF_INET6
;
1307 remote
.sin6
.sin6_addr
=
1308 nla_get_in6_addr(data
[IFLA_GENEVE_REMOTE6
]);
1310 if (ipv6_addr_type(&remote
.sin6
.sin6_addr
) &
1311 IPV6_ADDR_LINKLOCAL
) {
1312 netdev_dbg(dev
, "link-local remote is unsupported\n");
1317 if (data
[IFLA_GENEVE_ID
])
1318 vni
= nla_get_u32(data
[IFLA_GENEVE_ID
]);
1320 if (data
[IFLA_GENEVE_TTL
])
1321 ttl
= nla_get_u8(data
[IFLA_GENEVE_TTL
]);
1323 if (data
[IFLA_GENEVE_TOS
])
1324 tos
= nla_get_u8(data
[IFLA_GENEVE_TOS
]);
1326 if (data
[IFLA_GENEVE_PORT
])
1327 dst_port
= nla_get_be16(data
[IFLA_GENEVE_PORT
]);
1329 if (data
[IFLA_GENEVE_COLLECT_METADATA
])
1332 if (data
[IFLA_GENEVE_UDP_CSUM
] &&
1333 nla_get_u8(data
[IFLA_GENEVE_UDP_CSUM
]))
1334 flags
|= GENEVE_F_UDP_CSUM
;
1336 if (data
[IFLA_GENEVE_UDP_ZERO_CSUM6_TX
] &&
1337 nla_get_u8(data
[IFLA_GENEVE_UDP_ZERO_CSUM6_TX
]))
1338 flags
|= GENEVE_F_UDP_ZERO_CSUM6_TX
;
1340 if (data
[IFLA_GENEVE_UDP_ZERO_CSUM6_RX
] &&
1341 nla_get_u8(data
[IFLA_GENEVE_UDP_ZERO_CSUM6_RX
]))
1342 flags
|= GENEVE_F_UDP_ZERO_CSUM6_RX
;
1344 return geneve_configure(net
, dev
, &remote
, vni
, ttl
, tos
, dst_port
,
1348 static void geneve_dellink(struct net_device
*dev
, struct list_head
*head
)
1350 struct geneve_dev
*geneve
= netdev_priv(dev
);
1352 list_del(&geneve
->next
);
1353 unregister_netdevice_queue(dev
, head
);
1356 static size_t geneve_get_size(const struct net_device
*dev
)
1358 return nla_total_size(sizeof(__u32
)) + /* IFLA_GENEVE_ID */
1359 nla_total_size(sizeof(struct in6_addr
)) + /* IFLA_GENEVE_REMOTE{6} */
1360 nla_total_size(sizeof(__u8
)) + /* IFLA_GENEVE_TTL */
1361 nla_total_size(sizeof(__u8
)) + /* IFLA_GENEVE_TOS */
1362 nla_total_size(sizeof(__be16
)) + /* IFLA_GENEVE_PORT */
1363 nla_total_size(0) + /* IFLA_GENEVE_COLLECT_METADATA */
1364 nla_total_size(sizeof(__u8
)) + /* IFLA_GENEVE_UDP_CSUM */
1365 nla_total_size(sizeof(__u8
)) + /* IFLA_GENEVE_UDP_ZERO_CSUM6_TX */
1366 nla_total_size(sizeof(__u8
)) + /* IFLA_GENEVE_UDP_ZERO_CSUM6_RX */
1370 static int geneve_fill_info(struct sk_buff
*skb
, const struct net_device
*dev
)
1372 struct geneve_dev
*geneve
= netdev_priv(dev
);
1375 vni
= (geneve
->vni
[0] << 16) | (geneve
->vni
[1] << 8) | geneve
->vni
[2];
1376 if (nla_put_u32(skb
, IFLA_GENEVE_ID
, vni
))
1377 goto nla_put_failure
;
1379 if (geneve
->remote
.sa
.sa_family
== AF_INET
) {
1380 if (nla_put_in_addr(skb
, IFLA_GENEVE_REMOTE
,
1381 geneve
->remote
.sin
.sin_addr
.s_addr
))
1382 goto nla_put_failure
;
1383 #if IS_ENABLED(CONFIG_IPV6)
1385 if (nla_put_in6_addr(skb
, IFLA_GENEVE_REMOTE6
,
1386 &geneve
->remote
.sin6
.sin6_addr
))
1387 goto nla_put_failure
;
1391 if (nla_put_u8(skb
, IFLA_GENEVE_TTL
, geneve
->ttl
) ||
1392 nla_put_u8(skb
, IFLA_GENEVE_TOS
, geneve
->tos
))
1393 goto nla_put_failure
;
1395 if (nla_put_be16(skb
, IFLA_GENEVE_PORT
, geneve
->dst_port
))
1396 goto nla_put_failure
;
1398 if (geneve
->collect_md
) {
1399 if (nla_put_flag(skb
, IFLA_GENEVE_COLLECT_METADATA
))
1400 goto nla_put_failure
;
1403 if (nla_put_u8(skb
, IFLA_GENEVE_UDP_CSUM
,
1404 !!(geneve
->flags
& GENEVE_F_UDP_CSUM
)) ||
1405 nla_put_u8(skb
, IFLA_GENEVE_UDP_ZERO_CSUM6_TX
,
1406 !!(geneve
->flags
& GENEVE_F_UDP_ZERO_CSUM6_TX
)) ||
1407 nla_put_u8(skb
, IFLA_GENEVE_UDP_ZERO_CSUM6_RX
,
1408 !!(geneve
->flags
& GENEVE_F_UDP_ZERO_CSUM6_RX
)))
1409 goto nla_put_failure
;
1417 static struct rtnl_link_ops geneve_link_ops __read_mostly
= {
1419 .maxtype
= IFLA_GENEVE_MAX
,
1420 .policy
= geneve_policy
,
1421 .priv_size
= sizeof(struct geneve_dev
),
1422 .setup
= geneve_setup
,
1423 .validate
= geneve_validate
,
1424 .newlink
= geneve_newlink
,
1425 .dellink
= geneve_dellink
,
1426 .get_size
= geneve_get_size
,
1427 .fill_info
= geneve_fill_info
,
1430 struct net_device
*geneve_dev_create_fb(struct net
*net
, const char *name
,
1431 u8 name_assign_type
, u16 dst_port
)
1433 struct nlattr
*tb
[IFLA_MAX
+ 1];
1434 struct net_device
*dev
;
1437 memset(tb
, 0, sizeof(tb
));
1438 dev
= rtnl_create_link(net
, name
, name_assign_type
,
1439 &geneve_link_ops
, tb
);
1443 err
= geneve_configure(net
, dev
, &geneve_remote_unspec
,
1444 0, 0, 0, htons(dst_port
), true, 0);
1447 return ERR_PTR(err
);
1451 EXPORT_SYMBOL_GPL(geneve_dev_create_fb
);
1453 static __net_init
int geneve_init_net(struct net
*net
)
1455 struct geneve_net
*gn
= net_generic(net
, geneve_net_id
);
1457 INIT_LIST_HEAD(&gn
->geneve_list
);
1458 INIT_LIST_HEAD(&gn
->sock_list
);
1462 static void __net_exit
geneve_exit_net(struct net
*net
)
1464 struct geneve_net
*gn
= net_generic(net
, geneve_net_id
);
1465 struct geneve_dev
*geneve
, *next
;
1466 struct net_device
*dev
, *aux
;
1471 /* gather any geneve devices that were moved into this ns */
1472 for_each_netdev_safe(net
, dev
, aux
)
1473 if (dev
->rtnl_link_ops
== &geneve_link_ops
)
1474 unregister_netdevice_queue(dev
, &list
);
1476 /* now gather any other geneve devices that were created in this ns */
1477 list_for_each_entry_safe(geneve
, next
, &gn
->geneve_list
, next
) {
1478 /* If geneve->dev is in the same netns, it was already added
1479 * to the list by the previous loop.
1481 if (!net_eq(dev_net(geneve
->dev
), net
))
1482 unregister_netdevice_queue(geneve
->dev
, &list
);
1485 /* unregister the devices gathered above */
1486 unregister_netdevice_many(&list
);
1490 static struct pernet_operations geneve_net_ops
= {
1491 .init
= geneve_init_net
,
1492 .exit
= geneve_exit_net
,
1493 .id
= &geneve_net_id
,
1494 .size
= sizeof(struct geneve_net
),
1497 static int __init
geneve_init_module(void)
1501 rc
= register_pernet_subsys(&geneve_net_ops
);
1505 rc
= rtnl_link_register(&geneve_link_ops
);
1511 unregister_pernet_subsys(&geneve_net_ops
);
1515 late_initcall(geneve_init_module
);
1517 static void __exit
geneve_cleanup_module(void)
1519 rtnl_link_unregister(&geneve_link_ops
);
1520 unregister_pernet_subsys(&geneve_net_ops
);
1522 module_exit(geneve_cleanup_module
);
1524 MODULE_LICENSE("GPL");
1525 MODULE_VERSION(GENEVE_NETDEV_VER
);
1526 MODULE_AUTHOR("John W. Linville <linville@tuxdriver.com>");
1527 MODULE_DESCRIPTION("Interface driver for GENEVE encapsulated traffic");
1528 MODULE_ALIAS_RTNL_LINK("geneve");