]> git.proxmox.com Git - mirror_ovs.git/blob - datapath/linux/compat/geneve.c
projects / mirror_ovs.git / blob
? search:


5b183963d637884902439a87a66598b687ffcee5
[mirror_ovs.git] / datapath / linux / compat / geneve.c
1 /*
2 * GENEVE: Generic Network Virtualization Encapsulation
3 *
4 * Copyright (c) 2015 Red Hat, Inc.
5 *
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.
9 */
10
11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12
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 <linux/if_link.h>
19 #include <linux/if_vlan.h>
20
21 #include <net/addrconf.h>
22 #include <net/dst_cache.h>
23 #include <net/dst_metadata.h>
24 #include <net/net_namespace.h>
25 #include <net/netns/generic.h>
26 #include <net/rtnetlink.h>
27 #include <net/geneve.h>
28 #include <net/protocol.h>
29 #include <net/udp_tunnel.h>
30 #include <net/ip6_route.h>
31 #if IS_ENABLED(CONFIG_IPV6)
32 #include <net/ipv6.h>
33 #include <net/addrconf.h>
34 #include <net/ip6_tunnel.h>
35 #include <net/ip6_checksum.h>
36 #endif
37
38
39 #include "gso.h"
40 #include "vport-netdev.h"
41 #include "compat.h"
42
43 #ifndef USE_UPSTREAM_TUNNEL
44
45 #define GENEVE_NETDEV_VER "0.6"
46
47 #define GENEVE_UDP_PORT 6081
48
49 #define GENEVE_N_VID (1u << 24)
50 #define GENEVE_VID_MASK (GENEVE_N_VID - 1)
51
52 #define VNI_HASH_BITS 10
53 #define VNI_HASH_SIZE (1<<VNI_HASH_BITS)
54
55 #define GENEVE_VER 0
56 #define GENEVE_BASE_HLEN (sizeof(struct udphdr) + sizeof(struct genevehdr))
57
58 /* per-network namespace private data for this module */
59 struct geneve_net {
60 struct list_head geneve_list;
61 struct list_head sock_list;
62 };
63
64 static int geneve_net_id;
65
66 union geneve_addr {
67 struct sockaddr_in sin;
68 struct sockaddr_in6 sin6;
69 struct sockaddr sa;
70 };
71
72 static union geneve_addr geneve_remote_unspec = { .sa.sa_family = AF_UNSPEC, };
73
74 /* Pseudo network device */
75 struct geneve_dev {
76 struct hlist_node hlist; /* vni hash table */
77 struct net *net; /* netns for packet i/o */
78 struct net_device *dev; /* netdev for geneve tunnel */
79 struct geneve_sock __rcu *sock4; /* IPv4 socket used for geneve tunnel */
80 #if IS_ENABLED(CONFIG_IPV6)
81 struct geneve_sock __rcu *sock6; /* IPv6 socket used for geneve tunnel */
82 #endif
83 u8 vni[3]; /* virtual network ID for tunnel */
84 u8 ttl; /* TTL override */
85 u8 tos; /* TOS override */
86 union geneve_addr remote; /* IP address for link partner */
87 struct list_head next; /* geneve's per namespace list */
88 __be32 label; /* IPv6 flowlabel override */
89 __be16 dst_port;
90 bool collect_md;
91 u32 flags;
92 struct dst_cache dst_cache;
93 };
94
95 /* Geneve device flags */
96 #define GENEVE_F_UDP_ZERO_CSUM_TX BIT(0)
97 #define GENEVE_F_UDP_ZERO_CSUM6_TX BIT(1)
98 #define GENEVE_F_UDP_ZERO_CSUM6_RX BIT(2)
99
100 struct geneve_sock {
101 bool collect_md;
102 struct list_head list;
103 struct socket *sock;
104 struct rcu_head rcu;
105 int refcnt;
106 struct hlist_head vni_list[VNI_HASH_SIZE];
107 u32 flags;
108 #ifdef HAVE_UDP_OFFLOAD
109 struct udp_offload udp_offloads;
110 #endif
111 };
112
113 static inline __u32 geneve_net_vni_hash(u8 vni[3])
114 {
115 __u32 vnid;
116
117 vnid = (vni[0] << 16) | (vni[1] << 8) | vni[2];
118 return hash_32(vnid, VNI_HASH_BITS);
119 }
120
121 static __be64 vni_to_tunnel_id(const __u8 *vni)
122 {
123 #ifdef __BIG_ENDIAN
124 return (vni[0] << 16) | (vni[1] << 8) | vni[2];
125 #else
126 return (__force __be64)(((__force u64)vni[0] << 40) |
127 ((__force u64)vni[1] << 48) |
128 ((__force u64)vni[2] << 56));
129 #endif
130 }
131
132 static sa_family_t geneve_get_sk_family(struct geneve_sock *gs)
133 {
134 return gs->sock->sk->sk_family;
135 }
136
137 static struct geneve_dev *geneve_lookup(struct geneve_sock *gs,
138 __be32 addr, u8 vni[])
139 {
140 struct hlist_head *vni_list_head;
141 struct geneve_dev *geneve;
142 __u32 hash;
143
144 /* Find the device for this VNI */
145 hash = geneve_net_vni_hash(vni);
146 vni_list_head = &gs->vni_list[hash];
147 hlist_for_each_entry_rcu(geneve, vni_list_head, hlist) {
148 if (!memcmp(vni, geneve->vni, sizeof(geneve->vni)) &&
149 addr == geneve->remote.sin.sin_addr.s_addr)
150 return geneve;
151 }
152 return NULL;
153 }
154
155 #if IS_ENABLED(CONFIG_IPV6)
156 static struct geneve_dev *geneve6_lookup(struct geneve_sock *gs,
157 struct in6_addr addr6, u8 vni[])
158 {
159 struct hlist_head *vni_list_head;
160 struct geneve_dev *geneve;
161 __u32 hash;
162
163 /* Find the device for this VNI */
164 hash = geneve_net_vni_hash(vni);
165 vni_list_head = &gs->vni_list[hash];
166 hlist_for_each_entry_rcu(geneve, vni_list_head, hlist) {
167 if (!memcmp(vni, geneve->vni, sizeof(geneve->vni)) &&
168 ipv6_addr_equal(&addr6, &geneve->remote.sin6.sin6_addr))
169 return geneve;
170 }
171 return NULL;
172 }
173 #endif
174
175 static inline struct genevehdr *geneve_hdr(const struct sk_buff *skb)
176 {
177 return (struct genevehdr *)(udp_hdr(skb) + 1);
178 }
179
180 static struct geneve_dev *geneve_lookup_skb(struct geneve_sock *gs,
181 struct sk_buff *skb)
182 {
183 u8 *vni;
184 __be32 addr;
185 static u8 zero_vni[3];
186 #if IS_ENABLED(CONFIG_IPV6)
187 static struct in6_addr zero_addr6;
188 #endif
189
190 if (geneve_get_sk_family(gs) == AF_INET) {
191 struct iphdr *iph;
192
193 iph = ip_hdr(skb); /* outer IP header... */
194
195 if (gs->collect_md) {
196 vni = zero_vni;
197 addr = 0;
198 } else {
199 vni = geneve_hdr(skb)->vni;
200 addr = iph->saddr;
201 }
202
203 return geneve_lookup(gs, addr, vni);
204 #if IS_ENABLED(CONFIG_IPV6)
205 } else if (geneve_get_sk_family(gs) == AF_INET6) {
206 struct ipv6hdr *ip6h;
207 struct in6_addr addr6;
208
209 ip6h = ipv6_hdr(skb); /* outer IPv6 header... */
210
211 if (gs->collect_md) {
212 vni = zero_vni;
213 addr6 = zero_addr6;
214 } else {
215 vni = geneve_hdr(skb)->vni;
216 addr6 = ip6h->saddr;
217 }
218
219 return geneve6_lookup(gs, addr6, vni);
220 #endif
221 }
222 return NULL;
223 }
224
225 /* geneve receive/decap routine */
226 static void geneve_rx(struct geneve_dev *geneve, struct geneve_sock *gs,
227 struct sk_buff *skb)
228 {
229 struct genevehdr *gnvh = geneve_hdr(skb);
230 struct metadata_dst *tun_dst = NULL;
231 struct pcpu_sw_netstats *stats;
232 int err = 0;
233 void *oiph;
234 union {
235 struct metadata_dst dst;
236 char buf[sizeof(struct metadata_dst) + 256];
237 } buf;
238
239 if (ip_tunnel_collect_metadata() || gs->collect_md) {
240 __be16 flags;
241
242 flags = TUNNEL_KEY | TUNNEL_GENEVE_OPT |
243 (gnvh->oam ? TUNNEL_OAM : 0) |
244 (gnvh->critical ? TUNNEL_CRIT_OPT : 0);
245
246 tun_dst = &buf.dst;
247 ovs_udp_tun_rx_dst(tun_dst,
248 skb, geneve_get_sk_family(gs), flags,
249 vni_to_tunnel_id(gnvh->vni),
250 gnvh->opt_len * 4);
251 if (!tun_dst)
252 goto drop;
253 /* Update tunnel dst according to Geneve options. */
254 ip_tunnel_info_opts_set(&tun_dst->u.tun_info,
255 gnvh->options, gnvh->opt_len * 4,
256 TUNNEL_GENEVE_OPT);
257 } else {
258 /* Drop packets w/ critical options,
259 * since we don't support any...
260 */
261 if (gnvh->critical)
262 goto drop;
263 }
264
265 skb_reset_mac_header(skb);
266 skb->protocol = eth_type_trans(skb, geneve->dev);
267 skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
268
269 if (tun_dst)
270 ovs_skb_dst_set(skb, &tun_dst->dst);
271
272 /* Ignore packet loops (and multicast echo) */
273 if (ether_addr_equal(eth_hdr(skb)->h_source, geneve->dev->dev_addr))
274 goto drop;
275
276 oiph = skb_network_header(skb);
277 skb_reset_network_header(skb);
278
279 if (geneve_get_sk_family(gs) == AF_INET)
280 err = IP_ECN_decapsulate(oiph, skb);
281 #if IS_ENABLED(CONFIG_IPV6)
282 else
283 err = IP6_ECN_decapsulate(oiph, skb);
284 #endif
285 if (unlikely(err > 1)) {
286 ++geneve->dev->stats.rx_frame_errors;
287 ++geneve->dev->stats.rx_errors;
288 goto drop;
289 }
290
291 stats = this_cpu_ptr(geneve->dev->tstats);
292 u64_stats_update_begin(&stats->syncp);
293 stats->rx_packets++;
294 stats->rx_bytes += skb->len;
295 u64_stats_update_end(&stats->syncp);
296
297 netdev_port_receive(skb, skb_tunnel_info(skb));
298 return;
299 drop:
300 /* Consume bad packet */
301 kfree_skb(skb);
302 }
303
304 /* Setup stats when device is created */
305 static int geneve_init(struct net_device *dev)
306 {
307 struct geneve_dev *geneve = netdev_priv(dev);
308 int err;
309
310 dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
311 if (!dev->tstats)
312 return -ENOMEM;
313
314 err = dst_cache_init(&geneve->dst_cache, GFP_KERNEL);
315 if (err) {
316 free_percpu(dev->tstats);
317 return err;
318 }
319
320 return 0;
321 }
322
323 static void geneve_uninit(struct net_device *dev)
324 {
325 struct geneve_dev *geneve = netdev_priv(dev);
326
327 dst_cache_destroy(&geneve->dst_cache);
328 free_percpu(dev->tstats);
329 }
330
331 /* Callback from net/ipv4/udp.c to receive packets */
332 static int geneve_udp_encap_recv(struct sock *sk, struct sk_buff *skb)
333 {
334 struct genevehdr *geneveh;
335 struct geneve_dev *geneve;
336 struct geneve_sock *gs;
337 int opts_len;
338
339 /* Need Geneve and inner Ethernet header to be present */
340 if (unlikely(!pskb_may_pull(skb, GENEVE_BASE_HLEN)))
341 goto drop;
342
343 /* Return packets with reserved bits set */
344 geneveh = geneve_hdr(skb);
345 if (unlikely(geneveh->ver != GENEVE_VER))
346 goto drop;
347
348 if (unlikely(geneveh->proto_type != htons(ETH_P_TEB)))
349 goto drop;
350
351 gs = rcu_dereference_sk_user_data(sk);
352 if (!gs)
353 goto drop;
354
355 #if IS_ENABLED(CONFIG_IPV6)
356 #ifdef OVS_CHECK_UDP_TUNNEL_ZERO_CSUM
357 if (geneve_get_sk_family(gs) == AF_INET6 &&
358 !udp_hdr(skb)->check &&
359 !(gs->flags & GENEVE_F_UDP_ZERO_CSUM6_RX)) {
360 udp6_csum_zero_error(skb);
361 goto drop;
362 }
363 #endif
364 #endif
365 geneve = geneve_lookup_skb(gs, skb);
366 if (!geneve)
367 goto drop;
368
369 opts_len = geneveh->opt_len * 4;
370 if (iptunnel_pull_header(skb, GENEVE_BASE_HLEN + opts_len,
371 htons(ETH_P_TEB),
372 !net_eq(geneve->net, dev_net(geneve->dev))))
373 goto drop;
374
375 geneve_rx(geneve, gs, skb);
376 return 0;
377
378 drop:
379 /* Consume bad packet */
380 kfree_skb(skb);
381 return 0;
382 }
383
384 static struct socket *geneve_create_sock(struct net *net, bool ipv6,
385 __be16 port, u32 flags)
386 {
387 struct socket *sock;
388 struct udp_port_cfg udp_conf;
389 int err;
390
391 memset(&udp_conf, 0, sizeof(udp_conf));
392
393 if (ipv6) {
394 udp_conf.family = AF_INET6;
395 udp_conf.ipv6_v6only = 1;
396 udp_conf.use_udp6_rx_checksums =
397 !(flags & GENEVE_F_UDP_ZERO_CSUM6_RX);
398 } else {
399 udp_conf.family = AF_INET;
400 udp_conf.local_ip.s_addr = htonl(INADDR_ANY);
401 }
402
403 udp_conf.local_udp_port = port;
404
405 /* Open UDP socket */
406 err = udp_sock_create(net, &udp_conf, &sock);
407 if (err < 0)
408 return ERR_PTR(err);
409
410 return sock;
411 }
412
413 static void geneve_notify_add_rx_port(struct geneve_sock *gs)
414 {
415 struct net_device *dev;
416 struct sock *sk = gs->sock->sk;
417 struct net *net = sock_net(sk);
418 sa_family_t sa_family = geneve_get_sk_family(gs);
419 int err;
420
421 if (sa_family == AF_INET) {
422 err = udp_add_offload(sock_net(sk), &gs->udp_offloads);
423 if (err)
424 pr_warn("geneve: udp_add_offload failed with status %d\n",
425 err);
426 }
427
428 rcu_read_lock();
429 for_each_netdev_rcu(net, dev) {
430 #ifdef HAVE_NDO_ADD_GENEVE_PORT
431 __be16 port = inet_sk(sk)->inet_sport;
432
433 if (dev->netdev_ops->ndo_add_geneve_port)
434 dev->netdev_ops->ndo_add_geneve_port(dev, sa_family,
435 port);
436 #elif defined(HAVE_NDO_UDP_TUNNEL_ADD)
437 struct udp_tunnel_info ti;
438 ti.type = UDP_TUNNEL_TYPE_GENEVE;
439 ti.sa_family = sa_family;
440 ti.port = inet_sk(sk)->inet_sport;
441
442 if (dev->netdev_ops->ndo_udp_tunnel_add)
443 dev->netdev_ops->ndo_udp_tunnel_add(dev, &ti);
444 #endif
445 }
446 rcu_read_unlock();
447 }
448
449 static void geneve_notify_del_rx_port(struct geneve_sock *gs)
450 {
451 struct net_device *dev;
452 struct sock *sk = gs->sock->sk;
453 struct net *net = sock_net(sk);
454 sa_family_t sa_family = geneve_get_sk_family(gs);
455
456 rcu_read_lock();
457 for_each_netdev_rcu(net, dev) {
458 #ifdef HAVE_NDO_ADD_GENEVE_PORT
459 __be16 port = inet_sk(sk)->inet_sport;
460
461 if (dev->netdev_ops->ndo_del_geneve_port)
462 dev->netdev_ops->ndo_del_geneve_port(dev, sa_family,
463 port);
464 #elif defined(HAVE_NDO_UDP_TUNNEL_ADD)
465 struct udp_tunnel_info ti;
466 ti.type = UDP_TUNNEL_TYPE_GENEVE;
467 ti.port = inet_sk(sk)->inet_sport;
468 ti.sa_family = sa_family;
469
470 if (dev->netdev_ops->ndo_udp_tunnel_del)
471 dev->netdev_ops->ndo_udp_tunnel_del(dev, &ti);
472 #endif
473 }
474
475 rcu_read_unlock();
476
477 if (sa_family == AF_INET)
478 udp_del_offload(&gs->udp_offloads);
479 }
480
481 #if defined(HAVE_UDP_OFFLOAD) || \
482 defined(HAVE_UDP_TUNNEL_SOCK_CFG_GRO_RECEIVE)
483
484 static int geneve_hlen(struct genevehdr *gh)
485 {
486 return sizeof(*gh) + gh->opt_len * 4;
487 }
488
489 #ifndef HAVE_UDP_OFFLOAD_ARG_UOFF
490 static struct sk_buff **geneve_gro_receive(struct sk_buff **head,
491 struct sk_buff *skb)
492 #else
493 static struct sk_buff **geneve_gro_receive(struct sk_buff **head,
494 struct sk_buff *skb,
495 struct udp_offload *uoff)
496 #endif
497 {
498 struct sk_buff *p, **pp = NULL;
499 struct genevehdr *gh, *gh2;
500 unsigned int hlen, gh_len, off_gnv;
501 const struct packet_offload *ptype;
502 __be16 type;
503 int flush = 1;
504
505 off_gnv = skb_gro_offset(skb);
506 hlen = off_gnv + sizeof(*gh);
507 gh = skb_gro_header_fast(skb, off_gnv);
508 if (skb_gro_header_hard(skb, hlen)) {
509 gh = skb_gro_header_slow(skb, hlen, off_gnv);
510 if (unlikely(!gh))
511 goto out;
512 }
513
514 if (gh->ver != GENEVE_VER || gh->oam)
515 goto out;
516 gh_len = geneve_hlen(gh);
517
518 hlen = off_gnv + gh_len;
519 if (skb_gro_header_hard(skb, hlen)) {
520 gh = skb_gro_header_slow(skb, hlen, off_gnv);
521 if (unlikely(!gh))
522 goto out;
523 }
524
525 for (p = *head; p; p = p->next) {
526 if (!NAPI_GRO_CB(p)->same_flow)
527 continue;
528
529 gh2 = (struct genevehdr *)(p->data + off_gnv);
530 if (gh->opt_len != gh2->opt_len ||
531 memcmp(gh, gh2, gh_len)) {
532 NAPI_GRO_CB(p)->same_flow = 0;
533 continue;
534 }
535 }
536
537 type = gh->proto_type;
538
539 rcu_read_lock();
540 ptype = gro_find_receive_by_type(type);
541 if (!ptype)
542 goto out_unlock;
543
544 skb_gro_pull(skb, gh_len);
545 skb_gro_postpull_rcsum(skb, gh, gh_len);
546 pp = ptype->callbacks.gro_receive(head, skb);
547 flush = 0;
548
549 out_unlock:
550 rcu_read_unlock();
551 out:
552 NAPI_GRO_CB(skb)->flush |= flush;
553
554 return pp;
555 }
556
557 #ifndef HAVE_UDP_OFFLOAD_ARG_UOFF
558 static int geneve_gro_complete(struct sk_buff *skb, int nhoff)
559 #else
560 static int geneve_gro_complete(struct sk_buff *skb, int nhoff,
561 struct udp_offload *uoff)
562 #endif
563 {
564 struct genevehdr *gh;
565 struct packet_offload *ptype;
566 __be16 type;
567 int gh_len;
568 int err = -ENOSYS;
569
570 udp_tunnel_gro_complete(skb, nhoff);
571
572 gh = (struct genevehdr *)(skb->data + nhoff);
573 gh_len = geneve_hlen(gh);
574 type = gh->proto_type;
575
576 rcu_read_lock();
577 ptype = gro_find_complete_by_type(type);
578 if (ptype)
579 err = ptype->callbacks.gro_complete(skb, nhoff + gh_len);
580
581 rcu_read_unlock();
582
583 skb_set_inner_mac_header(skb, nhoff + gh_len);
584 return err;
585 }
586 #endif
587
588 /* Create new listen socket if needed */
589 static struct geneve_sock *geneve_socket_create(struct net *net, __be16 port,
590 bool ipv6, u32 flags)
591 {
592 struct geneve_net *gn = net_generic(net, geneve_net_id);
593 struct geneve_sock *gs;
594 struct socket *sock;
595 struct udp_tunnel_sock_cfg tunnel_cfg;
596 int h;
597
598 gs = kzalloc(sizeof(*gs), GFP_KERNEL);
599 if (!gs)
600 return ERR_PTR(-ENOMEM);
601
602 sock = geneve_create_sock(net, ipv6, port, flags);
603 if (IS_ERR(sock)) {
604 kfree(gs);
605 return ERR_CAST(sock);
606 }
607
608 gs->sock = sock;
609 gs->refcnt = 1;
610 for (h = 0; h < VNI_HASH_SIZE; ++h)
611 INIT_HLIST_HEAD(&gs->vni_list[h]);
612
613 /* Initialize the geneve udp offloads structure */
614 #ifdef HAVE_UDP_OFFLOAD
615 gs->udp_offloads.port = port;
616 gs->udp_offloads.callbacks.gro_receive = geneve_gro_receive;
617 gs->udp_offloads.callbacks.gro_complete = geneve_gro_complete;
618 #endif
619
620 geneve_notify_add_rx_port(gs);
621 /* Mark socket as an encapsulation socket */
622 memset(&tunnel_cfg, 0, sizeof(tunnel_cfg));
623 tunnel_cfg.sk_user_data = gs;
624 tunnel_cfg.encap_type = 1;
625 #ifdef HAVE_UDP_TUNNEL_SOCK_CFG_GRO_RECEIVE
626 tunnel_cfg.gro_receive = geneve_gro_receive;
627 tunnel_cfg.gro_complete = geneve_gro_complete;
628 #endif
629 tunnel_cfg.encap_rcv = geneve_udp_encap_recv;
630 tunnel_cfg.encap_destroy = NULL;
631 setup_udp_tunnel_sock(net, sock, &tunnel_cfg);
632 list_add(&gs->list, &gn->sock_list);
633 return gs;
634 }
635
636 static void __geneve_sock_release(struct geneve_sock *gs)
637 {
638 if (!gs || --gs->refcnt)
639 return;
640
641 list_del(&gs->list);
642 geneve_notify_del_rx_port(gs);
643 udp_tunnel_sock_release(gs->sock);
644 kfree_rcu(gs, rcu);
645 }
646
647 static void geneve_sock_release(struct geneve_dev *geneve)
648 {
649 struct geneve_sock *gs4 = rtnl_dereference(geneve->sock4);
650 #if IS_ENABLED(CONFIG_IPV6)
651 struct geneve_sock *gs6 = rtnl_dereference(geneve->sock6);
652
653 rcu_assign_pointer(geneve->sock6, NULL);
654 #endif
655
656 rcu_assign_pointer(geneve->sock4, NULL);
657 synchronize_net();
658
659 __geneve_sock_release(gs4);
660 #if IS_ENABLED(CONFIG_IPV6)
661 __geneve_sock_release(gs6);
662 #endif
663 }
664
665 static struct geneve_sock *geneve_find_sock(struct geneve_net *gn,
666 sa_family_t family,
667 __be16 dst_port)
668 {
669 struct geneve_sock *gs;
670
671 list_for_each_entry(gs, &gn->sock_list, list) {
672 if (inet_sk(gs->sock->sk)->inet_sport == dst_port &&
673 geneve_get_sk_family(gs) == family) {
674 return gs;
675 }
676 }
677 return NULL;
678 }
679
680 static int geneve_sock_add(struct geneve_dev *geneve, bool ipv6)
681 {
682 struct net *net = geneve->net;
683 struct geneve_net *gn = net_generic(net, geneve_net_id);
684 struct geneve_sock *gs;
685 __u32 hash;
686
687 gs = geneve_find_sock(gn, ipv6 ? AF_INET6 : AF_INET, geneve->dst_port);
688 if (gs) {
689 gs->refcnt++;
690 goto out;
691 }
692
693 gs = geneve_socket_create(net, geneve->dst_port, ipv6, geneve->flags);
694 if (IS_ERR(gs))
695 return PTR_ERR(gs);
696
697 out:
698 gs->collect_md = geneve->collect_md;
699 gs->flags = geneve->flags;
700 #if IS_ENABLED(CONFIG_IPV6)
701 if (ipv6)
702 rcu_assign_pointer(geneve->sock6, gs);
703 else
704 #endif
705 rcu_assign_pointer(geneve->sock4, gs);
706
707 hash = geneve_net_vni_hash(geneve->vni);
708 hlist_add_head_rcu(&geneve->hlist, &gs->vni_list[hash]);
709 return 0;
710 }
711
712 static int geneve_open(struct net_device *dev)
713 {
714 struct geneve_dev *geneve = netdev_priv(dev);
715 bool ipv6 = geneve->remote.sa.sa_family == AF_INET6;
716 bool metadata = geneve->collect_md;
717 int ret = 0;
718
719 #if IS_ENABLED(CONFIG_IPV6)
720 if (ipv6 || metadata)
721 ret = geneve_sock_add(geneve, true);
722 #endif
723
724 if (!ret && (!ipv6 || metadata))
725 ret = geneve_sock_add(geneve, false);
726 if (ret < 0)
727 geneve_sock_release(geneve);
728
729 return ret;
730 }
731
732 static int geneve_stop(struct net_device *dev)
733 {
734 struct geneve_dev *geneve = netdev_priv(dev);
735
736 if (!hlist_unhashed(&geneve->hlist))
737 hlist_del_rcu(&geneve->hlist);
738 geneve_sock_release(geneve);
739 return 0;
740 }
741
742 static void geneve_build_header(struct genevehdr *geneveh,
743 __be16 tun_flags, u8 vni[3],
744 u8 options_len, u8 *options)
745 {
746 geneveh->ver = GENEVE_VER;
747 geneveh->opt_len = options_len / 4;
748 geneveh->oam = !!(tun_flags & TUNNEL_OAM);
749 geneveh->critical = !!(tun_flags & TUNNEL_CRIT_OPT);
750 geneveh->rsvd1 = 0;
751 memcpy(geneveh->vni, vni, 3);
752 geneveh->proto_type = htons(ETH_P_TEB);
753 geneveh->rsvd2 = 0;
754
755 memcpy(geneveh->options, options, options_len);
756 }
757
758 static int push_vlan_tag(struct sk_buff *skb)
759 {
760 if (skb_vlan_tag_present(skb)) {
761 __be16 vlan_proto = skb->vlan_proto;
762 int err;
763
764 err = __vlan_insert_tag(skb, skb->vlan_proto,
765 skb_vlan_tag_get(skb));
766
767 if (unlikely(err))
768 return err;
769 skb->vlan_tci = 0;
770 skb->protocol = vlan_proto;
771 }
772 return 0;
773 }
774
775 static int geneve_build_skb(struct rtable *rt, struct sk_buff *skb,
776 __be16 tun_flags, u8 vni[3], u8 opt_len, u8 *opt,
777 u32 flags, bool xnet)
778 {
779 struct genevehdr *gnvh;
780 int min_headroom;
781 int err;
782 bool udp_sum = !(flags & GENEVE_F_UDP_ZERO_CSUM_TX);
783
784 skb_scrub_packet(skb, xnet);
785
786 min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len
787 + GENEVE_BASE_HLEN + opt_len + sizeof(struct iphdr)
788 + (skb_vlan_tag_present(skb) ? VLAN_HLEN : 0);
789
790 err = skb_cow_head(skb, min_headroom);
791 if (unlikely(err))
792 goto free_rt;
793
794 err = push_vlan_tag(skb);
795 if (unlikely(err))
796 goto free_rt;
797
798 err = udp_tunnel_handle_offloads(skb, udp_sum);
799 if (err)
800 goto free_rt;
801
802 gnvh = (struct genevehdr *)__skb_push(skb, sizeof(*gnvh) + opt_len);
803 geneve_build_header(gnvh, tun_flags, vni, opt_len, opt);
804
805 ovs_skb_set_inner_protocol(skb, htons(ETH_P_TEB));
806 return 0;
807
808 free_rt:
809 ip_rt_put(rt);
810 return err;
811 }
812
813 #if IS_ENABLED(CONFIG_IPV6)
814 static int geneve6_build_skb(struct dst_entry *dst, struct sk_buff *skb,
815 __be16 tun_flags, u8 vni[3], u8 opt_len, u8 *opt,
816 u32 flags, bool xnet)
817 {
818 struct genevehdr *gnvh;
819 int min_headroom;
820 int err;
821 bool udp_sum = !(flags & GENEVE_F_UDP_ZERO_CSUM6_TX);
822
823 skb_scrub_packet(skb, xnet);
824
825 min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len
826 + GENEVE_BASE_HLEN + opt_len + sizeof(struct ipv6hdr)
827 + (skb_vlan_tag_present(skb) ? VLAN_HLEN : 0);
828
829 err = skb_cow_head(skb, min_headroom);
830 if (unlikely(err))
831 goto free_dst;
832
833 err = push_vlan_tag(skb);
834 if (unlikely(err))
835 goto free_dst;
836
837 err = udp_tunnel_handle_offloads(skb, udp_sum);
838 if (err)
839 goto free_dst;
840
841 gnvh = (struct genevehdr *)__skb_push(skb, sizeof(*gnvh) + opt_len);
842 geneve_build_header(gnvh, tun_flags, vni, opt_len, opt);
843
844 ovs_skb_set_inner_protocol(skb, htons(ETH_P_TEB));
845 return 0;
846
847 free_dst:
848 dst_release(dst);
849 return err;
850 }
851 #endif
852
853 static struct rtable *geneve_get_v4_rt(struct sk_buff *skb,
854 struct net_device *dev,
855 struct flowi4 *fl4,
856 struct ip_tunnel_info *info,
857 __be16 dport, __be16 sport)
858 {
859 bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
860 struct geneve_dev *geneve = netdev_priv(dev);
861 struct dst_cache *dst_cache;
862 struct rtable *rt = NULL;
863 __u8 tos;
864
865 if (!rcu_dereference(geneve->sock4))
866 return ERR_PTR(-EIO);
867
868 memset(fl4, 0, sizeof(*fl4));
869 fl4->flowi4_mark = skb->mark;
870 fl4->flowi4_proto = IPPROTO_UDP;
871 fl4->fl4_dport = dport;
872 fl4->fl4_sport = sport;
873
874 if (info) {
875 fl4->daddr = info->key.u.ipv4.dst;
876 fl4->saddr = info->key.u.ipv4.src;
877 fl4->flowi4_tos = RT_TOS(info->key.tos);
878 dst_cache = &info->dst_cache;
879 } else {
880 tos = geneve->tos;
881 if (tos == 1) {
882 const struct iphdr *iip = ip_hdr(skb);
883
884 tos = ip_tunnel_get_dsfield(iip, skb);
885 use_cache = false;
886 }
887
888 fl4->flowi4_tos = RT_TOS(tos);
889 fl4->daddr = geneve->remote.sin.sin_addr.s_addr;
890 dst_cache = &geneve->dst_cache;
891 }
892
893 if (use_cache) {
894 rt = dst_cache_get_ip4(dst_cache, &fl4->saddr);
895 if (rt)
896 return rt;
897 }
898
899 rt = ip_route_output_key(geneve->net, fl4);
900 if (IS_ERR(rt)) {
901 netdev_dbg(dev, "no route to %pI4\n", &fl4->daddr);
902 return ERR_PTR(-ENETUNREACH);
903 }
904 if (rt->dst.dev == dev) { /* is this necessary? */
905 netdev_dbg(dev, "circular route to %pI4\n", &fl4->daddr);
906 ip_rt_put(rt);
907 return ERR_PTR(-ELOOP);
908 }
909 if (use_cache)
910 dst_cache_set_ip4(dst_cache, &rt->dst, fl4->saddr);
911 return rt;
912 }
913
914 #if IS_ENABLED(CONFIG_IPV6)
915 static struct dst_entry *geneve_get_v6_dst(struct sk_buff *skb,
916 struct net_device *dev,
917 struct flowi6 *fl6,
918 struct ip_tunnel_info *info,
919 __be16 dport, __be16 sport)
920 {
921 bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
922 struct geneve_dev *geneve = netdev_priv(dev);
923 struct dst_entry *dst = NULL;
924 struct dst_cache *dst_cache;
925 struct geneve_sock *gs6;
926 __u8 prio;
927
928 gs6 = rcu_dereference(geneve->sock6);
929 if (!gs6)
930 return ERR_PTR(-EIO);
931
932 memset(fl6, 0, sizeof(*fl6));
933 fl6->flowi6_mark = skb->mark;
934 fl6->flowi6_proto = IPPROTO_UDP;
935 fl6->fl6_dport = dport;
936 fl6->fl6_sport = sport;
937
938 if (info) {
939 fl6->daddr = info->key.u.ipv6.dst;
940 fl6->saddr = info->key.u.ipv6.src;
941 fl6->flowlabel = ip6_make_flowinfo(RT_TOS(info->key.tos),
942 info->key.label);
943 dst_cache = &info->dst_cache;
944 } else {
945 prio = geneve->tos;
946 if (prio == 1) {
947 const struct iphdr *iip = ip_hdr(skb);
948
949 prio = ip_tunnel_get_dsfield(iip, skb);
950 use_cache = false;
951 }
952
953 fl6->flowlabel = ip6_make_flowinfo(RT_TOS(prio),
954 geneve->label);
955 fl6->daddr = geneve->remote.sin6.sin6_addr;
956 dst_cache = &geneve->dst_cache;
957 }
958
959 if (use_cache) {
960 dst = dst_cache_get_ip6(dst_cache, &fl6->saddr);
961 if (dst)
962 return dst;
963 }
964
965 #ifdef HAVE_IPV6_DST_LOOKUP_NET
966 if (ipv6_stub->ipv6_dst_lookup(geneve->net, gs6->sock->sk, &dst, fl6)) {
967 #else
968 #ifdef HAVE_IPV6_STUB
969 if (ipv6_stub->ipv6_dst_lookup(gs6->sock->sk, &dst, fl6)) {
970 #else
971 if (ip6_dst_lookup(gs6->sock->sk, &dst, fl6)) {
972 #endif
973 #endif
974 netdev_dbg(dev, "no route to %pI6\n", &fl6->daddr);
975 return ERR_PTR(-ENETUNREACH);
976 }
977 if (dst->dev == dev) { /* is this necessary? */
978 netdev_dbg(dev, "circular route to %pI6\n", &fl6->daddr);
979 dst_release(dst);
980 return ERR_PTR(-ELOOP);
981 }
982
983 if (use_cache)
984 dst_cache_set_ip6(dst_cache, dst, &fl6->saddr);
985 return dst;
986 }
987 #endif
988
989 /* Convert 64 bit tunnel ID to 24 bit VNI. */
990 static void tunnel_id_to_vni(__be64 tun_id, __u8 *vni)
991 {
992 #ifdef __BIG_ENDIAN
993 vni[0] = (__force __u8)(tun_id >> 16);
994 vni[1] = (__force __u8)(tun_id >> 8);
995 vni[2] = (__force __u8)tun_id;
996 #else
997 vni[0] = (__force __u8)((__force u64)tun_id >> 40);
998 vni[1] = (__force __u8)((__force u64)tun_id >> 48);
999 vni[2] = (__force __u8)((__force u64)tun_id >> 56);
1000 #endif
1001 }
1002
1003 static netdev_tx_t geneve_xmit_skb(struct sk_buff *skb, struct net_device *dev,
1004 struct ip_tunnel_info *info)
1005 {
1006 struct geneve_dev *geneve = netdev_priv(dev);
1007 struct geneve_sock *gs4;
1008 struct rtable *rt = NULL;
1009 const struct iphdr *iip; /* interior IP header */
1010 int err = -EINVAL;
1011 struct flowi4 fl4;
1012 __u8 tos, ttl;
1013 __be16 sport;
1014 __be16 df;
1015 bool xnet = !net_eq(geneve->net, dev_net(geneve->dev));
1016 u32 flags = geneve->flags;
1017
1018 gs4 = rcu_dereference(geneve->sock4);
1019 if (!gs4)
1020 goto tx_error;
1021
1022 if (geneve->collect_md) {
1023 if (unlikely(!info || !(info->mode & IP_TUNNEL_INFO_TX))) {
1024 netdev_dbg(dev, "no tunnel metadata\n");
1025 goto tx_error;
1026 }
1027 if (info && ip_tunnel_info_af(info) != AF_INET)
1028 goto tx_error;
1029 }
1030
1031 sport = udp_flow_src_port(geneve->net, skb, 1, USHRT_MAX, true);
1032 rt = geneve_get_v4_rt(skb, dev, &fl4, info, geneve->dst_port, sport);
1033 if (IS_ERR(rt)) {
1034 err = PTR_ERR(rt);
1035 goto tx_error;
1036 }
1037
1038 skb_reset_mac_header(skb);
1039
1040 iip = ip_hdr(skb);
1041
1042 if (info) {
1043 const struct ip_tunnel_key *key = &info->key;
1044 u8 *opts = NULL;
1045 u8 vni[3];
1046
1047 tunnel_id_to_vni(key->tun_id, vni);
1048 if (info->options_len)
1049 opts = ip_tunnel_info_opts(info);
1050
1051 if (key->tun_flags & TUNNEL_CSUM)
1052 flags &= ~GENEVE_F_UDP_ZERO_CSUM_TX;
1053 else
1054 flags |= GENEVE_F_UDP_ZERO_CSUM_TX;
1055
1056 err = geneve_build_skb(rt, skb, key->tun_flags, vni,
1057 info->options_len, opts, flags, xnet);
1058 if (unlikely(err))
1059 goto tx_error;
1060
1061 tos = ip_tunnel_ecn_encap(key->tos, iip, skb);
1062 ttl = key->ttl;
1063 df = key->tun_flags & TUNNEL_DONT_FRAGMENT ? htons(IP_DF) : 0;
1064 } else {
1065 err = geneve_build_skb(rt, skb, 0, geneve->vni,
1066 0, NULL, flags, xnet);
1067 if (unlikely(err))
1068 goto tx_error;
1069
1070 tos = ip_tunnel_ecn_encap(fl4.flowi4_tos, iip, skb);
1071 ttl = geneve->ttl;
1072 if (!ttl && IN_MULTICAST(ntohl(fl4.daddr)))
1073 ttl = 1;
1074 ttl = ttl ? : ip4_dst_hoplimit(&rt->dst);
1075 df = 0;
1076 }
1077 udp_tunnel_xmit_skb(rt, gs4->sock->sk, skb, fl4.saddr, fl4.daddr,
1078 tos, ttl, df, sport, geneve->dst_port,
1079 !net_eq(geneve->net, dev_net(geneve->dev)),
1080 !!(flags & GENEVE_F_UDP_ZERO_CSUM_TX));
1081
1082 return NETDEV_TX_OK;
1083
1084 tx_error:
1085 dev_kfree_skb(skb);
1086
1087 if (err == -ELOOP)
1088 dev->stats.collisions++;
1089 else if (err == -ENETUNREACH)
1090 dev->stats.tx_carrier_errors++;
1091
1092 dev->stats.tx_errors++;
1093 return NETDEV_TX_OK;
1094 }
1095
1096 #if IS_ENABLED(CONFIG_IPV6)
1097 static netdev_tx_t geneve6_xmit_skb(struct sk_buff *skb, struct net_device *dev,
1098 struct ip_tunnel_info *info)
1099 {
1100 struct geneve_dev *geneve = netdev_priv(dev);
1101 struct dst_entry *dst = NULL;
1102 const struct iphdr *iip; /* interior IP header */
1103 struct geneve_sock *gs6;
1104 int err = -EINVAL;
1105 struct flowi6 fl6;
1106 __u8 prio, ttl;
1107 __be16 sport;
1108 __be32 label;
1109 bool xnet = !net_eq(geneve->net, dev_net(geneve->dev));
1110 u32 flags = geneve->flags;
1111
1112 gs6 = rcu_dereference(geneve->sock6);
1113 if (!gs6)
1114 goto tx_error;
1115
1116 if (geneve->collect_md) {
1117 if (unlikely(!info || !(info->mode & IP_TUNNEL_INFO_TX))) {
1118 netdev_dbg(dev, "no tunnel metadata\n");
1119 goto tx_error;
1120 }
1121 }
1122
1123 sport = udp_flow_src_port(geneve->net, skb, 1, USHRT_MAX, true);
1124 dst = geneve_get_v6_dst(skb, dev, &fl6, info, geneve->dst_port, sport);
1125 if (IS_ERR(dst)) {
1126 err = PTR_ERR(dst);
1127 goto tx_error;
1128 }
1129
1130 skb_reset_mac_header(skb);
1131
1132 iip = ip_hdr(skb);
1133
1134 if (info) {
1135 const struct ip_tunnel_key *key = &info->key;
1136 u8 *opts = NULL;
1137 u8 vni[3];
1138
1139 tunnel_id_to_vni(key->tun_id, vni);
1140 if (info->options_len)
1141 opts = ip_tunnel_info_opts(info);
1142
1143 if (key->tun_flags & TUNNEL_CSUM)
1144 flags &= ~GENEVE_F_UDP_ZERO_CSUM6_TX;
1145 else
1146 flags |= GENEVE_F_UDP_ZERO_CSUM6_TX;
1147
1148 err = geneve6_build_skb(dst, skb, key->tun_flags, vni,
1149 info->options_len, opts,
1150 flags, xnet);
1151 if (unlikely(err))
1152 goto tx_error;
1153
1154 prio = ip_tunnel_ecn_encap(key->tos, iip, skb);
1155 ttl = key->ttl;
1156 label = info->key.label;
1157 } else {
1158 err = geneve6_build_skb(dst, skb, 0, geneve->vni,
1159 0, NULL, flags, xnet);
1160 if (unlikely(err))
1161 goto tx_error;
1162
1163 prio = ip_tunnel_ecn_encap(ip6_tclass(fl6.flowlabel),
1164 iip, skb);
1165 ttl = geneve->ttl;
1166 if (!ttl && ipv6_addr_is_multicast(&fl6.daddr))
1167 ttl = 1;
1168 ttl = ttl ? : ip6_dst_hoplimit(dst);
1169 label = geneve->label;
1170 }
1171 udp_tunnel6_xmit_skb(dst, gs6->sock->sk, skb, dev,
1172 &fl6.saddr, &fl6.daddr, prio, ttl, label,
1173 sport, geneve->dst_port,
1174 !!(flags & GENEVE_F_UDP_ZERO_CSUM6_TX));
1175 return NETDEV_TX_OK;
1176
1177 tx_error:
1178 dev_kfree_skb(skb);
1179
1180 if (err == -ELOOP)
1181 dev->stats.collisions++;
1182 else if (err == -ENETUNREACH)
1183 dev->stats.tx_carrier_errors++;
1184
1185 dev->stats.tx_errors++;
1186 return NETDEV_TX_OK;
1187 }
1188 #endif
1189
1190 netdev_tx_t rpl_geneve_xmit(struct sk_buff *skb)
1191 {
1192 struct net_device *dev = skb->dev;
1193 struct geneve_dev *geneve = netdev_priv(dev);
1194 struct ip_tunnel_info *info = NULL;
1195
1196 if (geneve->collect_md)
1197 info = skb_tunnel_info(skb);
1198
1199 #if IS_ENABLED(CONFIG_IPV6)
1200 if ((info && ip_tunnel_info_af(info) == AF_INET6) ||
1201 (!info && geneve->remote.sa.sa_family == AF_INET6))
1202 return geneve6_xmit_skb(skb, dev, info);
1203 #endif
1204 return geneve_xmit_skb(skb, dev, info);
1205 }
1206 EXPORT_SYMBOL_GPL(rpl_geneve_xmit);
1207
1208 static netdev_tx_t geneve_dev_xmit(struct sk_buff *skb, struct net_device *dev)
1209 {
1210 /* Drop All packets coming from networking stack. OVS-CB is
1211 * not initialized for these packets.
1212 */
1213
1214 dev_kfree_skb(skb);
1215 dev->stats.tx_dropped++;
1216 return NETDEV_TX_OK;
1217 }
1218
1219 static int __geneve_change_mtu(struct net_device *dev, int new_mtu, bool strict)
1220 {
1221 struct geneve_dev *geneve = netdev_priv(dev);
1222 /* The max_mtu calculation does not take account of GENEVE
1223 * options, to avoid excluding potentially valid
1224 * configurations.
1225 */
1226 int max_mtu = IP_MAX_MTU - GENEVE_BASE_HLEN - dev->hard_header_len;
1227
1228 if (geneve->remote.sa.sa_family == AF_INET6)
1229 max_mtu -= sizeof(struct ipv6hdr);
1230 else
1231 max_mtu -= sizeof(struct iphdr);
1232
1233 if (new_mtu < 68)
1234 return -EINVAL;
1235
1236 if (new_mtu > max_mtu) {
1237 if (strict)
1238 return -EINVAL;
1239
1240 new_mtu = max_mtu;
1241 }
1242
1243 dev->mtu = new_mtu;
1244 return 0;
1245 }
1246
1247 static int geneve_change_mtu(struct net_device *dev, int new_mtu)
1248 {
1249 return __geneve_change_mtu(dev, new_mtu, true);
1250 }
1251
1252 int ovs_geneve_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
1253 {
1254 struct ip_tunnel_info *info = skb_tunnel_info(skb);
1255 struct geneve_dev *geneve = netdev_priv(dev);
1256 struct rtable *rt;
1257 struct flowi4 fl4;
1258 __be16 sport;
1259 #if IS_ENABLED(CONFIG_IPV6)
1260 struct dst_entry *dst;
1261 struct flowi6 fl6;
1262 #endif
1263
1264 sport = udp_flow_src_port(geneve->net, skb,
1265 1, USHRT_MAX, true);
1266
1267 if (ip_tunnel_info_af(info) == AF_INET) {
1268 rt = geneve_get_v4_rt(skb, dev, &fl4, info, geneve->dst_port, sport);
1269 if (IS_ERR(rt))
1270 return PTR_ERR(rt);
1271
1272 ip_rt_put(rt);
1273 info->key.u.ipv4.src = fl4.saddr;
1274 #if IS_ENABLED(CONFIG_IPV6)
1275 } else if (ip_tunnel_info_af(info) == AF_INET6) {
1276 dst = geneve_get_v6_dst(skb, dev, &fl6, info, geneve->dst_port, sport);
1277 if (IS_ERR(dst))
1278 return PTR_ERR(dst);
1279
1280 dst_release(dst);
1281 info->key.u.ipv6.src = fl6.saddr;
1282 #endif
1283 } else {
1284 return -EINVAL;
1285 }
1286
1287 info->key.tp_src = sport;
1288 info->key.tp_dst = geneve->dst_port;
1289 return 0;
1290 }
1291 EXPORT_SYMBOL_GPL(ovs_geneve_fill_metadata_dst);
1292
1293 static const struct net_device_ops geneve_netdev_ops = {
1294 .ndo_init = geneve_init,
1295 .ndo_uninit = geneve_uninit,
1296 .ndo_open = geneve_open,
1297 .ndo_stop = geneve_stop,
1298 .ndo_start_xmit = geneve_dev_xmit,
1299 .ndo_get_stats64 = ip_tunnel_get_stats64,
1300 #ifdef HAVE_RHEL7_MAX_MTU
1301 .ndo_size = sizeof(struct net_device_ops),
1302 .extended.ndo_change_mtu = geneve_change_mtu,
1303 #else
1304 .ndo_change_mtu = geneve_change_mtu,
1305 #endif
1306 .ndo_validate_addr = eth_validate_addr,
1307 .ndo_set_mac_address = eth_mac_addr,
1308 #ifdef HAVE_NDO_FILL_METADATA_DST
1309 .ndo_fill_metadata_dst = geneve_fill_metadata_dst,
1310 #endif
1311 };
1312
1313 static void geneve_get_drvinfo(struct net_device *dev,
1314 struct ethtool_drvinfo *drvinfo)
1315 {
1316 strlcpy(drvinfo->version, GENEVE_NETDEV_VER, sizeof(drvinfo->version));
1317 strlcpy(drvinfo->driver, "geneve", sizeof(drvinfo->driver));
1318 }
1319
1320 static const struct ethtool_ops geneve_ethtool_ops = {
1321 .get_drvinfo = geneve_get_drvinfo,
1322 .get_link = ethtool_op_get_link,
1323 };
1324
1325 /* Info for udev, that this is a virtual tunnel endpoint */
1326 static struct device_type geneve_type = {
1327 .name = "geneve",
1328 };
1329
1330 /* Calls the ndo_add_geneve_port or ndo_udp_tunnel_add of the caller
1331 * in order to supply the listening GENEVE udp ports. Callers are
1332 * expected to implement the ndo_add_geneve_port.
1333 */
1334 static void geneve_push_rx_ports(struct net_device *dev)
1335 {
1336 #ifdef HAVE_NDO_ADD_GENEVE_PORT
1337 struct net *net = dev_net(dev);
1338 struct geneve_net *gn = net_generic(net, geneve_net_id);
1339 struct geneve_sock *gs;
1340 sa_family_t sa_family;
1341 struct sock *sk;
1342 __be16 port;
1343
1344 if (!dev->netdev_ops->ndo_add_geneve_port)
1345 return;
1346
1347 rcu_read_lock();
1348 list_for_each_entry_rcu(gs, &gn->sock_list, list) {
1349 sk = gs->sock->sk;
1350 sa_family = sk->sk_family;
1351 port = inet_sk(sk)->inet_sport;
1352 dev->netdev_ops->ndo_add_geneve_port(dev, sa_family, port);
1353 }
1354 rcu_read_unlock();
1355 #elif defined(HAVE_NDO_UDP_TUNNEL_ADD)
1356 struct net *net = dev_net(dev);
1357 struct geneve_net *gn = net_generic(net, geneve_net_id);
1358 struct geneve_sock *gs;
1359 struct sock *sk;
1360
1361 if (!dev->netdev_ops->ndo_udp_tunnel_add)
1362 return;
1363
1364 rcu_read_lock();
1365 list_for_each_entry_rcu(gs, &gn->sock_list, list) {
1366 struct udp_tunnel_info ti;
1367 ti.type = UDP_TUNNEL_TYPE_GENEVE;
1368 sk = gs->sock->sk;
1369 ti.port = inet_sk(sk)->inet_sport;
1370 ti.sa_family = sk->sk_family;
1371 dev->netdev_ops->ndo_udp_tunnel_add(dev, &ti);
1372 }
1373 rcu_read_unlock();
1374 #endif
1375 }
1376
1377 /* Initialize the device structure. */
1378 static void geneve_setup(struct net_device *dev)
1379 {
1380 ether_setup(dev);
1381
1382 dev->netdev_ops = &geneve_netdev_ops;
1383 dev->ethtool_ops = &geneve_ethtool_ops;
1384 #ifndef HAVE_NEEDS_FREE_NETDEV
1385 dev->destructor = free_netdev;
1386 #else
1387 dev->needs_free_netdev = true;
1388 #endif
1389
1390 SET_NETDEV_DEVTYPE(dev, &geneve_type);
1391
1392 dev->features |= NETIF_F_LLTX;
1393 dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
1394 dev->features |= NETIF_F_RXCSUM;
1395 dev->features |= NETIF_F_GSO_SOFTWARE;
1396
1397 dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
1398 dev->hw_features |= NETIF_F_GSO_SOFTWARE;
1399
1400 #if 0
1401 netif_keep_dst(dev);
1402 #endif
1403 dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1404 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE | IFF_NO_QUEUE;
1405 eth_hw_addr_random(dev);
1406 }
1407
1408 static const struct nla_policy geneve_policy[IFLA_GENEVE_MAX + 1] = {
1409 [IFLA_GENEVE_ID] = { .type = NLA_U32 },
1410 [IFLA_GENEVE_REMOTE] = { .len = sizeof_field(struct iphdr, daddr) },
1411 [IFLA_GENEVE_REMOTE6] = { .len = sizeof(struct in6_addr) },
1412 [IFLA_GENEVE_TTL] = { .type = NLA_U8 },
1413 [IFLA_GENEVE_TOS] = { .type = NLA_U8 },
1414 [IFLA_GENEVE_LABEL] = { .type = NLA_U32 },
1415 [IFLA_GENEVE_PORT] = { .type = NLA_U16 },
1416 [IFLA_GENEVE_COLLECT_METADATA] = { .type = NLA_FLAG },
1417 [IFLA_GENEVE_UDP_CSUM] = { .type = NLA_U8 },
1418 [IFLA_GENEVE_UDP_ZERO_CSUM6_TX] = { .type = NLA_U8 },
1419 [IFLA_GENEVE_UDP_ZERO_CSUM6_RX] = { .type = NLA_U8 },
1420 };
1421
1422 #ifdef HAVE_EXT_ACK_IN_RTNL_LINKOPS
1423 static int geneve_validate(struct nlattr *tb[], struct nlattr *data[],
1424 struct netlink_ext_ack *extack)
1425 #else
1426 static int geneve_validate(struct nlattr *tb[], struct nlattr *data[])
1427 #endif
1428 {
1429 if (tb[IFLA_ADDRESS]) {
1430 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
1431 return -EINVAL;
1432
1433 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
1434 return -EADDRNOTAVAIL;
1435 }
1436
1437 if (!data)
1438 return -EINVAL;
1439
1440 if (data[IFLA_GENEVE_ID]) {
1441 __u32 vni = nla_get_u32(data[IFLA_GENEVE_ID]);
1442
1443 if (vni >= GENEVE_VID_MASK)
1444 return -ERANGE;
1445 }
1446
1447 return 0;
1448 }
1449
1450 static struct geneve_dev *geneve_find_dev(struct geneve_net *gn,
1451 __be16 dst_port,
1452 union geneve_addr *remote,
1453 u8 vni[],
1454 bool *tun_on_same_port,
1455 bool *tun_collect_md)
1456 {
1457 struct geneve_dev *geneve, *t;
1458
1459 *tun_on_same_port = false;
1460 *tun_collect_md = false;
1461 t = NULL;
1462 list_for_each_entry(geneve, &gn->geneve_list, next) {
1463 if (geneve->dst_port == dst_port) {
1464 *tun_collect_md = geneve->collect_md;
1465 *tun_on_same_port = true;
1466 }
1467 if (!memcmp(vni, geneve->vni, sizeof(geneve->vni)) &&
1468 !memcmp(remote, &geneve->remote, sizeof(geneve->remote)) &&
1469 dst_port == geneve->dst_port)
1470 t = geneve;
1471 }
1472 return t;
1473 }
1474
1475 static int geneve_configure(struct net *net, struct net_device *dev,
1476 union geneve_addr *remote,
1477 __u32 vni, __u8 ttl, __u8 tos, __be32 label,
1478 __be16 dst_port, bool metadata, u32 flags)
1479 {
1480 struct geneve_net *gn = net_generic(net, geneve_net_id);
1481 struct geneve_dev *t, *geneve = netdev_priv(dev);
1482 bool tun_collect_md, tun_on_same_port;
1483 int err, encap_len;
1484
1485 if (!remote)
1486 return -EINVAL;
1487 if (metadata &&
1488 (remote->sa.sa_family != AF_UNSPEC || vni || tos || ttl || label))
1489 return -EINVAL;
1490
1491 geneve->net = net;
1492 geneve->dev = dev;
1493
1494 geneve->vni[0] = (vni & 0x00ff0000) >> 16;
1495 geneve->vni[1] = (vni & 0x0000ff00) >> 8;
1496 geneve->vni[2] = vni & 0x000000ff;
1497
1498 if ((remote->sa.sa_family == AF_INET &&
1499 IN_MULTICAST(ntohl(remote->sin.sin_addr.s_addr))) ||
1500 (remote->sa.sa_family == AF_INET6 &&
1501 ipv6_addr_is_multicast(&remote->sin6.sin6_addr)))
1502 return -EINVAL;
1503 if (label && remote->sa.sa_family != AF_INET6)
1504 return -EINVAL;
1505
1506 geneve->remote = *remote;
1507
1508 geneve->ttl = ttl;
1509 geneve->tos = tos;
1510 geneve->label = label;
1511 geneve->dst_port = dst_port;
1512 geneve->collect_md = metadata;
1513 geneve->flags = flags;
1514
1515 t = geneve_find_dev(gn, dst_port, remote, geneve->vni,
1516 &tun_on_same_port, &tun_collect_md);
1517 if (t)
1518 return -EBUSY;
1519
1520 /* make enough headroom for basic scenario */
1521 encap_len = GENEVE_BASE_HLEN + ETH_HLEN;
1522 if (remote->sa.sa_family == AF_INET)
1523 encap_len += sizeof(struct iphdr);
1524 else
1525 encap_len += sizeof(struct ipv6hdr);
1526 dev->needed_headroom = encap_len + ETH_HLEN;
1527
1528 if (metadata) {
1529 if (tun_on_same_port)
1530 return -EPERM;
1531 } else {
1532 if (tun_collect_md)
1533 return -EPERM;
1534 }
1535
1536 dst_cache_reset(&geneve->dst_cache);
1537
1538 err = register_netdevice(dev);
1539 if (err)
1540 return err;
1541
1542 list_add(&geneve->next, &gn->geneve_list);
1543 return 0;
1544 }
1545
1546 #ifdef HAVE_EXT_ACK_IN_RTNL_LINKOPS
1547 static int geneve_newlink(struct net *net, struct net_device *dev,
1548 struct nlattr *tb[], struct nlattr *data[],
1549 struct netlink_ext_ack *extack)
1550 #else
1551 static int geneve_newlink(struct net *net, struct net_device *dev,
1552 struct nlattr *tb[], struct nlattr *data[])
1553 #endif
1554 {
1555 __be16 dst_port = htons(GENEVE_UDP_PORT);
1556 __u8 ttl = 0, tos = 0;
1557 bool metadata = false;
1558 union geneve_addr remote = geneve_remote_unspec;
1559 __be32 label = 0;
1560 __u32 vni = 0;
1561 u32 flags = 0;
1562
1563 if (data[IFLA_GENEVE_REMOTE] && data[IFLA_GENEVE_REMOTE6])
1564 return -EINVAL;
1565
1566 if (data[IFLA_GENEVE_REMOTE]) {
1567 remote.sa.sa_family = AF_INET;
1568 remote.sin.sin_addr.s_addr =
1569 nla_get_in_addr(data[IFLA_GENEVE_REMOTE]);
1570 }
1571
1572 if (data[IFLA_GENEVE_REMOTE6]) {
1573 if (!IS_ENABLED(CONFIG_IPV6))
1574 return -EPFNOSUPPORT;
1575
1576 remote.sa.sa_family = AF_INET6;
1577 remote.sin6.sin6_addr =
1578 nla_get_in6_addr(data[IFLA_GENEVE_REMOTE6]);
1579
1580 if (ipv6_addr_type(&remote.sin6.sin6_addr) &
1581 IPV6_ADDR_LINKLOCAL) {
1582 netdev_dbg(dev, "link-local remote is unsupported\n");
1583 return -EINVAL;
1584 }
1585 }
1586
1587 if (data[IFLA_GENEVE_ID])
1588 vni = nla_get_u32(data[IFLA_GENEVE_ID]);
1589
1590 if (data[IFLA_GENEVE_TTL])
1591 ttl = nla_get_u8(data[IFLA_GENEVE_TTL]);
1592
1593 if (data[IFLA_GENEVE_TOS])
1594 tos = nla_get_u8(data[IFLA_GENEVE_TOS]);
1595
1596 if (data[IFLA_GENEVE_LABEL])
1597 label = nla_get_be32(data[IFLA_GENEVE_LABEL]) &
1598 IPV6_FLOWLABEL_MASK;
1599
1600 if (data[IFLA_GENEVE_PORT])
1601 dst_port = nla_get_be16(data[IFLA_GENEVE_PORT]);
1602
1603 if (data[IFLA_GENEVE_COLLECT_METADATA])
1604 metadata = true;
1605
1606 if (data[IFLA_GENEVE_UDP_CSUM] &&
1607 !nla_get_u8(data[IFLA_GENEVE_UDP_CSUM]))
1608 flags |= GENEVE_F_UDP_ZERO_CSUM_TX;
1609
1610 if (data[IFLA_GENEVE_UDP_ZERO_CSUM6_TX] &&
1611 nla_get_u8(data[IFLA_GENEVE_UDP_ZERO_CSUM6_TX]))
1612 flags |= GENEVE_F_UDP_ZERO_CSUM6_TX;
1613
1614 if (data[IFLA_GENEVE_UDP_ZERO_CSUM6_RX] &&
1615 nla_get_u8(data[IFLA_GENEVE_UDP_ZERO_CSUM6_RX]))
1616 flags |= GENEVE_F_UDP_ZERO_CSUM6_RX;
1617
1618 return geneve_configure(net, dev, &remote, vni, ttl, tos, label,
1619 dst_port, metadata, flags);
1620 }
1621
1622 static void geneve_dellink(struct net_device *dev, struct list_head *head)
1623 {
1624 struct geneve_dev *geneve = netdev_priv(dev);
1625
1626 list_del(&geneve->next);
1627 unregister_netdevice_queue(dev, head);
1628 }
1629
1630 static size_t geneve_get_size(const struct net_device *dev)
1631 {
1632 return nla_total_size(sizeof(__u32)) + /* IFLA_GENEVE_ID */
1633 nla_total_size(sizeof(struct in6_addr)) + /* IFLA_GENEVE_REMOTE{6} */
1634 nla_total_size(sizeof(__u8)) + /* IFLA_GENEVE_TTL */
1635 nla_total_size(sizeof(__u8)) + /* IFLA_GENEVE_TOS */
1636 nla_total_size(sizeof(__be32)) + /* IFLA_GENEVE_LABEL */
1637 nla_total_size(sizeof(__be16)) + /* IFLA_GENEVE_PORT */
1638 nla_total_size(0) + /* IFLA_GENEVE_COLLECT_METADATA */
1639 nla_total_size(sizeof(__u8)) + /* IFLA_GENEVE_UDP_CSUM */
1640 nla_total_size(sizeof(__u8)) + /* IFLA_GENEVE_UDP_ZERO_CSUM6_TX */
1641 nla_total_size(sizeof(__u8)) + /* IFLA_GENEVE_UDP_ZERO_CSUM6_RX */
1642 0;
1643 }
1644
1645 static int geneve_fill_info(struct sk_buff *skb, const struct net_device *dev)
1646 {
1647 struct geneve_dev *geneve = netdev_priv(dev);
1648 __u32 vni;
1649
1650 vni = (geneve->vni[0] << 16) | (geneve->vni[1] << 8) | geneve->vni[2];
1651 if (nla_put_u32(skb, IFLA_GENEVE_ID, vni))
1652 goto nla_put_failure;
1653
1654 if (geneve->remote.sa.sa_family == AF_INET) {
1655 if (nla_put_in_addr(skb, IFLA_GENEVE_REMOTE,
1656 geneve->remote.sin.sin_addr.s_addr))
1657 goto nla_put_failure;
1658 #if IS_ENABLED(CONFIG_IPV6)
1659 } else {
1660 if (nla_put_in6_addr(skb, IFLA_GENEVE_REMOTE6,
1661 &geneve->remote.sin6.sin6_addr))
1662 goto nla_put_failure;
1663 #endif
1664 }
1665
1666 if (nla_put_u8(skb, IFLA_GENEVE_TTL, geneve->ttl) ||
1667 nla_put_u8(skb, IFLA_GENEVE_TOS, geneve->tos) ||
1668 nla_put_be32(skb, IFLA_GENEVE_LABEL, geneve->label))
1669 goto nla_put_failure;
1670
1671 if (nla_put_be16(skb, IFLA_GENEVE_PORT, geneve->dst_port))
1672 goto nla_put_failure;
1673
1674 if (geneve->collect_md) {
1675 if (nla_put_flag(skb, IFLA_GENEVE_COLLECT_METADATA))
1676 goto nla_put_failure;
1677 }
1678
1679 if (nla_put_u8(skb, IFLA_GENEVE_UDP_CSUM,
1680 !(geneve->flags & GENEVE_F_UDP_ZERO_CSUM_TX)) ||
1681 nla_put_u8(skb, IFLA_GENEVE_UDP_ZERO_CSUM6_TX,
1682 !!(geneve->flags & GENEVE_F_UDP_ZERO_CSUM6_TX)) ||
1683 nla_put_u8(skb, IFLA_GENEVE_UDP_ZERO_CSUM6_RX,
1684 !!(geneve->flags & GENEVE_F_UDP_ZERO_CSUM6_RX)))
1685 goto nla_put_failure;
1686
1687 return 0;
1688
1689 nla_put_failure:
1690 return -EMSGSIZE;
1691 }
1692
1693 static struct rtnl_link_ops geneve_link_ops __read_mostly = {
1694 .kind = "ovs_geneve",
1695 .maxtype = IFLA_GENEVE_MAX,
1696 .policy = geneve_policy,
1697 .priv_size = sizeof(struct geneve_dev),
1698 .setup = geneve_setup,
1699 .validate = geneve_validate,
1700 .newlink = geneve_newlink,
1701 .dellink = geneve_dellink,
1702 .get_size = geneve_get_size,
1703 .fill_info = geneve_fill_info,
1704 };
1705
1706 struct net_device *rpl_geneve_dev_create_fb(struct net *net, const char *name,
1707 u8 name_assign_type, u16 dst_port)
1708 {
1709 struct nlattr *tb[IFLA_MAX + 1];
1710 struct net_device *dev;
1711 LIST_HEAD(list_kill);
1712 int err;
1713
1714 memset(tb, 0, sizeof(tb));
1715 dev = rtnl_create_link(net, name, name_assign_type,
1716 &geneve_link_ops, tb);
1717 if (IS_ERR(dev))
1718 return dev;
1719
1720 err = geneve_configure(net, dev, &geneve_remote_unspec,
1721 0, 0, 0, 0, htons(dst_port), true,
1722 GENEVE_F_UDP_ZERO_CSUM6_RX);
1723 if (err) {
1724 free_netdev(dev);
1725 return ERR_PTR(err);
1726 }
1727
1728 /* openvswitch users expect packet sizes to be unrestricted,
1729 * so set the largest MTU we can.
1730 */
1731 err = __geneve_change_mtu(dev, IP_MAX_MTU, false);
1732 if (err)
1733 goto err;
1734
1735 err = rtnl_configure_link(dev, NULL);
1736 if (err < 0)
1737 goto err;
1738
1739 return dev;
1740
1741 err:
1742 geneve_dellink(dev, &list_kill);
1743 unregister_netdevice_many(&list_kill);
1744 return ERR_PTR(err);
1745 }
1746 EXPORT_SYMBOL_GPL(rpl_geneve_dev_create_fb);
1747
1748 static int geneve_netdevice_event(struct notifier_block *unused,
1749 unsigned long event, void *ptr)
1750 {
1751 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1752
1753 if (event == NETDEV_OFFLOAD_PUSH_GENEVE)
1754 geneve_push_rx_ports(dev);
1755
1756 return NOTIFY_DONE;
1757 }
1758
1759 static struct notifier_block geneve_notifier_block __read_mostly = {
1760 .notifier_call = geneve_netdevice_event,
1761 };
1762
1763 static __net_init int geneve_init_net(struct net *net)
1764 {
1765 struct geneve_net *gn = net_generic(net, geneve_net_id);
1766
1767 INIT_LIST_HEAD(&gn->geneve_list);
1768 INIT_LIST_HEAD(&gn->sock_list);
1769 return 0;
1770 }
1771
1772 static void __net_exit geneve_exit_net(struct net *net)
1773 {
1774 struct geneve_net *gn = net_generic(net, geneve_net_id);
1775 struct geneve_dev *geneve, *next;
1776 struct net_device *dev, *aux;
1777 LIST_HEAD(list);
1778
1779 rtnl_lock();
1780
1781 /* gather any geneve devices that were moved into this ns */
1782 for_each_netdev_safe(net, dev, aux)
1783 if (dev->rtnl_link_ops == &geneve_link_ops)
1784 unregister_netdevice_queue(dev, &list);
1785
1786 /* now gather any other geneve devices that were created in this ns */
1787 list_for_each_entry_safe(geneve, next, &gn->geneve_list, next) {
1788 /* If geneve->dev is in the same netns, it was already added
1789 * to the list by the previous loop.
1790 */
1791 if (!net_eq(dev_net(geneve->dev), net))
1792 unregister_netdevice_queue(geneve->dev, &list);
1793 }
1794
1795 /* unregister the devices gathered above */
1796 unregister_netdevice_many(&list);
1797 rtnl_unlock();
1798 }
1799
1800 static struct pernet_operations geneve_net_ops = {
1801 .init = geneve_init_net,
1802 .exit = geneve_exit_net,
1803 .id = &geneve_net_id,
1804 .size = sizeof(struct geneve_net),
1805 };
1806
1807 int rpl_geneve_init_module(void)
1808 {
1809 int rc;
1810
1811 rc = register_pernet_subsys(&geneve_net_ops);
1812 if (rc)
1813 goto out1;
1814
1815 rc = register_netdevice_notifier(&geneve_notifier_block);
1816 if (rc)
1817 goto out2;
1818
1819 rc = rtnl_link_register(&geneve_link_ops);
1820 if (rc)
1821 goto out3;
1822
1823 pr_info("Geneve tunneling driver\n");
1824 return 0;
1825
1826 out3:
1827 unregister_netdevice_notifier(&geneve_notifier_block);
1828 out2:
1829 unregister_pernet_subsys(&geneve_net_ops);
1830 out1:
1831 pr_err("Error while initializing GENEVE %d\n", rc);
1832 return rc;
1833 }
1834
1835 void rpl_geneve_cleanup_module(void)
1836 {
1837 rtnl_link_unregister(&geneve_link_ops);
1838 unregister_netdevice_notifier(&geneve_notifier_block);
1839 unregister_pernet_subsys(&geneve_net_ops);
1840 }
1841
1842 #endif
openvswitch mirror